From c8bae7493d2f2910b57f13ded012e86bdcfb0532 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 16:47:53 +0200 Subject: Adding upstream version 1:2.39.2. Signed-off-by: Daniel Baumann --- Documentation/revisions.txt | 400 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 400 insertions(+) create mode 100644 Documentation/revisions.txt (limited to 'Documentation/revisions.txt') diff --git a/Documentation/revisions.txt b/Documentation/revisions.txt new file mode 100644 index 0000000..0d2e55d --- /dev/null +++ b/Documentation/revisions.txt @@ -0,0 +1,400 @@ +SPECIFYING REVISIONS +-------------------- + +A revision parameter '' typically, but not necessarily, names a +commit object. It uses what is called an 'extended SHA-1' +syntax. Here are various ways to spell object names. The +ones listed near the end of this list name trees and +blobs contained in a commit. + +NOTE: This document shows the "raw" syntax as seen by git. The shell +and other UIs might require additional quoting to protect special +characters and to avoid word splitting. + +'', e.g. 'dae86e1950b1277e545cee180551750029cfe735', 'dae86e':: + The full SHA-1 object name (40-byte hexadecimal string), or + a leading substring that is unique within the repository. + E.g. dae86e1950b1277e545cee180551750029cfe735 and dae86e both + name the same commit object if there is no other object in + your repository whose object name starts with dae86e. + +'', e.g. 'v1.7.4.2-679-g3bee7fb':: + Output from `git describe`; i.e. a closest tag, optionally + followed by a dash and a number of commits, followed by a dash, a + 'g', and an abbreviated object name. + +'', e.g. 'master', 'heads/master', 'refs/heads/master':: + A symbolic ref name. E.g. 'master' typically means the commit + object referenced by 'refs/heads/master'. If you + happen to have both 'heads/master' and 'tags/master', you can + explicitly say 'heads/master' to tell Git which one you mean. + When ambiguous, a '' is disambiguated by taking the + first match in the following rules: + + . If '$GIT_DIR/' exists, that is what you mean (this is usually + useful only for `HEAD`, `FETCH_HEAD`, `ORIG_HEAD`, `MERGE_HEAD` + and `CHERRY_PICK_HEAD`); + + . otherwise, 'refs/' if it exists; + + . otherwise, 'refs/tags/' if it exists; + + . otherwise, 'refs/heads/' if it exists; + + . otherwise, 'refs/remotes/' if it exists; + + . otherwise, 'refs/remotes//HEAD' if it exists. ++ +`HEAD` names the commit on which you based the changes in the working tree. +`FETCH_HEAD` records the branch which you fetched from a remote repository +with your last `git fetch` invocation. +`ORIG_HEAD` is created by commands that move your `HEAD` in a drastic +way, to record the position of the `HEAD` before their operation, so that +you can easily change the tip of the branch back to the state before you ran +them. +`MERGE_HEAD` records the commit(s) which you are merging into your branch +when you run `git merge`. +`CHERRY_PICK_HEAD` records the commit which you are cherry-picking +when you run `git cherry-pick`. ++ +Note that any of the 'refs/*' cases above may come either from +the `$GIT_DIR/refs` directory or from the `$GIT_DIR/packed-refs` file. +While the ref name encoding is unspecified, UTF-8 is preferred as +some output processing may assume ref names in UTF-8. + +'@':: + '@' alone is a shortcut for `HEAD`. + +'[]@{}', e.g. 'master@\{yesterday\}', 'HEAD@{5 minutes ago}':: + A ref followed by the suffix '@' with a date specification + enclosed in a brace + pair (e.g. '\{yesterday\}', '{1 month 2 weeks 3 days 1 hour 1 + second ago}' or '{1979-02-26 18:30:00}') specifies the value + of the ref at a prior point in time. This suffix may only be + used immediately following a ref name and the ref must have an + existing log ('$GIT_DIR/logs/'). Note that this looks up the state + of your *local* ref at a given time; e.g., what was in your local + 'master' branch last week. If you want to look at commits made during + certain times, see `--since` and `--until`. + +'@{}', e.g. 'master@\{1\}':: + A ref followed by the suffix '@' with an ordinal specification + enclosed in a brace pair (e.g. '\{1\}', '\{15\}') specifies + the n-th prior value of that ref. For example 'master@\{1\}' + is the immediate prior value of 'master' while 'master@\{5\}' + is the 5th prior value of 'master'. This suffix may only be used + immediately following a ref name and the ref must have an existing + log ('$GIT_DIR/logs/'). + +'@{}', e.g. '@\{1\}':: + You can use the '@' construct with an empty ref part to get at a + reflog entry of the current branch. For example, if you are on + branch 'blabla' then '@\{1\}' means the same as 'blabla@\{1\}'. + +'@{-}', e.g. '@{-1}':: + The construct '@{-}' means the th branch/commit checked out + before the current one. + +'[]@\{upstream\}', e.g. 'master@\{upstream\}', '@\{u\}':: + A branch B may be set up to build on top of a branch X (configured with + `branch..merge`) at a remote R (configured with + `branch..remote`). B@{u} refers to the remote-tracking branch for + the branch X taken from remote R, typically found at `refs/remotes/R/X`. + +'[]@\{push\}', e.g. 'master@\{push\}', '@\{push\}':: + The suffix '@\{push}' reports the branch "where we would push to" if + `git push` were run while `branchname` was checked out (or the current + `HEAD` if no branchname is specified). Like for '@\{upstream\}', we report + the remote-tracking branch that corresponds to that branch at the remote. ++ +Here's an example to make it more clear: ++ +------------------------------ +$ git config push.default current +$ git config remote.pushdefault myfork +$ git switch -c mybranch origin/master + +$ git rev-parse --symbolic-full-name @{upstream} +refs/remotes/origin/master + +$ git rev-parse --symbolic-full-name @{push} +refs/remotes/myfork/mybranch +------------------------------ ++ +Note in the example that we set up a triangular workflow, where we pull +from one location and push to another. In a non-triangular workflow, +'@\{push}' is the same as '@\{upstream}', and there is no need for it. ++ +This suffix is also accepted when spelled in uppercase, and means the same +thing no matter the case. + +'{caret}[]', e.g. 'HEAD{caret}, v1.5.1{caret}0':: + A suffix '{caret}' to a revision parameter means the first parent of + that commit object. '{caret}' means the th parent (i.e. + '{caret}' + is equivalent to '{caret}1'). As a special rule, + '{caret}0' means the commit itself and is used when '' is the + object name of a tag object that refers to a commit object. + +'{tilde}[]', e.g. 'HEAD{tilde}, master{tilde}3':: + A suffix '{tilde}' to a revision parameter means the first parent of + that commit object. + A suffix '{tilde}' to a revision parameter means the commit + object that is the th generation ancestor of the named + commit object, following only the first parents. I.e. '{tilde}3' is + equivalent to '{caret}{caret}{caret}' which is equivalent to + '{caret}1{caret}1{caret}1'. See below for an illustration of + the usage of this form. + +'{caret}{}', e.g. 'v0.99.8{caret}\{commit\}':: + A suffix '{caret}' followed by an object type name enclosed in + brace pair means dereference the object at '' recursively until + an object of type '' is found or the object cannot be + dereferenced anymore (in which case, barf). + For example, if '' is a commit-ish, '{caret}\{commit\}' + describes the corresponding commit object. + Similarly, if '' is a tree-ish, '{caret}\{tree\}' + describes the corresponding tree object. + '{caret}0' + is a short-hand for '{caret}\{commit\}'. ++ +'{caret}\{object\}' can be used to make sure '' names an +object that exists, without requiring '' to be a tag, and +without dereferencing ''; because a tag is already an object, +it does not have to be dereferenced even once to get to an object. ++ +'{caret}\{tag\}' can be used to ensure that '' identifies an +existing tag object. + +'{caret}{}', e.g. 'v0.99.8{caret}{}':: + A suffix '{caret}' followed by an empty brace pair + means the object could be a tag, + and dereference the tag recursively until a non-tag object is + found. + +'{caret}{/}', e.g. 'HEAD^{/fix nasty bug}':: + A suffix '{caret}' to a revision parameter, followed by a brace + pair that contains a text led by a slash, + is the same as the ':/fix nasty bug' syntax below except that + it returns the youngest matching commit which is reachable from + the '' before '{caret}'. + +':/', e.g. ':/fix nasty bug':: + A colon, followed by a slash, followed by a text, names + a commit whose commit message matches the specified regular expression. + This name returns the youngest matching commit which is + reachable from any ref, including HEAD. + The regular expression can match any part of the + commit message. To match messages starting with a string, one can use + e.g. ':/^foo'. The special sequence ':/!' is reserved for modifiers to what + is matched. ':/!-foo' performs a negative match, while ':/!!foo' matches a + literal '!' character, followed by 'foo'. Any other sequence beginning with + ':/!' is reserved for now. + Depending on the given text, the shell's word splitting rules might + require additional quoting. + +':', e.g. 'HEAD:README', 'master:./README':: + A suffix ':' followed by a path names the blob or tree + at the given path in the tree-ish object named by the part + before the colon. + A path starting with './' or '../' is relative to the current working directory. + The given path will be converted to be relative to the working tree's root directory. + This is most useful to address a blob or tree from a commit or tree that has + the same tree structure as the working tree. + +':[:]', e.g. ':0:README', ':README':: + A colon, optionally followed by a stage number (0 to 3) and a + colon, followed by a path, names a blob object in the + index at the given path. A missing stage number (and the colon + that follows it) names a stage 0 entry. During a merge, stage + 1 is the common ancestor, stage 2 is the target branch's version + (typically the current branch), and stage 3 is the version from + the branch which is being merged. + +Here is an illustration, by Jon Loeliger. Both commit nodes B +and C are parents of commit node A. Parent commits are ordered +left-to-right. + +........................................ +G H I J + \ / \ / + D E F + \ | / \ + \ | / | + \|/ | + B C + \ / + \ / + A +........................................ + + A = = A^0 + B = A^ = A^1 = A~1 + C = = A^2 + D = A^^ = A^1^1 = A~2 + E = B^2 = A^^2 + F = B^3 = A^^3 + G = A^^^ = A^1^1^1 = A~3 + H = D^2 = B^^2 = A^^^2 = A~2^2 + I = F^ = B^3^ = A^^3^ + J = F^2 = B^3^2 = A^^3^2 + + +SPECIFYING RANGES +----------------- + +History traversing commands such as `git log` operate on a set +of commits, not just a single commit. + +For these commands, +specifying a single revision, using the notation described in the +previous section, means the set of commits `reachable` from the given +commit. + +Specifying several revisions means the set of commits reachable from +any of the given commits. + +A commit's reachable set is the commit itself and the commits in +its ancestry chain. + +There are several notations to specify a set of connected commits +(called a "revision range"), illustrated below. + + +Commit Exclusions +~~~~~~~~~~~~~~~~~ + +'{caret}' (caret) Notation:: + To exclude commits reachable from a commit, a prefix '{caret}' + notation is used. E.g. '{caret}r1 r2' means commits reachable + from 'r2' but exclude the ones reachable from 'r1' (i.e. 'r1' and + its ancestors). + +Dotted Range Notations +~~~~~~~~~~~~~~~~~~~~~~ + +The '..' (two-dot) Range Notation:: + The '{caret}r1 r2' set operation appears so often that there is a shorthand + for it. When you have two commits 'r1' and 'r2' (named according + to the syntax explained in SPECIFYING REVISIONS above), you can ask + for commits that are reachable from r2 excluding those that are reachable + from r1 by '{caret}r1 r2' and it can be written as 'r1..r2'. + +The '\...' (three-dot) Symmetric Difference Notation:: + A similar notation 'r1\...r2' is called symmetric difference + of 'r1' and 'r2' and is defined as + 'r1 r2 --not $(git merge-base --all r1 r2)'. + It is the set of commits that are reachable from either one of + 'r1' (left side) or 'r2' (right side) but not from both. + +In these two shorthand notations, you can omit one end and let it default to HEAD. +For example, 'origin..' is a shorthand for 'origin..HEAD' and asks "What +did I do since I forked from the origin branch?" Similarly, '..origin' +is a shorthand for 'HEAD..origin' and asks "What did the origin do since +I forked from them?" Note that '..' would mean 'HEAD..HEAD' which is an +empty range that is both reachable and unreachable from HEAD. + +Commands that are specifically designed to take two distinct ranges +(e.g. "git range-diff R1 R2" to compare two ranges) do exist, but +they are exceptions. Unless otherwise noted, all "git" commands +that operate on a set of commits work on a single revision range. +In other words, writing two "two-dot range notation" next to each +other, e.g. + + $ git log A..B C..D + +does *not* specify two revision ranges for most commands. Instead +it will name a single connected set of commits, i.e. those that are +reachable from either B or D but are reachable from neither A or C. +In a linear history like this: + + ---A---B---o---o---C---D + +because A and B are reachable from C, the revision range specified +by these two dotted ranges is a single commit D. + + +Other {caret} Parent Shorthand Notations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Three other shorthands exist, particularly useful for merge commits, +for naming a set that is formed by a commit and its parent commits. + +The 'r1{caret}@' notation means all parents of 'r1'. + +The 'r1{caret}!' notation includes commit 'r1' but excludes all of its parents. +By itself, this notation denotes the single commit 'r1'. + +The '{caret}-[]' notation includes '' but excludes the th +parent (i.e. a shorthand for '{caret}..'), with '' = 1 if +not given. This is typically useful for merge commits where you +can just pass '{caret}-' to get all the commits in the branch +that was merged in merge commit '' (including '' +itself). + +While '{caret}' was about specifying a single commit parent, these +three notations also consider its parents. For example you can say +'HEAD{caret}2{caret}@', however you cannot say 'HEAD{caret}@{caret}2'. + +Revision Range Summary +---------------------- + +'':: + Include commits that are reachable from (i.e. and its + ancestors). + +'{caret}':: + Exclude commits that are reachable from (i.e. and its + ancestors). + +'..':: + Include commits that are reachable from but exclude + those that are reachable from . When either or + is omitted, it defaults to `HEAD`. + +'\...':: + Include commits that are reachable from either or + but exclude those that are reachable from both. When + either or is omitted, it defaults to `HEAD`. + +'{caret}@', e.g. 'HEAD{caret}@':: + A suffix '{caret}' followed by an at sign is the same as listing + all parents of '' (meaning, include anything reachable from + its parents, but not the commit itself). + +'{caret}!', e.g. 'HEAD{caret}!':: + A suffix '{caret}' followed by an exclamation mark is the same + as giving commit '' and all its parents prefixed with + '{caret}' to exclude them (and their ancestors). + +'{caret}-', e.g. 'HEAD{caret}-, HEAD{caret}-2':: + Equivalent to '{caret}..', with '' = 1 if not + given. + +Here are a handful of examples using the Loeliger illustration above, +with each step in the notation's expansion and selection carefully +spelt out: + +.... + Args Expanded arguments Selected commits + D G H D + D F G H I J D F + ^G D H D + ^D B E I J F B + ^D B C E I J F B C + C I J F C + B..C = ^B C C + B...C = B ^F C G H D E B C + B^- = B^..B + = ^B^1 B E I J F B + C^@ = C^1 + = F I J F + B^@ = B^1 B^2 B^3 + = D E F D G H E F I J + C^! = C ^C^@ + = C ^C^1 + = C ^F C + B^! = B ^B^@ + = B ^B^1 ^B^2 ^B^3 + = B ^D ^E ^F B + F^! D = F ^I ^J D G H D F +.... -- cgit v1.2.3