Toll Free Numbers
  • Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads
  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           git rev-list [ --max-count=number ]
                        [ --skip=number ]
                        [ --max-age=timestamp ]
                        [ --min-age=timestamp ]
                        [ --sparse ]
                        [ --merges ]
                        [ --no-merges ]
                        [ --first-parent ]
                        [ --remove-empty ]
                        [ --full-history ]
                        [ --not ]
                        [ --all ]
                        [ --branches[=pattern] ]
                        [ --tags[=pattern] ]
                        [ --remotes[=pattern] ]
                        [ --glob=glob-pattern ]
                        [ --stdin ]
                        [ --quiet ]
                        [ --topo-order ]
                        [ --parents ]
                        [ --timestamp ]
                        [ --left-right ]
                        [ --cherry-pick ]
                        [ --encoding[=<encoding>] ]
                        [ --(author|committer|grep)=<pattern> ]
                        [ --regexp-ignore-case | -i ]
                        [ --extended-regexp | -E ]
                        [ --fixed-strings | -F ]
                        [ --date={local|relative|default|iso|rfc|short} ]
                        [ [--objects | --objects-edge] [ --unpacked ] ]
                        [ --pretty | --header ]
                        [ --bisect ]
                        [ --bisect-vars ]
                        [ --bisect-all ]
                        [ --merge ]
                        [ --reverse ]
                        [ --walk-reflogs ]
                        [ --no-walk ] [ --do-walk ]
                        <commit>... [ -- <paths>... ]


           List commits that are reachable by following the parent links from the
           given commit(s), but exclude commits that are reachable from the one(s)
           given with a ^ in front of them. The output is given in reverse
           chronological order by default.
           You can think of this as a set operation. Commits given on the command
           line form a set of commits that are reachable from any of them, and
           then commits reachable from any of the ones given with ^ in front are
           subtracted from that set. The remaining commits are what comes out in
                       $ git rev-list origin..HEAD
                       $ git rev-list HEAD ^origin
           Another special notation is "<commit1>...<commit2>" which is useful for
           merges. The resulting set of commits is the symmetric difference
           between the two operands. The following two commands are equivalent:
                       $ git rev-list A B --not $(git merge-base --all A B)
                       $ git rev-list A...B
           rev-list is a very essential git command, since it provides the ability
           to build and traverse commit ancestry graphs. For this reason, it has a
           lot of different options that enables it to be used by commands as
           different as git bisect and git repack.


       Commit Formatting
           Using these options, git-rev-list(1) will act similar to the more
           specialized family of commit log tools: git-log(1), git-show(1), and
           --pretty[=<format>], --format[=<format>]
               Pretty-print the contents of the commit logs in a given format,
               where <format> can be one of oneline, short, medium, full, fuller,
               email, raw and format:<string>. When omitted, the format defaults
               to medium.
               Note: you can specify the default pretty format in the repository
               configuration (see git-config(1)).
               Instead of showing the full 40-byte hexadecimal commit object name,
               show only a partial prefix. Non default number of digits can be
               specified with "--abbrev=<n>" (which also modifies diff output, if
               it is displayed).
               This should make "--pretty=oneline" a whole lot more readable for
               people using 80-column terminals.
               This is a shorthand for "--pretty=oneline --abbrev-commit" used
               The commit objects record the encoding used for the log message in
               their encoding header; this option can be used to tell the command
               to re-code the commit log message in the encoding preferred by the
               user. For non plumbing commands this defaults to UTF-8.
               Synonym for --date=relative.
               Only takes effect for dates shown in human-readable format, such as
               when using "--pretty". config variable sets a default
               value for log command's --date option.
               --date=relative shows dates relative to the current time, e.g. "2
               hours ago".
               --date=local shows timestamps in user's local timezone.
               --date=iso (or --date=iso8601) shows timestamps in ISO 8601 format.
               --date=rfc (or --date=rfc2822) shows timestamps in RFC 2822 format,
               often found in E-mail messages.
               --date=short shows only date but not time, in YYYY-MM-DD format.
               --date=raw shows the date in the internal raw git format %s %z
               --date=default shows timestamps in the original timezone (either
               committer's or author's).
               Print the contents of the commit in raw-format; each record is
               separated with a NUL character.
               Print the parents of the commit. Also enables parent rewriting, see
               History Simplification below.
               Print the children of the commit. Also enables parent rewriting,
               see History Simplification below.
               Print the raw commit timestamp.
               Mark which side of a symmetric diff a commit is reachable from.
               Commits from the left side are prefixed with < and those from the
               right with >. If combined with --boundary, those commits are
               prefixed with -.
               For example, if you have this topology:
                                y---b---b  branch B
                               / \ /
                              /   .
               Draw a text-based graphical representation of the commit history on
               the left hand side of the output. This may cause extra lines to be
               printed in between commits, in order for the graph history to be
               drawn properly.
               This implies the --topo-order option by default, but the
               --date-order option may also be specified.
       Commit Limiting
           Besides specifying a range of commits that should be listed using the
           special notations explained in the description, additional commit
           limiting may be applied.
           -n number, --max-count=<number>
               Limit the number of commits output.
               Skip number commits before starting to show the commit output.
           --since=<date>, --after=<date>
               Show commits more recent than a specific date.
           --until=<date>, --before=<date>
               Show commits older than a specific date.
           --max-age=<timestamp>, --min-age=<timestamp>
               Limit the commits output to specified time range.
           --author=<pattern>, --committer=<pattern>
               Limit the commits output to ones with author/committer header lines
               that match the specified pattern (regular expression).
               Limit the commits output to ones with log message that matches the
               specified pattern (regular expression).
               Limit the commits output to ones that match all given --grep,
               --author and --committer instead of ones that match at least one.
           -i, --regexp-ignore-case
               Match the regexp limiting patterns without regard to letters case.
           -E, --extended-regexp
               Consider the limiting patterns to be extended regular expressions
               instead of the default basic regular expressions.
           -F, --fixed-strings
               Consider the limiting patterns to be fixed strings (don't interpret
               pattern as a regular expression).
               tend to be only about adjusting to updated upstream from time to
               time, and this option allows you to ignore the individual commits
               brought in to your history by such a merge.
               Reverses the meaning of the ^ prefix (or lack thereof) for all
               following revision specifiers, up to the next --not.
               Pretend as if all the refs in refs/ are listed on the command line
               as <commit>.
               Pretend as if all the refs in refs/heads are listed on the command
               line as <commit>. If pattern is given, limit branches to ones
               matching given shell glob. If pattern lacks ?, , or [, / at the end
               is implied.
               Pretend as if all the refs in refs/tags are listed on the command
               line as <commit>. If pattern is given, limit tags to ones matching
               given shell glob. If pattern lacks ?, , or [, / at the end is
               Pretend as if all the refs in refs/remotes are listed on the
               command line as <commit>. If 'pattern'is given, limit remote
               tracking branches to ones matching given shell glob. If pattern
               lacks ?, , or [, / at the end is implied.
               Pretend as if all the refs matching shell glob glob-pattern are
               listed on the command line as <commit>. Leading refs/, is
               automatically prepended if missing. If pattern lacks ?, , or [, /
               at the end is implied.
               In addition to the <commit> listed on the command line, read them
               from the standard input. If a -- separator is seen, stop reading
               commits and start reading paths to limit the result.
               Don't print anything to standard output. This form is primarily
               meant to allow the caller to test the exit status to see if a range
               of objects is fully connected (or not). It is faster than
               redirecting stdout to /dev/null as the output does not have to be
               Omit any commit that introduces the same change as another commit
               on the "other side" when the set of commits are limited with
               symmetric difference.
               With --pretty format other than oneline (for obvious reasons), this
               causes the output to have two extra lines of information taken from
               the reflog. By default, commit@{Nth} notation is used in the
               output. When the starting commit is specified as commit@{now},
               output also uses commit@{timestamp} notation instead. Under
               --pretty=oneline, the commit message is prefixed with this
               information on the same line. This option cannot be combined with
               --reverse. See also git-reflog(1).
               After a failed merge, show refs that touch files having a conflict
               and don't exist on all heads to merge.
               Output uninteresting commits at the boundary, which are usually not
       History Simplification
           Sometimes you are only interested in parts of the history, for example
           the commits modifying a particular <path>. But there are two parts of
           History Simplification, one part is selecting the commits and the other
           is how to do it, as there are various strategies to simplify the
           The following options select the commits to be shown:
               Commits modifying the given <paths> are selected.
               Commits that are referred by some branch or tag are selected.
           Note that extra commits can be shown to give a meaningful history.
           The following options affect the way the simplification is performed:
           Default mode
               Simplifies the history to the simplest history explaining the final
               state of the tree. Simplest because it prunes some side branches if
               the end result is the same (i.e. merging branches with the same
               As the default mode but does not prune some history.
               Only the selected commits are shown, plus some to have a meaningful
               All commits in the simplified history are shown.
                        /     /   /   /   /
                       I     B   C   D   E
                        \   /   /   /   /
           The horizontal line of history A--P is taken to be the first parent of
           each merge. The commits are:
           ?    I is the initial commit, in which foo exists with contents "asdf",
               and a file quux exists with contents "quux". Initial commits are
               compared to an empty tree, so I is !TREESAME.
           ?   In A, foo contains just "foo".
           ?    B contains the same change as A. Its merge M is trivial and hence
               TREESAME to all parents.
           ?    C does not change foo, but its merge N changes it to "foobar", so
               it is not TREESAME to any parent.
           ?    D sets foo to "baz". Its merge O combines the strings from N and D
               to "foobarbaz"; i.e., it is not TREESAME to any parent.
           ?    E changes quux to "xyzzy", and its merge P combines the strings to
               "quux xyzzy". Despite appearing interesting, P is TREESAME to all
           rev-list walks backwards through history, including or excluding
           commits based on whether --full-history and/or parent rewriting (via
           --parents or --children) are used. The following settings are
           Default mode
               Commits are included if they are not TREESAME to any parent (though
               this can be changed, see --sparse below). If the commit was a
               merge, and it was TREESAME to one parent, follow only that parent.
               (Even if there are several TREESAME parents, follow only one of
               them.) Otherwise, follow all parents.
               This results in:
                            /         /
               Note how the rule to only follow the TREESAME parent, if one is
               available, removed B from consideration entirely.  C was considered
               via N, but is TREESAME. Root commits are compared to an empty tree,
               so I is !TREESAME.
               and B were all walked, but only B was !TREESAME, so the others do
               not appear.
               Note that without parent rewriting, it is not really possible to
               talk about the parent/child relationships between the commits, so
               we show them disconnected.
           --full-history with parent rewriting
               Ordinary commits are only included if they are !TREESAME (though
               this can be changed, see --sparse below).
               Merges are always included. However, their parent list is
               rewritten: Along each parent, prune away commits that are not
               included themselves. This results in
                            /     /   /   /   /
                           I     B   /   D   /
                            \   /   /   /   /
               Compare to --full-history without rewriting above. Note that E was
               pruned away because it is TREESAME, but the parent list of P was
               rewritten to contain E?s parent I. The same happened for C and N.
               Note also that P was included despite being TREESAME.
           In addition to the above settings, you can change whether TREESAME
           affects inclusion:
               Commits that are walked are included if they are not TREESAME to
               any parent.
               All commits that are walked are included.
               Note that without --full-history, this still simplifies merges: if
               one of the parents is TREESAME, we follow only that one, so the
               other sides of the merge are never walked.
           Finally, there is a fourth simplification mode available:
               First, build a history graph in the same way that --full-history
               with parent rewriting does (see above).
               Then simplify each commit 'C' to its replacement C' in the final
               history according to the following rules:
               ?   Set 'C'' to C.
               ?   Replace each parent 'P' of C' with its simplification 'P''. In
                   Note the major differences in N and P over --full-history:
                   ?    N?s parent list had I removed, because it is an ancestor
                       of the other parent M. Still, N remained because it is
                   ?    P?s parent list similarly had I removed.  P was then
                       removed completely, because it had one parent and is
               The --simplify-by-decoration option allows you to view only the big
               picture of the topology of the history, by omitting commits that
               are not referenced by tags. Commits are marked as !TREESAME (in
               other words, kept after history simplification rules described
               above) if (1) they are referenced by tags, or (2) they change the
               contents of the paths given on the command line. All other commits
               are marked as TREESAME (subject to be simplified away).
       Bisection Helpers
               Limit output to the one commit object which is roughly halfway
               between included and excluded commits. Note that the bad bisection
               ref refs/bisect/bad is added to the included commits (if it exists)
               and the good bisection refs refs/bisect/good-* are added to the
               excluded commits (if they exist). Thus, supposing there are no refs
               in refs/bisect/, if
                       $ git rev-list --bisect foo ^bar ^baz
           outputs midpoint, the output of the two commands
                       $ git rev-list foo ^midpoint
                       $ git rev-list midpoint ^bar ^baz
           would be of roughly the same length. Finding the change which
           introduces a regression is thus reduced to a binary search: repeatedly
           generate and test new ?midpoint's until the commit chain is of length
               This calculates the same as --bisect, except that refs in
               refs/bisect/ are not used, and except that this outputs text ready
               to be eval'ed by the shell. These lines will assign the name of the
               midpoint revision to the variable bisect_rev, and the expected
               number of commits to be tested after bisect_rev is tested to
               bisect_nr, the expected number of commits to be tested if
               bisect_rev turns out to be good to bisect_good, the expected number
               of commits to be tested if bisect_rev turns out to be bad to
               bisect_bad, and the number of commits we are bisecting right now to
               after all the sorted commit objects, there will be the same text as
               if --bisect-vars had been used alone.
       Commit Ordering
           By default, the commits are shown in reverse chronological order.
               This option makes them appear in topological order (i.e. descendant
               commits are shown before their parents).
               This option is similar to --topo-order in the sense that no parent
               comes before all of its children, but otherwise things are still
               ordered in the commit timestamp order.
               Output the commits in reverse order. Cannot be combined with
       Object Traversal
           These options are mostly targeted for packing of git repositories.
               Print the object IDs of any object referenced by the listed
               commits.  --objects foo ^bar thus means "send me all object IDs
               which I need to download if I have the commit object bar, but not
               Similar to --objects, but also print the IDs of excluded commits
               prefixed with a "-" character. This is used by git-pack-objects(1)
               to build "thin" pack, which records objects in deltified form based
               on objects contained in these excluded commits to reduce network
               Only useful with --objects; print the object IDs that are not in
               Only show the given revs, but do not traverse their ancestors.
               Overrides a previous --no-walk.


           If the commit is a merge, and if the pretty-format is not oneline,
           email or raw, an additional line is inserted before the Author: line.
           This line begins with "Merge: " and the sha1s of ancestral commits are
           printed, separated by spaces. Note that the listed commits may not
           necessarily be the list of the direct parent commits if you have
           limited your view of history: for example, if you are only interested
                   <title line>
           ?    medium
                   commit <sha1>
                   Author: <author>
                   Date:   <author date>
                   <title line>
                   <full commit message>
           ?    full
                   commit <sha1>
                   Author: <author>
                   Commit: <committer>
                   <title line>
                   <full commit message>
           ?    fuller
                   commit <sha1>
                   Author:     <author>
                   AuthorDate: <author date>
                   Commit:     <committer>
                   CommitDate: <committer date>
                   <title line>
                   <full commit message>
           ?    email
                   From <sha1> <date>
                   From: <author>
                   Date: <author date>
                   Subject: [PATCH] <title line>
                   <full commit message>
           ?    raw
               The raw format shows the entire commit exactly as stored in the
               commit object. Notably, the SHA1s are displayed in full, regardless
               of whether --abbrev or --no-abbrev are used, and parents
               information show the true parent commits, without taking grafts nor
               history simplification into account.
               ?    %H: commit hash
               ?    %h: abbreviated commit hash
               ?    %T: tree hash
               ?    %t: abbreviated tree hash
               ?    %P: parent hashes
               ?    %p: abbreviated parent hashes
               ?    %an: author name
               ?    %aN: author name (respecting .mailmap, see git-shortlog(1) or
               ?    %ae: author email
               ?    %aE: author email (respecting .mailmap, see git-shortlog(1) or
               ?    %ad: author date (format respects --date= option)
               ?    %aD: author date, RFC2822 style
               ?    %ar: author date, relative
               ?    %at: author date, UNIX timestamp
               ?    %ai: author date, ISO 8601 format
               ?    %cn: committer name
               ?    %cN: committer name (respecting .mailmap, see git-shortlog(1)
                   or git-blame(1))
               ?    %ce: committer email
               ?    %cE: committer email (respecting .mailmap, see git-shortlog(1)
                   or git-blame(1))
               ?    %cd: committer date
               ?    %cD: committer date, RFC2822 style
               ?    %cr: committer date, relative
               ?    %ct: committer date, UNIX timestamp
               ?    %ci: committer date, ISO 8601 format
               ?    %gd: shortened reflog selector, e.g., stash@{1}
               ?    %gs: reflog subject
               ?    %Cred: switch color to red
               ?    %Cgreen: switch color to green
               ?    %Cblue: switch color to blue
               ?    %Creset: reset color
               ?    %C(...): color specification, as described in color.branch.*
                   config option
               ?    %m: left, right or boundary mark
               ?    %n: newline
               ?    %%: a raw %
               ?    %x00: print a byte from a hex code
               ?    %w([<w>[,<i1>[,<i2>]]]): switch line wrapping, like the -w
                   option of git-shortlog(1).
               Some placeholders may depend on other options given to the revision
               traversal engine. For example, the %g* reflog options will insert
               an empty string unless we are traversing reflog entries (e.g., by
               git log -g). The %d placeholder will use the "short" decoration
               format if --decorate was not already provided on the command line.
           If you add a + (plus sign) after % of a placeholder, a line-feed is
           inserted immediately before the expansion if and only if the
           placeholder expands to a non-empty string.
           If you add a - (minus sign) after % of a placeholder, line-feeds that
           immediately precede the expansion are deleted if and only if the
           placeholder expands to an empty string.
           ?    tformat:
               The tformat: format works exactly like format:, except that it
               provides "terminator" semantics instead of "separator" semantics.
               In other words, each commit has the message terminator character
               (usually a newline) appended, rather than a separator placed
               between entries. This means that the final entry of a single-line
               format will be properly terminated with a new line, just as the
               "oneline" format does. For example:
                   $ git log -2 --pretty=format:%h 4da45bef \
                   $ git log -2 --pretty=%h 4da45bef


           Written by Linus Torvalds <[1]>


           Documentation by David Greaves, Junio C Hamano, Jonas Fonseca and the
           git-list <[2]>.


           Part of the git(1) suite



    Git 1.7.1 08/16/2017 GIT-REV-LIST(1)


  • Linux

    The Distributions


    The Software


    The News


  • Toll Free

Toll Free Numbers
Copyright © 1999 - 2016 by LinuxGuruz