Valider uniquement une partie d'un fichier dans Git

Lorsque j'apporte des modifications à un fichier dans Git, comment puis-je valider uniquement certaines des modifications?

Par exemple, comment pourrais-je valider seulement 15 lignes sur 30 lignes qui ont été modifiées dans un fichier?

Vous pouvez utiliser git add --patch <filename>(ou -ppour faire court), et git commencera à décomposer votre fichier en ce qu'il pense être des "mecs" sensés (parties du fichier). Il vous posera alors cette question:

Stage this hunk [y,n,q,a,d,/,j,J,g,s,e,?]?

Voici une description de chaque option:

• y mettre en scène ce morceau pour le prochain commit
• n ne pas mettre en scène ce morceau pour le prochain commit
• qquitter; ne mettez pas en scène ce morceau ou l'un des autres morceaux
• a mettre en scène ce morceau et tous les mecs ultérieurs dans le fichier
• d ne pas mettre en scène ce morceau ou l'un des derniers morceaux du fichier
• g sélectionner un morceau pour aller
• / rechercher un morceau correspondant à l'expression régulière donnée
• j laisser ce morceau indécis, voir le prochain morceau indécis
• J laisser ce morceau indécis, voir le morceau suivant
• k laisser ce morceau indécis, voir le morceau indécis précédent
• K laisser ce morceau indécis, voir le morceau précédent
• s diviser le morceau actuel en plus petits morceaux
• e éditer manuellement le morceau actuel
• ? imprimer l'aide du morceau

Si le fichier n'est pas encore dans le référentiel, vous pouvez d'abord le faire git add -N <filename>. Ensuite, vous pouvez continuer avecgit add -p <filename> .

Ensuite, vous pouvez utiliser:

• git diff --staged pour vérifier que vous avez mis en place les modifications correctes
• git reset -p pour mettre en scène des mecs ajoutés par erreur
• git commit -v pour afficher votre validation pendant que vous modifiez le message de validation.

Notez que cela est très différent de la git format-patchcommande, dont le but est d'analyser les données de validation dans un .patchfichier.

Référence pour l'avenir: Git Tools - Interactive Staging

Vous pouvez utiliser git add --interactiveou , puis ( non ); voir le mode interactif dans git-addgit add -p <file>git commit git commit -a page de manuel , ou suivez simplement les instructions.

Modern Git a également git commit --interactive(etgit commit --patch , qui est un raccourci vers l'option de patch dans la validation interactive).

Si vous préférez le faire à partir de l'interface graphique, vous pouvez utiliser git-gui . Vous pouvez simplement marquer les morceaux que vous souhaitez inclure dans la validation. Personnellement, je trouve cela plus facile que d'utiliser git add -i. D'autres interfaces graphiques git, comme QGit ou GitX, pourraient également avoir cette fonctionnalité.

git gui fournit cette fonctionnalité sous la vue diff. Faites simplement un clic droit sur la ou les lignes qui vous intéressent et vous devriez voir un élément de menu "Mettre cette ligne en ligne pour valider".

je crois que git add -e myfile c'est la façon la plus simple (ma préférence au moins) car elle ouvre simplement un éditeur de texte et vous permet de choisir la ligne que vous souhaitez mettre en scène et celle que vous ne souhaitez pas. Concernant les commandes d'édition:

contenu ajouté:

Le contenu ajouté est représenté par des lignes commençant par "+". Vous pouvez empêcher le transfert de lignes d'ajout en les supprimant.

contenu supprimé:

Le contenu supprimé est représenté par des lignes commençant par "-". Vous pouvez empêcher la mise en scène de leur suppression en convertissant le "-" en "" (espace).

contenu modifié:

Le contenu modifié est représenté par des lignes "-" (suppression de l'ancien contenu) suivies de lignes "+" (ajout du contenu de remplacement). Vous pouvez empêcher la mise en scène de la modification en convertissant les lignes "-" en "" et en supprimant les lignes "+". Attention, la modification de seulement la moitié de la paire risque d'introduire des changements déroutants dans l'indice.

Tous les détails git addsont disponibles surgit --help add

Si vous utilisez vim, vous voudrez peut-être essayer l'excellent plugin appelé fugitive .

Vous pouvez voir la différence d'un fichier entre la copie de travail et l'index avec :Gdiff, puis ajouter des lignes ou des morceaux à l'index à l'aide des commandes de diff vim classiques comme dp. Enregistrez les modifications dans l'index et validez avec :Gcommit, et vous avez terminé.

Très bons screencasts d'introduction ici (voir en particulier la partie 2 ).

Je recommanderais fortement d'utiliser SourceTree d'Atlassian. (C'est gratuit.) Cela rend cela trivial. Vous pouvez mettre en scène des morceaux de code individuels ou des lignes de code individuelles rapidement et facilement.

Il convient de noter que pour utiliser git add --patchun nouveau fichier, vous devez d'abord ajouter le fichier à indexer avec git add --intent-to-add:

git add -N file
git add -p file

Lorsque j'ai beaucoup de changements et que je vais finir par créer quelques commits à partir des changements, je veux enregistrer temporairement mon point de départ avant de mettre en scène les choses.

Comme ça:

$ git stash -u
Saved working directory and index state WIP on master: 47a1413 ...
$ git checkout -p stash
... step through patch hunks
$ git commit -m "message for 1st commit"
$ git checkout -p stash
... step through patch hunks
$ git commit -m "message for 2nd commit"
$ git stash pop

La réponse de Whymarrh est ce que je fais habituellement, sauf que parfois il y a beaucoup de changements et je peux dire que je peux faire une erreur en mettant en scène les choses, et je veux un état engagé sur lequel je peux me rabattre pour un deuxième passage.

Si vous utilisez emacs, jetez un œil à Magit , qui fournit une interface git pour emacs. Il prend assez bien en charge les segments intermédiaires (parties de fichiers).

Intellij IDEA (et je suppose que tous les autres produits de la série) prennent en charge les validations partielles depuis v2018.1

Pour ceux qui utilisent les extensions Git :

Dans la fenêtre Valider, sélectionnez le fichier que vous souhaitez valider partiellement, puis sélectionnez le texte que vous souhaitez valider dans le volet droit, puis cliquez avec le bouton droit sur la sélection et choisissez 'Mettre en scène les lignes sélectionnées' dans le menu contextuel.

Tout comme la réponse de jdsumsion, vous pouvez également cacher votre travail actuel, mais utiliser un outil différent comme meld pour extraire les modifications sélectionnées de la cachette. De cette façon, vous pouvez même modifier les mecs manuellement très facilement, ce qui est un peu pénible lorsque git add -p:

$ git stash -u
$ git difftool -d -t meld stash
$ git commit -a -m "some message"
$ git stash pop

L'utilisation de la méthode stash vous donne la possibilité de tester, si votre code fonctionne toujours, avant de le valider.

En ajoutant une réponse précédente, si vous préférez utiliser la ligne de commande, entrer git add -e myfilevous donne le choix de choisir ligne par ligne ce que vous voulez valider car cette commande ouvrira un éditeur avec les différences, comme ceci:

Comme vous le savez peut-être, les lignes commençant par +sont des ajouts, les lignes commençant par -sont des suppressions. Donc:

• Pour ne pas mettre en scène un ajout, supprimez simplement cette ligne.
• Pour ne pas mettre en scène une suppression, il suffit de la remplacer -par de l'espace .

Voici ce que git add -hdit l'ajout de fichiers de cette façon (patcher des fichiers):

contenu ajouté ajouté est représenté par des lignes commençant par "+". Vous pouvez empêcher le transfert de lignes d'ajout en les supprimant.

contenu supprimé: supprimé est représenté par des lignes commençant par "-". Vous pouvez empêcher la mise en scène de leur suppression en convertissant le "-" en "" (espace).

contenu modifié: le contenu modifié est représenté par des lignes "-" (suppression de l'ancien contenu) suivies de lignes "+" (ajout du contenu de remplacement). Vous pouvez empêcher la mise en scène de la modification en convertissant les lignes "-" en "" et en supprimant les lignes "+". Attention, la modification de seulement la moitié de la paire risque d'introduire des changements déroutants dans l'indice.

Attention: ne modifiez pas le contenu du fichier, ce n'est pas un bon endroit pour le faire. Modifiez simplement les opérateurs des lignes supprimées ou ajoutées.

Le plugin vim-gitgutter peut mettre en scène des mecs sans quitter l'éditeur vim en utilisant

:GitGutterStageHunk

En plus de cela, il fournit d'autres fonctionnalités intéressantes comme une colonne de signe diff comme dans certains IDE modernes

Si seulement une partie du morceau doit être mise en scène vim-fugitive

:Gdiff

permet ensuite la sélection visuelle de la plage :'<,'>diffputou :'<,'>diffgetpour mettre en scène / annuler les modifications de ligne individuelles.

git add -p filename.xJ'ai essayé , mais sur un mac, j'ai trouvé que gitx ( http://gitx.frim.nl/ ou https://github.com/pieter/gitx ) était beaucoup plus facile à valider exactement les lignes que je voulais.

Avec TortoiseGit:

faites un clic droit sur le fichier et utilisez Context Menu → Restore after commit. Cela créera une copie du fichier tel quel. Ensuite, vous pouvez modifier le fichier, par exemple dans TortoiseGitMerge et annuler toutes les modifications que vous ne souhaitez pas valider. Après avoir enregistré ces modifications, vous pouvez valider le fichier.

Cela fait 10 ans que cette question a été posée. Et j'espère que cette réponse sera utile à quelqu'un. Comme mentionné dans la réponse ici , où l'interface graphique n'est pas une option, l' extension de crecord d' Andrew Shadura permet d'apporter une fenêtre ncurses dans laquelle nous pouvons sélectionner les lignes à valider.

Configurez l'extension comme suit:

git clone https://github.com/andrewshadura/git-crecord
cd git-crecord
./setup.py install
ln -s $PWD/git-crecord ~/.local/bin/git-crecord

cd à votre dépôt git et invoquez-le comme suit:

git crecord

Cela ferait apparaître l'interface ncurses qui peut être utilisée comme indiqué ci-dessous. Appuyez sur les touches suivantes dans la fenêtre ncurses pour effectuer certaines actions:

f       hunk toggle fold (arrow keys can also be used)
space   toggle hunk selection
a       toggle commit or amend
c       confirm and open commit window

Screencast montrant un exemple d'utilisation

Pour les utilisateurs d' Atom , le package github comprend une mise en scène interactive, dans le style de git gui. Pour les raccourcis, voir la documentation du package .

L'utilisation d'Atom permet de travailler avec un thème qui a un fond sombre (par défaut, git guia un fond blanc).

Pour emacs il y a aussi du gitsum

git-meld-index - extrait du site Web:

git-meld-index exécute meld - ou tout autre outil git difftool (kdiff3, diffus, etc.) - pour vous permettre de mettre en scène de manière interactive les modifications de l'index git (également connu sous le nom de zone de transit git).

Ceci est similaire à la fonctionnalité de git add -p et git add --interactive. Dans certains cas, meld est plus facile / plus rapide à utiliser que git add -p. En effet, meld vous permet, par exemple, de:

• voir plus de contexte
• voir les différences intra-ligne
• modifier à la main et voir les mises à jour de diff en direct (mises à jour après chaque pression de touche)
• accédez à un changement sans dire «n» à chaque changement que vous souhaitez ignorer

Usage

Dans un référentiel git, exécutez:

git meld-index

Vous verrez meld (ou votre gt difftool configuré) apparaître avec:

GAUCHE : répertoire temporaire contenant les fichiers copiés à partir de votre arborescence de travail

DROITE : répertoire temporaire avec le contenu de l'index. Cela inclut également les fichiers qui ne sont pas encore dans l'index mais qui sont modifiés ou non suivis dans la copie de travail - dans ce cas, vous verrez le contenu du fichier de HEAD.

Modifiez l'index (côté droit) jusqu'à ce que vous soyez satisfait. N'oubliez pas d'enregistrer en cas de besoin.

Lorsque vous avez terminé, fermez meld et git-meld-index mettra à jour l'index pour qu'il corresponde au contenu du répertoire temporaire sur le côté droit de meld que vous venez de modifier.

Si c'est sur la Windowsplate-forme, à mon avis, git guic'est un très bon outil pour stage/ commitquelques lignes deunstaged fichier

1. En ce qui concerne le gros morceau:

• Sélectionnez le fichier dans la unstagged Changessection
• Clic droit morceau de code qui doit être mis en scène
• Sélectionner Stage Hunk for commit

2. Ligne sage:

• Sélectionnez le fichier dans la unstagged Changessection
• Sélectionnez la ou les lignes à mettre en scène
• Faites un clic droit et sélectionnez Stage Lines for commit

3. Si vous souhaitez mettre en scène le fichier complet sauf quelques lignes:

• Sélectionnez le fichier dans la unstagged Changessection
• presse Ctrl+T (Stage file to commit)
• Le fichier sélectionné est désormais déplacé vers la Staged Changessection
• Sélectionnez la ou les lignes à mettre en scène
• Faites un clic droit et sélectionnez UnStage Lines for commit

Comme le montre une des réponses ci-dessus, vous pouvez utiliser git add --patch filename.txt

ou la forme courte git add -p filename.txt

... mais pour les fichiers déjà dans votre référentiel, il est préférable d'utiliser s --patch flag sur la commande commit directement (si vous utilisez une version assez récente de git): git commit --patch filename.txt

... ou, encore une fois, la forme courte git commit -p filename.txt

... puis en utilisant les clés mentionnées, (o / n, etc.) pour choisir les lignes à inclure dans la validation.

git-cola est une excellente interface graphique et a également cette fonctionnalité intégrée. Sélectionnez simplement les lignes à mettre en scène et appuyez sur S. Si aucune sélection n'est effectuée, le morceau complet est mis en scène.