range-diff: use dim/bold cues to improve dual color mode
[git/git.git] / Documentation / git-range-diff.txt
CommitLineData
348ae56c
JS
1git-range-diff(1)
2=================
3
4NAME
5----
6git-range-diff - Compare two commit ranges (e.g. two versions of a branch)
7
ba931edd
JS
8SYNOPSIS
9--------
10[verse]
11'git range-diff' [--color=[<when>]] [--no-color] [<diff-options>]
27526793 12 [--no-dual-color] [--creation-factor=<factor>]
ba931edd
JS
13 ( <range1> <range2> | <rev1>...<rev2> | <base> <rev1> <rev2> )
14
15DESCRIPTION
16-----------
17
18This command shows the differences between two versions of a patch
19series, or more generally, two commit ranges (ignoring merge commits).
20
21To that end, it first finds pairs of commits from both commit ranges
22that correspond with each other. Two commits are said to correspond when
23the diff between their patches (i.e. the author information, the commit
24message and the commit diff) is reasonably small compared to the
25patches' size. See ``Algorithm`` below for details.
26
27Finally, the list of matching commits is shown in the order of the
28second commit range, with unmatched commits being inserted just after
29all of their ancestors have been shown.
30
31
32OPTIONS
33-------
27526793
JS
34--no-dual-color::
35 When the commit diffs differ, `git range-diff` recreates the
36 original diffs' coloring, and adds outer -/+ diff markers with
37 the *background* being red/green to make it easier to see e.g.
a7be92ac
JS
38 when there was a change in what exact lines were added.
39+
40Additionally, the commit diff lines that are only present in the first commit
41range are shown "dimmed" (this can be overridden using the `color.diff.<slot>`
42config setting where `<slot>` is one of `contextDimmed`, `oldDimmed` and
43`newDimmed`), and the commit diff lines that are only present in the second
44commit range are shown in bold (which can be overridden using the config
45settings `color.diff.<slot>` with `<slot>` being one of `contextBold`,
46`oldBold` or `newBold`).
47+
48This is known to `range-diff` as "dual coloring". Use `--no-dual-color`
49to revert to color all lines according to the outer diff markers
50(and completely ignore the inner diff when it comes to color).
ba931edd
JS
51
52--creation-factor=<percent>::
53 Set the creation/deletion cost fudge factor to `<percent>`.
54 Defaults to 60. Try a larger value if `git range-diff` erroneously
55 considers a large change a total rewrite (deletion of one commit
56 and addition of another), and a smaller one in the reverse case.
57 See the ``Algorithm`` section below for an explanation why this is
58 needed.
59
60<range1> <range2>::
61 Compare the commits specified by the two ranges, where
62 `<range1>` is considered an older version of `<range2>`.
63
64<rev1>...<rev2>::
65 Equivalent to passing `<rev2>..<rev1>` and `<rev1>..<rev2>`.
66
67<base> <rev1> <rev2>::
68 Equivalent to passing `<base>..<rev1>` and `<base>..<rev2>`.
69 Note that `<base>` does not need to be the exact branch point
70 of the branches. Example: after rebasing a branch `my-topic`,
71 `git range-diff my-topic@{u} my-topic@{1} my-topic` would
72 show the differences introduced by the rebase.
73
74`git range-diff` also accepts the regular diff options (see
75linkgit:git-diff[1]), most notably the `--color=[<when>]` and
76`--no-color` options. These options are used when generating the "diff
77between patches", i.e. to compare the author, commit message and diff of
78corresponding old/new commits. There is currently no means to tweak the
79diff options passed to `git log` when generating those patches.
80
81
82CONFIGURATION
83-------------
84This command uses the `diff.color.*` and `pager.range-diff` settings
85(the latter is on by default).
86See linkgit:git-config[1].
87
88
89EXAMPLES
90--------
91
92When a rebase required merge conflicts to be resolved, compare the changes
93introduced by the rebase directly afterwards using:
94
95------------
96$ git range-diff @{u} @{1} @
97------------
98
99
100A typical output of `git range-diff` would look like this:
101
102------------
103-: ------- > 1: 0ddba11 Prepare for the inevitable!
1041: c0debee = 2: cab005e Add a helpful message at the start
1052: f00dbal ! 3: decafe1 Describe a bug
106 @@ -1,3 +1,3 @@
107 Author: A U Thor <author@example.com>
108
109 -TODO: Describe a bug
110 +Describe a bug
111 @@ -324,5 +324,6
112 This is expected.
113
114 -+What is unexpected is that it will also crash.
115 ++Unexpectedly, it also crashes. This is a bug, and the jury is
116 ++still out there how to fix it best. See ticket #314 for details.
117
118 Contact
1193: bedead < -: ------- TO-UNDO
120------------
121
122In this example, there are 3 old and 3 new commits, where the developer
123removed the 3rd, added a new one before the first two, and modified the
124commit message of the 2nd commit as well its diff.
125
126When the output goes to a terminal, it is color-coded by default, just
127like regular `git diff`'s output. In addition, the first line (adding a
128commit) is green, the last line (deleting a commit) is red, the second
129line (with a perfect match) is yellow like the commit header of `git
130show`'s output, and the third line colors the old commit red, the new
131one green and the rest like `git show`'s commit header.
132
27526793
JS
133A naive color-coded diff of diffs is actually a bit hard to read,
134though, as it colors the entire lines red or green. The line that added
135"What is unexpected" in the old commit, for example, is completely red,
136even if the intent of the old commit was to add something.
ba931edd 137
27526793
JS
138To help with that, `range` uses the `--dual-color` mode by default. In
139this mode, the diff of diffs will retain the original diff colors, and
140prefix the lines with -/+ markers that have their *background* red or
141green, to make it more obvious that they describe how the diff itself
142changed.
ba931edd
JS
143
144
145Algorithm
146---------
147
148The general idea is this: we generate a cost matrix between the commits
149in both commit ranges, then solve the least-cost assignment.
150
151The cost matrix is populated thusly: for each pair of commits, both
152diffs are generated and the "diff of diffs" is generated, with 3 context
153lines, then the number of lines in that diff is used as cost.
154
155To avoid false positives (e.g. when a patch has been removed, and an
156unrelated patch has been added between two iterations of the same patch
157series), the cost matrix is extended to allow for that, by adding
158fixed-cost entries for wholesale deletes/adds.
159
160Example: Let commits `1--2` be the first iteration of a patch series and
161`A--C` the second iteration. Let's assume that `A` is a cherry-pick of
162`2,` and `C` is a cherry-pick of `1` but with a small modification (say,
163a fixed typo). Visualize the commits as a bipartite graph:
164
165------------
166 1 A
167
168 2 B
169
170 C
171------------
172
173We are looking for a "best" explanation of the new series in terms of
174the old one. We can represent an "explanation" as an edge in the graph:
175
176
177------------
178 1 A
179 /
180 2 --------' B
181
182 C
183------------
184
185This explanation comes for "free" because there was no change. Similarly
186`C` could be explained using `1`, but that comes at some cost c>0
187because of the modification:
188
189------------
190 1 ----. A
191 | /
192 2 ----+---' B
193 |
194 `----- C
195 c>0
196------------
197
198In mathematical terms, what we are looking for is some sort of a minimum
199cost bipartite matching; `1` is matched to `C` at some cost, etc. The
200underlying graph is in fact a complete bipartite graph; the cost we
201associate with every edge is the size of the diff between the two
202commits' patches. To explain also new commits, we introduce dummy nodes
203on both sides:
204
205------------
206 1 ----. A
207 | /
208 2 ----+---' B
209 |
210 o `----- C
211 c>0
212 o o
213
214 o o
215------------
216
217The cost of an edge `o--C` is the size of `C`'s diff, modified by a
218fudge factor that should be smaller than 100%. The cost of an edge
219`o--o` is free. The fudge factor is necessary because even if `1` and
220`C` have nothing in common, they may still share a few empty lines and
221such, possibly making the assignment `1--C`, `o--o` slightly cheaper
222than `1--o`, `o--C` even if `1` and `C` have nothing in common. With the
223fudge factor we require a much larger common part to consider patches as
224corresponding.
225
226The overall time needed to compute this algorithm is the time needed to
227compute n+m commit diffs and then n*m diffs of patches, plus the time
228needed to compute the least-cost assigment between n and m diffs. Git
229uses an implementation of the Jonker-Volgenant algorithm to solve the
230assignment problem, which has cubic runtime complexity. The matching
231found in this case will look like this:
232
233------------
234 1 ----. A
235 | /
236 2 ----+---' B
237 .--+-----'
238 o -' `----- C
239 c>0
240 o ---------- o
241
242 o ---------- o
243------------
244
245
246SEE ALSO
247--------
248linkgit:git-log[1]
249
348ae56c
JS
250GIT
251---
252Part of the linkgit:git[1] suite