LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    git-rev-list

    
    
    

    SYNOPSIS

           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>... ]
    
    
    

    DESCRIPTION

           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.
    
    
    

    OPTIONS

       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
           git-whatchanged(1)
    
           --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)).
    
           --abbrev-commit
               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.
    
           --oneline
               This is a shorthand for "--pretty=oneline --abbrev-commit" used
               together.
    
           --encoding[=<encoding>]
               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.
    
           --relative-date
               Synonym for --date=relative.
    
           --date={relative,local,default,iso,rfc,short,raw}
               Only takes effect for dates shown in human-readable format, such as
               when using "--pretty".  log.date 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
               format.
    
               --date=default shows timestamps in the original timezone (either
               committer's or author's).
    
           --header
               Print the contents of the commit in raw-format; each record is
               separated with a NUL character.
    
           --parents
               Print the parents of the commit. Also enables parent rewriting, see
               History Simplification below.
    
           --children
               Print the children of the commit. Also enables parent rewriting,
               see History Simplification below.
    
           --timestamp
               Print the raw commit timestamp.
    
           --left-right
               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
                               / \ /
                              /   .
    
           --graph
               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>
               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).
    
           --grep=<pattern>
               Limit the commits output to ones with log message that matches the
               specified pattern (regular expression).
    
           --all-match
               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.
    
           --not
               Reverses the meaning of the ^ prefix (or lack thereof) for all
               following revision specifiers, up to the next --not.
    
           --all
               Pretend as if all the refs in refs/ are listed on the command line
               as <commit>.
    
           --branches[=pattern]
               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.
    
           --tags[=pattern]
               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
               implied.
    
           --remotes[=pattern]
               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.
    
           --glob=glob-pattern
               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.
    
           --stdin
               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.
    
           --quiet
               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
               formatted.
    
           --cherry-pick
               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).
    
           --merge
               After a failed merge, show refs that touch files having a conflict
               and don't exist on all heads to merge.
    
           --boundary
               Output uninteresting commits at the boundary, which are usually not
               shown.
    
       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
           history.
    
           The following options select the commits to be shown:
    
           <paths>
               Commits modifying the given <paths> are selected.
    
           --simplify-by-decoration
               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
               content)
    
           --full-history
               As the default mode but does not prune some history.
    
           --dense
               Only the selected commits are shown, plus some to have a meaningful
               history.
    
           --sparse
               All commits in the simplified history are shown.
    
    
                         .-A---M---N---O---P
                        /     /   /   /   /
                       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
               parents.
    
           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
           available.
    
           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:
    
                             .-A---N---O
                            /         /
                           I---------D
    
               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
    
                             .-A---M---N---O---P
                            /     /   /   /   /
                           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:
    
           --dense
               Commits that are walked are included if they are not TREESAME to
               any parent.
    
           --sparse
               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:
    
           --simplify-merges
               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
                       !TREESAME.
    
                   ?    P?s parent list similarly had I removed.  P was then
                       removed completely, because it had one parent and is
                       TREESAME.
    
               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
           --bisect
               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
           one.
    
           --bisect-vars
               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.
    
           --topo-order
               This option makes them appear in topological order (i.e. descendant
               commits are shown before their parents).
    
           --date-order
               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.
    
           --reverse
               Output the commits in reverse order. Cannot be combined with
               --walk-reflogs.
    
       Object Traversal
           These options are mostly targeted for packing of git repositories.
    
           --objects
               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
               foo".
    
           --objects-edge
               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
               traffic.
    
           --unpacked
               Only useful with --objects; print the object IDs that are not in
               packs.
    
           --no-walk
               Only show the given revs, but do not traverse their ancestors.
    
           --do-walk
               Overrides a previous --no-walk.
    
    
    

    PRETTY FORMATS

           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
                   git-blame(1))
    
               ?    %ae: author email
    
               ?    %aE: author email (respecting .mailmap, see git-shortlog(1) or
                   git-blame(1))
    
               ?    %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).
    
               Note
               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
    
    
    

    AUTHOR

           Written by Linus Torvalds <torvalds@osdl.org[1]>
    
    
    

    DOCUMENTATION

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

    GIT

           Part of the git(1) suite
    
    
    

    NOTES

            1. torvalds@osdl.org
               mailto:torvalds@osdl.org
    
            2. git@vger.kernel.org
               mailto:git@vger.kernel.org
    
    
    

    Git 1.7.1 03/04/2013 GIT-REV-LIST(1)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz