git@vger.kernel.org list mirror (unofficial, one of many)
 help / color / Atom feed
From: "Johannes Schindelin via GitGitGadget" <gitgitgadget@gmail.com>
To: git@vger.kernel.org
Cc: Junio C Hamano <gitster@pobox.com>
Subject: [PATCH v4 00/21] Add `range-diff`, a `tbdiff` lookalike
Date: Sat, 21 Jul 2018 15:04:44 -0700 (PDT)
Message-ID: <pull.1.v4.git.gitgitgadget@gmail.com> (raw)
In-Reply-To: <pull.1.v3.git.gitgitgadget@gmail.com>

The incredibly useful [`git-tbdiff`](https://github.com/trast/tbdiff) tool to compare patch series (say, to see what changed between two iterations sent to the Git mailing list) is slightly less useful for this developer due to the fact that it requires the `hungarian` and `numpy` Python packages which are for some reason really hard to build in MSYS2. So hard that I even had to give up, because it was simply easier to re-implement the whole shebang as a builtin command.

The project at https://github.com/trast/tbdiff seems to be dormant, anyway. Funny (and true) story: I looked at the open Pull Requests to see how active that project is, only to find to my surprise that I had submitted one in August 2015, and that it was still unanswered let alone merged.

While at it, I forward-ported AEvar's patch to force `--decorate=no` because `git -p tbdiff` would fail otherwise.

Side note: I work on implementing range-diff not only to make life easier for reviewers who have to suffer through v2, v3, ... of my patch series, but also to verify my changes before submitting a new iteration. And also, maybe even more importantly, I plan to use it to verify my merging-rebases of Git for
Windows (for which I previously used to redirect the pre-rebase/post-rebase diffs vs upstream and then compare them using `git diff --no-index`). And of course any interested person can see what changes were necessary e.g. in the merging-rebase of Git for Windows onto v2.17.0 by running a command like:

```sh
        base=^{/Start.the.merging-rebase}
        tag=v2.17.0.windows.1
        pre=$tag$base^2
        git range-diff $pre$base..$pre $tag$base..$tag
```

The command uses what it calls the "dual color mode" (can be disabled via `--no-dual-color`) which helps identifying what *actually* changed: it prefixes lines with a `-` (and red background) that correspond to the first commit range, and with a `+` (and green background) that correspond to the second range. The rest of the lines will be colored according to the original diffs.

Changes since v3:

- The cover letter was adjusted to reflect the new reality (the command is called `range-diff` now, not `branch-diff`, and `--dual-color` is the default).
- The documentation was adjusted a bit more in the patch that makes `--dual-color` the default.
- Clarified the calculation of the cost matrix, as per Stefan Beller's request.
- The man page now spells out that merge *commits* are ignored in the commit ranges (not merges per se).
- The code in `linear-assignment.c` was adjusted to use the `SWAP()` macro.
- The commit message of the patch introducing the first rudimentary implementation no longer talks about the "Hungarian" algorithm, but about the "linear assignment algorithm" instead.
- A bogus indentation change was backed out from the patch introducing the first rudimentary implementation.
- Instead of merely warning about missing `..` in the 2-parameter invocation, we now exit with the error message.
- The `diff_opt_parse()` function is allowed to return a value larger than 1, indicating that more than just one command-line parameter was parsed. We now advance by the indicated value instead of always advancing exactly 1 (which is still correct much of the time).
- A lengthy `if...else if...else if...else` was simplified (from a logical point of view) by reordering it.
- The unnecessarily `static` variable `dashes` was turned into a local variable of the caller.
- The commit message talking about the new man page still referred to `git branch --diff`, which has been fixed.
- A forgotten t7910 reference was changed to t3206.
- An unbalanced double-tick was fixed in the man page.
- Fixed grammar both of the commit message and the description of the `--no-dual-color` option.
- To fix the build, a blank man page is now introduced together with the new `range-diff` command, even if it is populated for real only at a later patch (i.e. at the same time as before).
- The headaches Junio fears would be incurred by that simple workaround to avoid bogus white-space error reporting are fended off: a more complex patch is now in place that adds (and uses) a new white-space flag. Sadly, as is all too common when Junio "encourages" me to replace a simple workaround by something "proper", it caused all kinds of headaches to get this right, so I am rather less certain that the "proper" fix will cause us less headaches than the simple workaround would have done. But whatever.
- The dual color mode now also dims the changes that are exclusively in the first specified commit range, and uses bold face on the changes exclusively in the second one. This matches the intuition when using `range-diff` to compare an older iteration of a patch series to a newer one: the changes from the previous iteration that were replaced by new ones "fade", while the changes that replace them are "shiny new".

Changes since v2:

- Right-aligned the patch numbers in the commit pairs.
- Used ALLOC_ARRAY() in hungarian.c instead of xmalloc(sizeof()*size).
- Changed compute_assignment()s return type from int to void, as it always succeeds.
- Changed the Hungarian Algorithm to use an integer cost matrix.
- Changed the --creation-weight <double> option to --creation-factor <percent> where <percent> is an integer.
- Retitled 1/19 and 2/19 to better conform with the current conventions, as pointed out (and suggested) by Junio.
- Shut up Coverity, and at the same time avoided passing the unnecessary `i` and `j` parameters to output_pair_header().
- Removed support for the `--no-patches` option: we inherit diff_options' support for `-s` already (and much more).
- Removed the ugly `_INV` enum values, and introduced a beautiful GIT_COLOR_REVERSE instead. This way, whatever the user configured as color.diff.new (or .old) will be used in reverse in the dual color mode.
- Instead of overriding the fragment header color, the dual color mode will now reverse the "outer" fragment headers, too.
- Turned the stand-alone branch-diff command into the `--diff` option of `git branch`. Adjusted pretty much *all* commit messages to account for this. This change should no longer be visible: see below.
- Pretty much re-wrote the completion, to support the new --diff mode of git-branch. See below: it was reverted for range-diff.
- Renamed t7910 to t3206, to be closer to the git-branch tests.
- Ensured that git_diff_ui_config() gets called, and therefore color.diff.* respected.
- Avoided leaking `four_spaces`.
- Fixed a declaration in a for (;;) statement (which Junio had as a fixup! that I almost missed).
- Renamed `branch --diff`, which had been renamed from `branch-diff` (which was picked to avoid re-using `tbdiff`) to `range-diff`.
- Renamed `hungarian.c` and its header to `linear-assignment.c`
- Made `--dual-color` the default, and changed it to still auto-detect whether color should be used rather than forcing it

Johannes Schindelin (20):
  linear-assignment: a function to solve least-cost assignment problems
  Introduce `range-diff` to compare iterations of a topic branch
  range-diff: first rudimentary implementation
  range-diff: improve the order of the shown commits
  range-diff: also show the diff between patches
  range-diff: right-trim commit messages
  range-diff: indent the diffs just like tbdiff
  range-diff: suppress the diff headers
  range-diff: adjust the output of the commit pairs
  range-diff: do not show "function names" in hunk headers
  range-diff: use color for the commit pairs
  color: add the meta color GIT_COLOR_REVERSE
  diff: add an internal option to dual-color diffs of diffs
  range-diff: offer to dual-color the diffs
  range-diff --dual-color: fix bogus white-space warning
  range-diff: populate the man page
  completion: support `git range-diff`
  range-diff: left-pad patch numbers
  range-diff: make --dual-color the default mode
  range-diff: use dim/bold cues to improve dual color mode

Thomas Rast (1):
  range-diff: add tests

 .gitignore                             |   1 +
 Documentation/config.txt               |   6 +-
 Documentation/git-range-diff.txt       | 252 +++++++++++
 Makefile                               |   3 +
 builtin.h                              |   1 +
 builtin/range-diff.c                   | 106 +++++
 cache.h                                |   3 +-
 color.h                                |   7 +
 command-list.txt                       |   1 +
 contrib/completion/git-completion.bash |  14 +
 diff.c                                 | 119 ++++-
 diff.h                                 |  16 +-
 git.c                                  |   1 +
 linear-assignment.c                    | 201 ++++++++
 linear-assignment.h                    |  22 +
 range-diff.c                           | 440 ++++++++++++++++++
 range-diff.h                           |   9 +
 t/.gitattributes                       |   1 +
 t/t3206-range-diff.sh                  | 145 ++++++
 t/t3206/history.export                 | 604 +++++++++++++++++++++++++
 ws.c                                   |  11 +-
 21 files changed, 1932 insertions(+), 31 deletions(-)
 create mode 100644 Documentation/git-range-diff.txt
 create mode 100644 builtin/range-diff.c
 create mode 100644 linear-assignment.c
 create mode 100644 linear-assignment.h
 create mode 100644 range-diff.c
 create mode 100644 range-diff.h
 create mode 100755 t/t3206-range-diff.sh
 create mode 100644 t/t3206/history.export


base-commit: b7bd9486b055c3f967a870311e704e3bb0654e4f
Published-As: https://github.com/gitgitgadget/git/releases/tags/pr-1%2Fdscho%2Fbranch-diff-v4
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-1/dscho/branch-diff-v4
Pull-Request: https://github.com/gitgitgadget/git/pull/1

Range-diff vs v3:

  1:  39272eefc !  1:  f7e70689e linear-assignment: a function to solve least-cost assignment problems
     @@ -223,9 +223,7 @@
      +				BUG("negative j: %d", j);
      +			i = pred[j];
      +			column2row[j] = i;
     -+			k = j;
     -+			j = row2column[i];
     -+			row2column[i] = k;
     ++			SWAP(j, row2column[i]);
      +		} while (i1 != i);
      +	}
      +
  2:  7f15b26d4 !  2:  88134121d Introduce `range-diff` to compare iterations of a topic branch
     @@ -10,6 +10,10 @@
          At this point, we ignore tbdiff's color options, as they will all be
          implemented later using diff_options.
      
     +    Since f318d739159 (generate-cmds.sh: export all commands to
     +    command-list.h, 2018-05-10), every new command *requires* a man page to
     +    build right away, so let's also add a blank man page, too.
     +
          Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
      
      diff --git a/.gitignore b/.gitignore
     @@ -24,6 +28,22 @@
       /git-rebase
       /git-rebase--am
      
     +diff --git a/Documentation/git-range-diff.txt b/Documentation/git-range-diff.txt
     +new file mode 100644
     +--- /dev/null
     ++++ b/Documentation/git-range-diff.txt
     +@@
     ++git-range-diff(1)
     ++==================
     ++
     ++NAME
     ++----
     ++git-range-diff - Compare two commit ranges (e.g. two versions of a branch)
     ++
     ++GIT
     ++---
     ++Part of the linkgit:git[1] suite
     +
      diff --git a/Makefile b/Makefile
      --- a/Makefile
      +++ b/Makefile
  3:  076e1192d !  3:  4e3fb47a1 range-diff: first rudimentary implementation
     @@ -4,7 +4,7 @@
      
          At this stage, `git range-diff` can determine corresponding commits
          of two related commit ranges. This makes use of the recently introduced
     -    implementation of the Hungarian algorithm.
     +    implementation of the linear assignment algorithm.
      
          The core of this patch is a straight port of the ideas of tbdiff, the
          apparently dormant project at https://github.com/trast/tbdiff.
     @@ -51,19 +51,17 @@
      +	int res = 0;
      +	struct strbuf range1 = STRBUF_INIT, range2 = STRBUF_INIT;
       
     --	argc = parse_options(argc, argv, NULL, options,
     --			     builtin_range_diff_usage, 0);
     -+	argc = parse_options(argc, argv, NULL, options, builtin_range_diff_usage,
     -+			     0);
     + 	argc = parse_options(argc, argv, NULL, options,
     + 			     builtin_range_diff_usage, 0);
       
      -	return 0;
      +	if (argc == 2) {
      +		if (!strstr(argv[0], ".."))
     -+			warning(_("no .. in range: '%s'"), argv[0]);
     ++			die(_("no .. in range: '%s'"), argv[0]);
      +		strbuf_addstr(&range1, argv[0]);
      +
      +		if (!strstr(argv[1], ".."))
     -+			warning(_("no .. in range: '%s'"), argv[1]);
     ++			die(_("no .. in range: '%s'"), argv[1]);
      +		strbuf_addstr(&range2, argv[1]);
      +	} else if (argc == 3) {
      +		strbuf_addf(&range1, "%s..%s", argv[0], argv[1]);
     @@ -195,17 +193,21 @@
      +			continue;
      +		} else if (starts_with(line.buf, "@@ "))
      +			strbuf_addstr(&buf, "@@");
     -+		else if (line.buf[0] && !starts_with(line.buf, "index "))
     ++		else if (!line.buf[0] || starts_with(line.buf, "index "))
      +			/*
      +			 * A completely blank (not ' \n', which is context)
      +			 * line is not valid in a diff.  We skip it
      +			 * silently, because this neatly handles the blank
      +			 * separator line between commits in git-log
      +			 * output.
     ++			 *
     ++			 * We also want to ignore the diff's `index` lines
     ++			 * because they contain exact blob hashes in which
     ++			 * we are not interested.
      +			 */
     -+			strbuf_addbuf(&buf, &line);
     -+		else
      +			continue;
     ++		else
     ++			strbuf_addbuf(&buf, &line);
      +
      +		strbuf_addch(&buf, '\n');
      +		util->diffsize++;
  4:  e98489c8c =  4:  47bee09b0 range-diff: improve the order of the shown commits
  5:  935cad180 !  5:  94afaeaf2 range-diff: also show the diff between patches
     @@ -55,21 +55,22 @@
      +	int i, j, res = 0;
       	struct strbuf range1 = STRBUF_INIT, range2 = STRBUF_INIT;
       
     --	argc = parse_options(argc, argv, NULL, options, builtin_range_diff_usage,
     --			     0);
      +	git_config(git_diff_ui_config, NULL);
      +
      +	diff_setup(&diffopt);
      +	diffopt.output_format = DIFF_FORMAT_PATCH;
      +
     -+	argc = parse_options(argc, argv, NULL, options,
     -+			builtin_range_diff_usage, PARSE_OPT_KEEP_UNKNOWN);
     + 	argc = parse_options(argc, argv, NULL, options,
     +-			     builtin_range_diff_usage, 0);
     ++			     builtin_range_diff_usage, PARSE_OPT_KEEP_UNKNOWN);
      +
     -+	for (i = j = 0; i < argc; i++) {
     ++	for (i = j = 0; i < argc; ) {
      +		int c = diff_opt_parse(&diffopt, argv + i, argc - i, prefix);
      +
      +		if (!c)
     -+			argv[j++] = argv[i];
     ++			argv[j++] = argv[i++];
     ++		else
     ++			i += c;
      +	}
      +	argc = j;
      +	diff_setup_done(&diffopt);
  6:  93ac1931d =  6:  41ab875a3 range-diff: right-trim commit messages
  7:  ca5282815 !  7:  a3dd99509 range-diff: indent the diffs just like tbdiff
     @@ -39,7 +39,7 @@
      +	diffopt.output_prefix_data = &four_spaces;
       
       	argc = parse_options(argc, argv, NULL, options,
     - 			builtin_range_diff_usage, PARSE_OPT_KEEP_UNKNOWN);
     + 			     builtin_range_diff_usage, PARSE_OPT_KEEP_UNKNOWN);
      @@
       
       	strbuf_release(&range1);
  8:  80622685f =  8:  61b2ff2f7 range-diff: suppress the diff headers
  9:  6b31cbf72 !  9:  9641ab5c0 range-diff: adjust the output of the commit pairs
     @@ -26,25 +26,22 @@
       
      -static const char *short_oid(struct patch_util *util)
      +static void output_pair_header(struct strbuf *buf,
     ++			       struct strbuf *dashes,
      +			       struct patch_util *a_util,
      +			       struct patch_util *b_util)
       {
      -	return find_unique_abbrev(&util->oid, DEFAULT_ABBREV);
     -+	static char *dashes;
      +	struct object_id *oid = a_util ? &a_util->oid : &b_util->oid;
      +	struct commit *commit;
      +
     -+	if (!dashes) {
     -+		char *p;
     -+
     -+		dashes = xstrdup(find_unique_abbrev(oid, DEFAULT_ABBREV));
     -+		for (p = dashes; *p; p++)
     -+			*p = '-';
     -+	}
     ++	if (!dashes->len)
     ++		strbuf_addchars(dashes, '-',
     ++				strlen(find_unique_abbrev(oid,
     ++							  DEFAULT_ABBREV)));
      +
      +	strbuf_reset(buf);
      +	if (!a_util)
     -+		strbuf_addf(buf, "-:  %s ", dashes);
     ++		strbuf_addf(buf, "-:  %s ", dashes->buf);
      +	else
      +		strbuf_addf(buf, "%d:  %s ", a_util->i + 1,
      +			    find_unique_abbrev(&a_util->oid, DEFAULT_ABBREV));
     @@ -59,7 +56,7 @@
      +		strbuf_addch(buf, '=');
      +
      +	if (!b_util)
     -+		strbuf_addf(buf, " -:  %s", dashes);
     ++		strbuf_addf(buf, " -:  %s", dashes->buf);
      +	else
      +		strbuf_addf(buf, " %d:  %s", b_util->i + 1,
      +			    find_unique_abbrev(&b_util->oid, DEFAULT_ABBREV));
     @@ -84,7 +81,7 @@
       static void output(struct string_list *a, struct string_list *b,
       		   struct diff_options *diffopt)
       {
     -+	struct strbuf buf = STRBUF_INIT;
     ++	struct strbuf buf = STRBUF_INIT, dashes = STRBUF_INIT;
       	int i = 0, j = 0;
       
       	/*
     @@ -94,7 +91,7 @@
       		if (i < a->nr && a_util->matching < 0) {
      -			printf("%d: %s < -: --------\n",
      -			       i + 1, short_oid(a_util));
     -+			output_pair_header(&buf, a_util, NULL);
     ++			output_pair_header(&buf, &dashes, a_util, NULL);
       			i++;
       			continue;
       		}
     @@ -103,7 +100,7 @@
       		while (j < b->nr && b_util->matching < 0) {
      -			printf("-: -------- > %d: %s\n",
      -			       j + 1, short_oid(b_util));
     -+			output_pair_header(&buf, NULL, b_util);
     ++			output_pair_header(&buf, &dashes, NULL, b_util);
       			b_util = ++j < b->nr ? b->items[j].util : NULL;
       		}
       
     @@ -113,7 +110,7 @@
      -			printf("%d: %s ! %d: %s\n",
      -			       b_util->matching + 1, short_oid(a_util),
      -			       j + 1, short_oid(b_util));
     -+			output_pair_header(&buf, a_util, b_util);
     ++			output_pair_header(&buf, &dashes, a_util, b_util);
       			if (!(diffopt->output_format & DIFF_FORMAT_NO_OUTPUT))
       				patch_diff(a->items[b_util->matching].string,
       					   b->items[j].string, diffopt);
     @@ -122,6 +119,7 @@
       		}
       	}
      +	strbuf_release(&buf);
     ++	strbuf_release(&dashes);
       }
       
       int show_range_diff(const char *range1, const char *range2,
 10:  ef997bb8b = 10:  0a52f8878 range-diff: do not show "function names" in hunk headers
 11:  3d9e5b0ba ! 11:  2b8d09020 range-diff: add tests
     @@ -3,8 +3,8 @@
          range-diff: add tests
      
          These are essentially lifted from https://github.com/trast/tbdiff, with
     -    light touch-ups to account for the command now being an option of `git
     -    branch`.
     +    light touch-ups to account for the command now being names `git
     +    range-diff`.
      
          Apart from renaming `tbdiff` to `range-diff`, only one test case needed
          to be adjusted: 11 - 'changed message'.
     @@ -22,12 +22,13 @@
      --- a/t/.gitattributes
      +++ b/t/.gitattributes
      @@
     - /t5515/* eol=lf
     - /t556x_common eol=lf
     - /t7500/* eol=lf
     -+/t7910/* eol=lf
     - /t8005/*.txt eol=lf
     - /t9*/*.dump eol=lf
     + t[0-9][0-9][0-9][0-9]/* -whitespace
     + /diff-lib/* eol=lf
     + /t0110/url-* binary
     ++/t3206/* eol=lf
     + /t3900/*.txt eol=lf
     + /t3901/*.txt eol=lf
     + /t4034/*/* eol=lf
      
      diff --git a/t/t3206-range-diff.sh b/t/t3206-range-diff.sh
      new file mode 100755
 12:  7273cc647 ! 12:  fb83ce71a range-diff: use color for the commit pairs
     @@ -20,11 +20,12 @@
       }
       
      -static void output_pair_header(struct strbuf *buf,
     -+static void output_pair_header(struct diff_options *diffopt, struct strbuf *buf,
     ++static void output_pair_header(struct diff_options *diffopt,
     ++			       struct strbuf *buf,
     + 			       struct strbuf *dashes,
       			       struct patch_util *a_util,
       			       struct patch_util *b_util)
       {
     - 	static char *dashes;
       	struct object_id *oid = a_util ? &a_util->oid : &b_util->oid;
       	struct commit *commit;
      +	char status;
     @@ -34,11 +35,10 @@
      +	const char *color_commit = diff_get_color_opt(diffopt, DIFF_COMMIT);
      +	const char *color;
       
     - 	if (!dashes) {
     - 		char *p;
     -@@
     - 			*p = '-';
     - 	}
     + 	if (!dashes->len)
     + 		strbuf_addchars(dashes, '-',
     + 				strlen(find_unique_abbrev(oid,
     + 							  DEFAULT_ABBREV)));
       
      +	if (!b_util) {
      +		color = color_old;
     @@ -57,7 +57,7 @@
       	strbuf_reset(buf);
      +	strbuf_addstr(buf, status == '!' ? color_old : color);
       	if (!a_util)
     - 		strbuf_addf(buf, "-:  %s ", dashes);
     + 		strbuf_addf(buf, "-:  %s ", dashes->buf);
       	else
       		strbuf_addf(buf, "%d:  %s ", a_util->i + 1,
       			    find_unique_abbrev(&a_util->oid, DEFAULT_ABBREV));
     @@ -77,7 +77,7 @@
      +		strbuf_addf(buf, "%s%s", color_reset, color_new);
       
       	if (!b_util)
     - 		strbuf_addf(buf, " -:  %s", dashes);
     + 		strbuf_addf(buf, " -:  %s", dashes->buf);
      @@
       		const char *commit_buffer = get_commit_buffer(commit, NULL);
       		const char *subject;
     @@ -99,24 +99,27 @@
       
       		/* Show unmatched LHS commit whose predecessors were shown. */
       		if (i < a->nr && a_util->matching < 0) {
     --			output_pair_header(&buf, a_util, NULL);
     -+			output_pair_header(diffopt, &buf, a_util, NULL);
     +-			output_pair_header(&buf, &dashes, a_util, NULL);
     ++			output_pair_header(diffopt,
     ++					   &buf, &dashes, a_util, NULL);
       			i++;
       			continue;
       		}
       
       		/* Show unmatched RHS commits. */
       		while (j < b->nr && b_util->matching < 0) {
     --			output_pair_header(&buf, NULL, b_util);
     -+			output_pair_header(diffopt, &buf, NULL, b_util);
     +-			output_pair_header(&buf, &dashes, NULL, b_util);
     ++			output_pair_header(diffopt,
     ++					   &buf, &dashes, NULL, b_util);
       			b_util = ++j < b->nr ? b->items[j].util : NULL;
       		}
       
       		/* Show matching LHS/RHS pair. */
       		if (j < b->nr) {
       			a_util = a->items[b_util->matching].util;
     --			output_pair_header(&buf, a_util, b_util);
     -+			output_pair_header(diffopt, &buf, a_util, b_util);
     +-			output_pair_header(&buf, &dashes, a_util, b_util);
     ++			output_pair_header(diffopt,
     ++					   &buf, &dashes, a_util, b_util);
       			if (!(diffopt->output_format & DIFF_FORMAT_NO_OUTPUT))
       				patch_diff(a->items[b_util->matching].string,
       					   b->items[j].string, diffopt);
 13:  96a3073fb = 13:  9ccb9516a color: add the meta color GIT_COLOR_REVERSE
 14:  6be4baf60 = 14:  9de5bd229 diff: add an internal option to dual-color diffs of diffs
 15:  02e13c0c6 ! 15:  21b2f9e4b range-diff: offer to dual-color the diffs
     @@ -40,4 +40,4 @@
      +
       	if (argc == 2) {
       		if (!strstr(argv[0], ".."))
     - 			warning(_("no .. in range: '%s'"), argv[0]);
     + 			die(_("no .. in range: '%s'"), argv[0]);
 16:  dfa7b1e71 <  -:  --------- range-diff --dual-color: work around bogus white-space warning
  -:  --------- > 16:  f4252f2b2 range-diff --dual-color: fix bogus white-space warning
 17:  799da25ef ! 17:  9e09c6be6 range-diff: add a man page
     @@ -1,6 +1,6 @@
      Author: Johannes Schindelin <johannes.schindelin@gmx.de>
      
     -    range-diff: add a man page
     +    range-diff: populate the man page
      
          The bulk of this patch consists of a heavily butchered version of
          tbdiff's README written by Thomas Rast and Thomas Gummerer, lifted from
     @@ -9,17 +9,12 @@
          Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
      
      diff --git a/Documentation/git-range-diff.txt b/Documentation/git-range-diff.txt
     -new file mode 100644
     ---- /dev/null
     +--- a/Documentation/git-range-diff.txt
      +++ b/Documentation/git-range-diff.txt
      @@
     -+git-range-diff(1)
     -+==================
     -+
     -+NAME
     -+----
     -+git-range-diff - Compare two commit ranges (e.g. two versions of a branch)
     -+
     + ----
     + git-range-diff - Compare two commit ranges (e.g. two versions of a branch)
     + 
      +SYNOPSIS
      +--------
      +[verse]
     @@ -31,13 +26,13 @@
      +-----------
      +
      +This command shows the differences between two versions of a patch
     -+series, or more generally, two commit ranges (ignoring merges).
     ++series, or more generally, two commit ranges (ignoring merge commits).
      +
      +To that end, it first finds pairs of commits from both commit ranges
      +that correspond with each other. Two commits are said to correspond when
      +the diff between their patches (i.e. the author information, the commit
      +message and the commit diff) is reasonably small compared to the
     -+patches' size. See ``Algorithm` below for details.
     ++patches' size. See ``Algorithm`` below for details.
      +
      +Finally, the list of matching commits is shown in the order of the
      +second commit range, with unmatched commits being inserted just after
     @@ -150,6 +145,10 @@
      +The general idea is this: we generate a cost matrix between the commits
      +in both commit ranges, then solve the least-cost assignment.
      +
     ++The cost matrix is populated thusly: for each pair of commits, both
     ++diffs are generated and the "diff of diffs" is generated, with 3 context
     ++lines, then the number of lines in that diff is used as cost.
     ++
      +To avoid false positives (e.g. when a patch has been removed, and an
      +unrelated patch has been added between two iterations of the same patch
      +series), the cost matrix is extended to allow for that, by adding
     @@ -245,6 +244,6 @@
      +--------
      +linkgit:git-log[1]
      +
     -+GIT
     -+---
     -+Part of the linkgit:git[1] suite
     + GIT
     + ---
     + Part of the linkgit:git[1] suite
 18:  d05b54c60 ! 18:  9b3632324 completion: support `git range-diff`
     @@ -4,17 +4,11 @@
      
          Tab completion of `git range-diff` is very convenient, especially
          given that the revision arguments to specify the commit ranges to
     -    compare are typically more complex than, say, your grandfather's `git
     -    log` arguments.
     +    compare are typically more complex than, say, what is normally passed
     +    to `git log`.
      
          Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
      
     -    squash! WIP completion: support `git range-diff`
     -
     -    Revert "WIP completion: support `git range-diff`"
     -
     -    This reverts commit 2e7af652af9e53a19fd947f8ebe37a78043afa49.
     -
      diff --git a/contrib/completion/git-completion.bash b/contrib/completion/git-completion.bash
      --- a/contrib/completion/git-completion.bash
      +++ b/contrib/completion/git-completion.bash
 19:  144363006 <  -:  --------- range-diff: left-pad patch numbers
  -:  --------- > 19:  07ec215e8 range-diff: left-pad patch numbers
 20:  4a68b95ce ! 20:  b370468e7 range-diff: make --dual-color the default mode
     @@ -4,7 +4,7 @@
      
          After using this command extensively for the last two months, this
          developer came to the conclusion that even if the dual color mode still
     -    leaves a lot of room for confusion what was actually changed, the
     +    leaves a lot of room for confusion about what was actually changed, the
          non-dual color mode is substantially worse in that regard.
      
          Therefore, we really want to make the dual color mode the default.
     @@ -14,6 +14,15 @@
      diff --git a/Documentation/git-range-diff.txt b/Documentation/git-range-diff.txt
      --- a/Documentation/git-range-diff.txt
      +++ b/Documentation/git-range-diff.txt
     +@@
     + --------
     + [verse]
     + 'git range-diff' [--color=[<when>]] [--no-color] [<diff-options>]
     +-	[--dual-color] [--creation-factor=<factor>]
     ++	[--no-dual-color] [--creation-factor=<factor>]
     + 	( <range1> <range2> | <rev1>...<rev2> | <base> <rev1> <rev2> )
     + 
     + DESCRIPTION
      @@
       
       OPTIONS
     @@ -25,7 +34,7 @@
      -	change in what exact lines were added.
      +--no-dual-color::
      +	When the commit diffs differ, `git range-diff` recreates the
     -+	original diffs' coloring, and add outer -/+ diff markers with
     ++	original diffs' coloring, and adds outer -/+ diff markers with
      +	the *background* being red/green to make it easier to see e.g.
      +	when there was a change in what exact lines were added. This is
      +	known to `range-diff` as "dual coloring". Use `--no-dual-color`
     @@ -34,6 +43,31 @@
       
       --creation-factor=<percent>::
       	Set the creation/deletion cost fudge factor to `<percent>`.
     +@@
     + show`'s output, and the third line colors the old commit red, the new
     + one green and the rest like `git show`'s commit header.
     + 
     +-The color-coded diff is actually a bit hard to read, though, as it
     +-colors the entire lines red or green. The line that added "What is
     +-unexpected" in the old commit, for example, is completely red, even if
     +-the intent of the old commit was to add something.
     ++A naive color-coded diff of diffs is actually a bit hard to read,
     ++though, as it colors the entire lines red or green. The line that added
     ++"What is unexpected" in the old commit, for example, is completely red,
     ++even if the intent of the old commit was to add something.
     + 
     +-To help with that, use the `--dual-color` mode. In this mode, the diff
     +-of diffs will retain the original diff colors, and prefix the lines with
     +--/+ markers that have their *background* red or green, to make it more
     +-obvious that they describe how the diff itself changed.
     ++To help with that, `range` uses the `--dual-color` mode by default. In
     ++this mode, the diff of diffs will retain the original diff colors, and
     ++prefix the lines with -/+ markers that have their *background* red or
     ++green, to make it more obvious that they describe how the diff itself
     ++changed.
     + 
     + 
     + Algorithm
      
      diff --git a/builtin/range-diff.c b/builtin/range-diff.c
      --- a/builtin/range-diff.c
  -:  --------- > 21:  d8498fb32 range-diff: use dim/bold cues to improve dual color mode

-- 
gitgitgadget

  parent reply index

Thread overview: 387+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2018-05-03 15:30 [PATCH 00/18] Add `branch-diff`, " Johannes Schindelin
2018-05-03 15:30 ` [PATCH 01/18] Add a function to solve least-cost assignment problems Johannes Schindelin
2018-05-13 18:19   ` Duy Nguyen
2018-05-21  9:52     ` Johannes Schindelin
2018-05-03 15:30 ` [PATCH 02/18] Add a new builtin: branch-diff Johannes Schindelin
2018-05-03 16:10   ` Ramsay Jones
2018-05-03 20:25     ` Johannes Schindelin
2018-05-03 23:20       ` Ramsay Jones
2018-05-04  6:40         ` Johannes Schindelin
2018-05-04 15:37           ` Ramsay Jones
2018-05-05 19:41             ` Johannes Schindelin
2018-05-09 16:24               ` Ramsay Jones
2018-06-01  8:23                 ` Johannes Schindelin
2018-05-04 16:34           ` Elijah Newren
2018-05-05 20:24             ` Johannes Schindelin
2018-05-03 16:41   ` Duy Nguyen
2018-05-03 20:30     ` Johannes Schindelin
2018-05-03 20:32       ` Johannes Schindelin
2018-05-04  5:15         ` Duy Nguyen
2018-05-04  7:23           ` Johannes Schindelin
2018-05-04 14:44             ` Duy Nguyen
2018-05-04 15:17               ` Duy Nguyen
2018-05-04 15:23               ` Johannes Schindelin
2018-05-04 15:29                 ` Duy Nguyen
2018-05-03 16:43   ` Stefan Beller
2018-05-03 20:42     ` Johannes Schindelin
2018-05-03 21:12       ` Stefan Beller
2018-05-03 21:49         ` Johannes Schindelin
2018-05-04  3:23           ` Junio C Hamano
2018-05-04  2:35   ` Eric Sunshine
2018-05-04  6:52     ` Johannes Schindelin
2018-05-04  7:27       ` Eric Sunshine
2018-05-03 15:30 ` [PATCH 03/18] branch-diff: first rudimentary implementation Johannes Schindelin
2018-05-03 16:30   ` Ramsay Jones
2018-05-03 20:44     ` Johannes Schindelin
2018-05-03 17:06   ` Stefan Beller
2018-05-03 21:01     ` Johannes Schindelin
2018-05-03 21:19       ` Stefan Beller
2018-05-03 22:00         ` Johannes Schindelin
2018-05-04  2:35   ` Eric Sunshine
2018-05-04  7:03     ` Johannes Schindelin
2018-05-04  4:56   ` Junio C Hamano
2018-05-04  7:18     ` Johannes Schindelin
2018-05-03 15:30 ` [PATCH 04/18] branch-diff: improve the order of the shown commits Johannes Schindelin
2018-05-03 15:30 ` [PATCH 05/18] branch-diff: also show the diff between patches Johannes Schindelin
2018-05-04  2:51   ` Eric Sunshine
2018-05-04  3:15     ` Eric Sunshine
2018-05-04  7:15     ` Johannes Schindelin
2018-05-03 15:30 ` [PATCH 06/18] branch-diff: right-trim commit messages Johannes Schindelin
2018-05-03 15:30 ` [PATCH 07/18] branch-diff: indent the diffs just like tbdiff Johannes Schindelin
2018-05-03 15:30 ` [PATCH 08/18] branch-diff: suppress the diff headers Johannes Schindelin
2018-05-03 15:30 ` [PATCH 09/18] branch-diff: adjust the output of the commit pairs Johannes Schindelin
2018-05-03 15:30 ` [PATCH 10/18] branch-diff: do not show "function names" in hunk headers Johannes Schindelin
2018-05-03 15:30 ` [PATCH 11/18] branch-diff: add tests Johannes Schindelin
2018-05-03 16:56   ` Ævar Arnfjörð Bjarmason
2018-05-03 21:03     ` Johannes Schindelin
2018-05-03 17:11   ` Stefan Beller
2018-05-03 21:05     ` Johannes Schindelin
2018-05-03 23:27   ` Philip Oakley
2018-05-04  6:42     ` Johannes Schindelin
2018-05-03 15:30 ` [PATCH 12/18] branch-diff: use color for the commit pairs Johannes Schindelin
2018-05-03 15:30 ` [PATCH 13/18] color: provide inverted colors, too Johannes Schindelin
2018-05-03 15:30 ` [PATCH 14/18] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin
2018-05-03 15:31 ` [PATCH 15/18] branch-diff: offer to dual-color the diffs Johannes Schindelin
2018-05-03 15:31 ` [PATCH 16/18] branch-diff --dual-color: work around bogus white-space warning Johannes Schindelin
2018-05-03 15:31 ` [PATCH 17/18] branch-diff: add a man page Johannes Schindelin
2018-05-04  3:27   ` Eric Sunshine
2018-05-04  7:17     ` Johannes Schindelin
2018-05-03 15:31 ` [PATCH 18/18] completion: support branch-diff Johannes Schindelin
2018-05-03 18:05 ` [PATCH 00/18] Add `branch-diff`, a `tbdiff` lookalike Ævar Arnfjörð Bjarmason
2018-05-03 21:07   ` Johannes Schindelin
2018-05-03 21:50   ` Jacob Keller
2018-05-04  5:24 ` Junio C Hamano
2018-05-04  7:24   ` Johannes Schindelin
2018-05-04 15:34 ` [PATCH v2 " Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 01/18] Add a function to solve least-cost assignment problems Johannes Schindelin
2018-05-05 18:24     ` Jeff King
2018-05-05 21:55       ` Johannes Schindelin
2018-05-30 13:55     ` SZEDER Gábor
2018-05-30 16:14       ` Stefan Beller
2018-05-30 23:28         ` brian m. carlson
2018-05-31 12:19           ` Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 02/18] Add a new builtin: branch-diff Johannes Schindelin
2018-05-05 18:26     ` Jeff King
2018-05-05 21:57       ` Johannes Schindelin
2018-05-06  0:25         ` Todd Zullinger
2018-05-06  0:38           ` Todd Zullinger
2018-05-06 12:04             ` Johannes Schindelin
2018-05-06  1:05         ` Igor Djordjevic
2018-05-06  4:53           ` Jacob Keller
2018-05-06  8:32             ` Duy Nguyen
2018-05-06 12:08               ` Johannes Schindelin
2018-05-06 12:10           ` Johannes Schindelin
2018-05-06 13:37             ` Igor Djordjevic
2018-05-07  1:34               ` Johannes Schindelin
2018-05-07 22:05                 ` Igor Djordjevic
2018-05-07 22:24                   ` Stefan Beller
2018-05-07 23:39                     ` Igor Djordjevic
2018-05-08  3:44                     ` Jeff King
2018-05-08  3:48                       ` Jeff King
2018-05-22 11:38                       ` Ævar Arnfjörð Bjarmason
2018-05-25 22:06                         ` Stefan Beller
     [not found]                           ` <CAA8fPEkNjy+ETz4Mx+C2kUfLjLzR9uuOmO3GfN48ZH1SwyfE1A@mail.gmail.com>
2018-05-26  6:15                             ` Fwd: " Øyvind Rønningstad
2018-06-01  8:15                             ` Johannes Schindelin
2018-05-06  2:33         ` Junio C Hamano
2018-05-06 12:21           ` Johannes Schindelin
2018-05-06 20:51             ` Eric Sunshine
2018-05-07  2:04               ` Johannes Schindelin
2018-05-07  7:48                 ` Jeff King
2018-05-07 21:33                   ` Igor Djordjevic
2018-05-21 10:33                     ` Johannes Schindelin
2018-05-21 17:56                       ` Stefan Beller
2018-05-21 20:24                         ` Jeff King
2018-05-21 21:40                           ` Brandon Williams
2018-05-21 21:48                             ` Stefan Beller
2018-05-21 21:52                             ` Jeff King
2018-05-22  2:08                               ` Junio C Hamano
2018-05-08  0:30                   ` Junio C Hamano
2018-05-07  1:45             ` Junio C Hamano
2018-05-07  5:39               ` Johannes Schindelin
2018-05-07 15:12                 ` Junio C Hamano
2018-05-21 10:41                   ` Johannes Schindelin
2018-05-07  7:50         ` Jeff King
2018-05-07 15:28           ` Duy Nguyen
2018-05-07 19:58             ` Stefan Beller
2018-05-04 15:34   ` [PATCH v2 03/18] branch-diff: first rudimentary implementation Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 04/18] branch-diff: improve the order of the shown commits Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 05/18] branch-diff: also show the diff between patches Johannes Schindelin
2018-05-06  1:14     ` Igor Djordjevic
2018-05-06 12:18       ` Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 06/18] branch-diff: right-trim commit messages Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 07/18] branch-diff: indent the diffs just like tbdiff Johannes Schindelin
2018-05-06 14:15     ` Martin Ågren
2018-05-07  1:54       ` Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 08/18] branch-diff: suppress the diff headers Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 09/18] branch-diff: adjust the output of the commit pairs Johannes Schindelin
2018-05-04 16:25     ` Elijah Newren
2018-05-04 15:34   ` [PATCH v2 10/18] branch-diff: do not show "function names" in hunk headers Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 11/18] branch-diff: add tests Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 12/18] branch-diff: use color for the commit pairs Johannes Schindelin
2018-05-05 23:48     ` Todd Zullinger
2018-05-07  1:52       ` Johannes Schindelin
2018-05-08  2:10         ` Todd Zullinger
2018-06-01  8:17           ` Johannes Schindelin
2018-05-04 15:34   ` [PATCH v2 13/18] color: provide inverted colors, too Johannes Schindelin
2018-05-05 18:29     ` Jeff King
2018-05-05 22:03       ` Johannes Schindelin
2018-05-06  6:35         ` Jeff King
2018-05-06  6:41           ` Jeff King
2018-05-07  1:20             ` Johannes Schindelin
2018-05-07  7:37               ` Jeff King
2018-05-07  1:35             ` Junio C Hamano
2018-05-07  5:38               ` Johannes Schindelin
2018-05-07  7:40               ` Jeff King
2018-05-04 15:34   ` [PATCH v2 14/18] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin
2018-05-04 15:35   ` [PATCH v2 15/18] branch-diff: offer to dual-color the diffs Johannes Schindelin
2018-05-04 15:35   ` [PATCH v2 16/18] branch-diff --dual-color: work around bogus white-space warning Johannes Schindelin
2018-05-04 15:35   ` [PATCH v2 17/18] branch-diff: add a man page Johannes Schindelin
2018-05-04 15:35   ` [PATCH v2 18/18] completion: support branch-diff Johannes Schindelin
2018-05-06  8:24     ` Duy Nguyen
2018-05-07  1:23       ` Johannes Schindelin
2018-05-04 16:21   ` [PATCH v2 00/18] Add `branch-diff`, a `tbdiff` lookalike Elijah Newren
2018-05-04 16:30     ` Elijah Newren
2018-05-05 20:03     ` Johannes Schindelin
2018-05-07 17:07       ` Elijah Newren
2018-05-07 17:50         ` SZEDER Gábor
2018-05-07 18:38           ` Elijah Newren
2018-05-06  5:22   ` Junio C Hamano
2018-05-06 12:23     ` Johannes Schindelin
2018-05-06 22:56   ` brian m. carlson
2018-05-07  2:05     ` Johannes Schindelin
2018-07-03 11:26   ` [PATCH v3 00/20] Add `range-diff`, " Johannes Schindelin via GitGitGadget
2018-04-30 21:54     ` [PATCH v3 01/20] linear-assignment: a function to solve least-cost assignment problems Johannes Schindelin via GitGitGadget
2018-07-06 22:43       ` Junio C Hamano
2018-07-07 11:34         ` Johannes Schindelin
2018-07-07 16:34           ` Junio C Hamano
2018-07-07 19:27             ` Johannes Schindelin
2018-07-07 22:23               ` Johannes Schindelin
2018-07-09 22:08                 ` refs/notes/amlog problems, was " Johannes Schindelin
2018-07-11 16:12                   ` Junio C Hamano
2018-07-12 15:23                     ` Johannes Schindelin
2018-07-12 16:59                       ` Junio C Hamano
2018-07-19 17:06                         ` Junio C Hamano
2018-07-20 18:51                           ` Johannes Schindelin
2018-07-20 19:34                             ` Junio C Hamano
2018-07-20 21:20                               ` Stefan Beller
2018-07-20 21:24                                 ` Junio C Hamano
     [not found]                                   ` <CAPc5daW-KoyUX3i7M5YbdQC2mFKAmVBS42-XT84hpm30VFcZ1g@mail.gmail.com>
2018-07-20 21:30                                     ` Stefan Beller
2018-07-21 22:02                                       ` Johannes Schindelin
2018-07-21 21:56                               ` Johannes Schindelin
2018-07-23  1:25                                 ` Jeff King
2018-07-24  1:50                                   ` Junio C Hamano
2018-07-24  9:45                                     ` Jeff King
2018-07-09 22:23                 ` Junio C Hamano
2018-07-10 10:47                   ` refs/notes/amlog woes, was " Johannes Schindelin
2018-07-11 10:07       ` SZEDER Gábor
2018-07-12 15:11         ` Johannes Schindelin
2018-05-01 19:42     ` [PATCH v3 02/20] Introduce `range-diff` to compare iterations of a topic branch Johannes Schindelin via GitGitGadget
2018-05-02  0:34     ` [PATCH v3 03/20] range-diff: first rudimentary implementation Johannes Schindelin via GitGitGadget
2018-07-16  6:55       ` Eric Sunshine
2018-07-17  9:53         ` Johannes Schindelin
2018-05-02 10:22     ` [PATCH v3 04/20] range-diff: improve the order of the shown commits Johannes Schindelin via GitGitGadget
2018-05-02 14:49     ` [PATCH v3 06/20] range-diff: right-trim commit messages Johannes Schindelin via GitGitGadget
2018-05-02 14:52     ` [PATCH v3 07/20] range-diff: indent the diffs just like tbdiff Johannes Schindelin via GitGitGadget
2018-05-02 14:53     ` [PATCH v3 08/20] range-diff: suppress the diff headers Johannes Schindelin via GitGitGadget
2018-05-02 15:19     ` [PATCH v3 11/20] range-diff: add tests Thomas Rast via GitGitGadget
2018-07-16  7:28       ` Eric Sunshine
2018-07-17 16:28         ` Johannes Schindelin
2018-05-02 21:35     ` [PATCH v3 09/20] range-diff: adjust the output of the commit pairs Johannes Schindelin via GitGitGadget
2018-07-16  7:21       ` Eric Sunshine
2018-07-17 16:24         ` Johannes Schindelin
2018-07-17 17:47           ` Stefan Beller
2018-07-20 18:57             ` Johannes Schindelin
2018-07-20 19:16               ` Stefan Beller
2018-07-21 22:07                 ` Johannes Schindelin
2018-05-02 23:32     ` [PATCH v3 12/20] range-diff: use color for " Johannes Schindelin via GitGitGadget
2018-05-03  0:14     ` [PATCH v3 13/20] color: add the meta color GIT_COLOR_REVERSE Johannes Schindelin via GitGitGadget
2018-05-03  0:17     ` [PATCH v3 14/20] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin via GitGitGadget
2018-07-09 19:29       ` Stefan Beller
2018-07-10 17:45         ` [PATCH 0/2] " Stefan Beller
2018-07-10 17:45           ` [PATCH 1/2] diff.c: convert emit_line_ws_markup to take string for sign Stefan Beller
2018-07-10 17:45           ` [PATCH 2/2] WIP diff.c: clarify emit_line_0 Stefan Beller
2018-07-10 19:58             ` [PATCH 1/2] diff.c: convert emit_line_ws_markup to take string for sign Stefan Beller
2018-07-10 19:59             ` [PATCH] diff.c: clarify emit_line_0 Stefan Beller
2018-07-10 21:54               ` [PATCH] ws: do not reset and set color twice Stefan Beller
2018-07-21 21:13           ` [PATCH 0/2] Re: [PATCH v3 14/20] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin
2018-05-03  1:01     ` [PATCH v3 15/20] range-diff: offer to dual-color the diffs Johannes Schindelin via GitGitGadget
2018-05-03  1:11     ` [PATCH v3 16/20] range-diff --dual-color: work around bogus white-space warning Johannes Schindelin via GitGitGadget
2018-07-09 19:34       ` Stefan Beller
2018-07-09 21:02         ` Junio C Hamano
2018-07-10 10:08           ` Johannes Schindelin
2018-07-10 15:50             ` Junio C Hamano
2018-07-10 16:32             ` Stefan Beller
2018-07-21 21:44               ` Johannes Schindelin
2018-05-03 13:50     ` [PATCH v3 17/20] range-diff: add a man page Johannes Schindelin via GitGitGadget
2018-07-09 18:20       ` Stefan Beller
2018-07-09 20:00         ` Johannes Schindelin
2018-07-09 20:25           ` Stefan Beller
2018-07-09 20:38             ` Johannes Schindelin
2018-07-16  8:01       ` Eric Sunshine
2018-07-17 16:39         ` Johannes Schindelin
2018-05-03 14:44     ` [PATCH v3 18/20] completion: support `git range-diff` Johannes Schindelin via GitGitGadget
2018-07-06 22:46       ` Junio C Hamano
2018-07-07 11:38         ` Johannes Schindelin
2018-05-05 19:52     ` [PATCH v3 19/20] range-diff: left-pad patch numbers Johannes Schindelin via GitGitGadget
2018-05-06 15:26     ` [PATCH v3 05/20] range-diff: also show the diff between patches Johannes Schindelin via GitGitGadget
2018-05-06 15:35     ` [PATCH v3 10/20] range-diff: do not show "function names" in hunk headers Johannes Schindelin via GitGitGadget
2018-06-30 20:41     ` [PATCH v3 20/20] range-diff: make --dual-color the default mode Johannes Schindelin via GitGitGadget
2018-07-16  8:06       ` Eric Sunshine
2018-07-17 16:40         ` Johannes Schindelin
2018-07-21 22:04     ` Johannes Schindelin via GitGitGadget [this message]
2018-07-21 22:04       ` [PATCH v4 01/21] linear-assignment: a function to solve least-cost assignment problems Johannes Schindelin via GitGitGadget
2018-07-28  8:46         ` Thomas Gummerer
2018-07-30 15:59           ` Johannes Schindelin
2018-07-21 22:04       ` [PATCH v4 02/21] Introduce `range-diff` to compare iterations of a topic branch Johannes Schindelin via GitGitGadget
2018-07-21 22:04       ` [PATCH v4 03/21] range-diff: first rudimentary implementation Johannes Schindelin via GitGitGadget
2018-07-29 18:36         ` Thomas Gummerer
2018-07-30 16:21           ` Johannes Schindelin
2018-07-30 21:16             ` Thomas Gummerer
2018-08-10 20:50               ` Johannes Schindelin
2018-07-21 22:04       ` [PATCH v4 04/21] range-diff: improve the order of the shown commits Johannes Schindelin via GitGitGadget
2018-07-21 22:04       ` [PATCH v4 05/21] range-diff: also show the diff between patches Johannes Schindelin via GitGitGadget
2018-07-29 19:03         ` Thomas Gummerer
2018-07-29 19:22           ` Eric Sunshine
2018-07-29 21:45             ` Thomas Gummerer
2018-07-30 16:28               ` Johannes Schindelin
2018-07-30 21:26                 ` Thomas Gummerer
2018-07-30 21:51                   ` Eric Sunshine
2018-08-10 21:12                     ` Johannes Schindelin
2018-08-10 21:31                       ` Eric Sunshine
2018-08-10 22:02                         ` Johannes Schindelin
2018-08-10 20:36                   ` Johannes Schindelin
2018-07-21 22:04       ` [PATCH v4 06/21] range-diff: right-trim commit messages Johannes Schindelin via GitGitGadget
2018-07-21 22:04       ` [PATCH v4 07/21] range-diff: indent the diffs just like tbdiff Johannes Schindelin via GitGitGadget
2018-07-21 22:04       ` [PATCH v4 08/21] range-diff: suppress the diff headers Johannes Schindelin via GitGitGadget
2018-07-21 22:04       ` [PATCH v4 09/21] range-diff: adjust the output of the commit pairs Johannes Schindelin via GitGitGadget
2018-07-29 19:38         ` Thomas Gummerer
2018-08-10 21:01           ` Johannes Schindelin
2018-07-29 21:28         ` Thomas Gummerer
2018-07-21 22:04       ` [PATCH v4 10/21] range-diff: do not show "function names" in hunk headers Johannes Schindelin via GitGitGadget
2018-07-29 20:52         ` Thomas Gummerer
2018-08-10 21:03           ` Johannes Schindelin
2018-07-21 22:05       ` [PATCH v4 11/21] range-diff: add tests Thomas Rast via GitGitGadget
2018-07-22  5:04         ` Eric Sunshine
2018-07-30 16:30           ` Johannes Schindelin
2018-07-30 20:18             ` Junio C Hamano
2018-07-30 23:40               ` Stefan Beller
2018-07-31 15:19                 ` Junio C Hamano
2018-07-23 21:25         ` Stefan Beller
2018-07-21 22:05       ` [PATCH v4 12/21] range-diff: use color for the commit pairs Johannes Schindelin via GitGitGadget
2018-07-21 22:05       ` [PATCH v4 13/21] color: add the meta color GIT_COLOR_REVERSE Johannes Schindelin via GitGitGadget
2018-07-21 22:05       ` [PATCH v4 14/21] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin via GitGitGadget
2018-07-23 22:27         ` Junio C Hamano
2018-07-23 22:48           ` Stefan Beller
2018-07-21 22:05       ` [PATCH v4 15/21] range-diff: offer to dual-color the diffs Johannes Schindelin via GitGitGadget
2018-07-21 22:05       ` [PATCH v4 16/21] range-diff --dual-color: fix bogus white-space warning Johannes Schindelin via GitGitGadget
2018-07-23 22:20         ` Stefan Beller
2018-08-10 21:05           ` Johannes Schindelin
2018-07-23 22:39         ` Junio C Hamano
2018-07-24  1:27           ` Junio C Hamano
2018-07-21 22:05       ` [PATCH v4 17/21] range-diff: populate the man page Johannes Schindelin via GitGitGadget
2018-07-29 21:23         ` Thomas Gummerer
2018-08-10 21:06           ` Johannes Schindelin
2018-07-21 22:05       ` [PATCH v4 18/21] completion: support `git range-diff` Johannes Schindelin via GitGitGadget
2018-07-22  5:49         ` Eric Sunshine
2018-08-10 20:24           ` Johannes Schindelin
2018-07-21 22:05       ` [PATCH v4 19/21] range-diff: left-pad patch numbers Johannes Schindelin via GitGitGadget
2018-07-21 22:05       ` [PATCH v4 20/21] range-diff: make --dual-color the default mode Johannes Schindelin via GitGitGadget
2018-07-29 21:33         ` Thomas Gummerer
2018-08-10 21:07           ` Johannes Schindelin
2018-07-21 22:05       ` [PATCH v4 21/21] range-diff: use dim/bold cues to improve dual color mode Johannes Schindelin via GitGitGadget
2018-07-23 21:03       ` [PATCH v4 00/21] Add `range-diff`, a `tbdiff` lookalike Stefan Beller
2018-07-23 21:49         ` Junio C Hamano
2018-07-25 17:44           ` Stefan Beller
2018-07-26  9:47         ` Johannes Schindelin
2018-08-08 13:05         ` Johannes Schindelin
2018-08-08 17:33           ` Stefan Beller
2018-08-10 21:18             ` Johannes Schindelin
2018-08-10 21:31               ` Junio C Hamano
2018-08-10 22:00                 ` Johannes Schindelin
2018-07-29 21:50       ` Thomas Gummerer
2018-08-10 22:14       ` [PATCH v5 00/21] Add range-diff, a tbdiff lookalike Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 01/21] linear-assignment: a function to solve least-cost assignment problems Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 02/21] Introduce `range-diff` to compare iterations of a topic branch Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 03/21] range-diff: first rudimentary implementation Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 04/21] range-diff: improve the order of the shown commits Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 05/21] range-diff: also show the diff between patches Johannes Schindelin via GitGitGadget
2018-08-12 21:47           ` Thomas Gummerer
2018-08-13  9:46             ` Johannes Schindelin
2018-08-13 18:01               ` Thomas Gummerer
2018-08-10 22:14         ` [PATCH v5 06/21] range-diff: right-trim commit messages Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 07/21] range-diff: indent the diffs just like tbdiff Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 08/21] range-diff: suppress the diff headers Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 09/21] range-diff: adjust the output of the commit pairs Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 10/21] range-diff: do not show "function names" in hunk headers Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 11/21] range-diff: add tests Thomas Rast via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 12/21] range-diff: use color for the commit pairs Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 13/21] color: add the meta color GIT_COLOR_REVERSE Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 14/21] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 15/21] range-diff: offer to dual-color the diffs Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 16/21] range-diff --dual-color: skip white-space warnings Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 17/21] range-diff: populate the man page Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 18/21] completion: support `git range-diff` Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 19/21] range-diff: left-pad patch numbers Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 20/21] range-diff: make --dual-color the default mode Johannes Schindelin via GitGitGadget
2018-08-10 22:14         ` [PATCH v5 21/21] range-diff: use dim/bold cues to improve dual color mode Johannes Schindelin via GitGitGadget
2018-08-13 11:32         ` [PATCH v6 00/21] Add range-diff, a tbdiff lookalike Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 01/21] linear-assignment: a function to solve least-cost assignment problems Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 02/21] Introduce `range-diff` to compare iterations of a topic branch Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 03/21] range-diff: first rudimentary implementation Johannes Schindelin via GitGitGadget
2019-03-05  6:29             ` Junio C Hamano
2018-08-13 11:33           ` [PATCH v6 04/21] range-diff: improve the order of the shown commits Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 05/21] range-diff: also show the diff between patches Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 06/21] range-diff: right-trim commit messages Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 07/21] range-diff: indent the diffs just like tbdiff Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 08/21] range-diff: suppress the diff headers Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 09/21] range-diff: adjust the output of the commit pairs Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 10/21] range-diff: do not show "function names" in hunk headers Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 11/21] range-diff: add tests Thomas Rast via GitGitGadget
2018-08-13 18:35             ` Thomas Gummerer
2018-08-14 14:53               ` Johannes Schindelin
2018-08-14 15:03                 ` Jeff King
2018-08-14 15:06                   ` Jeff King
2018-08-14 15:18                 ` Junio C Hamano
2018-08-13 11:33           ` [PATCH v6 12/21] range-diff: use color for the commit pairs Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 13/21] color: add the meta color GIT_COLOR_REVERSE Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 14/21] diff: add an internal option to dual-color diffs of diffs Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 15/21] range-diff: offer to dual-color the diffs Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 16/21] range-diff --dual-color: skip white-space warnings Johannes Schindelin via GitGitGadget
2018-08-13 17:48             ` Junio C Hamano
2018-08-13 11:33           ` [PATCH v6 17/21] range-diff: populate the man page Johannes Schindelin via GitGitGadget
2018-09-09 11:14             ` Ævar Arnfjörð Bjarmason
2018-09-09 16:54               ` SZEDER Gábor
2018-09-09 17:19                 ` Ævar Arnfjörð Bjarmason
2018-09-10 13:37                   ` Jeff King
2018-10-02 15:06                     ` Johannes Schindelin
2018-09-10 17:17                   ` Junio C Hamano
2018-08-13 11:33           ` [PATCH v6 18/21] completion: support `git range-diff` Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 19/21] range-diff: left-pad patch numbers Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 20/21] range-diff: make --dual-color the default mode Johannes Schindelin via GitGitGadget
2018-08-13 11:33           ` [PATCH v6 21/21] range-diff: use dim/bold cues to improve dual color mode Johannes Schindelin via GitGitGadget
2018-08-13 11:38           ` [PATCH v6 00/21] Add range-diff, a tbdiff lookalike Johannes Schindelin
2018-08-13 20:47             ` Thomas Gummerer
2018-05-21  4:48 ` [PATCH 00/18] Add `branch-diff`, a `tbdiff` lookalike Junio C Hamano
2018-05-21  9:51   ` Johannes Schindelin
2018-05-22  1:42     ` Junio C Hamano
2018-06-01  8:28       ` Johannes Schindelin

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: http://vger.kernel.org/majordomo-info.html

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=pull.1.v4.git.gitgitgadget@gmail.com \
    --to=gitgitgadget@gmail.com \
    --cc=git@vger.kernel.org \
    --cc=gitster@pobox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

git@vger.kernel.org list mirror (unofficial, one of many)

Archives are clonable:
	git clone --mirror https://public-inbox.org/git
	git clone --mirror http://ou63pmih66umazou.onion/git
	git clone --mirror http://czquwvybam4bgbro.onion/git
	git clone --mirror http://hjrcffqmbrq6wope.onion/git

Example config snippet for mirrors

Newsgroups are available over NNTP:
	nntp://news.public-inbox.org/inbox.comp.version-control.git
	nntp://ou63pmih66umazou.onion/inbox.comp.version-control.git
	nntp://czquwvybam4bgbro.onion/inbox.comp.version-control.git
	nntp://hjrcffqmbrq6wope.onion/inbox.comp.version-control.git
	nntp://news.gmane.org/gmane.comp.version-control.git

 note: .onion URLs require Tor: https://www.torproject.org/

AGPL code for this site: git clone https://public-inbox.org/ public-inbox