| /* |
| * mergeinfo-cmd.c -- Query merge-relative info. |
| * |
| * ==================================================================== |
| * 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_compat.h" |
| #include "svn_pools.h" |
| #include "svn_props.h" |
| #include "svn_client.h" |
| #include "svn_cmdline.h" |
| #include "svn_path.h" |
| #include "svn_error.h" |
| #include "svn_error_codes.h" |
| #include "svn_types.h" |
| #include "cl.h" |
| #include "cl-log.h" |
| |
| #include "svn_private_config.h" |
| |
| |
| /*** Code. ***/ |
| |
| /* Implements the svn_log_entry_receiver_t interface. */ |
| static svn_error_t * |
| print_log_rev(void *baton, |
| svn_log_entry_t *log_entry, |
| apr_pool_t *pool) |
| { |
| if (log_entry->non_inheritable) |
| SVN_ERR(svn_cmdline_printf(pool, "r%ld*\n", log_entry->revision)); |
| else |
| SVN_ERR(svn_cmdline_printf(pool, "r%ld\n", log_entry->revision)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* Implements a svn_log_entry_receiver_t interface that filters out changed |
| * paths data before calling the svn_cl__log_entry_receiver(). Right now we |
| * always have to pass TRUE for discover_changed_paths for |
| * svn_client_mergeinfo_log2() due to the side effect of that option. The |
| * svn_cl__log_entry_receiver() discovers if it should print the changed paths |
| * implicitly by the path info existing. As a result this filter is needed |
| * to allow expected output without changed paths. |
| */ |
| static svn_error_t * |
| print_log_details(void *baton, |
| svn_log_entry_t *log_entry, |
| apr_pool_t *pool) |
| { |
| log_entry->changed_paths = NULL; |
| log_entry->changed_paths2 = NULL; |
| |
| return svn_cl__log_entry_receiver(baton, log_entry, pool); |
| } |
| |
| /* Draw a diagram (by printing text to the console) summarizing the state |
| * of merging between two branches, given the merge description |
| * indicated by YCA, BASE, RIGHT, TARGET, REINTEGRATE_LIKE. */ |
| static svn_error_t * |
| mergeinfo_diagram(const char *yca_url, |
| const char *base_url, |
| const char *right_url, |
| const char *target_url, |
| svn_revnum_t yca_rev, |
| svn_revnum_t base_rev, |
| svn_revnum_t right_rev, |
| svn_revnum_t target_rev, |
| const char *repos_root_url, |
| svn_boolean_t target_is_wc, |
| svn_boolean_t reintegrate_like, |
| apr_pool_t *pool) |
| { |
| /* The graph occupies 4 rows of text, and the annotations occupy |
| * another 2 rows above and 2 rows below. The graph is constructed |
| * from left to right in discrete sections ("columns"), each of which |
| * can have a different width (measured in characters). Each element in |
| * the array is either a text string of the appropriate width, or can |
| * be NULL to draw a blank cell. */ |
| #define ROWS 8 |
| #define COLS 4 |
| const char *g[ROWS][COLS] = {{0}}; |
| int col_width[COLS]; |
| int row, col; |
| |
| /* The YCA (that is, the branching point). And an ellipsis, because we |
| * don't show information about earlier merges */ |
| g[0][0] = apr_psprintf(pool, " %-8ld ", yca_rev); |
| g[1][0] = " | "; |
| if (strcmp(yca_url, right_url) == 0) |
| { |
| g[2][0] = "-------| |--"; |
| g[3][0] = " \\ "; |
| g[4][0] = " \\ "; |
| g[5][0] = " --| |--"; |
| } |
| else if (strcmp(yca_url, target_url) == 0) |
| { |
| g[2][0] = " --| |--"; |
| g[3][0] = " / "; |
| g[4][0] = " / "; |
| g[5][0] = "-------| |--"; |
| } |
| else |
| { |
| g[2][0] = " --| |--"; |
| g[3][0] = "... / "; |
| g[4][0] = " \\ "; |
| g[5][0] = " --| |--"; |
| } |
| |
| /* The last full merge */ |
| if ((base_rev > yca_rev) && reintegrate_like) |
| { |
| g[2][2] = "---------"; |
| g[3][2] = " / "; |
| g[4][2] = " / "; |
| g[5][2] = "---------"; |
| g[6][2] = "| "; |
| g[7][2] = apr_psprintf(pool, "%-8ld ", base_rev); |
| } |
| else if (base_rev > yca_rev) |
| { |
| g[0][2] = apr_psprintf(pool, "%-8ld ", base_rev); |
| g[1][2] = "| "; |
| g[2][2] = "---------"; |
| g[3][2] = " \\ "; |
| g[4][2] = " \\ "; |
| g[5][2] = "---------"; |
| } |
| else |
| { |
| g[2][2] = "---------"; |
| g[3][2] = " "; |
| g[4][2] = " "; |
| g[5][2] = "---------"; |
| } |
| |
| /* The tips of the branches */ |
| { |
| g[0][3] = apr_psprintf(pool, "%-8ld", right_rev); |
| g[1][3] = "| "; |
| g[2][3] = "- "; |
| g[3][3] = " "; |
| g[4][3] = " "; |
| g[5][3] = "- "; |
| g[6][3] = "| "; |
| g[7][3] = target_is_wc ? "WC " |
| : apr_psprintf(pool, "%-8ld", target_rev); |
| } |
| |
| /* Find the width of each column, so we know how to print blank cells */ |
| for (col = 0; col < COLS; col++) |
| { |
| col_width[col] = 0; |
| for (row = 0; row < ROWS; row++) |
| { |
| if (g[row][col] && ((int)strlen(g[row][col]) > col_width[col])) |
| col_width[col] = (int)strlen(g[row][col]); |
| } |
| } |
| |
| /* Column headings */ |
| SVN_ERR(svn_cmdline_printf(pool, |
| " %s\n" |
| " | %s\n" |
| " | | %s\n" |
| " | | | %s\n" |
| "\n", |
| _("youngest common ancestor"), _("last full merge"), |
| _("tip of branch"), _("repository path"))); |
| |
| /* Print the diagram, row by row */ |
| for (row = 0; row < ROWS; row++) |
| { |
| SVN_ERR(svn_cmdline_fputs(" ", stdout, pool)); |
| for (col = 0; col < COLS; col++) |
| { |
| if (g[row][col]) |
| { |
| SVN_ERR(svn_cmdline_fputs(g[row][col], stdout, pool)); |
| } |
| else |
| { |
| /* Print <column-width> spaces */ |
| SVN_ERR(svn_cmdline_printf(pool, "%*s", col_width[col], "")); |
| } |
| } |
| if (row == 2) |
| SVN_ERR(svn_cmdline_printf(pool, " %s", |
| svn_uri_skip_ancestor(repos_root_url, right_url, pool))); |
| if (row == 5) |
| SVN_ERR(svn_cmdline_printf(pool, " %s", |
| svn_uri_skip_ancestor(repos_root_url, target_url, pool))); |
| SVN_ERR(svn_cmdline_fputs("\n", stdout, pool)); |
| } |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* Display a summary of the state of merging between the two branches |
| * SOURCE_PATH_OR_URL@SOURCE_REVISION and |
| * TARGET_PATH_OR_URL@TARGET_REVISION. */ |
| static svn_error_t * |
| mergeinfo_summary( |
| const char *source_path_or_url, |
| const svn_opt_revision_t *source_revision, |
| const char *target_path_or_url, |
| const svn_opt_revision_t *target_revision, |
| svn_client_ctx_t *ctx, |
| apr_pool_t *pool) |
| { |
| const char *yca_url, *base_url, *right_url, *target_url; |
| svn_revnum_t yca_rev, base_rev, right_rev, target_rev; |
| const char *repos_root_url; |
| svn_boolean_t target_is_wc, is_reintegration; |
| |
| target_is_wc = (! svn_path_is_url(target_path_or_url)) |
| && (target_revision->kind == svn_opt_revision_unspecified |
| || target_revision->kind == svn_opt_revision_working |
| || target_revision->kind == svn_opt_revision_base); |
| SVN_ERR(svn_client_get_merging_summary( |
| &is_reintegration, |
| &yca_url, &yca_rev, |
| &base_url, &base_rev, |
| &right_url, &right_rev, |
| &target_url, &target_rev, |
| &repos_root_url, |
| source_path_or_url, source_revision, |
| target_path_or_url, target_revision, |
| ctx, pool, pool)); |
| |
| SVN_ERR(mergeinfo_diagram(yca_url, base_url, right_url, target_url, |
| yca_rev, base_rev, right_rev, target_rev, |
| repos_root_url, target_is_wc, is_reintegration, |
| pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| static svn_error_t * |
| mergeinfo_log(svn_boolean_t finding_merged, |
| const char *target, |
| const svn_opt_revision_t *tgt_peg_revision, |
| const char *source, |
| const svn_opt_revision_t *src_peg_revision, |
| const svn_opt_revision_t *src_start_revision, |
| const svn_opt_revision_t *src_end_revision, |
| svn_depth_t depth, |
| svn_boolean_t include_log_details, |
| svn_boolean_t quiet, |
| svn_boolean_t verbose, |
| svn_boolean_t incremental, |
| svn_client_ctx_t *ctx, |
| apr_pool_t *pool) |
| { |
| apr_array_header_t *revprops; |
| svn_log_entry_receiver_t log_receiver; |
| void *log_receiver_baton; |
| |
| if (include_log_details) |
| { |
| svn_cl__log_receiver_baton *baton; |
| |
| revprops = apr_array_make(pool, 3, sizeof(const char *)); |
| APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_AUTHOR; |
| APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_DATE; |
| if (!quiet) |
| APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_LOG; |
| |
| if (verbose) |
| log_receiver = svn_cl__log_entry_receiver; |
| else |
| log_receiver = print_log_details; |
| |
| baton = apr_palloc(pool, sizeof(svn_cl__log_receiver_baton)); |
| baton->ctx = ctx; |
| baton->target_path_or_url = target; |
| baton->target_peg_revision = *tgt_peg_revision; |
| baton->omit_log_message = quiet; |
| baton->show_diff = FALSE; |
| baton->depth = depth; |
| baton->diff_extensions = NULL; |
| baton->merge_stack = NULL; |
| baton->search_patterns = NULL; |
| baton->pool = pool; |
| log_receiver_baton = baton; |
| } |
| else |
| { |
| /* We need only revisions number, not revision properties. */ |
| revprops = apr_array_make(pool, 0, sizeof(const char *)); |
| log_receiver = print_log_rev; |
| log_receiver_baton = NULL; |
| } |
| |
| SVN_ERR(svn_client_mergeinfo_log2(finding_merged, target, |
| tgt_peg_revision, |
| source, src_peg_revision, |
| src_start_revision, |
| src_end_revision, |
| log_receiver, log_receiver_baton, |
| TRUE, depth, revprops, ctx, |
| pool)); |
| |
| if (include_log_details && !incremental) |
| SVN_ERR(svn_cmdline_printf(pool, SVN_CL__LOG_SEP_STRING)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| svn_error_t * |
| svn_cl__mergeinfo(apr_getopt_t *os, |
| void *baton, |
| apr_pool_t *pool) |
| { |
| svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; |
| svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; |
| apr_array_header_t *targets; |
| const char *source, *target; |
| svn_opt_revision_t src_peg_revision, tgt_peg_revision; |
| svn_opt_revision_t *src_start_revision, *src_end_revision; |
| /* Default to depth empty. */ |
| svn_depth_t depth = (opt_state->depth == svn_depth_unknown) |
| ? svn_depth_empty : opt_state->depth; |
| |
| SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, |
| opt_state->targets, |
| ctx, FALSE, pool)); |
| |
| /* Parse the arguments: SOURCE[@REV] optionally followed by TARGET[@REV]. */ |
| if (targets->nelts < 1) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("Not enough arguments given")); |
| if (targets->nelts > 2) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("Too many arguments given")); |
| SVN_ERR(svn_opt_parse_path(&src_peg_revision, &source, |
| APR_ARRAY_IDX(targets, 0, const char *), pool)); |
| if (targets->nelts == 2) |
| { |
| SVN_ERR(svn_opt_parse_path(&tgt_peg_revision, &target, |
| APR_ARRAY_IDX(targets, 1, const char *), |
| pool)); |
| } |
| else |
| { |
| target = ""; |
| tgt_peg_revision.kind = svn_opt_revision_unspecified; |
| } |
| |
| /* If no peg-rev was attached to the source URL, assume HEAD. */ |
| /* ### But what if SOURCE is a WC path not a URL -- shouldn't we then use |
| * BASE (but not WORKING: that would be inconsistent with 'svn merge')? */ |
| if (src_peg_revision.kind == svn_opt_revision_unspecified) |
| src_peg_revision.kind = svn_opt_revision_head; |
| |
| /* If no peg-rev was attached to a URL target, then assume HEAD; if |
| no peg-rev was attached to a non-URL target, then assume BASE. */ |
| /* ### But we would like to be able to examine a working copy with an |
| uncommitted merge in it, so change this to use WORKING not BASE? */ |
| if (tgt_peg_revision.kind == svn_opt_revision_unspecified) |
| { |
| if (svn_path_is_url(target)) |
| tgt_peg_revision.kind = svn_opt_revision_head; |
| else |
| tgt_peg_revision.kind = svn_opt_revision_base; |
| } |
| |
| src_start_revision = &(opt_state->start_revision); |
| if (opt_state->end_revision.kind == svn_opt_revision_unspecified) |
| src_end_revision = src_start_revision; |
| else |
| src_end_revision = &(opt_state->end_revision); |
| |
| if (!opt_state->mergeinfo_log) |
| { |
| if (opt_state->quiet) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("--quiet (-q) option valid only with --log " |
| "option")); |
| |
| if (opt_state->verbose) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("--verbose (-v) option valid only with " |
| "--log option")); |
| |
| if (opt_state->incremental) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("--incremental option valid only with " |
| "--log option")); |
| } |
| |
| /* Do the real work, depending on the requested data flavor. */ |
| if (opt_state->show_revs == svn_cl__show_revs_merged) |
| { |
| SVN_ERR(mergeinfo_log(TRUE, target, &tgt_peg_revision, |
| source, &src_peg_revision, |
| src_start_revision, |
| src_end_revision, |
| depth, opt_state->mergeinfo_log, |
| opt_state->quiet, opt_state->verbose, |
| opt_state->incremental, ctx, pool)); |
| } |
| else if (opt_state->show_revs == svn_cl__show_revs_eligible) |
| { |
| SVN_ERR(mergeinfo_log(FALSE, target, &tgt_peg_revision, |
| source, &src_peg_revision, |
| src_start_revision, |
| src_end_revision, |
| depth, opt_state->mergeinfo_log, |
| opt_state->quiet, opt_state->verbose, |
| opt_state->incremental, ctx, pool)); |
| } |
| else |
| { |
| if ((opt_state->start_revision.kind != svn_opt_revision_unspecified) |
| || (opt_state->end_revision.kind != svn_opt_revision_unspecified)) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("--revision (-r) option valid only with " |
| "--show-revs option")); |
| if (opt_state->depth != svn_depth_unknown) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("Depth specification options valid only " |
| "with --show-revs option")); |
| if (opt_state->mergeinfo_log) |
| return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, |
| _("--log option valid only with " |
| "--show-revs option")); |
| |
| |
| SVN_ERR(mergeinfo_summary(source, &src_peg_revision, |
| target, &tgt_peg_revision, |
| ctx, pool)); |
| } |
| return SVN_NO_ERROR; |
| } |
