/* Implements svn_ra_reporter3_t->link_path. */
static svn_error_t *
reporter_link_path(void *report_baton, const char *path, const char *url,
svn_revnum_t revision, svn_depth_t depth,
svn_boolean_t start_empty,
const char *lock_token, apr_pool_t *pool)
{
report_baton_t *rb = report_baton;
const char *ancestor;
apr_size_t len;
ancestor = svn_path_get_longest_ancestor(url, rb->ancestor, pool);
/* If we got a shorter ancestor, truncate our current ancestor.
Note that svn_path_get_longest_ancestor will allocate its return
value even if it identical to one of its arguments. */
len = strlen(ancestor);
if (len < strlen(rb->ancestor))
rb->ancestor[len] = '\0';
return rb->wrapped_reporter->link_path(rb->wrapped_report_baton, path, url,
revision, depth, start_empty,
lock_token, pool);
}
svn_error_t *
svn_path_condense_targets(const char **pcommon,
apr_array_header_t **pcondensed_targets,
const apr_array_header_t *targets,
svn_boolean_t remove_redundancies,
apr_pool_t *pool)
{
int i, j, num_condensed = targets->nelts;
svn_boolean_t *removed;
apr_array_header_t *abs_targets;
int basedir_len;
/* Early exit when there's no data to work on. */
if (targets->nelts <= 0)
{
*pcommon = NULL;
if (pcondensed_targets)
*pcondensed_targets = NULL;
return SVN_NO_ERROR;
}
/* Get the absolute path of the first target. */
SVN_ERR(svn_path_get_absolute(pcommon,
APR_ARRAY_IDX(targets, 0, const char *),
pool));
/* Early exit when there's only one path to work on. */
if (targets->nelts == 1)
{
if (pcondensed_targets)
*pcondensed_targets = apr_array_make(pool, 0, sizeof(const char *));
return SVN_NO_ERROR;
}
/* Copy the targets array, but with absolute paths instead of
relative. Also, find the pcommon argument by finding what is
common in all of the absolute paths. NOTE: This is not as
efficient as it could be. The calculation of the basedir could
be done in the loop below, which would save some calls to
svn_path_get_longest_ancestor. I decided to do it this way
because I thought it would be simpler, since this way, we don't
even do the loop if we don't need to condense the targets. */
removed = apr_pcalloc(pool, (targets->nelts * sizeof(svn_boolean_t)));
abs_targets = apr_array_make(pool, targets->nelts, sizeof(const char *));
APR_ARRAY_PUSH(abs_targets, const char *) = *pcommon;
for (i = 1; i < targets->nelts; ++i)
{
const char *rel = APR_ARRAY_IDX(targets, i, const char *);
const char *absolute;
SVN_ERR(svn_path_get_absolute(&absolute, rel, pool));
APR_ARRAY_PUSH(abs_targets, const char *) = absolute;
*pcommon = svn_path_get_longest_ancestor(*pcommon, absolute, pool);
}
if (pcondensed_targets != NULL)
{
if (remove_redundancies)
{
/* Find the common part of each pair of targets. If
common part is equal to one of the paths, the other
is a child of it, and can be removed. If a target is
equal to *pcommon, it can also be removed. */
/* First pass: when one non-removed target is a child of
another non-removed target, remove the child. */
for (i = 0; i < abs_targets->nelts; ++i)
{
if (removed[i])
continue;
for (j = i + 1; j < abs_targets->nelts; ++j)
{
const char *abs_targets_i;
const char *abs_targets_j;
const char *ancestor;
if (removed[j])
continue;
abs_targets_i = APR_ARRAY_IDX(abs_targets, i, const char *);
abs_targets_j = APR_ARRAY_IDX(abs_targets, j, const char *);
ancestor = svn_path_get_longest_ancestor
(abs_targets_i, abs_targets_j, pool);
if (*ancestor == '\0')
continue;
if (strcmp(ancestor, abs_targets_i) == 0)
{
removed[j] = TRUE;
num_condensed--;
}
else if (strcmp(ancestor, abs_targets_j) == 0)
{
removed[i] = TRUE;
num_condensed--;
}
}
}
/* Second pass: when a target is the same as *pcommon,
remove the target. */
for (i = 0; i < abs_targets->nelts; ++i)
{
const char *abs_targets_i = APR_ARRAY_IDX(abs_targets, i,
const char *);
if ((strcmp(abs_targets_i, *pcommon) == 0) && (! removed[i]))
{
removed[i] = TRUE;
num_condensed--;
}
}
}
/* Now create the return array, and copy the non-removed items */
basedir_len = strlen(*pcommon);
*pcondensed_targets = apr_array_make(pool, num_condensed,
sizeof(const char *));
for (i = 0; i < abs_targets->nelts; ++i)
{
const char *rel_item = APR_ARRAY_IDX(abs_targets, i, const char *);
/* Skip this if it's been removed. */
if (removed[i])
continue;
/* If a common prefix was found, condensed_targets are given
relative to that prefix. */
if (basedir_len > 0)
{
/* Only advance our pointer past a path separator if
REL_ITEM isn't the same as *PCOMMON.
If *PCOMMON is a root path, basedir_len will already
include the closing '/', so never advance the pointer
here.
*/
rel_item += basedir_len;
if (rel_item[0] &&
! svn_dirent_is_root(*pcommon, basedir_len))
rel_item++;
}
APR_ARRAY_PUSH(*pcondensed_targets, const char *)
= apr_pstrdup(pool, rel_item);
}
}
return SVN_NO_ERROR;
}
