1GIT-RANGE-DIFF(1)                 Git Manual                 GIT-RANGE-DIFF(1)
2
3
4

NAME

6       git-range-diff - Compare two commit ranges (e.g. two versions of a
7       branch)
8

SYNOPSIS

10       git range-diff [--color=[<when>]] [--no-color] [<diff-options>]
11               [--no-dual-color] [--creation-factor=<factor>]
12               ( <range1> <range2> | <rev1>...<rev2> | <base> <rev1> <rev2> )
13

DESCRIPTION

15       This command shows the differences between two versions of a patch
16       series, or more generally, two commit ranges (ignoring merge commits).
17
18       To that end, it first finds pairs of commits from both commit ranges
19       that correspond with each other. Two commits are said to correspond
20       when the diff between their patches (i.e. the author information, the
21       commit message and the commit diff) is reasonably small compared to the
22       patches' size. See ``Algorithm`` below for details.
23
24       Finally, the list of matching commits is shown in the order of the
25       second commit range, with unmatched commits being inserted just after
26       all of their ancestors have been shown.
27

OPTIONS

29       --no-dual-color
30           When the commit diffs differ, git range-diff recreates the original
31           diffs' coloring, and adds outer -/+ diff markers with the
32           background being red/green to make it easier to see e.g. when there
33           was a change in what exact lines were added.
34
35           Additionally, the commit diff lines that are only present in the
36           first commit range are shown "dimmed" (this can be overridden using
37           the color.diff.<slot> config setting where <slot> is one of
38           contextDimmed, oldDimmed and newDimmed), and the commit diff lines
39           that are only present in the second commit range are shown in bold
40           (which can be overridden using the config settings
41           color.diff.<slot> with <slot> being one of contextBold, oldBold or
42           newBold).
43
44           This is known to range-diff as "dual coloring". Use --no-dual-color
45           to revert to color all lines according to the outer diff markers
46           (and completely ignore the inner diff when it comes to color).
47
48       --creation-factor=<percent>
49           Set the creation/deletion cost fudge factor to <percent>. Defaults
50           to 60. Try a larger value if git range-diff erroneously considers a
51           large change a total rewrite (deletion of one commit and addition
52           of another), and a smaller one in the reverse case. See the
53           ``Algorithm`` section below for an explanation why this is needed.
54
55       --[no-]notes[=<ref>]
56           This flag is passed to the git log program (see git-log(1)) that
57           generates the patches.
58
59       <range1> <range2>
60           Compare the commits specified by the two ranges, where <range1> is
61           considered an older version of <range2>.
62
63       <rev1>...<rev2>
64           Equivalent to passing <rev2>..<rev1> and <rev1>..<rev2>.
65
66       <base> <rev1> <rev2>
67           Equivalent to passing <base>..<rev1> and <base>..<rev2>. Note that
68           <base> does not need to be the exact branch point of the branches.
69           Example: after rebasing a branch my-topic, git range-diff
70           my-topic@{u} my-topic@{1} my-topic would show the differences
71           introduced by the rebase.
72
73       git range-diff also accepts the regular diff options (see git-diff(1)),
74       most notably the --color=[<when>] and --no-color options. These options
75       are used when generating the "diff between patches", i.e. to compare
76       the author, commit message and diff of corresponding old/new commits.
77       There is currently no means to tweak most of the diff options passed to
78       git log when generating those patches.
79

OUTPUT STABILITY

81       The output of the range-diff command is subject to change. It is
82       intended to be human-readable porcelain output, not something that can
83       be used across versions of Git to get a textually stable range-diff (as
84       opposed to something like the --stable option to git-patch-id(1)).
85       There’s also no equivalent of git-apply(1) for range-diff, the output
86       is not intended to be machine-readable.
87
88       This is particularly true when passing in diff options. Currently some
89       options like --stat can, as an emergent effect, produce output that’s
90       quite useless in the context of range-diff. Future versions of
91       range-diff may learn to interpret such options in a manner specific to
92       range-diff (e.g. for --stat producing human-readable output which
93       summarizes how the diffstat changed).
94

CONFIGURATION

96       This command uses the diff.color.* and pager.range-diff settings (the
97       latter is on by default). See git-config(1).
98

EXAMPLES

100       When a rebase required merge conflicts to be resolved, compare the
101       changes introduced by the rebase directly afterwards using:
102
103           $ git range-diff @{u} @{1} @
104
105       A typical output of git range-diff would look like this:
106
107           -:  ------- > 1:  0ddba11 Prepare for the inevitable!
108           1:  c0debee = 2:  cab005e Add a helpful message at the start
109           2:  f00dbal ! 3:  decafe1 Describe a bug
110               @@ -1,3 +1,3 @@
111                Author: A U Thor <author@example.com>
112
113               -TODO: Describe a bug
114               +Describe a bug
115               @@ -324,5 +324,6
116                 This is expected.
117
118               -+What is unexpected is that it will also crash.
119               ++Unexpectedly, it also crashes. This is a bug, and the jury is
120               ++still out there how to fix it best. See ticket #314 for details.
121
122                 Contact
123           3:  bedead < -:  ------- TO-UNDO
124
125       In this example, there are 3 old and 3 new commits, where the developer
126       removed the 3rd, added a new one before the first two, and modified the
127       commit message of the 2nd commit as well its diff.
128
129       When the output goes to a terminal, it is color-coded by default, just
130       like regular git diff's output. In addition, the first line (adding a
131       commit) is green, the last line (deleting a commit) is red, the second
132       line (with a perfect match) is yellow like the commit header of git
133       show's output, and the third line colors the old commit red, the new
134       one green and the rest like git show's commit header.
135
136       A naive color-coded diff of diffs is actually a bit hard to read,
137       though, as it colors the entire lines red or green. The line that added
138       "What is unexpected" in the old commit, for example, is completely red,
139       even if the intent of the old commit was to add something.
140
141       To help with that, range uses the --dual-color mode by default. In this
142       mode, the diff of diffs will retain the original diff colors, and
143       prefix the lines with -/+ markers that have their background red or
144       green, to make it more obvious that they describe how the diff itself
145       changed.
146

ALGORITHM

148       The general idea is this: we generate a cost matrix between the commits
149       in both commit ranges, then solve the least-cost assignment.
150
151       The cost matrix is populated thusly: for each pair of commits, both
152       diffs are generated and the "diff of diffs" is generated, with 3
153       context lines, then the number of lines in that diff is used as cost.
154
155       To avoid false positives (e.g. when a patch has been removed, and an
156       unrelated patch has been added between two iterations of the same patch
157       series), the cost matrix is extended to allow for that, by adding
158       fixed-cost entries for wholesale deletes/adds.
159
160       Example: 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 2,
162       and C is a cherry-pick of 1 but with a small modification (say, a fixed
163       typo). Visualize the commits as a bipartite graph:
164
165               1            A
166
167               2            B
168
169                            C
170
171       We are looking for a "best" explanation of the new series in terms of
172       the old one. We can represent an "explanation" as an edge in the graph:
173
174               1            A
175                          /
176               2 --------'  B
177
178                            C
179
180       This explanation comes for "free" because there was no change.
181       Similarly C could be explained using 1, but that comes at some cost c>0
182       because of the modification:
183
184               1 ----.      A
185                     |    /
186               2 ----+---'  B
187                     |
188                     `----- C
189                     c>0
190
191       In mathematical terms, what we are looking for is some sort of a
192       minimum cost bipartite matching; 1 is matched to C at some cost, etc.
193       The underlying graph is in fact a complete bipartite graph; the cost we
194       associate with every edge is the size of the diff between the two
195       commits' patches. To explain also new commits, we introduce dummy nodes
196       on both sides:
197
198               1 ----.      A
199                     |    /
200               2 ----+---'  B
201                     |
202               o     `----- C
203                     c>0
204               o            o
205
206               o            o
207
208       The cost of an edge o--C is the size of C's diff, modified by a fudge
209       factor that should be smaller than 100%. The cost of an edge o--o is
210       free. The fudge factor is necessary because even if 1 and C have
211       nothing in common, they may still share a few empty lines and such,
212       possibly making the assignment 1--C, o--o slightly cheaper than 1--o,
213       o--C even if 1 and C have nothing in common. With the fudge factor we
214       require a much larger common part to consider patches as corresponding.
215
216       The overall time needed to compute this algorithm is the time needed to
217       compute n+m commit diffs and then n*m diffs of patches, plus the time
218       needed to compute the least-cost assignment between n and m diffs. Git
219       uses an implementation of the Jonker-Volgenant algorithm to solve the
220       assignment problem, which has cubic runtime complexity. The matching
221       found in this case will look like this:
222
223               1 ----.      A
224                     |    /
225               2 ----+---'  B
226                  .--+-----'
227               o -'  `----- C
228                     c>0
229               o ---------- o
230
231               o ---------- o
232

SEE ALSO

234       git-log(1)
235

GIT

237       Part of the git(1) suite
238
239
240
241Git 2.30.2                        2021-03-08                 GIT-RANGE-DIFF(1)
Impressum