From 47dd0d595d04ee5283dfd8a0b4cbd6e6de8ad57f Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Tue, 13 Dec 2005 17:21:41 -0800 Subject: [PATCH] diff: --abbrev option When I show transcripts to explain how something works, I often find myself hand-editing the diff-raw output to shorten various object names in the output. This adds --abbrev option to the diff family, which shortens diff-raw output and diff-tree commit id headers. Signed-off-by: Junio C Hamano --- Documentation/diff-options.txt | 7 ++++++ diff-tree.c | 40 +++++++++++++++++------------ diff.c | 57 +++++++++++++++++++++++++++++++++++++----- diff.h | 9 ++++++- sha1_name.c | 3 +++ 5 files changed, 93 insertions(+), 23 deletions(-) diff --git a/Documentation/diff-options.txt b/Documentation/diff-options.txt index 6b496ede25..3d1175e864 100644 --- a/Documentation/diff-options.txt +++ b/Documentation/diff-options.txt @@ -18,6 +18,13 @@ object name of pre- and post-image blob on the "index" line when generating a patch format output. +--abbrev:: + Instead of showing the full 40-byte hexadecimal object + name in diff-raw format output and diff-tree header + lines, show only handful prefix. This is independent of + --full-index option above, which controls the diff-patch + output format. + -B:: Break complete rewrite changes into pairs of delete and create. diff --git a/diff-tree.c b/diff-tree.c index d56d921585..efa2b9476e 100644 --- a/diff-tree.c +++ b/diff-tree.c @@ -14,11 +14,6 @@ static enum cmit_fmt commit_format = CMIT_FMT_RAW; static struct diff_options diff_options; -static void call_diff_setup_done(void) -{ - diff_setup_done(&diff_options); -} - static int call_diff_flush(void) { diffcore_std(&diff_options); @@ -43,7 +38,6 @@ static int diff_tree_sha1_top(const unsigned char *old, { int ret; - call_diff_setup_done(); ret = diff_tree_sha1(old, new, base, &diff_options); call_diff_flush(); return ret; @@ -55,7 +49,6 @@ static int diff_root_tree(const unsigned char *new, const char *base) void *tree; struct tree_desc empty, real; - call_diff_setup_done(); tree = read_object_with_reference(new, "tree", &real.size, NULL); if (!tree) die("unable to read root tree (%s)", sha1_to_hex(new)); @@ -69,18 +62,29 @@ static int diff_root_tree(const unsigned char *new, const char *base) return retval; } -static const char *generate_header(const char *commit, const char *parent, const char *msg) +static const char *generate_header(const unsigned char *commit_sha1, + const unsigned char *parent_sha1, + const char *msg) { static char this_header[16384]; int offset; unsigned long len; + int abbrev = diff_options.abbrev; if (!verbose_header) - return commit; + return sha1_to_hex(commit_sha1); len = strlen(msg); - offset = sprintf(this_header, "%s%s (from %s)\n", header_prefix, commit, parent); - offset += pretty_print_commit(commit_format, msg, len, this_header + offset, sizeof(this_header) - offset); + + offset = sprintf(this_header, "%s%s ", + header_prefix, + diff_unique_abbrev(commit_sha1, abbrev)); + offset += sprintf(this_header + offset, "(from %s)\n", + parent_sha1 ? + diff_unique_abbrev(parent_sha1, abbrev) : "root"); + offset += pretty_print_commit(commit_format, msg, len, + this_header + offset, + sizeof(this_header) - offset); return this_header; } @@ -99,18 +103,18 @@ static int diff_tree_commit(const unsigned char *commit_sha1) /* Root commit? */ if (show_root_diff && !commit->parents) { - header = generate_header(name, "root", commit->buffer); + header = generate_header(sha1, NULL, commit->buffer); diff_root_tree(commit_sha1, ""); } /* More than one parent? */ if (ignore_merges && commit->parents && commit->parents->next) - return 0; + return 0; for (parents = commit->parents; parents; parents = parents->next) { struct commit *parent = parents->item; - header = generate_header(name, - sha1_to_hex(parent->object.sha1), + header = generate_header(sha1, + parent->object.sha1, commit->buffer); diff_tree_sha1_top(parent->object.sha1, commit_sha1, ""); if (!header && verbose_header) { @@ -129,6 +133,7 @@ static int diff_tree_stdin(char *line) int len = strlen(line); unsigned char commit[20], parent[20]; static char this_header[1000]; + int abbrev = diff_options.abbrev; if (!len || line[len-1] != '\n') return -1; @@ -138,7 +143,9 @@ static int diff_tree_stdin(char *line) if (isspace(line[40]) && !get_sha1_hex(line+41, parent)) { line[40] = 0; line[81] = 0; - sprintf(this_header, "%s (from %s)\n", line, line+41); + sprintf(this_header, "%s (from %s)\n", + diff_unique_abbrev(commit, abbrev), + diff_unique_abbrev(parent, abbrev)); header = this_header; return diff_tree_sha1_top(parent, commit, ""); } @@ -239,6 +246,7 @@ int main(int argc, const char **argv) diff_options.recursive = 1; diff_tree_setup_paths(get_pathspec(prefix, argv)); + diff_setup_done(&diff_options); switch (nr_sha1) { case 0: diff --git a/diff.c b/diff.c index 2e0797bf3e..c8159183da 100644 --- a/diff.c +++ b/diff.c @@ -723,11 +723,13 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o) if (memcmp(one->sha1, two->sha1, 20)) { char one_sha1[41]; - const char *index_fmt = o->full_index ? "index %s..%s" : "index %.7s..%.7s"; + int abbrev = o->full_index ? 40 : DIFF_DEFAULT_INDEX_ABBREV; memcpy(one_sha1, sha1_to_hex(one->sha1), 41); len += snprintf(msg + len, sizeof(msg) - len, - index_fmt, one_sha1, sha1_to_hex(two->sha1)); + "index %.*s..%.*s", + abbrev, one_sha1, abbrev, + sha1_to_hex(two->sha1)); if (one->mode == two->mode) len += snprintf(msg + len, sizeof(msg) - len, " %06o", one->mode); @@ -791,6 +793,8 @@ int diff_setup_done(struct diff_options *options) } if (options->setup & DIFF_SETUP_USE_SIZE_CACHE) use_size_cache = 1; + if (options->abbrev <= 0 || 40 < options->abbrev) + options->abbrev = 40; /* full */ return 0; } @@ -841,6 +845,10 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac) } else if (!strcmp(arg, "--find-copies-harder")) options->find_copies_harder = 1; + else if (!strcmp(arg, "--abbrev")) + options->abbrev = DIFF_DEFAULT_ABBREV; + else if (!strncmp(arg, "--abbrev=", 9)) + options->abbrev = strtoul(arg + 9, NULL, 10); else return 0; return 1; @@ -947,14 +955,49 @@ void diff_free_filepair(struct diff_filepair *p) free(p); } +/* This is different from find_unique_abbrev() in that + * it needs to deal with 0{40} SHA1. + */ +const char *diff_unique_abbrev(const unsigned char *sha1, int len) +{ + int abblen; + const char *abbrev; + if (len == 40) + return sha1_to_hex(sha1); + + abbrev = find_unique_abbrev(sha1, len); + if (!abbrev) { + if (!memcmp(sha1, null_sha1, 20)) { + char *buf = sha1_to_hex(null_sha1); + if (len < 37) + strcpy(buf + len, "..."); + return buf; + } + else + return sha1_to_hex(sha1); + } + abblen = strlen(abbrev); + if (abblen < 37) { + static char hex[41]; + if (len < abblen && abblen <= len + 2) + sprintf(hex, "%s%.*s", abbrev, len+3-abblen, ".."); + else + sprintf(hex, "%s...", abbrev); + return hex; + } + return sha1_to_hex(sha1); +} + static void diff_flush_raw(struct diff_filepair *p, int line_termination, int inter_name_termination, - int output_format) + struct diff_options *options) { int two_paths; char status[10]; + int abbrev = options->abbrev; const char *path_one, *path_two; + int output_format = options->output_format; path_one = p->one->path; path_two = p->two->path; @@ -985,8 +1028,10 @@ static void diff_flush_raw(struct diff_filepair *p, } if (output_format != DIFF_FORMAT_NAME_STATUS) { printf(":%06o %06o %s ", - p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1)); - printf("%s ", sha1_to_hex(p->two->sha1)); + p->one->mode, p->two->mode, + diff_unique_abbrev(p->one->sha1, abbrev)); + printf("%s ", + diff_unique_abbrev(p->two->sha1, abbrev)); } printf("%s%c%s", status, inter_name_termination, path_one); if (two_paths) @@ -1194,7 +1239,7 @@ void diff_flush(struct diff_options *options) case DIFF_FORMAT_NAME_STATUS: diff_flush_raw(p, line_termination, inter_name_termination, - diff_output_format); + options); break; case DIFF_FORMAT_NAME: diff_flush_name(p, diff --git a/diff.h b/diff.h index 32b4780173..c3486ffa86 100644 --- a/diff.h +++ b/diff.h @@ -44,6 +44,7 @@ struct diff_options { int reverse_diff; int rename_limit; int setup; + int abbrev; change_fn_t change; add_remove_fn_t add_remove; @@ -87,6 +88,9 @@ extern int diff_setup_done(struct diff_options *); #define DIFF_PICKAXE_ALL 1 +#define DIFF_DEFAULT_INDEX_ABBREV 7 /* hex digits */ +#define DIFF_DEFAULT_ABBREV 7 /* hex digits */ + extern void diffcore_std(struct diff_options *); extern void diffcore_std_no_resolve(struct diff_options *); @@ -98,7 +102,8 @@ extern void diffcore_std_no_resolve(struct diff_options *); " -u synonym for -p.\n" \ " --name-only show only names of changed files.\n" \ " --name-status show names and status of changed files.\n" \ -" --full-index show full object name on index ines.\n" \ +" --full-index show full object name on index lines.\n" \ +" --abbrev abbreviate object names in diff-tree header and diff-raw.\n" \ " -R swap input file pairs.\n" \ " -B detect complete rewrites.\n" \ " -M detect renames.\n" \ @@ -137,4 +142,6 @@ extern void diff_flush(struct diff_options*); #define DIFF_STATUS_FILTER_AON '*' #define DIFF_STATUS_FILTER_BROKEN 'B' +extern const char *diff_unique_abbrev(const unsigned char *, int); + #endif /* DIFF_H */ diff --git a/sha1_name.c b/sha1_name.c index 67b69a54fb..b13ed78cee 100644 --- a/sha1_name.c +++ b/sha1_name.c @@ -188,7 +188,10 @@ const char *find_unique_abbrev(const unsigned char *sha1, int len) { int status; static char hex[41]; + memcpy(hex, sha1_to_hex(sha1), 40); + if (len == 40) + return hex; while (len < 40) { unsigned char sha1_ret[20]; status = get_short_sha1(hex, len, sha1_ret, 1); -- 2.11.4.GIT