| /* |
| * 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; |
| } |
