1GIT-SHORTLOG(1)                   Git Manual                   GIT-SHORTLOG(1)
2
3
4

NAME

6       git-shortlog - Summarize 'git log' output
7

SYNOPSIS

9       git shortlog [<options>] [<revision-range>] [[--] <path>...]
10       git log --pretty=short | git shortlog [<options>]
11

DESCRIPTION

13       Summarizes git log output in a format suitable for inclusion in release
14       announcements. Each commit will be grouped by author and title.
15
16       Additionally, "[PATCH]" will be stripped from the commit description.
17
18       If no revisions are passed on the command line and either standard
19       input is not a terminal or there is no current branch, git shortlog
20       will output a summary of the log read from standard input, without
21       reference to the current repository.
22

OPTIONS

24       -n, --numbered
25           Sort output according to the number of commits per author instead
26           of author alphabetic order.
27
28       -s, --summary
29           Suppress commit description and provide a commit count summary
30           only.
31
32       -e, --email
33           Show the email address of each author.
34
35       --format[=<format>]
36           Instead of the commit subject, use some other information to
37           describe each commit.  <format> can be any string accepted by the
38           --format option of git log, such as * [%h] %s. (See the "PRETTY
39           FORMATS" section of git-log(1).)
40
41               Each pretty-printed commit will be rewrapped before it is shown.
42
43       --group=<type>
44           Group commits based on <type>. If no --group option is specified,
45           the default is author.  <type> is one of:
46
47author, commits are grouped by author
48
49committer, commits are grouped by committer (the same as -c)
50
51trailer:<field>, the <field> is interpreted as a
52               case-insensitive commit message trailer (see git-interpret-
53               trailers(1)). For example, if your project uses Reviewed-by
54               trailers, you might want to see who has been reviewing with git
55               shortlog -ns --group=trailer:reviewed-by.
56
57               Note that commits that do not include the trailer will not be
58               counted. Likewise, commits with multiple trailers (e.g.,
59               multiple signoffs) may be counted more than once (but only once
60               per unique trailer value in that commit).
61
62               Shortlog will attempt to parse each trailer value as a name
63               <email> identity. If successful, the mailmap is applied and the
64               email is omitted unless the --email option is specified. If the
65               value cannot be parsed as an identity, it will be taken
66               literally and completely.
67
68           If --group is specified multiple times, commits are counted under
69           each value (but again, only once per unique value in that commit).
70           For example, git shortlog --group=author
71           --group=trailer:co-authored-by counts both authors and co-authors.
72
73       -c, --committer
74           This is an alias for --group=committer.
75
76       -w[<width>[,<indent1>[,<indent2>]]]
77           Linewrap the output by wrapping each line at width. The first line
78           of each entry is indented by indent1 spaces, and the second and
79           subsequent lines are indented by indent2 spaces.  width, indent1,
80           and indent2 default to 76, 6 and 9 respectively.
81
82           If width is 0 (zero) then indent the lines of the output without
83           wrapping them.
84
85       <revision-range>
86           Show only commits in the specified revision range. When no
87           <revision-range> is specified, it defaults to HEAD (i.e. the whole
88           history leading to the current commit).  origin..HEAD specifies all
89           the commits reachable from the current commit (i.e.  HEAD), but not
90           from origin. For a complete list of ways to spell <revision-range>,
91           see the "Specifying Ranges" section of gitrevisions(7).
92
93       [--] <path>...
94           Consider only commits that are enough to explain how the files that
95           match the specified paths came to be.
96
97           Paths may need to be prefixed with -- to separate them from options
98           or the revision range, when confusion arises.
99
100   Commit Limiting
101       Besides specifying a range of commits that should be listed using the
102       special notations explained in the description, additional commit
103       limiting may be applied.
104
105       Using more options generally further limits the output (e.g.
106       --since=<date1> limits to commits newer than <date1>, and using it with
107       --grep=<pattern> further limits to commits whose log message has a line
108       that matches <pattern>), unless otherwise noted.
109
110       Note that these are applied before commit ordering and formatting
111       options, such as --reverse.
112
113       -<number>, -n <number>, --max-count=<number>
114           Limit the number of commits to output.
115
116       --skip=<number>
117           Skip number commits before starting to show the commit output.
118
119       --since=<date>, --after=<date>
120           Show commits more recent than a specific date.
121
122       --until=<date>, --before=<date>
123           Show commits older than a specific date.
124
125       --author=<pattern>, --committer=<pattern>
126           Limit the commits output to ones with author/committer header lines
127           that match the specified pattern (regular expression). With more
128           than one --author=<pattern>, commits whose author matches any of
129           the given patterns are chosen (similarly for multiple
130           --committer=<pattern>).
131
132       --grep-reflog=<pattern>
133           Limit the commits output to ones with reflog entries that match the
134           specified pattern (regular expression). With more than one
135           --grep-reflog, commits whose reflog message matches any of the
136           given patterns are chosen. It is an error to use this option unless
137           --walk-reflogs is in use.
138
139       --grep=<pattern>
140           Limit the commits output to ones with log message that matches the
141           specified pattern (regular expression). With more than one
142           --grep=<pattern>, commits whose message matches any of the given
143           patterns are chosen (but see --all-match).
144
145           When --notes is in effect, the message from the notes is matched as
146           if it were part of the log message.
147
148       --all-match
149           Limit the commits output to ones that match all given --grep,
150           instead of ones that match at least one.
151
152       --invert-grep
153           Limit the commits output to ones with log message that do not match
154           the pattern specified with --grep=<pattern>.
155
156       -i, --regexp-ignore-case
157           Match the regular expression limiting patterns without regard to
158           letter case.
159
160       --basic-regexp
161           Consider the limiting patterns to be basic regular expressions;
162           this is the default.
163
164       -E, --extended-regexp
165           Consider the limiting patterns to be extended regular expressions
166           instead of the default basic regular expressions.
167
168       -F, --fixed-strings
169           Consider the limiting patterns to be fixed strings (don’t interpret
170           pattern as a regular expression).
171
172       -P, --perl-regexp
173           Consider the limiting patterns to be Perl-compatible regular
174           expressions.
175
176           Support for these types of regular expressions is an optional
177           compile-time dependency. If Git wasn’t compiled with support for
178           them providing this option will cause it to die.
179
180       --remove-empty
181           Stop when a given path disappears from the tree.
182
183       --merges
184           Print only merge commits. This is exactly the same as
185           --min-parents=2.
186
187       --no-merges
188           Do not print commits with more than one parent. This is exactly the
189           same as --max-parents=1.
190
191       --min-parents=<number>, --max-parents=<number>, --no-min-parents,
192       --no-max-parents
193           Show only commits which have at least (or at most) that many parent
194           commits. In particular, --max-parents=1 is the same as --no-merges,
195           --min-parents=2 is the same as --merges.  --max-parents=0 gives all
196           root commits and --min-parents=3 all octopus merges.
197
198           --no-min-parents and --no-max-parents reset these limits (to no
199           limit) again. Equivalent forms are --min-parents=0 (any commit has
200           0 or more parents) and --max-parents=-1 (negative numbers denote no
201           upper limit).
202
203       --first-parent
204           When finding commits to include, follow only the first parent
205           commit upon seeing a merge commit. This option can give a better
206           overview when viewing the evolution of a particular topic branch,
207           because merges into a topic branch tend to be only about adjusting
208           to updated upstream from time to time, and this option allows you
209           to ignore the individual commits brought in to your history by such
210           a merge.
211
212       --exclude-first-parent-only
213           When finding commits to exclude (with a ^), follow only the first
214           parent commit upon seeing a merge commit. This can be used to find
215           the set of changes in a topic branch from the point where it
216           diverged from the remote branch, given that arbitrary merges can be
217           valid topic branch changes.
218
219       --not
220           Reverses the meaning of the ^ prefix (or lack thereof) for all
221           following revision specifiers, up to the next --not.
222
223       --all
224           Pretend as if all the refs in refs/, along with HEAD, are listed on
225           the command line as <commit>.
226
227       --branches[=<pattern>]
228           Pretend as if all the refs in refs/heads are listed on the command
229           line as <commit>. If <pattern> is given, limit branches to ones
230           matching given shell glob. If pattern lacks ?, *, or [, /* at the
231           end is implied.
232
233       --tags[=<pattern>]
234           Pretend as if all the refs in refs/tags are listed on the command
235           line as <commit>. If <pattern> is given, limit tags to ones
236           matching given shell glob. If pattern lacks ?, *, or [, /* at the
237           end is implied.
238
239       --remotes[=<pattern>]
240           Pretend as if all the refs in refs/remotes are listed on the
241           command line as <commit>. If <pattern> is given, limit
242           remote-tracking branches to ones matching given shell glob. If
243           pattern lacks ?, *, or [, /* at the end is implied.
244
245       --glob=<glob-pattern>
246           Pretend as if all the refs matching shell glob <glob-pattern> are
247           listed on the command line as <commit>. Leading refs/, is
248           automatically prepended if missing. If pattern lacks ?, *, or [, /*
249           at the end is implied.
250
251       --exclude=<glob-pattern>
252           Do not include refs matching <glob-pattern> that the next --all,
253           --branches, --tags, --remotes, or --glob would otherwise consider.
254           Repetitions of this option accumulate exclusion patterns up to the
255           next --all, --branches, --tags, --remotes, or --glob option (other
256           options or arguments do not clear accumulated patterns).
257
258           The patterns given should not begin with refs/heads, refs/tags, or
259           refs/remotes when applied to --branches, --tags, or --remotes,
260           respectively, and they must begin with refs/ when applied to --glob
261           or --all. If a trailing /* is intended, it must be given
262           explicitly.
263
264       --reflog
265           Pretend as if all objects mentioned by reflogs are listed on the
266           command line as <commit>.
267
268       --alternate-refs
269           Pretend as if all objects mentioned as ref tips of alternate
270           repositories were listed on the command line. An alternate
271           repository is any repository whose object directory is specified in
272           objects/info/alternates. The set of included objects may be
273           modified by core.alternateRefsCommand, etc. See git-config(1).
274
275       --single-worktree
276           By default, all working trees will be examined by the following
277           options when there are more than one (see git-worktree(1)): --all,
278           --reflog and --indexed-objects. This option forces them to examine
279           the current working tree only.
280
281       --ignore-missing
282           Upon seeing an invalid object name in the input, pretend as if the
283           bad input was not given.
284
285       --bisect
286           Pretend as if the bad bisection ref refs/bisect/bad was listed and
287           as if it was followed by --not and the good bisection refs
288           refs/bisect/good-* on the command line.
289
290       --stdin
291           In addition to the <commit> listed on the command line, read them
292           from the standard input. If a -- separator is seen, stop reading
293           commits and start reading paths to limit the result.
294
295       --cherry-mark
296           Like --cherry-pick (see below) but mark equivalent commits with =
297           rather than omitting them, and inequivalent ones with +.
298
299       --cherry-pick
300           Omit any commit that introduces the same change as another commit
301           on the “other side” when the set of commits are limited with
302           symmetric difference.
303
304           For example, if you have two branches, A and B, a usual way to list
305           all commits on only one side of them is with --left-right (see the
306           example below in the description of the --left-right option).
307           However, it shows the commits that were cherry-picked from the
308           other branch (for example, “3rd on b” may be cherry-picked from
309           branch A). With this option, such pairs of commits are excluded
310           from the output.
311
312       --left-only, --right-only
313           List only commits on the respective side of a symmetric difference,
314           i.e. only those which would be marked < resp.  > by --left-right.
315
316           For example, --cherry-pick --right-only A...B omits those commits
317           from B which are in A or are patch-equivalent to a commit in A. In
318           other words, this lists the + commits from git cherry A B. More
319           precisely, --cherry-pick --right-only --no-merges gives the exact
320           list.
321
322       --cherry
323           A synonym for --right-only --cherry-mark --no-merges; useful to
324           limit the output to the commits on our side and mark those that
325           have been applied to the other side of a forked history with git
326           log --cherry upstream...mybranch, similar to git cherry upstream
327           mybranch.
328
329       -g, --walk-reflogs
330           Instead of walking the commit ancestry chain, walk reflog entries
331           from the most recent one to older ones. When this option is used
332           you cannot specify commits to exclude (that is, ^commit,
333           commit1..commit2, and commit1...commit2 notations cannot be used).
334
335           With --pretty format other than oneline and reference (for obvious
336           reasons), this causes the output to have two extra lines of
337           information taken from the reflog. The reflog designator in the
338           output may be shown as ref@{Nth} (where Nth is the
339           reverse-chronological index in the reflog) or as ref@{timestamp}
340           (with the timestamp for that entry), depending on a few rules:
341
342            1. If the starting point is specified as ref@{Nth}, show the index
343               format.
344
345            2. If the starting point was specified as ref@{now}, show the
346               timestamp format.
347
348            3. If neither was used, but --date was given on the command line,
349               show the timestamp in the format requested by --date.
350
351            4. Otherwise, show the index format.
352
353           Under --pretty=oneline, the commit message is prefixed with this
354           information on the same line. This option cannot be combined with
355           --reverse. See also git-reflog(1).
356
357           Under --pretty=reference, this information will not be shown at
358           all.
359
360       --merge
361           After a failed merge, show refs that touch files having a conflict
362           and don’t exist on all heads to merge.
363
364       --boundary
365           Output excluded boundary commits. Boundary commits are prefixed
366           with -.
367
368   History Simplification
369       Sometimes you are only interested in parts of the history, for example
370       the commits modifying a particular <path>. But there are two parts of
371       History Simplification, one part is selecting the commits and the other
372       is how to do it, as there are various strategies to simplify the
373       history.
374
375       The following options select the commits to be shown:
376
377       <paths>
378           Commits modifying the given <paths> are selected.
379
380       --simplify-by-decoration
381           Commits that are referred by some branch or tag are selected.
382
383       Note that extra commits can be shown to give a meaningful history.
384
385       The following options affect the way the simplification is performed:
386
387       Default mode
388           Simplifies the history to the simplest history explaining the final
389           state of the tree. Simplest because it prunes some side branches if
390           the end result is the same (i.e. merging branches with the same
391           content)
392
393       --show-pulls
394           Include all commits from the default mode, but also any merge
395           commits that are not TREESAME to the first parent but are TREESAME
396           to a later parent. This mode is helpful for showing the merge
397           commits that "first introduced" a change to a branch.
398
399       --full-history
400           Same as the default mode, but does not prune some history.
401
402       --dense
403           Only the selected commits are shown, plus some to have a meaningful
404           history.
405
406       --sparse
407           All commits in the simplified history are shown.
408
409       --simplify-merges
410           Additional option to --full-history to remove some needless merges
411           from the resulting history, as there are no selected commits
412           contributing to this merge.
413
414       --ancestry-path
415           When given a range of commits to display (e.g.  commit1..commit2 or
416           commit2 ^commit1), only display commits that exist directly on the
417           ancestry chain between the commit1 and commit2, i.e. commits that
418           are both descendants of commit1, and ancestors of commit2.
419
420       A more detailed explanation follows.
421
422       Suppose you specified foo as the <paths>. We shall call commits that
423       modify foo !TREESAME, and the rest TREESAME. (In a diff filtered for
424       foo, they look different and equal, respectively.)
425
426       In the following, we will always refer to the same example history to
427       illustrate the differences between simplification settings. We assume
428       that you are filtering for a file foo in this commit graph:
429
430                     .-A---M---N---O---P---Q
431                    /     /   /   /   /   /
432                   I     B   C   D   E   Y
433                    \   /   /   /   /   /
434                     `-------------'   X
435
436       The horizontal line of history A---Q is taken to be the first parent of
437       each merge. The commits are:
438
439I is the initial commit, in which foo exists with contents “asdf”,
440           and a file quux exists with contents “quux”. Initial commits are
441           compared to an empty tree, so I is !TREESAME.
442
443       •   In A, foo contains just “foo”.
444
445B contains the same change as A. Its merge M is trivial and hence
446           TREESAME to all parents.
447
448C does not change foo, but its merge N changes it to “foobar”, so
449           it is not TREESAME to any parent.
450
451D sets foo to “baz”. Its merge O combines the strings from N and D
452           to “foobarbaz”; i.e., it is not TREESAME to any parent.
453
454E changes quux to “xyzzy”, and its merge P combines the strings to
455           “quux xyzzy”.  P is TREESAME to O, but not to E.
456
457X is an independent root commit that added a new file side, and Y
458           modified it.  Y is TREESAME to X. Its merge Q added side to P, and
459           Q is TREESAME to P, but not to Y.
460
461       rev-list walks backwards through history, including or excluding
462       commits based on whether --full-history and/or parent rewriting (via
463       --parents or --children) are used. The following settings are
464       available.
465
466       Default mode
467           Commits are included if they are not TREESAME to any parent (though
468           this can be changed, see --sparse below). If the commit was a
469           merge, and it was TREESAME to one parent, follow only that parent.
470           (Even if there are several TREESAME parents, follow only one of
471           them.) Otherwise, follow all parents.
472
473           This results in:
474
475                         .-A---N---O
476                        /     /   /
477                       I---------D
478
479           Note how the rule to only follow the TREESAME parent, if one is
480           available, removed B from consideration entirely.  C was considered
481           via N, but is TREESAME. Root commits are compared to an empty tree,
482           so I is !TREESAME.
483
484           Parent/child relations are only visible with --parents, but that
485           does not affect the commits selected in default mode, so we have
486           shown the parent lines.
487
488       --full-history without parent rewriting
489           This mode differs from the default in one point: always follow all
490           parents of a merge, even if it is TREESAME to one of them. Even if
491           more than one side of the merge has commits that are included, this
492           does not imply that the merge itself is! In the example, we get
493
494                       I  A  B  N  D  O  P  Q
495
496           M was excluded because it is TREESAME to both parents.  E, C and B
497           were all walked, but only B was !TREESAME, so the others do not
498           appear.
499
500           Note that without parent rewriting, it is not really possible to
501           talk about the parent/child relationships between the commits, so
502           we show them disconnected.
503
504       --full-history with parent rewriting
505           Ordinary commits are only included if they are !TREESAME (though
506           this can be changed, see --sparse below).
507
508           Merges are always included. However, their parent list is
509           rewritten: Along each parent, prune away commits that are not
510           included themselves. This results in
511
512                         .-A---M---N---O---P---Q
513                        /     /   /   /   /
514                       I     B   /   D   /
515                        \   /   /   /   /
516                         `-------------'
517
518           Compare to --full-history without rewriting above. Note that E was
519           pruned away because it is TREESAME, but the parent list of P was
520           rewritten to contain E's parent I. The same happened for C and N,
521           and X, Y and Q.
522
523       In addition to the above settings, you can change whether TREESAME
524       affects inclusion:
525
526       --dense
527           Commits that are walked are included if they are not TREESAME to
528           any parent.
529
530       --sparse
531           All commits that are walked are included.
532
533           Note that without --full-history, this still simplifies merges: if
534           one of the parents is TREESAME, we follow only that one, so the
535           other sides of the merge are never walked.
536
537       --simplify-merges
538           First, build a history graph in the same way that --full-history
539           with parent rewriting does (see above).
540
541           Then simplify each commit C to its replacement C' in the final
542           history according to the following rules:
543
544           •   Set C' to C.
545
546           •   Replace each parent P of C' with its simplification P'. In the
547               process, drop parents that are ancestors of other parents or
548               that are root commits TREESAME to an empty tree, and remove
549               duplicates, but take care to never drop all parents that we are
550               TREESAME to.
551
552           •   If after this parent rewriting, C' is a root or merge commit
553               (has zero or >1 parents), a boundary commit, or !TREESAME, it
554               remains. Otherwise, it is replaced with its only parent.
555
556           The effect of this is best shown by way of comparing to
557           --full-history with parent rewriting. The example turns into:
558
559                         .-A---M---N---O
560                        /     /       /
561                       I     B       D
562                        \   /       /
563                         `---------'
564
565           Note the major differences in N, P, and Q over --full-history:
566
567N's parent list had I removed, because it is an ancestor of the
568               other parent M. Still, N remained because it is !TREESAME.
569
570P's parent list similarly had I removed.  P was then removed
571               completely, because it had one parent and is TREESAME.
572
573Q's parent list had Y simplified to X.  X was then removed,
574               because it was a TREESAME root.  Q was then removed completely,
575               because it had one parent and is TREESAME.
576
577       There is another simplification mode available:
578
579       --ancestry-path
580           Limit the displayed commits to those directly on the ancestry chain
581           between the “from” and “to” commits in the given commit range. I.e.
582           only display commits that are ancestor of the “to” commit and
583           descendants of the “from” commit.
584
585           As an example use case, consider the following commit history:
586
587                           D---E-------F
588                          /     \       \
589                         B---C---G---H---I---J
590                        /                     \
591                       A-------K---------------L--M
592
593           A regular D..M computes the set of commits that are ancestors of M,
594           but excludes the ones that are ancestors of D. This is useful to
595           see what happened to the history leading to M since D, in the sense
596           that “what does M have that did not exist in D”. The result in this
597           example would be all the commits, except A and B (and D itself, of
598           course).
599
600           When we want to find out what commits in M are contaminated with
601           the bug introduced by D and need fixing, however, we might want to
602           view only the subset of D..M that are actually descendants of D,
603           i.e. excluding C and K. This is exactly what the --ancestry-path
604           option does. Applied to the D..M range, it results in:
605
606                               E-------F
607                                \       \
608                                 G---H---I---J
609                                              \
610                                               L--M
611
612       Before discussing another option, --show-pulls, we need to create a new
613       example history.
614
615       A common problem users face when looking at simplified history is that
616       a commit they know changed a file somehow does not appear in the file’s
617       simplified history. Let’s demonstrate a new example and show how
618       options such as --full-history and --simplify-merges works in that
619       case:
620
621                     .-A---M-----C--N---O---P
622                    /     / \  \  \/   /   /
623                   I     B   \  R-'`-Z'   /
624                    \   /     \/         /
625                     \ /      /\        /
626                      `---X--'  `---Y--'
627
628       For this example, suppose I created file.txt which was modified by A,
629       B, and X in different ways. The single-parent commits C, Z, and Y do
630       not change file.txt. The merge commit M was created by resolving the
631       merge conflict to include both changes from A and B and hence is not
632       TREESAME to either. The merge commit R, however, was created by
633       ignoring the contents of file.txt at M and taking only the contents of
634       file.txt at X. Hence, R is TREESAME to X but not M. Finally, the
635       natural merge resolution to create N is to take the contents of
636       file.txt at R, so N is TREESAME to R but not C. The merge commits O and
637       P are TREESAME to their first parents, but not to their second parents,
638       Z and Y respectively.
639
640       When using the default mode, N and R both have a TREESAME parent, so
641       those edges are walked and the others are ignored. The resulting
642       history graph is:
643
644                   I---X
645
646       When using --full-history, Git walks every edge. This will discover the
647       commits A and B and the merge M, but also will reveal the merge commits
648       O and P. With parent rewriting, the resulting graph is:
649
650                     .-A---M--------N---O---P
651                    /     / \  \  \/   /   /
652                   I     B   \  R-'`--'   /
653                    \   /     \/         /
654                     \ /      /\        /
655                      `---X--'  `------'
656
657       Here, the merge commits O and P contribute extra noise, as they did not
658       actually contribute a change to file.txt. They only merged a topic that
659       was based on an older version of file.txt. This is a common issue in
660       repositories using a workflow where many contributors work in parallel
661       and merge their topic branches along a single trunk: manu unrelated
662       merges appear in the --full-history results.
663
664       When using the --simplify-merges option, the commits O and P disappear
665       from the results. This is because the rewritten second parents of O and
666       P are reachable from their first parents. Those edges are removed and
667       then the commits look like single-parent commits that are TREESAME to
668       their parent. This also happens to the commit N, resulting in a history
669       view as follows:
670
671                     .-A---M--.
672                    /     /    \
673                   I     B      R
674                    \   /      /
675                     \ /      /
676                      `---X--'
677
678       In this view, we see all of the important single-parent changes from A,
679       B, and X. We also see the carefully-resolved merge M and the
680       not-so-carefully-resolved merge R. This is usually enough information
681       to determine why the commits A and B "disappeared" from history in the
682       default view. However, there are a few issues with this approach.
683
684       The first issue is performance. Unlike any previous option, the
685       --simplify-merges option requires walking the entire commit history
686       before returning a single result. This can make the option difficult to
687       use for very large repositories.
688
689       The second issue is one of auditing. When many contributors are working
690       on the same repository, it is important which merge commits introduced
691       a change into an important branch. The problematic merge R above is not
692       likely to be the merge commit that was used to merge into an important
693       branch. Instead, the merge N was used to merge R and X into the
694       important branch. This commit may have information about why the change
695       X came to override the changes from A and B in its commit message.
696
697       --show-pulls
698           In addition to the commits shown in the default history, show each
699           merge commit that is not TREESAME to its first parent but is
700           TREESAME to a later parent.
701
702           When a merge commit is included by --show-pulls, the merge is
703           treated as if it "pulled" the change from another branch. When
704           using --show-pulls on this example (and no other options) the
705           resulting graph is:
706
707                       I---X---R---N
708
709           Here, the merge commits R and N are included because they pulled
710           the commits X and R into the base branch, respectively. These
711           merges are the reason the commits A and B do not appear in the
712           default history.
713
714           When --show-pulls is paired with --simplify-merges, the graph
715           includes all of the necessary information:
716
717                         .-A---M--.   N
718                        /     /    \ /
719                       I     B      R
720                        \   /      /
721                         \ /      /
722                          `---X--'
723
724           Notice that since M is reachable from R, the edge from N to M was
725           simplified away. However, N still appears in the history as an
726           important commit because it "pulled" the change R into the main
727           branch.
728
729       The --simplify-by-decoration option allows you to view only the big
730       picture of the topology of the history, by omitting commits that are
731       not referenced by tags. Commits are marked as !TREESAME (in other
732       words, kept after history simplification rules described above) if (1)
733       they are referenced by tags, or (2) they change the contents of the
734       paths given on the command line. All other commits are marked as
735       TREESAME (subject to be simplified away).
736

MAPPING AUTHORS

738       See gitmailmap(5).
739
740       Note that if git shortlog is run outside of a repository (to process
741       log contents on standard input), it will look for a .mailmap file in
742       the current directory.
743

GIT

745       Part of the git(1) suite
746
747
748
749Git 2.36.1                        2022-05-05                   GIT-SHORTLOG(1)
Impressum