Git 🌙
Français ▾ Topics ▾ Latest version ▾ git-pull last updated in 2.46.2

NOM

git-pull - Rapatrier et intégrer un autre dépôt ou une branche locale

SYNOPSIS

git pull [<options>] [<dĂ©pĂ´t> [<spĂ©cification-de-rĂ©fĂ©rence>…​]]

DESCRIPTION

Incorpore les modifications d’un dĂ©pĂ´t distant dans la branche courante. Si la branche courante est en retard par rapport Ă  la branche distante, alors par dĂ©faut, cela avancera rapidement la branche courante pour correspondre Ă  la branche distante. Si la branche courante et le dĂ©pĂ´t distant ont divergĂ©, l’utilisateur doit spĂ©cifier comment rĂ©concilier les branches divergentes avec --rebase ou --no-rebase (ou l’option de configuration correspondante dans pull.rebase).

Plus précisément, git pull exécute git fetch avec les paramètres donnés et ensuite, selon les options de configuration ou les drapeaux de la ligne de commande, appellera soit git rebase soit git merge pour réconcilier les branches divergentes.

<dĂ©pĂ´t> doit ĂŞtre le nom d’un dĂ©pĂ´t distant tel que passĂ© Ă  git-fetch[1]. <spĂ©c-de-rĂ©f> peut nommer une rĂ©f distante arbitraire (par exemple, le nom d’une Ă©tiquette) ou mĂŞme une collection de rĂ©fs avec les branches de suivi Ă  distance correspondantes (par exemple, refs/heads/*:refs/remotes/origin/*), mais c’est gĂ©nĂ©ralement le nom d’une branche du dĂ©pĂ´t distant.

Les valeurs par défaut pour <dépôt> et <branche> sont lues à partir de la configuration "remote" et "merge" pour la branche actuelle comme défini par git-branch[1] --track.

Supposons que l’historique suivant existe et que la branche actuelle est master :

	  A---B---C master sur origin
	 /
    D---E---F---G master
	^
	origin/master dans votre dépôt

Ensuite, "git pull" rĂ©cupère et rejoue les modifications de la branche master distante, puisqu’elle a divergĂ© du master local (c’est-Ă -dire E) jusqu’Ă  son commit actuel (C) en plus de master et enregistre le rĂ©sultat dans un nouveau commit avec les noms des deux commits parents et un message de journal de l’utilisateur dĂ©crivant les modifications.

	  A---B---C origin/master
	 /         \
    D---E---F---G---H master

Voir git-merge[1] pour plus de détails, notamment sur la manière dont les conflits sont présentés et traités.

Dans Git 1.7.0 ou une version ultĂ©rieure, pour annuler une fusion conflictuelle, utilisez git reset --merge. Avertissement : dans les anciennes versions de Git, il est dĂ©conseillĂ© d’exĂ©cuter git pull avec des modifications non validĂ©es : bien que cela soit possible, cela vous laisse dans un Ă©tat dont il peut ĂŞtre difficile de se dĂ©faire en cas de conflit.

Si l’une des modifications sur le distant chevauche des modifications locales non validĂ©es, la fusion sera automatiquement annulĂ©e et l’arbre de travail sera conservĂ©. Il est gĂ©nĂ©ralement prĂ©fĂ©rable de mettre les modifications locales en ordre de marche ou de les remiser avec git-stash[1] avant de tirer.

OPTIONS

-q
--quiet

Ceci est transmis Ă  la fois au git-fetch sous-jacent pour Ă©liminer les rapports lors du transfert et au git-merge sous-jacent pour Ă©liminer les rapports lors de la fusion.

-v
--verbose

Passer --verbose Ă  git-fetch et git-merge.

--[no-]recurse-submodules[=(yes|on-demand|no)]

Cette option contrôle si les nouveaux commits des sous-modules peuplés doivent être récupérés et si les arbres de travail des sous-modules actifs devraient être aussi mis à jour (voir git-fetch[1], git-config[1] et gitmodules[5]).

Si l’extraction est effectuĂ©e via un rebasage, les commits des sous-module locaux sont Ă©galement rebasĂ©s.

Si la mise à jour est effectuée par fusion, les conflits de sous-module sont résolus et extraits.

Options relatives Ă  la fusion

--commit
--no-commit

Effectuer la fusion et valider le résultat. Cette option peut être utilisée pour passer outre --no-commit. Seulement utile lors de la fusion.

Avec --no-commit, effectuer la fusion et s’arrĂŞter juste avant de crĂ©er un commit de fusion, pour donner Ă  l’utilisateur une chance d’inspecter et de peaufiner le rĂ©sultat de la fusion avant de valider.

Notez que les mises Ă  jour en avance rapide ne crĂ©ent pas de commit de fusion et qu’il n’y a donc aucun moyen d’arrĂŞter ces fusions avec --no-commit. Ainsi, si vous voulez vous assurer que votre branche n’est pas modifiĂ©e ou mise Ă  jour par la commande de fusion, utilisez --no-ff avec --no-commit.

--edit
-e
--no-edit

Avant de procĂ©der Ă  une fusion automatisĂ©e rĂ©ussie, lancer un Ă©diteur pour modifier le message de fusion gĂ©nĂ©rĂ© automatiquement, afin que l’utilisateur puisse expliquer et justifier la fusion. L’option --no-edit peut ĂŞtre utilisĂ©e pour accepter le message gĂ©nĂ©rĂ© automatiquement (ce qui est gĂ©nĂ©ralement dĂ©conseillĂ©).

Les scripts plus anciens peuvent dĂ©pendre du comportement historique de ne pas autoriser l’utilisateur Ă  modifier le message du journal de fusion. Ils verront un Ă©diteur ouvert lorsqu’ils exĂ©cuteront git merge. Pour faciliter l’ajustement de ces scripts au comportement mis Ă  jour, la variable d’environnement GIT_MERGE_AUTOEDIT peut ĂŞtre dĂ©finie sur no Ă  leur dĂ©but.

--cleanup=<mode>

Cette option dĂ©termine comment le message de fusion sera nettoyĂ© avant d’ĂŞtre envoyĂ©. Voir git-commit[1] pour plus de dĂ©tails. De plus, si le <mode> a la valeur scissors, les ciseaux seront ajoutĂ©s Ă  MERGE_MSG avant d’ĂŞtre transmis Ă  la machinerie de commit dans le cas d’un conflit de fusion.

--ff-only

Mettre Ă  jour vers le nouvel historique seulement s’il n’y a pas d’historique local divergent. C’est la valeur par dĂ©faut lorsqu’aucune mĂ©thode pour rĂ©concilier des historiques divergents n’est fournie (via les drapeaux --rebase=*).

--ff
--no-ff

Lors d’une fusion plutĂ´t qu’un rebasage, prĂ©cise comment une fusion est traitĂ©e lorsque l’historique fusionnĂ© est dĂ©jĂ  un descendant de l’historique actuel. --ff est la valeur par dĂ©faut, sauf si l’on fusionne une Ă©tiquette annotĂ©e (et Ă©ventuellement signĂ©e) qui n’est pas stockĂ©e Ă  sa place naturelle dans la hiĂ©rarchie refs/tags/, auquel cas --no-ff est supposĂ©.

Avec --ff, lorsque c’est possible, rĂ©soudre la fusion comme une avance rapide (ne mettre Ă  jour le pointeur de branche que pour qu’il corresponde Ă  la branche fusionnĂ©e ; ne pas crĂ©er de commit de fusion). Lorsque ce n’est pas possible (lorsque l’historique fusionnĂ© n’est pas un descendant de l’historique actuel), crĂ©er un commit de fusion.

Avec --no-ff, créer un commit de fusion dans tous les cas, même si la fusion peut être résolue en avance rapide.

-S[<idclé>]
--gpg-sign[=<idclé>]
--no-gpg-sign

Signer le commit rĂ©sultant de la fusion avec GPG. L’argument idclĂ© est optionnel avec par dĂ©faut l’identitĂ© du validateur ; si spĂ©cifiĂ©e, elle doit ĂŞtre collĂ©e Ă  l’option sans aucun espace. --no-gpg-sign est utile pour annuler l’effet de la variable de configuration commit.gpgSign ainsi que tout --gpg-sign prĂ©cĂ©dent.

--log[=<n>]
--no-log

En plus des noms de branches, remplir le message du journal avec les descriptions d’une ligne depuis au maximum <n> commits rĂ©els qui sont en train d’ĂŞtre fusionnĂ©s. Voir aussi git-fmt-merge-msg[1]. Seulement utile lors de la fusion.

Avec --no-log, ne pas indiquer les descriptions d’une ligne des commits rĂ©els qui sont fusionnĂ©s.

--signoff
--no-signoff

Ajouter une ligne finale Signed-off-by du validateur Ă  la fin du message de validation. La signification de signoff dĂ©pend du projet sur lequel vous validez. Par exemple, cela peut certifier que le validateur a le droit de soumettre son travail sous la licence du projet ou accepte une certaine reprĂ©sentation du contributeur, tel qu’un Certificat d’Origine de DĂ©veloppeur. (Voir https://developercertificate.org/ pour celui utilisĂ© par les projet du noyau Linux ou de Git). Consultez la documentation ou la direction du projet auquel vous contribuez pour comprendre comment les signatures sont utilisĂ©es dans ce projet.

L’option --no-signoff peut ĂŞtre utilisĂ©e pour contrecarrer une option --signoff prĂ©cĂ©dente sur la ligne de commande.

--stat
-n
--no-stat

Afficher un diffstat Ă  la fin de la fusion. Le diffstat est Ă©galement contrĂ´lĂ© par l’option de configuration merge.stat.

Avec -n ou --no-stat, ne pas afficher de diffstat Ă  la fin de la fusion.

--squash
--no-squash

Produire l’arbre de travail et l’Ă©tat d’index comme si une fusion rĂ©elle s’Ă©tait produite (sauf pour les informations de fusion), mais ne pas faire de commit, dĂ©placer la HEAD, ou enregistrer $GIT_DIR/MERGE_HEAD (pour forcer le prochain git commit Ă  crĂ©er un commit de fusion). Cela vous permet de crĂ©er un seul commit au-dessus de la branche actuelle dont l’effet est identique Ă  la fusion d’une autre branche (ou plus dans le cas d’une fusion pieuvre).

Avec --no-squash, effectuer la fusion et valider le résultat. Cette option peut être utilisée pour passer outre --squash.

Avec --squash, --commit n’est pas permis, et Ă©chouera.

Seulement utile lors de la fusion.

--[no-]verify

Par défaut, les crochets pre-merge et commit-msg sont exécutés. Lorsque --no-verify est donné, ils sont contournés. Voir aussi githooks[5]. Seulement utile lors de la fusion.

-s <stratégie>
--strategy=<strategie>

Utiliser la stratĂ©gie de fusion donnĂ©e ; peut ĂŞtre fourni plus d’une fois pour spĂ©cifier l’ordre dans lequel elles doivent ĂŞtre essayĂ©es. S’il n’y a pas d’option -s, une liste intĂ©grĂ©e de stratĂ©gies est utilisĂ©e Ă  la place (ort lors de la fusion d’une seule tĂŞte, octopus sinon).

-X <option>
--strategy-option=<option>

Faire passer l’option spĂ©cifique de la stratĂ©gie de fusion Ă  la stratĂ©gie de fusion.

--verify-signatures
--no-verify-signatures

VĂ©rifier que le commit sommet de la branche latĂ©rale Ă  fusionner est signĂ© avec une clĂ© valide, c’est-Ă -dire une clĂ© qui a un uid valide : dans le modèle de confiance par dĂ©faut, cela signifie que la clĂ© de signature a Ă©tĂ© signĂ©e par une clĂ© de confiance. Si le commit sommet de la branche latĂ©rale n’est pas signĂ© avec une clĂ© valide, la fusion est annulĂ©e.

Seulement utile lors de la fusion.

--summary
--no-summary

Synonymes de --stat et --no-stat ; ils sont dĂ©conseillĂ©s et seront supprimĂ©s Ă  l’avenir.

--autostash
--no-autostash

CrĂ©er automatiquement une entrĂ©e temporaire de remisage avant le dĂ©but de l’opĂ©ration, l’enregistrer dans la rĂ©f MERGE_AUTOSTASH et l’appliquer après la fin de l’opĂ©ration. Cela signifie que vous pouvez exĂ©cuter l’opĂ©ration sur un arbre de travail sale. Cependant, utilisez-le avec prĂ©caution : l’application finale du remisage après une fusion rĂ©ussie peut entraĂ®ner des conflits non nĂ©gligeables.

--allow-unrelated-histories

Par dĂ©faut, la commande git merge refuse de fusionner les historiques qui ne partagent pas un ancĂŞtre commun. Cette option peut ĂŞtre utilisĂ©e pour passer outre cette sĂ©curitĂ© lors de la fusion des historiques de deux projets qui ont commencĂ© leur vie indĂ©pendamment l’un de l’autre. Comme c’est une occasion très rare, il n’existe pas de variable de configuration pour activer cette option par dĂ©faut et elle ne sera pas ajoutĂ©e.

Seulement utile lors de la fusion.

-r
--rebase[=(false|true|merges|interactive)]

Lorsque c’est le cas, rebaser la branche actuelle sur la branche amont après l’avoir rĂ©cupĂ©rĂ©e. S’il existe une branche de suivi Ă  distance correspondant Ă  la branche en amont et que la branche en amont a Ă©tĂ© rebasĂ©e depuis la dernière extraction, le rebasage utilise cette information pour Ă©viter de rebaser des modifications non locales.

Lorsqu’il est dĂ©fini sur merges, rebaser en utilisant git rebase --rebase-merges de sorte que les commits de fusion locaux soient inclus dans le rebasage (voir git-rebase[1] pour plus de dĂ©tails).

Lorsqu’elle est fausse, fusionner la branche amont dans la branche actuelle.

Lorsque vous ĂŞtes en mode interactive, activer le mode interactif de rebase.

Voir pull.rebase, branch. <nom> .rebase et branch.autoSetupRebase dans git-config[1] si vous voulez que git pull utilise toujours --rebase au lieu de fusionner .

Note
C’est un mode de fonctionnement potentiellement dangereux. Il rĂ©Ă©crit l’historique, ce qui n’est pas de bon augure lorsque vous avez dĂ©jĂ  publiĂ© cette historique. N’utilisez pas cette option Ă  moins d’avoir lu attentivement git-rebase[1].
--no-rebase

C’est un raccourci pour --rebase=false.

Options relatives au rapatriement

--[no-]all

RĂ©cupĂ©rer tous les distants, Ă  l’exception de ceux qui ont la variable de configuration remote.<nom>.skipFetchAll renseignĂ©e. Cela surcharge la variable de configuration fetch.all .

-a
--append

Ajouter les noms de rĂ©fĂ©rences et les noms d’objets des rĂ©fĂ©rences rĂ©cupĂ©rĂ©es au contenu existant de .git/FETCH_HEAD. Sans cette option, les anciennes donnĂ©es dans .git/FETCH_HEAD seront Ă©crasĂ©es.

--atomic

Utiliser une transaction atomique pour mettre Ă  jour les rĂ©fĂ©rences locales. Soit toutes les rĂ©fĂ©rences sont mises Ă  jour, soit, en cas d’erreur, aucune rĂ©fĂ©rence n’est mise Ă  jour.

--depth=<profondeur>

Limiter la rĂ©cupĂ©ration au nombre spĂ©cifiĂ© de commits Ă  partir du sommet de l’historique de chaque branche distante. Si vous allez chercher dans un dĂ©pĂ´t "superficiel" crĂ©Ă© par git clone avec l’option --depth=<profondeur> (voir git-clone[1]), approfondir ou raccourcir l’historique jusqu’au nombre spĂ©cifiĂ© de validations. Les Ă©tiquettes pour les commits approfondis ne sont pas rĂ©cupĂ©rĂ©es.

--deepen=<profondeur>

Semblable Ă  --depth, sauf que cela prĂ©cise le nombre de commits Ă  partir de la limite actuelle superficielle au lieu du sommet de l’historique de chaque branche distante.

--shallow-since=<date>

Approfondir ou raccourcir l’historique d’un dĂ©pĂ´t superficiel pour inclure tous les commits accessibles après <date>.

--shallow-exclude=<révision>

Approfondir ou raccourcir l’historique d’un dĂ©pĂ´t superficiel afin d’exclure les commits accessibles depuis une branche ou une Ă©tiquette distante spĂ©cifiĂ©e. Cette option peut ĂŞtre spĂ©cifiĂ©e plusieurs fois.

--unshallow

Si le dépôt de sources est complet, convertir un dépôt superficiel en un dépôt complet, en supprimant toutes les limitations imposées par les dépôts superficiels.

Si le dépôt source est superficiel, il faut en extraire le plus possible afin que le dépôt actuel ait le même historique que le dépôt source.

--update-shallow

Par dĂ©faut, lors de la rĂ©cupĂ©ration d’un dĂ©pĂ´t superficiel, git fetch refuse les rĂ©fĂ©rences qui nĂ©cessitent une mise Ă  jour de .git/shallow. Cette option met Ă  jour le fichier .git/shallow et accepte de telles rĂ©fĂ©rences.

--negotiation-tip=<commit|glob>

Par dĂ©faut, Git signalera au serveur les commits accessibles Ă  partir de toutes les rĂ©fĂ©rences locales pour trouver les commits communs afin de rĂ©duire la taille du fichier de paquet Ă  recevoir. Si ceci est spĂ©cifiĂ©, Git ne signalera que les commits accessibles Ă  partir des sommets donnĂ©s. Ceci est utile pour accĂ©lĂ©rer les recherches lorsque l’utilisateur sait quelle rĂ©f locale est susceptible d’avoir des commits en commun avec la rĂ©f amont qui est recherchĂ©e.

Cette option peut ĂŞtre spĂ©cifiĂ©e plus d’une fois ; si c’est le cas, Git signalera les commits accessibles Ă  partir de l’un des commits donnĂ©s.

L’argument de cette option peut ĂŞtre un glob sur les noms de rĂ©fĂ©rence, une rĂ©fĂ©rence ou le SHA-1 (Ă©ventuellement abrĂ©gĂ©) d’un commit. La spĂ©cification d’un glob Ă©quivaut Ă  spĂ©cifier cette option plusieurs fois, une pour chaque nom de rĂ©fĂ©rence correspondant.

Voir aussi les variables de configuration fetch.negotiationAlgorithm et push.negotiate documentĂ©es dans git-config[1], ainsi que l’option --negotiate-only ci-après.

--negotiate-only

Ne rien récupérer du serveur, et à la place afficher les ancêtres des arguments fournis par --negotiation-tip=*, que nous avons en commun avec le serveur.

C’est incompatible avec --recurse-submodules=[yes|on-demand]. En interne, ceci est utilisĂ© pour implĂ©menter l’option push.negotiate, voir git-config[1].

--dry-run

Montrer ce qui serait fait, sans faire de changements.

--porcelain

Afficher la sortie sur la sortie standard dans un format facile à décrypter pour les scripts. Voir la section SORTIE dans git-fetch[1] pour plus de détails.

C’est incompatible avec --recurse-submodules=[yes|on-demand]`et a la prioritĂ© sur l'option de configuration `fetch.output.

-f
--force

Lorsque git fetch est utilisé avec la spécification de référence <src>:<dst>, il peut refuser de mettre à jour la branche locale comme cela a été discuté dans la partie <spécificateur-de-référence> de la documentation git-fetch[1]. Cette option permet de passer outre à ce contrôle.

-k
--keep

Conserver le paquet téléchargé.

--prefetch

Modifier le spĂ©cificateur de rĂ©fĂ©rence configurĂ© pour placer toutes les refs dans l’espace de noms refs/prefetch/. Voir la tâche prefetch dans git-maintenance[1].

-p
--prune

Avant de rĂ©cupĂ©rer, supprimer toutes les rĂ©fĂ©rences de suivi Ă  distance qui n’existent plus sur le dĂ©pĂ´t distant. Les Ă©tiquettes ne sont pas sujettes Ă  l’Ă©lagage si elles ne sont rĂ©cupĂ©rĂ©es qu’en raison du suivi automatique de l’Ă©tiquette par dĂ©faut ou en raison d’une option --tags. Cependant, si les Ă©tiquettes sont rĂ©cupĂ©rĂ©es en raison d’un spĂ©cificateur de rĂ©fĂ©rence explicite (soit en ligne de commande, soit dans la configuration distante, par exemple si le dĂ©pĂ´t distant a Ă©tĂ© clonĂ© avec l’option --mirror), alors elles sont Ă©galement sujettes Ă  l’Ă©lagage. La fourniture de --prune-tags est une abrĂ©viation pour la fourniture du spĂ©cificateur de rĂ©fĂ©rence d’Ă©tiquette.

--no-tags

Par dĂ©faut, les Ă©tiquettes qui pointent sur des objets tĂ©lĂ©chargĂ©s Ă  partir du dĂ©pĂ´t distant sont rĂ©cupĂ©rĂ©es et stockĂ©es localement. Cette option dĂ©sactive le suivi automatique des Ă©tiquettes. Le comportement par dĂ©faut d’un distant peut ĂŞtre spĂ©cifiĂ© avec le paramètre remote.<nom>.tagOpt. Voir git-config[1].

--refmap=<spécificateur-de-référence>

Lors de la rĂ©cupĂ©ration des rĂ©fĂ©rences listĂ©es en ligne de commande, utiliser la spĂ©cification de rĂ©fĂ©rence (qui peut ĂŞtre donnĂ©e plusieurs fois) pour mapper les rĂ©fĂ©rences sur les branches de suivi Ă  distance, au lieu des valeurs des variables de configuration remote.*.fetch pour le dĂ©pĂ´t distant. Fournir un <spĂ©cificateur-de-rĂ©fĂ©rence> vide Ă  l’option --refmap fait que Git ignore les spĂ©cification de rĂ©fĂ©rence configurĂ©es et se fie entièrement aux spĂ©cifications de rĂ©fĂ©rence fournies comme arguments de la ligne de commande. Voir la section sur les "Branches de suivi Ă  distance configurĂ©es" pour plus de dĂ©tails.

-t
--tags

RĂ©cupĂ©rer toutes les Ă©tiquettes Ă  distance (c’est-Ă -dire, rĂ©cupĂ©rer les Ă©tiquettes refs/tags/* dans les Ă©tiquettes locales avec le mĂŞme nom), en plus de tout ce qui serait rĂ©cupĂ©rĂ© autrement. L’utilisation de cette seule option ne soumet pas les Ă©tiquettes Ă  un Ă©lagage, mĂŞme si --prune est utilisĂ© (bien que les Ă©tiquettes puissent ĂŞtre Ă©laguĂ©es de toute façon si elles sont aussi la destination d’une spĂ©cification de rĂ©fĂ©rence explicite ; voir --prune).

-j
--jobs=<n>

Nombre d’enfants parallèles Ă  utiliser pour toutes les formes d’extraction.

Si l’option --multiple a Ă©tĂ© spĂ©cifiĂ©e, les diffĂ©rents distants seront rĂ©cupĂ©rĂ©s en parallèle. Si plusieurs sous-modules sont rĂ©cupĂ©rĂ©s, ils seront rĂ©cupĂ©rĂ©s en parallèle. Pour les contrĂ´ler indĂ©pendamment, utilisez les paramètres de configuration fetch.parallel et submodule.fetchJobs (voir git-config[1]).

Généralement, les recherches récursives parallèles et sur des distants multiples seront plus rapides. Par défaut, les recherches sont effectuées de manière séquentielle, et non en parallèle.

--set-upstream

Si le distant est rĂ©cupĂ©rĂ© avec succès, ajouter la rĂ©fĂ©rence (de suivi) amont , utilisĂ©e par les commandes sans argument git-pull[1] et autres. Pour plus d’informations, voir branch.<nom>.merge et branch.<nom>.remote dans git-config[1].

--upload-pack <upload-pack>

Lorsqu’il est donnĂ©, et que le dĂ©pĂ´t Ă  rĂ©cupĂ©rer est gĂ©rĂ© par git fetch-pack, --exec=<upload-pack> est passĂ© Ă  la commande pour spĂ©cifier le chemin par dĂ©faut pour la commande exĂ©cutĂ©e Ă  l’autre bout.

--progress

L’Ă©tat d’avancement est affichĂ© sur la sortie d’erreur standard quand elle est attachĂ©e Ă  un terminal, Ă  moins que -q soit spĂ©cifiĂ©. Ce drapeau force l’Ă©tat d’avancement mĂŞme si le flux d’erreur standard n’est pas dirigĂ© vers un terminal.

-o <option>
--server-option=<option>

Transmettre la chaĂ®ne donnĂ©e au serveur lors d’une communication utilisant la version 2 du protocole. La chaĂ®ne donnĂ©e ne doit pas contenir de caractère NUL ou LF. La gestion par le serveur des options du serveur, y compris les options inconnues, est spĂ©cifique au serveur. Lorsque plusieurs --server-option=<option> sont donnĂ©s, ils sont tous envoyĂ©s Ă  l’autre cĂ´tĂ© dans l’ordre indiquĂ© sur la ligne de commande.

--show-forced-updates

Par dĂ©faut, git vĂ©rifie si une branche est mise Ă  jour de force pendant la rĂ©cupĂ©ration. Cela peut ĂŞtre dĂ©sactivĂ© via fetch.showForcedUpdates, mais l’option --show-forced-updates garantit que cette vĂ©rification a lieu. Voir git-config[1].

--no-show-forced-updates

Par dĂ©faut, git vĂ©rifie si une branche est mise Ă  jour de force pendant la rĂ©cupĂ©ration. Passer --no-show-forced-updates ou rĂ©gler fetch.showForcedUpdates Ă  false pour sauter cette vĂ©rification pour des raisons de performance. Si elle est utilisĂ©e pendant git-pull, l’option --ff-only vĂ©rifiera toujours les mises Ă  jour forcĂ©es avant de tenter une mise Ă  jour rapide. Voir git-config[1].

-4
--ipv4

Utiliser uniquement les adresses IPv4, en ignorant les adresses IPv6.

-6
--ipv6

Utiliser uniquement les adresses IPv6, en ignorant les adresses IPv4.

<dépôt>

Le dĂ©pĂ´t "distant" qui est la source d’une opĂ©ration de rĂ©cupĂ©ration ou de tirage. Ce paramètre peut ĂŞtre soit une URL (voir la section URLS GIT ci-dessous) soit le nom d’un remote (voir la section DISTANTS ci-dessous).

<spécificateur-de-référence>

PrĂ©ciser les rĂ©fĂ©rences Ă  rĂ©cupĂ©rer et les rĂ©fĂ©rences locales Ă  mettre Ă  jour. Lorsqu’aucun <spĂ©c-de-rĂ©f> n’apparaĂ®t sur la ligne de commande, les rĂ©fĂ©rences Ă  rĂ©cupĂ©rer sont lues Ă  partir des variables remote.<dĂ©pĂ´t>.fetch Ă  la place (voir la section "[BRANCHES DE SUIVI Ă€ DISTANCE CONFIGURÉES]" dans git-fetch[1]).

Le format d’un paramètre <spĂ©c-de-rĂ©f> est un plus + optionnel, suivi de la source <src>, suivi de deux points :, suivi de la destination ref <dst>. Les deux points peuvent ĂŞtre omis lorsque <dst> est vide. <src> est typiquement une rĂ©f, mais cela peut aussi ĂŞtre un nom d’objet hexadĂ©cimal entier.

Un <spec-de-rĂ©f> peut contenir un * dans son <src> pour indiquer une simple correspondance de motif. Un tel refspec fonctionne comme un motif qui correspond Ă  n’importe quelle ref avec le mĂŞme prĂ©fixe. Un motif <spec-de-rĂ©f> doit avoir un * dans les deux <src> et <dst>. Il va faire correspondre les rĂ©fĂ©rences Ă  la destination en remplaçant le * par le contenu correspondant de la source.

Si un spĂ©cificateur de rĂ©fĂ©rence est prĂ©fixĂ© par ^, il sera interprĂ©tĂ© comme un spĂ©cificateur de rĂ©fĂ©rence nĂ©gatif. PlutĂ´t que de spĂ©cifier les rĂ©fĂ©rences Ă  rĂ©cupĂ©rer ou les rĂ©fĂ©rences locales Ă  mettre Ă  jour, un tel spĂ©cificateur de rĂ©fĂ©rence spĂ©cifiera les rĂ©fĂ©rences Ă  exclure. Une rĂ©fĂ©rence sera considĂ©rĂ©e comme correspondante si elle correspond Ă  au moins une rĂ©fĂ©rence positive, et ne correspond Ă  aucune rĂ©fĂ©rence nĂ©gative. Les spĂ©cificateurs de rĂ©fĂ©rence nĂ©gatifs peuvent ĂŞtre utiles pour restreindre le champ d’application d’un spĂ©cificateur modèle de rĂ©fĂ©rence afin qu’il n’inclue pas de rĂ©fĂ©rences spĂ©cifiques. Les spĂ©cificateurs de rĂ©fĂ©rence nĂ©gatifs peuvent eux-mĂŞmes ĂŞtre des spĂ©cificateurs modèles de rĂ©fĂ©rence . Cependant, ils ne peuvent contenir qu’un <src> et ne peuvent pas spĂ©cifier un <dst>. Les noms d’objets hexagonaux complets ne sont pas non plus pris en charge.

tag <Ă©tiquette> signifie la mĂŞme chose que refs/tags/<tag>:refs/tags/<tag> ; cela demande de tout rĂ©cupĂ©rer jusqu’Ă  l’Ă©tiquette donnĂ©e.

La rĂ©fĂ©rence distante qui correspond Ă  <src> est rĂ©cupĂ©rĂ©e, et si <dst> n’est pas une chaĂ®ne vide, une tentative est faite pour mettre Ă  jour la rĂ©fĂ©rence locale qui lui correspond.

Le fait que cette mise Ă  jour soit autorisĂ©e sans --force dĂ©pend de l’espace de noms de rĂ©fĂ©rence vers lequel elle est rĂ©cupĂ©rĂ©e, du type d’objet rĂ©cupĂ©rĂ©, et si la mise Ă  jour est considĂ©rĂ©e comme une avance rapide. GĂ©nĂ©ralement, les mĂŞmes règles s’appliquent pour la rĂ©cupĂ©ration que pour la poussĂ©e, voir la section <spĂ©c-de-rĂ©f>... de git-push[1] pour les connaĂ®tre. Les exceptions Ă  ces règles particulières Ă  git fetch sont notĂ©es ci-dessous.

Jusqu’Ă  la version 2.20 de Git, et contrairement Ă  ce qui se passe avec git-push[1], toute mise Ă  jour de refs/tags/* serait acceptĂ©e sans + dans la spĂ©c-de-rĂ©f (ou --force). Lors de la rĂ©cupĂ©ration, nous considĂ©rons sans distinction toutes les mises Ă  jour d’Ă©tiquettes depuis un dĂ©pĂ´t distance comme des rĂ©cupĂ©rations forcĂ©es. Depuis la version 2.20 de Git, la rĂ©cupĂ©ration pour mettre Ă  jour les refs/tags/* fonctionne de la mĂŞme manière que lors de la poussĂ©e. C’est-Ă -dire que toute mise Ă  jour sera rejetĂ©e sans "+" dans le spĂ©cificateur de rĂ©fĂ©rence (ou --force).

Contrairement Ă  une poussĂ©e avec git-push[1], toute mise Ă  jour en dehors de refs/{tags,heads}/* sera acceptĂ©e sans + dans le spĂ©c-de-rĂ©f (ou --force), que ce soit en Ă©changeant par exemple un objet arbre pour un blob, ou un commit pour un autre commit qui n’a pas le commit prĂ©cĂ©dent comme ancĂŞtre etc.

Contrairement Ă  une poussĂ©e avec git-push[1], il n’y a pas de configuration qui modifie ces règles, et rien de tel qu’un crochet prĂ©-rĂ©cupĂ©ration pre-fetch analogue Ă  celui de prĂ©-rĂ©ception`pre-receive`.

Comme pour la poussĂ©e avec git-push[1], toutes les règles dĂ©crites ci-dessus concernant ce qui n’est pas autorisĂ© comme une mise Ă  jour, peuvent ĂŞtre annulĂ©es en ajoutant un "+" optionnel Ă  un spĂ©cificateur de rĂ©fĂ©rence (ou en utilisant l’option de ligne de commande --force). La seule exception Ă  cette règle est qu’aucun forçage ne fera accepter Ă  l’espace de noms refs/heads/* un objet non commit.

Note
Lorsque la branche distante que vous voulez rĂ©cupĂ©rer est connue pour ĂŞtre rĂ©gulièrement rembobinĂ©e et rebasĂ©e, on s’attend Ă  ce que son nouveau sommet ne soit pas un descendant de son sommet prĂ©cĂ©dent (telle qu’il Ă©tait stockĂ© dans votre branche de suivi Ă  distance la dernière fois que vous l’avez rĂ©cupĂ©rĂ©). Vous pouvez utiliser le signe "+" pour indiquer que des mises Ă  jour non en avance rapide seront nĂ©cessaires pour ces branches. Il n’y a aucun moyen de dĂ©terminer ou de dĂ©clarer qu’une branche sera rendue disponible dans un dĂ©pĂ´t avec ce comportement ; l’utilisateur qui tire doit simplement savoir que c’est le modèle d’utilisation attendu pour une branche.
Note
Il y a une diffĂ©rence entre le fait de lister plusieurs <spĂ©c-de-rĂ©f> directement sur la ligne de commande git pull et le fait d’avoir plusieurs entrĂ©es remote.<dĂ©pĂ´t>.fetch dans votre configuration pour un <dĂ©pĂ´t> et d’exĂ©cuter une commande git pull sans aucun paramètre <spĂ©c-de-rĂ©f> explicite. Les <spĂ©c-de-rĂ©f>s listĂ©s explicitement sur la ligne de commande sont toujours fusionnĂ©s dans la branche actuelle après avoir Ă©tĂ© rĂ©cupĂ©rĂ©es. En d’autres termes, si vous listez plus d’une rĂ©fĂ©rence distante, git pull crĂ©era une fusion Octopus. D’un autre cĂ´tĂ©, si vous n’indiquez aucun paramètre <spĂ©c-de-rĂ©f> explicite sur la ligne de commande, git pull rĂ©cupĂ©rera tous les <spĂ©c-de-rĂ©f>s qu’il trouve dans la configuration remote.<dĂ©pĂ´t>.fetch et fusionnera seulement le premier <rĂ©f-de-spĂ©c> trouvĂ© dans la branche actuelle. C’est parce que faire un Octopus Ă  partir de rĂ©fĂ©rences distantes est rarement fait, alors que garder la trace de plusieurs tĂŞtes distantes en un seul coup en en rĂ©cupĂ©rant plusieurs est souvent utile.

URL GIT

En gĂ©nĂ©ral, les URL contiennent une information sur le protocole de transport, l’adresse du serveur distant et le chemin vers le dĂ©pĂ´t. En fonction du protocole de transport, certaines de ces informations peuvent ĂŞtre absentes.

Git supporte les protocoles ssh, git, http et https (en plus, ftp et ftps peuvent être utilisés pour la récupération, mais ceux-ci sont inefficaces et déconseillés ; ne les utilisez pas).

Le transport natif (c’est-Ă -dire l’URL git://) n’utilise pas d’authentification et ne devrait ĂŞtre utilisĂ© qu’avec prĂ©caution sur des rĂ©seaux non sĂ©curisĂ©s.

Les syntaxes suivantes peuvent être utilisées avec eux :

  • ssh://[<utilisateur>@]<hĂ´te>[:<port>]/<chemin-du-dĂ©pĂ´t-git>

  • git://<hĂ´te>[:<port>]/<chemin-du-dĂ©pĂ´t-git>

  • http[s]://<hĂ´tet>[:<port>]/<chemin-du-dĂ©pĂ´t-git>

  • ftp[s]://<hĂ´te>[:<port>]/<chemin-du-dĂ©pĂ´t-git>

Une syntaxe alternative de type scp peut aussi être utilisée pour le protocole ssh :

  • [<utilisateur>@]<hĂ´te>:/<chemin-du-dĂ©pĂ´t-git>

Cette syntaxe n’est reconnue que s’il n’y a pas de barre oblique devant les premiers deux-points. Cela permet de prendre en charge des chemins locaux qui contiendraient des deux-points. Par exemple, le chemin local toto:titi pourrait ĂŞtre spĂ©cifiĂ© comme un chemin absolu ou ./toto:titi pour Ă©viter d’ĂŞtre interprĂ©tĂ© comme une url ssh.

Les protocoles ssh et git supportent en plus l’expansion ~<utilisateur>  :

  • ssh://[<utilisateur>@]<hĂ´te>[:<port>]/~<utilisateur>/<chemin-du-dĂ©pĂ´t-git>

  • git://<hĂ´te>[:<port>]/~<utilisateur>/<chemin-du-dĂ©pĂ´t-git>

  • [<utilisateur>@]<hĂ´te>:~<utilisateur>/<chemin-du-dĂ©pĂ´t-git>

Pour les dépôts locaux, supportés aussi nativement par Git, les syntaxes suivantes sont aussi admises :

Ces deux syntaxes sont Ă  peu près Ă©quivalentes, Ă  part lors d’un clonage, oĂą la première implique l’option --local. Voir git-clone[1] pour plus de dĂ©tails.

git clone, git fetch et git pull, mais pas git push, acceptent également un fichier paquet approprié. Voir git-bundle[1].

Quand Git ne sait pas comment gĂ©rer un certain protocole, il essaie d’utiliser l’assistant de gestion de distant remote-<transport>, s’il existe. Pour requĂ©rir l’emploi d’un assistant spĂ©cifique, la syntaxe suivante peut ĂŞtre utilisĂ©e :

  • <transport>::<adresse>

oĂą <adresse> peut ĂŞtre un chemin, un serveur et chemin, ou une chaĂ®ne URL arbitraire reconnue par l’assistant de gestion de distant invoquĂ©. Voir gitremote-helpers[7] pour plus de dĂ©tails.

S’il y a un grand nombre de dĂ©pĂ´ts aux noms similaires et que vous souhaitez utiliser un format diffĂ©rent pour eux (de telle sorte que les URL que vous utiliserez seront rĂ©Ă©crites en URL fonctionnelles), vous pouvez crĂ©er une section de configuration de la forme :

	[url "<veritable-base-d-url>"]
		insteadOf = <autre-base-d’URL>

Par exemple, avec ceci :

	[url "git://git.host.xz/"]
		insteadOf = host.xz:/chemin/vers/
		insteadOf = travail:

une URL comme « travail:depot.git » ou « host.xz:/chemin/vers/depot.git » sera réécrite dans tout contexte qui requiert une URL en « git://git.host.xz/depot.git ».

Si vous souhaitez réécrire les URL seulement pour pousser, vous pouvez créer une section de configuration de la forme :

	[url "<veritable-base-d’URL>"]
		pushInsteadOf = <autre-base-d-URL>

Par exemple, avec ceci :

	[url "ssh://exemple.org/"]
		pushInsteadOf = git://exemple.org/

une URL telle que « git://exemple.org/chemin/vers/le/depot.git » sera rĂ©Ă©crite en « ssh://exemple.org/chemin/vers/le/depot.git » pour les poussĂ©es, mais les tirages utiliseront encore l’URL originale.

DISTANTS

Le nom de l’un des Ă©lĂ©ments suivants peut ĂŞtre utilisĂ© Ă  la place d’une URL en tant qu’argument <dĂ©pĂ´t> :

  • un distant dans le fichier de configuration Git : $GIT_DIR/config,

  • un fichier dans le rĂ©pertoire $GIT_DIR/remotes, ou

  • un fichier dans le rĂ©pertoire $GIT_DIR/branches.

Toutes ces options vous permettent Ă©galement d’omettre le spĂ©cificateur de rĂ©fĂ©rence de la ligne de commande car elles contiennent chacune un spĂ©cificateur de rĂ©fĂ©rence que git utilisera par dĂ©faut.

distant nommé dans le fichier de configuration

Vous pouvez choisir de fournir le nom d’un distant que vous aviez prĂ©cĂ©demment configurĂ© en utilisant git-remote[1], git-config[1] ou mĂŞme par une modification manuelle du fichier $GIT_DIR/config. L’URL de ce distant sera utilisĂ©e pour accĂ©der au dĂ©pĂ´t. Le spĂ©cificateur de rĂ©fĂ©rence de ce distant sera utilisĂ© par dĂ©faut lorsque vous ne fournissez pas de spĂ©cificateur de rĂ©fĂ©rence sur la ligne de commande. L’entrĂ©e dans le fichier de configuration apparaĂ®tra comme ceci :

	[remote "<nom>"]
		url = <URL>
		pushurl = <url-poussée>
		push = <spéc-de-réf>
		fetch = <spéc-de-réf>

Le <url-de-poussĂ©e> est utilisĂ© uniquement pour les poussĂ©es. Il est optionnel et sa valeur par dĂ©faut est <URL>. Pousser vers un distant affecte tous les urls-de-poussĂ©s dĂ©finis ou tous les urls dĂ©finis si aucun url-de-poussĂ©e n’est dĂ©fini. Fetch, cependant, ne rĂ©cupĂ©rera que le premier url dĂ©fini si plusieurs urls sont dĂ©finis.

Fichier nommé dans $GIT_DIR/remotes

Vous pouvez choisir de fournir le nom d’un fichier dans $GIT_DIR/remotes. L’URL dans ce fichier sera utilisĂ©e pour accĂ©der au dĂ©pĂ´t. Le spĂ©cificateur de rĂ©fĂ©rence dans ce fichier sera utilisĂ© par dĂ©faut lorsque vous ne fournissez pas de spĂ©cificateur de rĂ©fĂ©rence sur la ligne de commande. Ce fichier doit avoir le format suivant :

	URL: un des format d'URL ci-dessus
	Push: <spéc-de-réf>
	Pull: <spéc-de-réf>

Les lignes Push:" sont utilisées par git push et les lignes Pull: sont utilisées par git pull et git fetch. Des lignes Push: et Pull: multiples peuvent être spécifiées pour des mappages supplémentaires de branches.

Fichier nommé dans $GIT_DIR/branches

Vous pouvez choisir de fournir le nom d’un fichier dans $GIT_DIR/branches. L’URL de ce fichier sera utilisĂ©e pour accĂ©der au dĂ©pĂ´t. Ce fichier doit avoir le format suivant :

	<URL>#<tĂŞte>

<URL> est obligatoire ; #<tĂŞte> est facultatif.

En fonction de l’opĂ©ration, git utilisera l’un des spĂ©cificateurs de rĂ©fĂ©rence suivants, si vous n’en fournissez pas un en ligne de commande. <branche> est le nom de ce fichier dans $GIT_DIR/branches et <tĂŞte> vaut par dĂ©faut master.

git fetch utilise :

	refs/heads/<tĂŞte>:refs/heads/<branche>

git push utilise :

	HEAD:refs/heads/<tĂŞte>

LES STRATÉGIES DE FUSION

Le mĂ©canisme de fusion (commandes git merge et git pull) permet de choisir les stratĂ©gies de fusion du backend avec l’option -s. Certaines stratĂ©gies peuvent Ă©galement prendre leurs propres options, qui peuvent ĂŞtre passĂ©es en donnant des arguments -X<option> Ă  git merge et/ou git pull.

ort

C’est la stratĂ©gie de fusion par dĂ©faut lors du tirage ou de la fusion d’une branche. Cette stratĂ©gie ne peut rĂ©soudre que deux tĂŞtes en utilisant un algorithme de fusion Ă  trois voies. Lorsqu’il y a plus d’un ancĂŞtre commun qui peut ĂŞtre utilisĂ© pour la fusion Ă  trois, il crĂ©e un arbre fusionnĂ© des ancĂŞtres communs et l’utilise comme arbre de rĂ©fĂ©rence pour la fusion Ă  trois. Il a Ă©tĂ© rapportĂ© que cela permettait de rĂ©duire les conflits de fusion sans provoquer de fausses fusions, grâce Ă  des tests effectuĂ©s sur de vraies fusions tirĂ©es de l’historique de dĂ©veloppement du noyau Linux 2.6. En outre, cette stratĂ©gie permet de dĂ©tecter et de gĂ©rer les fusions impliquant des renommages. Elle ne peut actuellement pas utiliser les copies dĂ©tectĂ©es. Le nom de cet algorithme est un acronyme ("Ostensibly Recursive’s Twin" : Jumeau ostensible de recurse) et vient du fait qu’il a Ă©tĂ© Ă©crit pour remplacer l’algorithme par dĂ©faut prĂ©cĂ©dent, recursive.

La stratégie ort peut prendre les options suivantes :

ours

Cette option oblige Ă  rĂ©soudre les sections en conflit de manière autonome et propre en favorisant notre version (our). Les modifications par rapport Ă  l’autre arbre qui n’entrent pas en conflit avec notre version se reflètent dans le rĂ©sultat de la fusion. Pour un fichier binaire, tout le contenu est pris de notre cĂ´tĂ©.

Il ne faut pas la confondre avec la stratĂ©gie de fusion ours, qui ne tient mĂŞme pas compte de ce que contient l’autre arbre. Elle rejette tout ce que l’autre arbre a fait, dĂ©clarant que "notre" historique (our) contient tout ce qui s’y est passĂ©.

theirs

C’est le contraire de ours ; notez que, contrairement Ă  ours, il n’y a pas de stratĂ©gie de fusion theirs avec laquelle confondre cette option de fusion.

ignore-space-change
ignore-all-space
ignore-space-at-eol
ignore-cr-at-eol

Traiter les lignes avec le type de changement d’espace indiquĂ© comme inchangĂ©es dans l’intĂ©rĂŞt d’une fusion Ă  trois points. Les changements d’espacement mĂ©langĂ©s Ă  d’autres changements de ligne ne sont pas ignorĂ©s. Voir aussi git-diff[1] -b, -w, --ignore-space-at-eol, et --ignore-cr-at-eol.

  • Si "leur" version (theirs) n’introduit que des changements d’espacement sur une ligne, "notre" version (our) est utilisĂ©e ;

  • Si "notre" version introduit des modifications dans l’espace blanc mais que "leur" version inclut un changement substantiel, "leur" version est utilisĂ©e ;

  • Dans le cas contraire, la fusion se dĂ©roule de la manière habituelle.

renormalize

Il s’agit d’une extraction et d’un validation virtuelle des trois Ă©tapes d’un fichier lors de la rĂ©solution d’une fusion Ă  trois points. Cette option est destinĂ©e Ă  ĂŞtre utilisĂ©e lors de la fusion de branches avec diffĂ©rents filtres clean ou règles de normalisation de fin de ligne. Voir "Fusion de branches avec diffĂ©rents attributs de validation/extraction" dans gitattributes[5] pour plus de dĂ©tails.

no-renormalize

DĂ©sactiver l’option renormalize. Cela surcharge la variable de configuration merge.renormalize .

find-renames[=<n>]

Activer la dĂ©tection de renommage, en fixant Ă©ventuellement le seuil de similaritĂ©. C’est la valeur par dĂ©faut. Cela surcharge la variable de configuration merge.renames. Voir aussi git-diff[1] --find-renames.

rename-threshold=<n>

Synonyme obsolète pour find-renames=<n>.

subtree[=<chemin>]

Cette option est une forme plus avancĂ©e de stratĂ©gie subtree, oĂą la stratĂ©gie fait une estimation de la façon dont deux arbres doivent ĂŞtre dĂ©placĂ©s pour correspondre l’un Ă  l’autre lors de la fusion. Au lieu de cela, le chemin spĂ©cifiĂ© est prĂ©fixĂ© (ou tronquĂ© au debut) pour faire correspondre la forme de deux arbres.

recursive

Cela ne peut rĂ©soudre que deux tĂŞtes en utilisant un algorithme de fusion Ă  trois voies. Lorsqu’il y a plus d’un ancĂŞtre commun qui peut ĂŞtre utilisĂ© pour la fusion Ă  trois, il crĂ©e un arbre fusionnĂ© des ancĂŞtres communs et l’utilise comme arbre de rĂ©fĂ©rence pour la fusion Ă  trois. Il a Ă©tĂ© rapportĂ© que cela permettait de rĂ©duire les conflits de fusion sans provoquer de fausses fusions, grâce Ă  des tests effectuĂ©s sur de vraies fusions tirĂ©es de l’historique de dĂ©veloppement du noyau Linux 2.6. En outre, cela permet de dĂ©tecter et de gĂ©rer les fusions impliquant des renommages. Cela n’utilise les copies dĂ©tectĂ©es. C’Ă©tait la stratĂ©gie par dĂ©faut lors de la rĂ©solution de deux sommets pour Git depuis la version v0.99.9k jusqu’Ă  v2.33.0.

La stratégie recursive utilise les mêmes options que ort. Cependant, il y a trois options supplémentaires que ort ignore (non documentées ci-dessus) et qui sont potentiellement utiles avec la stratégie recursive :

patience

Synonyme obsolète pour diff-algorithm=patience.

diff-algorithm=[patience|minimal|histogram|myers]

Utiliser un algorithme de diff différent lors des fusions, ce qui peut aider à éviter les erreurs de fusion dues à des lignes de correspondance sans importance (comme des accolades de fonctions distinctes). Voir aussi git-diff[1] --diff-algorithm. Notez que ort utilise spécifiquement diff-algorithm=histogram, alors que recursive utilise par défaut le paramètre de configuration diff.algorithm.

no-renames

Désactiver la détection de renommage. Ceci annule la variable de configuration merge.renames. Voir aussi git-diff[1] --no-renames.

resolve

Cela ne peut rĂ©soudre que deux tĂŞtes (c’est-Ă -dire la branche actuelle et une autre branche dont vous avez tirĂ©) en utilisant un algorithme de fusion Ă  trois points. Cela essaie de dĂ©tecter avec soin les ambiguĂŻtĂ©s de la fusion croisĂ©e. Les renommages ne sont pas gĂ©rĂ©s.

octopus

Cela permet de rĂ©soudre les cas Ă  plus de deux tĂŞtes, mais refuse de faire une fusion complexe qui nĂ©cessite une rĂ©solution manuelle. C’est principalement destinĂ© Ă  ĂŞtre utilisĂ© pour regrouper les tĂŞtes de branches thĂ©matiques. C’est la stratĂ©gie de fusion par dĂ©faut lorsque l’on tire ou fusionne plusieurs branches.

ours

Cela rĂ©sout un nombre quelconque de tĂŞtes, mais l’arbre rĂ©sultant de la fusion est toujours celui de la tĂŞte de la branche actuelle, ignorant effectivement toutes les modifications provenant de toutes les autres branches. C’est censĂ© ĂŞtre utilisĂ© pour remplacer l’ancienne historique du dĂ©veloppement des branches latĂ©rales. Notez que cette stratĂ©gie est diffĂ©rente de l’option -Xours de la stratĂ©gie de fusion recursive.

subtree

Il s’agit d’une stratĂ©gie ort modifiĂ©e. Lors de la fusion des arbres A et B, si B correspond Ă  un sous-arbre de A, B est d’abord ajustĂ© pour correspondre Ă  la structure arborescente de A, au lieu de lire les arbres au mĂŞme niveau. Cet ajustement est Ă©galement effectuĂ© sur l’arbre de l’ancĂŞtre commun.

Avec les stratĂ©gies qui utilisent la fusion Ă  trois points (y compris la fusion par dĂ©faut, ort), si une modification est effectuĂ©e sur les deux branches, mais qu’elle est ensuite inversĂ©e sur l’une des branches, ce changement sera prĂ©sent dans le rĂ©sultat de la fusion ; certaines personnes trouvent ce comportement dĂ©routant. Cela se produit parce que seules les tĂŞtes et la base de la fusion sont prises en compte lors d’une fusion, et non le commit individuel. L’algorithme de fusion considère donc le changement inversĂ© comme n’Ă©tant pas un changement du tout, et substitue la version modifiĂ©e Ă  la place.

COMPORTEMENT PAR DÉFAUT

Souvent, les gens utilisent git pull sans donner aucun paramètre. Traditionnellement, cela équivaut à dire git pull origin. Cependant, lorsque la configuration branch.<nom>.remote est présente alors que sur la branche <nom>, cette valeur est utilisée à la place de origin.

Afin de dĂ©terminer l’URL Ă  utiliser pour rĂ©cupĂ©rer, la valeur de la configuration remote. <origine> .url est consultĂ©e et s’il n’y a pas une telle variable, la valeur sur la ligne URL: dans $GIT_DIR/remotes/<origine> est utilisĂ©e.

Afin de dĂ©terminer les branches distantes Ă  rĂ©cupĂ©rer (et Ă©ventuellement stocker dans les branches de suivi Ă  distance) lorsque la commande est exĂ©cutĂ©e sans aucun paramètre spĂ©c-de-rĂ©f sur la ligne de commande, les valeurs de la variable de configuration remote. <origine> .fetch sont consultĂ©es , et s’il n’y en a pas, $GIT_DIR/remotes/<origine> est consultĂ© et ses lignes Pull : sont utilisĂ©es. En plus des formats spĂ©c-de-rĂ©f dĂ©crits dans la section OPTIONS, vous pouvez avoir un motif de spĂ©cificateur de rĂ©fĂ©rence qui ressemble Ă  ceci :

refs/heads/*:refs/remotes/origin/*

Un motif de spĂ©cificateur de rĂ©fĂ©rence doit avoir un partie droite non vide (c’est-Ă -dire qu’elle doit stocker ce qui a Ă©tĂ© rĂ©cupĂ©rĂ© dans des branches de suivi Ă  distance), et ses parties gauches et parties droites doivent se terminer par /*. Ce qui prĂ©cède prĂ©cise que toutes les branches distantes sont suivies en utilisant les branches de suivi Ă  distance dans la hiĂ©rarchie refs/remotes/origin/ sous le mĂŞme nom.

La règle qui consiste à déterminer quelle branche distante doit être fusionnée après avoir été récupérée est un peu compliquée, afin de ne pas rompre la rétrocompatibilité.

Si des spécificateurs de référence explicites ont été donnés sur la ligne de commande de git pull, elles sont toutes fusionnées.

Lorsqu’aucun spĂ©cificateur de rĂ©fĂ©rence n’a Ă©tĂ© donnĂ© sur la ligne de commande, alors git pull utilise le spĂ©cificateur de rĂ©fĂ©rence de la configuration ou $GIT_DIR/remotes/<origine>. Dans de tels cas, les règles suivantes s’appliquent :

  1. Si la configuration branch.<nom>.merge pour la branche actuelle <nom> existe, c’est le nom de la branche du site distant en cours de fusion.

  2. Si le spĂ©cificateur de rĂ©fĂ©rence est un spĂ©cificateur motif, rien n’est fusionnĂ©.

  3. Sinon, la branche distante du premier spécificateur de référence est fusionnée.

EXEMPLES

  • Mettre Ă  jour les branches de suivi Ă  distance pour le dĂ©pĂ´t d’oĂą vous avez clonĂ©, puis fusionner l’une d’entre elles dans votre branche actuelle :

    $ git pull
    $ git pull origin

    Normalement, la branche fusionnée est la HEAD du dépôt distant, mais le choix est déterminé par les options branch. <nom> .remote et branch. <nom> .merge ; voir git-config[1] pour plus de détails.

  • Fusionner dans la branche actuelle la branche distante next :

    $ git pull origin next

    Cela laisse une copie de next temporairement dans FETCH_HEAD, et met pas à jour la branche de suivi à distance origin/next. La même chose peut être faite en invoquant fetch et merge :

    $ git fetch origin
    $ git merge origin/next

Si vous avez tenté un tirage qui a entraîné des conflits complexes et que vous souhaitez recommencer à zéro, vous pouvez vous rembobiner grâce à git reset.

SÉCURITÉ

Les protocoles "fetch" et "push" ne sont pas conçus pour empĂŞcher un tiers de voler des donnĂ©es de l’autre dĂ©pĂ´t qui n’Ă©taient pas destinĂ©es Ă  ĂŞtre partagĂ©es. Si vous avez des donnĂ©es privĂ©es que vous devez protĂ©ger contre un tiers malveillant, la meilleure solution est de les stocker dans un autre dĂ©pĂ´t. Cela s’applique aussi bien aux clients qu’aux serveurs. En particulier, les espaces de noms sur un serveur ne sont pas efficaces pour le contrĂ´le de l’accès en lecture ; vous ne devez accorder l’accès en lecture Ă  un espace de noms qu’aux clients auxquels vous feriez confiance pour l’accès en lecture Ă  l’ensemble du dĂ©pĂ´t.

Les vecteurs d’attaque connus sont les suivants :

  1. La victime envoie des lignes "have" annonçant les identifiants des objets qu’elle possède et qui ne sont pas explicitement destinĂ©s Ă  ĂŞtre partagĂ©s, mais qui peuvent ĂŞtre utilisĂ©s pour optimiser le transfert si le pair les possède Ă©galement. L’attaquant choisit un ID d’objet X Ă  voler et envoie une rĂ©fĂ©rence Ă  X, mais n’est pas obligĂ© d’envoyer le contenu de X parce que la victime l’a dĂ©jĂ . La victime croit maintenant que l’attaquant a X, et elle lui renvoie le contenu de X plus tard. (Cette attaque est la plus simple Ă  rĂ©aliser pour un client sur un serveur, en crĂ©ant une rĂ©fĂ©rence Ă  X dans l’espace de noms auquel le client a accès et en la rĂ©cupĂ©rant ensuite. La façon la plus probable pour un serveur de l’exĂ©cuter sur un client est de "fusionner" X dans une branche publique et d’espĂ©rer que l’utilisateur fasse un travail supplĂ©mentaire sur cette branche et la repousse vers le serveur sans remarquer la fusion).

  2. Comme en n°1, l’attaquant choisit un objet ID X Ă  voler. La victime envoie un objet Y que l’attaquant possède dĂ©jĂ , et l’attaquant prĂ©tend faussement avoir X et non Y, de sorte que la victime envoie Y comme delta contre X. Le delta rĂ©vèle Ă  l’attaquant des rĂ©gions de X qui sont similaires Ă  Y.

BOGUES

L’utilisation de --recurse-submodules ne permet actuellement d’obtenir de nouveaux commits que dans les sous-modules dĂ©jĂ  vĂ©rifiĂ©s . Lorsque, par exemple, un nouveau sous-module est ajoutĂ© dans les commit en amont qui viennent d’ĂŞtre rĂ©cupĂ©rĂ©s du superprojet, le sous-module lui-mĂŞme ne peut pas ĂŞtre rĂ©cupĂ©rĂ©, ce qui rend impossible de vĂ©rifier ce sous-module plus tard sans avoir Ă  le rĂ©cupĂ©rer Ă  nouveau. Ce problème devrait ĂŞtre corrigĂ© dans une prochaine version de Git.

GIT

Fait partie de la suite git[1]

TRADUCTION

Cette page de manuel a été traduite par Jean-Noël Avila <jn.avila AT free DOT fr> et les membres du projet git-manpages-l10n. Veuillez signaler toute erreur de traduction par un rapport de bogue sur le site https://github.com/jnavila/git-manpages-l10n .

scroll-to-top