From 1187df57c2ee1119b7ef357cacb63d10581256bc Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sun, 26 Feb 2006 09:29:00 -0800 Subject: [PATCH 01/14] The war on trailing whitespace On Sat, 25 Feb 2006, Andrew Morton wrote: > > I'd suggest a) git will simply refuse to apply such a patch unless given a > special `forcing' flag, b) even when thus forced, it will still warn and c) > with a different flag, it will strip-then-apply, without generating a > warning. This doesn't do the "strip-then-apply" thing, but it allows you to make git-apply generate a warning or error on extraneous whitespace. Use --whitespace=warn to warn, and (surprise, surprise) --whitespace=error to make it a fatal error to have whitespace at the end. Totally untested, of course. But it compiles, so it must be fine. HOWEVER! Note that this literally will check every single patch-line with "+" at the beginning. Which means that if you fix a simple typo, and the line had a space at the end before, and you didn't remove it, that's still considered a "new line with whitespace at the end", even though obviously the line wasn't really new. I assume this is what you wanted, and there isn't really any sane alternatives (you could make the warning activate only for _pure_ additions with no deletions at all in that hunk, but that sounds a bit insane). Linus --- apply.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/apply.c b/apply.c index 2ad47fbbb3..69229f8861 100644 --- a/apply.c +++ b/apply.c @@ -34,6 +34,12 @@ static int line_termination = '\n'; static const char apply_usage[] = "git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM] ..."; +static enum whitespace_eol { + nowarn, + warn_on_whitespace, + error_on_whitespace +} new_whitespace = nowarn; + /* * For "diff-stat" like behaviour, we keep track of the biggest change * we've seen, and the longest filename. That allows us to do simple @@ -815,6 +821,22 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s oldlines--; break; case '+': + /* + * We know len is at least two, since we have a '+' and + * we checked that the last character was a '\n' above + */ + if (isspace(line[len-2])) { + switch (new_whitespace) { + case nowarn: + break; + case warn_on_whitespace: + new_whitespace = nowarn; /* Just once */ + error("Added whitespace at end of line at line %d", linenr); + break; + case error_on_whitespace: + die("Added whitespace at end of line at line %d", linenr); + } + } added++; newlines--; break; @@ -1831,6 +1853,17 @@ int main(int argc, char **argv) line_termination = 0; continue; } + if (!strncmp(arg, "--whitespace=", 13)) { + if (strcmp(arg+13, "warn")) { + new_whitespace = warn_on_whitespace; + continue; + } + if (strcmp(arg+13, "error")) { + new_whitespace = error_on_whitespace; + continue; + } + die("unrecognixed whitespace option '%s'", arg+13); + } if (check_index && prefix_length < 0) { prefix = setup_git_directory(); From 5c7b580c94b4217803a116e24a3ad924bfb35f86 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sun, 26 Feb 2006 18:13:25 -0800 Subject: [PATCH 02/14] apply --whitespace fixes and enhancements. In addition to fixing obvious command line parsing bugs in the previous round, this changes the following: * Adds "--whitespace=strip". This applies after stripping the new trailing whitespaces introduced to the patch. * The output error message format is changed to say "patch-filename:linenumber:contents of the line". This makes it similar to typical compiler error message format, and helps C-x ` (next-error) in Emacs compilation buffer. * --whitespace=error and --whitespace=warn do not stop at the first error. We might want to limit the output to say first 20 such lines to prevent cluttering, but on the other hand if you are willing to hand-fix after inspecting them, getting everything with a single run might be easier to work with. After all, somebody has to do the clean-up work somewhere. Signed-off-by: Junio C Hamano --- apply.c | 77 ++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 54 insertions(+), 23 deletions(-) diff --git a/apply.c b/apply.c index 69229f8861..a2f39b8005 100644 --- a/apply.c +++ b/apply.c @@ -37,8 +37,11 @@ static const char apply_usage[] = static enum whitespace_eol { nowarn, warn_on_whitespace, - error_on_whitespace + error_on_whitespace, + strip_and_apply, } new_whitespace = nowarn; +static int whitespace_error = 0; +static const char *patch_input_file = NULL; /* * For "diff-stat" like behaviour, we keep track of the biggest change @@ -823,19 +826,17 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s case '+': /* * We know len is at least two, since we have a '+' and - * we checked that the last character was a '\n' above + * we checked that the last character was a '\n' above. + * That is, an addition of an empty line would check + * the '+' here. Sneaky... */ - if (isspace(line[len-2])) { - switch (new_whitespace) { - case nowarn: - break; - case warn_on_whitespace: - new_whitespace = nowarn; /* Just once */ - error("Added whitespace at end of line at line %d", linenr); - break; - case error_on_whitespace: - die("Added whitespace at end of line at line %d", linenr); - } + if ((new_whitespace != nowarn) && + isspace(line[len-2])) { + fprintf(stderr, "Added whitespace\n"); + fprintf(stderr, "%s:%d:%.*s\n", + patch_input_file, + linenr, len-2, line+1); + whitespace_error = 1; } added++; newlines--; @@ -1114,6 +1115,27 @@ struct buffer_desc { unsigned long alloc; }; +static int apply_line(char *output, const char *patch, int plen) +{ + /* plen is number of bytes to be copied from patch, + * starting at patch+1 (patch[0] is '+'). Typically + * patch[plen] is '\n'. + */ + int add_nl_to_tail = 0; + if ((new_whitespace == strip_and_apply) && + 1 < plen && isspace(patch[plen-1])) { + if (patch[plen] == '\n') + add_nl_to_tail = 1; + plen--; + while (0 < plen && isspace(patch[plen])) + plen--; + } + memcpy(output, patch + 1, plen); + if (add_nl_to_tail) + output[plen++] = '\n'; + return plen; +} + static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag) { char *buf = desc->buffer; @@ -1149,10 +1171,9 @@ static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag) break; /* Fall-through for ' ' */ case '+': - if (*patch != '+' || !no_add) { - memcpy(new + newsize, patch + 1, plen); - newsize += plen; - } + if (*patch != '+' || !no_add) + newsize += apply_line(new + newsize, patch, + plen); break; case '@': case '\\': /* Ignore it, we already handled it */ @@ -1713,7 +1734,7 @@ static int use_patch(struct patch *p) return 1; } -static int apply_patch(int fd) +static int apply_patch(int fd, const char *filename) { int newfd; unsigned long offset, size; @@ -1721,6 +1742,7 @@ static int apply_patch(int fd) struct patch *list = NULL, **listp = &list; int skipped_patch = 0; + patch_input_file = filename; if (!buffer) return -1; offset = 0; @@ -1747,6 +1769,9 @@ static int apply_patch(int fd) } newfd = -1; + if (whitespace_error && (new_whitespace == error_on_whitespace)) + apply = 0; + write_index = check_index && apply; if (write_index) newfd = hold_index_file_for_update(&cache_file, get_index_file()); @@ -1793,7 +1818,7 @@ int main(int argc, char **argv) int fd; if (!strcmp(arg, "-")) { - apply_patch(0); + apply_patch(0, ""); read_stdin = 0; continue; } @@ -1854,14 +1879,18 @@ int main(int argc, char **argv) continue; } if (!strncmp(arg, "--whitespace=", 13)) { - if (strcmp(arg+13, "warn")) { + if (!strcmp(arg+13, "warn")) { new_whitespace = warn_on_whitespace; continue; } - if (strcmp(arg+13, "error")) { + if (!strcmp(arg+13, "error")) { new_whitespace = error_on_whitespace; continue; } + if (!strcmp(arg+13, "strip")) { + new_whitespace = strip_and_apply; + continue; + } die("unrecognixed whitespace option '%s'", arg+13); } @@ -1877,10 +1906,12 @@ int main(int argc, char **argv) if (fd < 0) usage(apply_usage); read_stdin = 0; - apply_patch(fd); + apply_patch(fd, arg); close(fd); } if (read_stdin) - apply_patch(0); + apply_patch(0, ""); + if (whitespace_error && new_whitespace == error_on_whitespace) + return 1; return 0; } From 59aa256204f74e02579d7586884c73f0db6eb0d6 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Mon, 27 Feb 2006 14:16:30 -0800 Subject: [PATCH 03/14] apply: squelch excessive errors and --whitespace=error-all This by default makes --whitespace=warn, error, and strip to warn only the first 5 additions of trailing whitespaces. A new option --whitespace=error-all can be used to view all of them before applying. Signed-off-by: Junio C Hamano --- apply.c | 53 +++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 8 deletions(-) diff --git a/apply.c b/apply.c index a2f39b8005..f01e3caea4 100644 --- a/apply.c +++ b/apply.c @@ -41,6 +41,8 @@ static enum whitespace_eol { strip_and_apply, } new_whitespace = nowarn; static int whitespace_error = 0; +static int squelch_whitespace_errors = 5; +static int applied_after_stripping = 0; static const char *patch_input_file = NULL; /* @@ -832,11 +834,16 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s */ if ((new_whitespace != nowarn) && isspace(line[len-2])) { - fprintf(stderr, "Added whitespace\n"); - fprintf(stderr, "%s:%d:%.*s\n", - patch_input_file, - linenr, len-2, line+1); - whitespace_error = 1; + whitespace_error++; + if (squelch_whitespace_errors && + squelch_whitespace_errors < + whitespace_error) + ; + else { + fprintf(stderr, "Adds trailing whitespace.\n%s:%d:%.*s\n", + patch_input_file, + linenr, len-2, line+1); + } } added++; newlines--; @@ -1129,6 +1136,7 @@ static int apply_line(char *output, const char *patch, int plen) plen--; while (0 < plen && isspace(patch[plen])) plen--; + applied_after_stripping++; } memcpy(output, patch + 1, plen); if (add_nl_to_tail) @@ -1887,11 +1895,16 @@ int main(int argc, char **argv) new_whitespace = error_on_whitespace; continue; } + if (!strcmp(arg+13, "error-all")) { + new_whitespace = error_on_whitespace; + squelch_whitespace_errors = 0; + continue; + } if (!strcmp(arg+13, "strip")) { new_whitespace = strip_and_apply; continue; } - die("unrecognixed whitespace option '%s'", arg+13); + die("unrecognized whitespace option '%s'", arg+13); } if (check_index && prefix_length < 0) { @@ -1911,7 +1924,31 @@ int main(int argc, char **argv) } if (read_stdin) apply_patch(0, ""); - if (whitespace_error && new_whitespace == error_on_whitespace) - return 1; + if (whitespace_error) { + if (squelch_whitespace_errors && + squelch_whitespace_errors < whitespace_error) { + int squelched = + whitespace_error - squelch_whitespace_errors; + fprintf(stderr, "warning: squelched %d whitespace error%s\n", + squelched, + squelched == 1 ? "" : "s"); + } + if (new_whitespace == error_on_whitespace) + die("%d line%s add%s trailing whitespaces.", + whitespace_error, + whitespace_error == 1 ? "" : "s", + whitespace_error == 1 ? "s" : ""); + if (applied_after_stripping) + fprintf(stderr, "warning: %d line%s applied after" + " stripping trailing whitespaces.\n", + applied_after_stripping, + applied_after_stripping == 1 ? "" : "s"); + else if (whitespace_error) + fprintf(stderr, "warning: %d line%s add%s trailing" + " whitespaces.\n", + whitespace_error, + whitespace_error == 1 ? "" : "s", + whitespace_error == 1 ? "s" : ""); + } return 0; } From 383e20b6144d01286c90c0c82d88f92173a038f6 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Mon, 27 Feb 2006 14:47:45 -0800 Subject: [PATCH 04/14] apply --whitespace: configuration option. The new configuration option apply.whitespace can take one of "warn", "error", "error-all", or "strip". When git-apply is run to apply the patch to the index, they are used as the default value if there is no command line --whitespace option. Andrew can now tell people who feed him git trees to update to this version and say: git repo-config apply.whitespace error Signed-off-by: Junio C Hamano --- apply.c | 72 ++++++++++++++++++++++++++++++++++----------------- cache.h | 2 ++ environment.c | 1 + 3 files changed, 51 insertions(+), 24 deletions(-) diff --git a/apply.c b/apply.c index f01e3caea4..4748d7f819 100644 --- a/apply.c +++ b/apply.c @@ -35,16 +35,42 @@ static const char apply_usage[] = "git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM] ..."; static enum whitespace_eol { - nowarn, + nowarn_whitespace, warn_on_whitespace, error_on_whitespace, - strip_and_apply, -} new_whitespace = nowarn; + strip_whitespace, +} new_whitespace = nowarn_whitespace; static int whitespace_error = 0; static int squelch_whitespace_errors = 5; static int applied_after_stripping = 0; static const char *patch_input_file = NULL; +static void parse_whitespace_option(const char *option) +{ + if (!option) { + new_whitespace = nowarn_whitespace; + return; + } + if (!strcmp(option, "warn")) { + new_whitespace = warn_on_whitespace; + return; + } + if (!strcmp(option, "error")) { + new_whitespace = error_on_whitespace; + return; + } + if (!strcmp(option, "error-all")) { + new_whitespace = error_on_whitespace; + squelch_whitespace_errors = 0; + return; + } + if (!strcmp(option, "strip")) { + new_whitespace = strip_whitespace; + return; + } + die("unrecognized whitespace option '%s'", option); +} + /* * For "diff-stat" like behaviour, we keep track of the biggest change * we've seen, and the longest filename. That allows us to do simple @@ -832,7 +858,7 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s * That is, an addition of an empty line would check * the '+' here. Sneaky... */ - if ((new_whitespace != nowarn) && + if ((new_whitespace != nowarn_whitespace) && isspace(line[len-2])) { whitespace_error++; if (squelch_whitespace_errors && @@ -1129,7 +1155,7 @@ static int apply_line(char *output, const char *patch, int plen) * patch[plen] is '\n'. */ int add_nl_to_tail = 0; - if ((new_whitespace == strip_and_apply) && + if ((new_whitespace == strip_whitespace) && 1 < plen && isspace(patch[plen-1])) { if (patch[plen] == '\n') add_nl_to_tail = 1; @@ -1816,10 +1842,21 @@ static int apply_patch(int fd, const char *filename) return 0; } +static int git_apply_config(const char *var, const char *value) +{ + if (!strcmp(var, "apply.whitespace")) { + apply_default_whitespace = strdup(value); + return 0; + } + return git_default_config(var, value); +} + + int main(int argc, char **argv) { int i; int read_stdin = 1; + const char *whitespace_option = NULL; for (i = 1; i < argc; i++) { const char *arg = argv[i]; @@ -1887,30 +1924,17 @@ int main(int argc, char **argv) continue; } if (!strncmp(arg, "--whitespace=", 13)) { - if (!strcmp(arg+13, "warn")) { - new_whitespace = warn_on_whitespace; - continue; - } - if (!strcmp(arg+13, "error")) { - new_whitespace = error_on_whitespace; - continue; - } - if (!strcmp(arg+13, "error-all")) { - new_whitespace = error_on_whitespace; - squelch_whitespace_errors = 0; - continue; - } - if (!strcmp(arg+13, "strip")) { - new_whitespace = strip_and_apply; - continue; - } - die("unrecognized whitespace option '%s'", arg+13); + whitespace_option = arg + 13; + parse_whitespace_option(arg + 13); + continue; } if (check_index && prefix_length < 0) { prefix = setup_git_directory(); prefix_length = prefix ? strlen(prefix) : 0; - git_config(git_default_config); + git_config(git_apply_config); + if (!whitespace_option && apply_default_whitespace) + parse_whitespace_option(apply_default_whitespace); } if (0 < prefix_length) arg = prefix_filename(prefix, prefix_length, arg); diff --git a/cache.h b/cache.h index 9f4adf5c3f..f686e72e66 100644 --- a/cache.h +++ b/cache.h @@ -160,10 +160,12 @@ extern int hold_index_file_for_update(struct cache_file *, const char *path); extern int commit_index_file(struct cache_file *); extern void rollback_index_file(struct cache_file *); +/* Environment bits from configuration mechanism */ extern int trust_executable_bit; extern int only_use_symrefs; extern int diff_rename_limit_default; extern int shared_repository; +extern const char *apply_default_whitespace; #define GIT_REPO_VERSION 0 extern int repository_format_version; diff --git a/environment.c b/environment.c index 0596fc647b..73e4b1c8b7 100644 --- a/environment.c +++ b/environment.c @@ -16,6 +16,7 @@ int only_use_symrefs = 0; int repository_format_version = 0; char git_commit_encoding[MAX_ENCODING_LENGTH] = "utf-8"; int shared_repository = 0; +const char *apply_default_whitespace = NULL; static char *git_dir, *git_object_dir, *git_index_file, *git_refs_dir, *git_graft_file; From 5c0d46eb3d5ab9182a2c6d942189671720f80f74 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Mon, 27 Feb 2006 17:07:16 -0800 Subject: [PATCH 05/14] git-apply --whitespace=nowarn Andrew insists --whitespace=warn should be the default, and I tend to agree. This introduces --whitespace=warn, so if your project policy is more lenient, you can squelch them by having apply.whitespace=nowarn in your configuration file. Signed-off-by: Junio C Hamano --- apply.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/apply.c b/apply.c index 4748d7f819..af9900ff1e 100644 --- a/apply.c +++ b/apply.c @@ -39,7 +39,7 @@ static enum whitespace_eol { warn_on_whitespace, error_on_whitespace, strip_whitespace, -} new_whitespace = nowarn_whitespace; +} new_whitespace = warn_on_whitespace; static int whitespace_error = 0; static int squelch_whitespace_errors = 5; static int applied_after_stripping = 0; @@ -48,13 +48,17 @@ static const char *patch_input_file = NULL; static void parse_whitespace_option(const char *option) { if (!option) { - new_whitespace = nowarn_whitespace; + new_whitespace = warn_on_whitespace; return; } if (!strcmp(option, "warn")) { new_whitespace = warn_on_whitespace; return; } + if (!strcmp(option, "nowarn")) { + new_whitespace = nowarn_whitespace; + return; + } if (!strcmp(option, "error")) { new_whitespace = error_on_whitespace; return; From 56248c5a5c77f65fe591dfec3ac413147d227ec4 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Tue, 28 Feb 2006 01:12:52 -0800 Subject: [PATCH 06/14] git-apply: war on whitespace -- finishing touches. This changes the default --whitespace policy to nowarn when we are only getting --stat, --summary etc. IOW when not applying the patch. When applying the patch, the default is warn (spit out warning message but apply the patch). Signed-off-by: Junio C Hamano --- apply.c | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/apply.c b/apply.c index af9900ff1e..453482a035 100644 --- a/apply.c +++ b/apply.c @@ -75,6 +75,15 @@ static void parse_whitespace_option(const char *option) die("unrecognized whitespace option '%s'", option); } +static void set_default_whitespace_mode(const char *whitespace_option) +{ + if (!whitespace_option && !apply_default_whitespace) { + new_whitespace = (apply + ? warn_on_whitespace + : nowarn_whitespace); + } +} + /* * For "diff-stat" like behaviour, we keep track of the biggest change * we've seen, and the longest filename. That allows us to do simple @@ -1947,9 +1956,11 @@ int main(int argc, char **argv) if (fd < 0) usage(apply_usage); read_stdin = 0; + set_default_whitespace_mode(whitespace_option); apply_patch(fd, arg); close(fd); } + set_default_whitespace_mode(whitespace_option); if (read_stdin) apply_patch(0, ""); if (whitespace_error) { From 12cbbdc40b50458b29b76af740ddc0ab1979b322 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Tue, 28 Feb 2006 20:26:25 -0800 Subject: [PATCH 07/14] git-am: --whitespace=x option. This is passed down to git-apply to override the built-in default and per-repository configuration at runtime. Signed-off-by: Junio C Hamano --- git-am.sh | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/git-am.sh b/git-am.sh index 7cc4ae5a30..ab133fbd51 100755 --- a/git-am.sh +++ b/git-am.sh @@ -100,7 +100,7 @@ fall_back_3way () { } prec=4 -dotest=.dotest sign= utf8= keep= skip= interactive= resolved= binary= +dotest=.dotest sign= utf8= keep= skip= interactive= resolved= binary= ws= while case "$#" in 0) break;; esac do @@ -133,6 +133,9 @@ do --sk|--ski|--skip) skip=t; shift ;; + --whitespace=*) + ws=$1; shift ;; + --) shift; break ;; -*) @@ -171,10 +174,11 @@ else exit 1 } - # -b, -s, -u and -k flags are kept for the resuming session after - # a patch failure. + # -b, -s, -u, -k and --whitespace flags are kept for the + # resuming session after a patch failure. # -3 and -i can and must be given when resuming. echo "$binary" >"$dotest/binary" + echo " $ws" >"$dotest/whitespace" echo "$sign" >"$dotest/sign" echo "$utf8" >"$dotest/utf8" echo "$keep" >"$dotest/keep" @@ -202,6 +206,7 @@ if test "$(cat "$dotest/keep")" = t then keep=-k fi +ws=`cat "$dotest/whitespace"` if test "$(cat "$dotest/sign")" = t then SIGNOFF=`git-var GIT_COMMITTER_IDENT | sed -e ' @@ -355,7 +360,7 @@ do case "$resolved" in '') - git-apply $binary --index "$dotest/patch" + git-apply $binary --index $ws "$dotest/patch" apply_status=$? ;; t) From a64dd34d8cce018742badb49b87c5c565be655ce Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Tue, 28 Feb 2006 20:19:47 -0800 Subject: [PATCH 08/14] diffcore-break: micro-optimize by avoiding delta between identical files. We did not check if we have the same file on both sides when computing break score. This is usually not a problem, but if the user said --find-copies-harde with -B, we ended up trying a delta between the same data even when we know the SHA1 hash of both sides match. Signed-off-by: Junio C Hamano (cherry picked from aeecd23ae2785a0462d42191974e9d9a8e439fbe commit) --- diffcore-break.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/diffcore-break.c b/diffcore-break.c index c57513a4fa..95b5eb492e 100644 --- a/diffcore-break.c +++ b/diffcore-break.c @@ -58,6 +58,10 @@ static int should_break(struct diff_filespec *src, if (!S_ISREG(src->mode) || !S_ISREG(dst->mode)) return 0; /* leave symlink rename alone */ + if (src->sha1_valid && dst->sha1_valid && + !memcmp(src->sha1, dst->sha1, 20)) + return 0; /* they are the same */ + if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0)) return 0; /* error but caught downstream */ From b9003c06a89a6d78255bb837c921ca03ee27fae6 Mon Sep 17 00:00:00 2001 From: Mark Wooding Date: Mon, 27 Feb 2006 12:52:50 +0000 Subject: [PATCH 09/14] combine-diff: Honour --full-index. For some reason, combined diffs don't honour the --full-index flag when emitting patches. Fix this. Signed-off-by: Mark Wooding Signed-off-by: Junio C Hamano (cherry picked from e70c6b35749c316f6e97099bd6bdac895c9d6f68 commit) --- combine-diff.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/combine-diff.c b/combine-diff.c index d812600d11..984103edce 100644 --- a/combine-diff.c +++ b/combine-diff.c @@ -621,7 +621,8 @@ static void reuse_combine_diff(struct sline *sline, unsigned long cnt, } static int show_patch_diff(struct combine_diff_path *elem, int num_parent, - int dense, const char *header) + int dense, const char *header, + struct diff_options *opt) { unsigned long size, cnt, lno; char *result, *cp, *ep; @@ -631,6 +632,7 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent, char ourtmp_buf[TMPPATHLEN]; char *ourtmp = ourtmp_buf; int working_tree_file = !memcmp(elem->sha1, null_sha1, 20); + int abbrev = opt->full_index ? 40 : DEFAULT_ABBREV; /* Read the result of merge first */ if (!working_tree_file) { @@ -735,10 +737,10 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent, printf("index "); for (i = 0; i < num_parent; i++) { abb = find_unique_abbrev(elem->parent[i].sha1, - DEFAULT_ABBREV); + abbrev); printf("%s%s", i ? "," : "", abb); } - abb = find_unique_abbrev(elem->sha1, DEFAULT_ABBREV); + abb = find_unique_abbrev(elem->sha1, abbrev); printf("..%s\n", abb); if (mode_differs) { @@ -862,7 +864,7 @@ int show_combined_diff(struct combine_diff_path *p, default: case DIFF_FORMAT_PATCH: - return show_patch_diff(p, num_parent, dense, header); + return show_patch_diff(p, num_parent, dense, header, opt); } } From feffaddce0cec7fd3f749d23e95579b683961002 Mon Sep 17 00:00:00 2001 From: Mark Wooding Date: Mon, 27 Feb 2006 12:52:52 +0000 Subject: [PATCH 10/14] combine-diff: Honour -z option correctly. Combined diffs don't null terminate things in the same way as standard diffs. This is presumably wrong. Signed-off-by: Mark Wooding Signed-off-by: Junio C Hamano (cherry picked from 6baf0484efcd29bb5e58ccd5ea0379481d4a83f4 commit) --- combine-diff.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/combine-diff.c b/combine-diff.c index 984103edce..a23894d869 100644 --- a/combine-diff.c +++ b/combine-diff.c @@ -726,7 +726,7 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent, if (header) { shown_header++; - puts(header); + printf("%s%c", header, opt->line_termination); } printf("diff --%s ", dense ? "cc" : "combined"); if (quote_c_style(elem->path, NULL, NULL, 0)) @@ -799,7 +799,7 @@ static void show_raw_diff(struct combine_diff_path *p, int num_parent, const cha inter_name_termination = 0; if (header) - puts(header); + printf("%s%c", header, line_termination); for (i = 0; i < num_parent; i++) { if (p->parent[i].mode) From 573464319f70bd54a7c48cfd7bed6a0f6f331f42 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sat, 18 Feb 2006 23:42:03 -0800 Subject: [PATCH 11/14] Allow git-mv to accept ./ in paths. Signed-off-by: Junio C Hamano (cherry picked from 9a0e6731c632c841cd2de9dec0b9091b2f10c6fd commit) --- git-mv.perl | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/git-mv.perl b/git-mv.perl index 83dc7e45cf..2ea852c918 100755 --- a/git-mv.perl +++ b/git-mv.perl @@ -75,6 +75,15 @@ while(scalar @srcArgs > 0) { $dst = shift @dstArgs; $bad = ""; + for ($src, $dst) { + # Be nicer to end-users by doing ".//a/./b/.//./c" ==> "a/b/c" + s|^\./||; + s|/\./|/| while (m|/\./|); + s|//+|/|g; + # Also "a/b/../c" ==> "a/c" + 1 while (s,(^|/)[^/]+/\.\./,$1,); + } + if ($opt_v) { print "Checking rename of '$src' to '$dst'\n"; } From 5e6f85f6c1d988d125dfcba16bb43a9a65f9eab3 Mon Sep 17 00:00:00 2001 From: Josef Weidendorfer Date: Wed, 1 Mar 2006 18:16:36 +0100 Subject: [PATCH 12/14] git-mv: Allow -h without repo & fix error message This fixes "git-mv -h" to output the usage without the need to be in a git repository. Additionally: - fix confusing error message when only one arg was given - fix typo in error message Signed-off-by: Josef Weidendorfer Signed-off-by: Junio C Hamano --- git-mv.perl | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/git-mv.perl b/git-mv.perl index 2ea852c918..8cd95c472f 100755 --- a/git-mv.perl +++ b/git-mv.perl @@ -19,15 +19,15 @@ EOT exit(1); } -my $GIT_DIR = `git rev-parse --git-dir`; -exit 1 if $?; # rev-parse would have given "not a git dir" message. -chomp($GIT_DIR); - our ($opt_n, $opt_f, $opt_h, $opt_k, $opt_v); getopts("hnfkv") || usage; usage() if $opt_h; @ARGV >= 1 or usage; +my $GIT_DIR = `git rev-parse --git-dir`; +exit 1 if $?; # rev-parse would have given "not a git dir" message. +chomp($GIT_DIR); + my (@srcArgs, @dstArgs, @srcs, @dsts); my ($src, $dst, $base, $dstDir); @@ -46,10 +46,14 @@ if (-d $ARGV[$argCount-1]) { } } else { - if ($argCount != 2) { + if ($argCount < 2) { + print "Error: need at least two arguments\n"; + exit(1); + } + if ($argCount > 2) { print "Error: moving to directory '" . $ARGV[$argCount-1] - . "' not possible; not exisiting\n"; + . "' not possible; not existing\n"; exit(1); } @srcArgs = ($ARGV[0]); From 9e7c73de0bcd410d12f897b19419dd35accd961e Mon Sep 17 00:00:00 2001 From: Josef Weidendorfer Date: Wed, 1 Mar 2006 19:09:23 +0100 Subject: [PATCH 13/14] git-mv: fixes for path handling Moving a directory ending in a slash was not working as the destination was not calculated correctly. E.g. in the git repo, git-mv t/ Documentation gave the error Error: destination 'Documentation' already exists To get rid of this problem, strip trailing slashes from all arguments. The comment in cg-mv made me curious about this issue; Pasky, thanks! As result, the workaround in cg-mv is not needed any more. Also, another bug was shown by cg-mv. When moving files outside of a subdirectory, it typically calls git-mv with something like git-mv Documentation/git.txt Documentation/../git-mv.txt which triggers the following error from git-update-index: Ignoring path Documentation/../git-mv.txt The result is a moved file, removed from git revisioning, but not added again. To fix this, the paths have to be normalized not have ".." in the middle. This was already done in git-mv, but only for a better visual appearance :( Signed-off-by: Josef Weidendorfer Signed-off-by: Junio C Hamano --- git-mv.perl | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/git-mv.perl b/git-mv.perl index 8cd95c472f..f3e859ae48 100755 --- a/git-mv.perl +++ b/git-mv.perl @@ -31,13 +31,14 @@ chomp($GIT_DIR); my (@srcArgs, @dstArgs, @srcs, @dsts); my ($src, $dst, $base, $dstDir); +# remove any trailing slash in arguments +for (@ARGV) { s/\/*$//; } + my $argCount = scalar @ARGV; if (-d $ARGV[$argCount-1]) { $dstDir = $ARGV[$argCount-1]; - # remove any trailing slash - $dstDir =~ s/\/$//; @srcArgs = @ARGV[0..$argCount-2]; - + foreach $src (@srcArgs) { $base = $src; $base =~ s/^.*\///; @@ -61,6 +62,16 @@ else { $dstDir = ""; } +# normalize paths, needed to compare against versioned files and update-index +# also, this is nicer to end-users by doing ".//a/./b/.//./c" ==> "a/b/c" +for (@srcArgs, @dstArgs) { + s|^\./||; + s|/\./|/| while (m|/\./|); + s|//+|/|g; + # Also "a/b/../c" ==> "a/c" + 1 while (s,(^|/)[^/]+/\.\./,$1,); +} + my (@allfiles,@srcfiles,@dstfiles); my $safesrc; my (%overwritten, %srcForDst); @@ -79,15 +90,6 @@ while(scalar @srcArgs > 0) { $dst = shift @dstArgs; $bad = ""; - for ($src, $dst) { - # Be nicer to end-users by doing ".//a/./b/.//./c" ==> "a/b/c" - s|^\./||; - s|/\./|/| while (m|/\./|); - s|//+|/|g; - # Also "a/b/../c" ==> "a/c" - 1 while (s,(^|/)[^/]+/\.\./,$1,); - } - if ($opt_v) { print "Checking rename of '$src' to '$dst'\n"; } From 2b74cffa9179eed274be2a38c59b7e323c813737 Mon Sep 17 00:00:00 2001 From: "Luck, Tony" Date: Wed, 1 Mar 2006 15:01:53 -0800 Subject: [PATCH 14/14] Re-fix compilation warnings. Commit 8fcf1ad9c68e15d881194c8544e7c11d33529c2b has a combination of double cast and Andreas' switch to using unsigned long ... just the latter is sufficient (and a lot less ugly than using the double cast). Signed-off-by: Tony Luck Signed-off-by: Junio C Hamano --- pack-objects.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pack-objects.c b/pack-objects.c index 21ee572f48..136a7f5aad 100644 --- a/pack-objects.c +++ b/pack-objects.c @@ -99,7 +99,7 @@ static int reused_delta = 0; static int pack_revindex_ix(struct packed_git *p) { - unsigned long ui = (unsigned long)(long)p; + unsigned long ui = (unsigned long)p; int i; ui = ui ^ (ui >> 16); /* defeat structure alignment */