text: /*
   * target.c:  functions which operate on a list of targets supplied to
   *              a subversion subcommand.
   *
   * ====================================================================
   *    Licensed to the Apache Software Foundation (ASF) under one
   *    or more contributor license agreements.  See the NOTICE file
   *    distributed with this work for additional information
   *    regarding copyright ownership.  The ASF licenses this file
   *    to you under the Apache License, Version 2.0 (the
   *    "License"); you may not use this file except in compliance
   *    with the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   *    Unless required by applicable law or agreed to in writing,
   *    software distributed under the License is distributed on an
   *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   *    KIND, either express or implied.  See the License for the
   *    specific language governing permissions and limitations
   *    under the License.
   * ====================================================================
   */
  
  /* ==================================================================== */
  
  
  
  /*** Includes. ***/
  
  #include "svn_pools.h"
  #include "svn_error.h"
  #include "svn_dirent_uri.h"
  #include "svn_path.h"
  
  
  /*** Code. ***/
  
  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;
    size_t basedir_len;
    const char *first_target;
    svn_boolean_t first_target_is_url;
  
    /* 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. */
    first_target = APR_ARRAY_IDX(targets, 0, const char *);
    first_target_is_url = svn_path_is_url(first_target);
    if (first_target_is_url)
      {
        first_target = apr_pstrdup(pool, first_target);
        *pcommon = first_target;
      }
    else
      SVN_ERR(svn_dirent_get_absolute(pcommon, first_target, 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_boolean_t is_url = svn_path_is_url(rel);
  
        if (is_url)
          absolute = apr_pstrdup(pool, rel); /* ### TODO: avoid pool dup? */
        else
          SVN_ERR(svn_dirent_get_absolute(&absolute, rel, pool));
  
        APR_ARRAY_PUSH(abs_targets, const char *) = absolute;
  
        /* If we've not already determined that there's no common
           parent, then continue trying to do so. */
        if (*pcommon && **pcommon)
          {
            /* If the is-url-ness of this target doesn't match that of
               the first target, our search for a common ancestor can
               end right here.  Otherwise, use the appropriate
               get-longest-ancestor function per the path type. */
            if (is_url != first_target_is_url)
              *pcommon = "";
            else if (first_target_is_url)
              *pcommon = svn_uri_get_longest_ancestor(*pcommon, absolute, pool);
            else
              *pcommon = svn_dirent_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;
                    svn_boolean_t i_is_url, j_is_url;
                    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 *);
                    i_is_url = svn_path_is_url(abs_targets_i);
                    j_is_url = svn_path_is_url(abs_targets_j);
  
                    if (i_is_url != j_is_url)
                      continue;
  
                    if (i_is_url)
                      ancestor = svn_uri_get_longest_ancestor(abs_targets_i,
                                                              abs_targets_j,
                                                              pool);
                    else
                      ancestor = svn_dirent_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;
  }
  
  
  svn_error_t *
  svn_path_remove_redundancies(apr_array_header_t **pcondensed_targets,
                               const apr_array_header_t *targets,
                               apr_pool_t *pool)
  {
    apr_pool_t *temp_pool;
    apr_array_header_t *abs_targets;
    apr_array_header_t *rel_targets;
    int i;
  
    if ((targets->nelts <= 0) || (! pcondensed_targets))
      {
        /* No targets or no place to store our work means this function
           really has nothing to do. */
        if (pcondensed_targets)
          *pcondensed_targets = NULL;
        return SVN_NO_ERROR;
      }
  
    /* Initialize our temporary pool. */
    temp_pool = svn_pool_create(pool);
  
    /* Create our list of absolute paths for our "keepers" */
    abs_targets = apr_array_make(temp_pool, targets->nelts,
                                 sizeof(const char *));
  
    /* Create our list of untainted paths for our "keepers" */
    rel_targets = apr_array_make(pool, targets->nelts,
                                 sizeof(const char *));
  
    /* For each target in our list we do the following:
  
       1.  Calculate its absolute path (ABS_PATH).
       2.  See if any of the keepers in ABS_TARGETS is a parent of, or
           is the same path as, ABS_PATH.  If so, we ignore this
           target.  If not, however, add this target's absolute path to
           ABS_TARGETS and its original path to REL_TARGETS.
    */
    for (i = 0; i < targets->nelts; i++)
      {
        const char *rel_path = APR_ARRAY_IDX(targets, i, const char *);
        const char *abs_path;
        int j;
        svn_boolean_t is_url, keep_me;
  
        /* Get the absolute path for this target. */
        is_url = svn_path_is_url(rel_path);
        if (is_url)
          abs_path = rel_path;
        else
          SVN_ERR(svn_dirent_get_absolute(&abs_path, rel_path, temp_pool));
  
        /* For each keeper in ABS_TARGETS, see if this target is the
           same as or a child of that keeper. */
        keep_me = TRUE;
        for (j = 0; j < abs_targets->nelts; j++)
          {
            const char *keeper = APR_ARRAY_IDX(abs_targets, j, const char *);
            svn_boolean_t keeper_is_url = svn_path_is_url(keeper);
            const char *child_relpath;
  
            /* If KEEPER hasn't the same is-url-ness as ABS_PATH, we
               know they aren't equal and that one isn't the child of
               the other. */
            if (is_url != keeper_is_url)
              continue;
  
            /* Quit here if this path is the same as or a child of one of the
               keepers. */
            if (is_url)
              child_relpath = svn_uri_skip_ancestor(keeper, abs_path, temp_pool);
            else
              child_relpath = svn_dirent_skip_ancestor(keeper, abs_path);
            if (child_relpath)
              {
                keep_me = FALSE;
                break;
              }
          }
  
        /* If this is a new keeper, add its absolute path to ABS_TARGETS
           and its original path to REL_TARGETS. */
        if (keep_me)
          {
            APR_ARRAY_PUSH(abs_targets, const char *) = abs_path;
            APR_ARRAY_PUSH(rel_targets, const char *) = rel_path;
          }
      }
  
    /* Destroy our temporary pool. */
    svn_pool_destroy(temp_pool);
  
    /* Make sure we return the list of untainted keeper paths. */
    *pcondensed_targets = rel_targets;
  
    return SVN_NO_ERROR;
  }
  