Git 🌙
Français ▾ Topics ▾ Latest version ▾ git-apply last updated in 2.47.0

NOM

git-apply - Applique une rustine Ă  des fichiers et/ou Ă  l’index

SYNOPSIS

git apply [--stat] [--numstat] [--summary] [--check]
	  [--index | --intent-to-add] [--3way] [--ours | --theirs | --union]
	  [--apply] [--no-add] [--build-fake-ancestor=<fichier>] [-R | --reverse]
	  [--allow-binary-replacement | --binary] [--reject] [-z]
	  [-p<n>] [-C<n>] [--inaccurate-eof] [--recount] [--cached]
	  [--ignore-space-change | --ignore-whitespace]
	  [--whitespace=(nowarn|warn|fix|error|error-all)]
	  [--exclude=<chemin>] [--include=<chemin>] [--directory=<racine>]
	  [--verbose | --quiet] [--unsafe-paths] [--allow-empty] [<rustine>…​]

DESCRIPTION

Lit la sortie diff fournie (c’est-Ă -dire "une rustine") et l’applique aux fichiers. Lors de l’exĂ©cution Ă  partir d’un sous-rĂ©pertoire dans un dĂ©pĂ´t, les chemins patchĂ©s en dehors du rĂ©pertoire sont ignorĂ©s. Avec l’option --index, la rustine est Ă©galement appliquĂ©e Ă  l’index, et avec l’option --cached, la rustine est seulement appliquĂ©e Ă  l’index. Sans ces options, la commande applique la rustine uniquement aux fichiers, et n’exige pas qu’ils soient dans un dĂ©pĂ´t Git.

Cette commande applique la rustine mais ne crée pas de commit. Utilisez git-am[1] pour créer des commits à partir des rustines générées par git-format-patch[1] et/ou reçus par courrier électronique.

OPTIONS

<rustine>…​

Prendre la rustine depuis le fichier indiquĂ©. Utilisez - pour lire la rustine depuis l’entrĂ©e standard.

--stat

Au lieu d’appliquer la rustine, afficher le diffstat de l’entrĂ©e. DĂ©sactiver "appliquer".

--numstat

Similaire à --stat, mais afficher le nombre de lignes ajoutées ou supprimées en notation décimale et le nom de chemin sans abréviation, pour le rendre plus facile à traiter automatiquement. Pour les fichiers binaires, affiche deux - au lieu de 0 0. Désactive "apply".

--summary

Au lieu d’appliquer la rustine, produire un rĂ©sumĂ© condensĂ© des informations obtenues Ă  partir des en-tĂŞtes Ă©tendus de git diff, tels que les crĂ©ations, les renommages et les changements de mode. DĂ©sactive "apply".

--check

Au lieu d’appliquer la rustine, voir si la rustine est applicable Ă  l’arbre de travail actuel et/ou au fichier d’index et dĂ©tecte les erreurs. DĂ©sactive "apply".

--index

Appliquer la rustine Ă  la fois Ă  l’index et Ă  l’arbre de travail (ou vĂ©rifier simplement qu’il s’appliquerait proprement aux deux si --check est en vigueur). Notez que --index s’attend Ă  ce que les entrĂ©es de l’index et les copies de l’arbre de travail pour les chemins pertinents soient identiques (leur contenu et leurs mĂ©tadonnĂ©es telles que le mode de fichier doivent correspondre), et qu’il gĂ©nĂ©rera une erreur si ce n’est pas le cas, mĂŞme si la rustine s’applique proprement Ă  l’index et Ă  l’arbre de travail de manière isolĂ©e.

--cached

Appliquer la rustine uniquement sur l’index, sans toucher l’arbre de travail. Si la fonction --check est activĂ©e, vĂ©rifier simplement qu’elle s’applique correctement Ă  l’entrĂ©e de l’index.

--intent-to-add

Lorsque de l’application de la rustine uniquement Ă  l’arbre de travail, marquer les nouveaux fichiers Ă  ajouter Ă  l’index plus tard (voir l’option --intent-to-add dans git-add[1]). Cette option est ignorĂ©e sauf si elle est exĂ©cutĂ©e dans un dĂ©pĂ´t Git et que --index n’est pas spĂ©cifiĂ©. Notez que --index peut ĂŞtre implicite par d’autres options telles que --cached ou --3way.

-3
--3way

Tenter une fusion Ă  3 voies si la rustine enregistre l’identitĂ© des blobs auxquels elle est censĂ©e s’appliquer et que nous avons ces blobs disponibles localement, laissant Ă©ventuellement les marqueurs de conflit dans les fichiers de l’arbre de travail pour que l’utilisateur les rĂ©solve. Cette option implique l’option --index sauf si l’option --cached est utilisĂ©e, et est incompatible avec l’option --reject. Lorsqu’elle est utilisĂ©e avec l’option --cached, tous les conflits sont laissĂ©s Ă  des Ă©tapes supĂ©rieures dans le cache.

--ours
--theirs
--union

Au lieu de laisser les conflits dans le dossier, résoudre les conflits en faveur des lignes de notre côté (ou du leur ou des deux). Nécessite --3way.

--build-fake-ancestor=<fichier>

La nouvelle sortie git diff contient des informations d’index pour chaque blob afin d’identifier la version originale Ă  laquelle la rustine s’applique. Lorsque ce drapeau est donnĂ©, et si les versions originales des blobs sont disponibles localement, construire un index temporaire contenant ces blobs.

Lorsqu’un changement de mode pur est rencontrĂ© (qui n’a pas d’information d’index), l’information est lue Ă  partir de l’index actuel Ă  la place.

-R
--reverse

Appliquer la rustine Ă  rebours.

--reject

Pour l’atomicitĂ©, git apply par dĂ©faut ne fonctionne pas sur l’ensemble de la rustine et ne touche pas l’arbre de travail lorsque certaines des sections ne s’appliquent pas. Cette option permet d’appliquer les parties de la rustine qui sont applicables et de laisser les sections rejetĂ©es dans les fichiers *.rej correspondants.

-z

Lorsque le --numstat a été donné, ne pas changer les noms de chemin, mais utiliser un format lisible par machine et terminé par NUL.

Sans cette option, les noms de chemin avec des caractères « inhabituels » sont cités comme expliqué pour la variable de configuration core.quotePath (voir git-config[1]).

-p<n>

Supprimer les composants <n> du chemin d’accès principal (sĂ©parĂ©s par des barres obliques) des chemins de diff traditionnels. Par exemple, avec -p2, une rustine contre a/dir/fichier sera appliquĂ©e directement Ă  fichier. La valeur par dĂ©faut est 1.

-C<n>

S’assurer qu’au moins <n> lignes du contexte environnant correspondent avant et après chaque modification. Lorsqu’il y a moins de lignes de contexte environnant, elles doivent toutes correspondre. Par dĂ©faut, aucun contexte n’est jamais ignorĂ©.

--unidiff-zero

Par dĂ©faut, git apply s’attend Ă  ce que la rustine appliquĂ©e soit un diff unifiĂ© avec au moins une ligne de contexte. Ceci fournit de bonnes mesures de sĂ©curitĂ©, mais s’effondre lorsque l’on applique un diff gĂ©nĂ©rĂ© avec --unified=0. Pour contourner ces vĂ©rifications, utilisez --unidiff-zero.

Notez que, pour les raisons mentionnĂ©es ci-dessus, l’utilisation de rustines sans contexte est dĂ©couragĂ©e.

--apply

Si vous utilisez l’une des options marquĂ©es "DĂ©sactiver apply" ci-dessus, git apply lit et produit les informations demandĂ©es sans appliquer la rustine. Donnez ce drapeau après ces drapeaux pour appliquer Ă©galement la rustine.

--no-add

Lors de l’application d’une rustine, ignorer les ajouts faits par la rustine. Cette option peut ĂŞtre utilisĂ©e pour extraire la partie commune entre deux fichiers en exĂ©cutant d’abord diff sur ceux-ci et en appliquant le rĂ©sultat avec cette option, ce qui appliquerait la partie de suppression mais pas la partie d’ajout.

--allow-binary-replacement
--binary

Historiquement, nous n’autorisions pas l’application de rustines binaires sans une autorisation explicite de l’utilisateur, et ce drapeau Ă©tait le moyen de le faire. Actuellement, nous autorisons toujours l’application de rustines binaires, donc c’est un non-op.

--exclude=<motif-de-chemin>

Ne pas appliquer les modifications aux fichiers correspondant au modèle de chemin donnĂ©. Cela peut ĂŞtre utile lors de l’importation d’ensembles de rustines, lorsque vous souhaitez exclure certains fichiers ou rĂ©pertoires.

--include=<modèle-de-chemin>

Appliquer les modifications aux fichiers correspondant au modèle de chemin donnĂ©. Cela peut ĂŞtre utile lors de l’importation d’ensembles de rustines, lorsque vous souhaitez inclure certains fichiers ou rĂ©pertoires.

Lorsque des motifs --exclude et --include sont utilisĂ©s, ils sont examinĂ©s dans l’ordre oĂą ils apparaissent sur la ligne de commande, et la première correspondance dĂ©termine si une rustine est utilisĂ©e pour chaque chemin. Une rustine pour un chemin qui ne correspond Ă  aucun motif d’inclusion/exclusion est utilisĂ©e par dĂ©faut s’il n’y a pas de motif d’inclusion sur la ligne de commande, et ignorĂ©e s’il y a un motif d’inclusion.

--ignore-space-change
--ignore-whitespace

Lors de l’application d’une rustine, ignorer les modifications d’espaces blancs dans les lignes de contexte si nécessaire. Les lignes contextatives préserveront leurs espaces blancs, et elles ne subiront pas de correction d’espaces blancs quelle que soit la valeur de l’option --whitespace. Les nouvelles lignes seront toutefois encore corrigées.

--whitespace=<action>

Lors de l’application d’une rustine, dĂ©tecter une ligne nouvelle ou modifiĂ©e qui comporte des erreurs d’espacement. Ce qui est considĂ©rĂ© comme des erreurs d’espacement est contrĂ´lĂ© par la configuration core.whitespace. Par dĂ©faut, les espaces de fin de ligne (y compris les lignes qui ne sont composĂ©es que d’espaces) et un caractère espace qui est immĂ©diatement suivi d’un caractère de tabulation Ă  l’intĂ©rieur de l’indentation initiale de la ligne sont considĂ©rĂ©s comme des erreurs d’espacement.

Par dĂ©faut, la commande Ă©met des messages d’avertissement mais applique la rustine. Lorsque git-apply est utilisĂ© pour des statistiques et non pour appliquer une rustine, la valeur par dĂ©faut est nowarn.

Vous pouvez utiliser différentes valeurs de <action> pour contrôler ce comportement :

  • nowarn dĂ©sactive l’alerte d’espace blanc.

  • warn Ă©met des avertissements pour quelques erreurs de ce type, mais applique la rustine tel quel (par dĂ©faut).

  • fix Ă©met des avertissements pour quelques erreurs de ce type, et applique la rustine après les avoir corrigĂ©es (strip est un synonyme — l’outil utilisĂ© pour ne considĂ©rer que les caractères d’espacement de fin de ligne comme des erreurs, et le correctif impliquait de les "dĂ©pouiller" (stripping), mais les Gits modernes font plus).

  • error gĂ©nère des avertissements pour quelques-unes de ces erreurs et refuse d’appliquer la rustine.

  • Le terme error-all est similaire Ă  error mais montre toutes les erreurs.

--inaccurate-eof

Dans certaines circonstances, certaines versions de diff ne dĂ©tectent pas correctement une nouvelle ligne manquante Ă  la fin du fichier. Par consĂ©quent, les rustines crĂ©Ă©es par ces programmes de diff n’enregistrent pas correctement les lignes incomplètes. Cette option permet d’appliquer ces rustines en contournant ce bogue.

-v
--verbose

Afficher l’Ă©tat d’avancement sur stderr. Par dĂ©faut, seul un message concernant la rustine en cours d’application sera imprimĂ©. Cette option entraĂ®nera l’affichage d’informations supplĂ©mentaires.

-q
--quiet

Supprimer la sortie stderr. Les messages concernant l’Ă©tat et la progression du rustinage ne seront pas imprimĂ©s.

--recount

Ne pas se fier au nombre de lignes dans les en-têtes de sections, mais le déduire en inspectant la rustine (par exemple, après avoir modifié la rustine sans avoir ajusté les en-têtes de section de manière appropriée).

--directory=<racine>

Préfixer <racine> à tous les noms de fichiers. Si un argument "-p" a également été passé, il est appliqué avant de préfixer la nouvelle racine.

Par exemple, une rustine qui parle de mettre Ă  jour a/git-gui.sh en b/git-gui.sh peut ĂŞtre appliquĂ©e au fichier dans l’arbre de travail modules/git-gui/git-gui.sh en lançant git apply --directory=modules/git-gui.

--unsafe-paths

Par dĂ©faut, une rustine qui affecte l’extĂ©rieur de la zone de travail (soit une arborescence de travail contrĂ´lĂ©e par Git, soit le rĂ©pertoire de travail actuel lorsque "git apply" est utilisĂ© en remplacement de patch de GNU) est rejetĂ© comme une erreur (ou un mĂ©fait).

Lorsque git apply est utilisĂ© comme « meilleur patch GNU », l’utilisateur peut passer l’option --unsafe-paths pour passer outre cette vĂ©rification de sĂ©curitĂ©. Cette option n’a aucun effet lorsque --index ou --cached est utilisĂ©.

--allow-empty

Ne pas renvoyer d’erreur pour les rustines ne contenant pas de diff. Cela inclut les rustines vides et les rustines contenant uniquement du texte de validation.

CONFIGURATION

Warning

Missing fr/includes/cmd-config-section-all.txt

See original version for this content.

Warning

Missing fr/config/apply.txt

See original version for this content.

SOUS-MODULES

Si la rustine contient des modifications de sous-modules, alors git apply traite ces modifications comme suit.

Si --index est spĂ©cifiĂ© (explicitement ou implicitement), alors les commits du sous-module doivent correspondre exactement Ă  l’index pour que la rustine s’applique. Si l’un des sous-modules est extrait, alors ces vĂ©rifications sont complètement ignorĂ©es, c’est-Ă -dire qu’il n’est pas nĂ©cessaire qu’il soit Ă  jour ou propre et qu’il n’est pas mis Ă  jour.

Si --index n’est pas spĂ©cifiĂ©, alors les commits de sous-module dans la rustine sont ignorĂ©es et seule l’absence ou la prĂ©sence du sous-rĂ©pertoire correspondant est vĂ©rifiĂ©e et (si possible) mise Ă  jour.

VOIR AUSSI

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