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/pull-fetch-param.txt | 119 +++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 Documentation/pull-fetch-param.txt (limited to 'Documentation/pull-fetch-param.txt') diff --git a/Documentation/pull-fetch-param.txt b/Documentation/pull-fetch-param.txt new file mode 100644 index 0000000..95a7390 --- /dev/null +++ b/Documentation/pull-fetch-param.txt @@ -0,0 +1,119 @@ +:: + The "remote" repository that is the source of a fetch + or pull operation. This parameter can be either a URL + (see the section <> below) or the name + of a remote (see the section <> below). + +ifndef::git-pull[] +:: + A name referring to a list of repositories as the value + of remotes. in the configuration file. + (See linkgit:git-config[1]). +endif::git-pull[] + +:: + Specifies which refs to fetch and which local refs to update. + When no s appear on the command line, the refs to fetch + are read from `remote..fetch` variables instead +ifndef::git-pull[] + (see <> below). +endif::git-pull[] +ifdef::git-pull[] + (see the section "CONFIGURED REMOTE-TRACKING BRANCHES" + in linkgit:git-fetch[1]). +endif::git-pull[] ++ +The format of a parameter is an optional plus +`+`, followed by the source , followed +by a colon `:`, followed by the destination ref . +The colon can be omitted when is empty. is +typically a ref, but it can also be a fully spelled hex object +name. ++ +A may contain a `*` in its to indicate a simple pattern +match. Such a refspec functions like a glob that matches any ref with the +same prefix. A pattern must have a `*` in both the and +. It will map refs to the destination by replacing the `*` with the +contents matched from the source. ++ +If a refspec is prefixed by `^`, it will be interpreted as a negative +refspec. Rather than specifying which refs to fetch or which local refs to +update, such a refspec will instead specify refs to exclude. A ref will be +considered to match if it matches at least one positive refspec, and does +not match any negative refspec. Negative refspecs can be useful to restrict +the scope of a pattern refspec so that it will not include specific refs. +Negative refspecs can themselves be pattern refspecs. However, they may only +contain a and do not specify a . Fully spelled out hex object +names are also not supported. ++ +`tag ` means the same as `refs/tags/:refs/tags/`; +it requests fetching everything up to the given tag. ++ +The remote ref that matches +is fetched, and if is not an empty string, an attempt +is made to update the local ref that matches it. ++ +Whether that update is allowed without `--force` depends on the ref +namespace it's being fetched to, the type of object being fetched, and +whether the update is considered to be a fast-forward. Generally, the +same rules apply for fetching as when pushing, see the `...` +section of linkgit:git-push[1] for what those are. Exceptions to those +rules particular to 'git fetch' are noted below. ++ +Until Git version 2.20, and unlike when pushing with +linkgit:git-push[1], any updates to `refs/tags/*` would be accepted +without `+` in the refspec (or `--force`). When fetching, we promiscuously +considered all tag updates from a remote to be forced fetches. Since +Git version 2.20, fetching to update `refs/tags/*` works the same way +as when pushing. I.e. any updates will be rejected without `+` in the +refspec (or `--force`). ++ +Unlike when pushing with linkgit:git-push[1], any updates outside of +`refs/{tags,heads}/*` will be accepted without `+` in the refspec (or +`--force`), whether that's swapping e.g. a tree object for a blob, or +a commit for another commit that's doesn't have the previous commit as +an ancestor etc. ++ +Unlike when pushing with linkgit:git-push[1], there is no +configuration which'll amend these rules, and nothing like a +`pre-fetch` hook analogous to the `pre-receive` hook. ++ +As with pushing with linkgit:git-push[1], all of the rules described +above about what's not allowed as an update can be overridden by +adding an the optional leading `+` to a refspec (or using `--force` +command line option). The only exception to this is that no amount of +forcing will make the `refs/heads/*` namespace accept a non-commit +object. ++ +[NOTE] +When the remote branch you want to fetch is known to +be rewound and rebased regularly, it is expected that +its new tip will not be descendant of its previous tip +(as stored in your remote-tracking branch the last time +you fetched). You would want +to use the `+` sign to indicate non-fast-forward updates +will be needed for such branches. There is no way to +determine or declare that a branch will be made available +in a repository with this behavior; the pulling user simply +must know this is the expected usage pattern for a branch. +ifdef::git-pull[] ++ +[NOTE] +There is a difference between listing multiple +directly on 'git pull' command line and having multiple +`remote..fetch` entries in your configuration +for a and running a +'git pull' command without any explicit parameters. +s listed explicitly on the command line are always +merged into the current branch after fetching. In other words, +if you list more than one remote ref, 'git pull' will create +an Octopus merge. On the other hand, if you do not list any +explicit parameter on the command line, 'git pull' +will fetch all the s it finds in the +`remote..fetch` configuration and merge +only the first found into the current branch. +This is because making an +Octopus from remote refs is rarely done, while keeping track +of multiple remote heads in one-go by fetching more than one +is often useful. +endif::git-pull[] -- cgit v1.2.3