Ne valider qu’une partie d’un fichier dans Git

Lorsque je modifie un fichier dans Git, comment puis-je ne commettre que certaines des modifications?

Par exemple, comment puis-je ne commettre que 15 lignes sur 30 lignes modifiées dans un fichier?

Vous pouvez utiliser git add --patch (ou -p pour faire court), et git commencera à décomposer votre fichier en ce qu’il pense être des “morceaux” sensibles (parties du fichier). Il vous demandera 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
  • q quitter; ne pas mettre en scène ce morceau ou l’un des autres mecs
  • une scène ce morceau et tous les derniers mecs dans le fichier
  • d ne pas mettre en scène ce morceau ou l’un des derniers morceaux du fichier
  • g sélectionnez un morceau pour aller à
  • / recherche d’un morceau correspondant à l’expression régulière donnée
  • j laisse ce morceau indécis, vois le prochain morceau indécis
  • J laisse ce morceau indécis, vois prochain morceau
  • k laisser ce morceau indécis, voir le morceau précédent indécis
  • K laisse ce morceau indécis, voir le morceau précédent
  • s diviser le morceau actuel en plus petits mecs
  • e modifier manuellement le morceau actuel
  • ? aide à la copie

Si le fichier n’est pas encore dans le référentiel, vous pouvez d’abord git add -N . Ensuite, vous pouvez continuer avec git add -p .

Ensuite, vous pouvez utiliser:
git diff --staged pour vérifier que vous avez effectué les changements corrects
git reset -p pour désinstaller les mecs ajoutés par erreur
git commit -v pour voir votre commit pendant que vous éditez le message de validation.

Notez que ceci est très différent de la commande git format-patch , dont le but est d’parsingr les données de validation dans un fichier .patch .

Référence pour le futur: https://git-scm.com/book/en/v2/Git-Tools-Interactive-Staging

Vous pouvez utiliser git add --interactive ou git add -p < file > , puis git commit ( pas git commit -a ); voir Mode interactif dans la page de manuel git-add , ou suivez simplement les instructions.

Modern Git a également git commit --interactive (et git commit --patch , qui est un raccourci vers l’option de patch en validation interactive).

Si vous préférez le faire depuis l’interface graphique, vous pouvez utiliser git-gui . Vous pouvez simplement marquer les morceaux que vous souhaitez inclure dans commit. Je trouve personnellement plus facile que d’utiliser git add -i . D’autres interfaces utilisateur graphiques, telles que QGit ou GitX, peuvent également avoir cette fonctionnalité.

git gui fournit cette fonctionnalité sous la vue diff. Il suffit de cliquer avec le bouton droit sur la ou les lignes qui vous intéressent et vous devriez voir un élément de menu “mettre en ligne cette ligne à valider”.

Je pense que git add -e myfile est le moyen le plus simple (ma préférence au moins) car il 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 voulez pas. En ce qui concerne 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 place de leur suppression en convertissant le “-” en “” (espace).

contenu modifié:

Le contenu modifié est représenté par les lignes “-” (suppression de l’ancien contenu) suivies des lignes “+” (ajout du contenu de remplacement). Vous pouvez empêcher la mise en place de la modification en convertissant les lignes “-” en “” et en supprimant les lignes “+”. Attention, la modification de la moitié seulement de la paire risque d’introduire des modifications déroutantes dans l’index.

Tous les détails sur git add sont disponibles sur git --help add

Si vous utilisez vim, vous pouvez essayer l’excellent plugin appelé fugitive .

Vous pouvez voir le diff d’un fichier entre la copie de travail et l’index avec :Gdiff , puis append des lignes ou des pièces à l’index en utilisant les commandes classiques vim diff comme dp . Enregistrez les modifications dans l’index et :Gcommit avec :Gcommit , et vous avez terminé.

Très bons screencasts d’introduction ici (voir surtout la partie 2 ).

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

entrer la description de l'image ici

À noter que pour utiliser git add --patch pour un nouveau fichier, vous devez d’abord append le fichier à index avec git add --intent-to-add :

 git add -N file git add -p file 

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

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 d’habitude, sauf que parfois il y a beaucoup de changements et je peux dire que je peux me tromper en mettant en scène des choses, et je veux un état engagé sur lequel je peux me reposer.

Si vous utilisez emacs, jetez un oeil à Magit , qui fournit une interface git pour emacs. Il supporte assez bien les stades de stockage (parties de fichiers).

Tout comme la réponse de jdsumsion, vous pouvez également cacher votre travail actuel, mais ensuite utiliser un difftool comme meld pour extraire les modifications sélectionnées du stock. De cette façon, vous pouvez même éditer 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 permet de tester si votre code fonctionne toujours avant de le valider.

Pour ceux qui utilisent Git Extensions :

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 de droite, puis cliquez avec le bouton droit de la souris sur la sélection et choisissez «Scène des lignes sélectionnées» dans le menu contextuel.

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

entrer la description de l'image ici

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

 :GitGutterStageHunk 

À côté 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 la sélection de la plage visuelle puis :'<,'>diffput ou :'<,'>diffget pour mettre en scène / :'<,'>diffget les changements de ligne individuels.

Essayé git add -p filename.x , 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 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 éditer le fichier, par exemple dans TortoiseGitMerge et annuler toutes les modifications que vous ne voulez pas commettre. Après avoir enregistré ces modifications, vous pouvez valider le fichier.

Pour emacs il y a aussi gitsum

git-meld-index – citant le site web:

git-meld-index exécute meld – ou tout autre diff gt (kdiff3, diffuse, etc.) – pour vous permettre de mettre en scène de manière interactive les modifications de l’index git (également appelé zone de stading git).

Ceci est similaire à la fonctionnalité de git add -p et git add –interactive. Dans certains cas, Meld est plus facile à utiliser que git add -p. C’est parce que Meld vous permet, par exemple, de:

  • voir plus de contexte
  • voir les diff intra-lignes
  • éditer à la main et voir les mises à jour diff ‘en direct (mises à jour après chaque pression de touche)
  • naviguer vers un changement sans dire “n” à chaque changement que vous souhaitez ignorer

Usage

Dans un repository git, exécutez:

 git meld-index 

Vous verrez apparaître Meld (ou votre diffitool configuré) avec:

GAUCHE : répertoire temporaire des fichiers en continu copiés à partir de votre arbre de travail

RIGHT : 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 dans la copie de travail – dans ce cas, vous verrez le contenu du fichier depuis HEAD.

Modifiez l’index (à droite) jusqu’à ce que vous soyez satisfait. N’oubliez pas de sauvegarder en cas de besoin.

Lorsque vous avez terminé, fermez la fusion 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.

Comme indiqué ci-dessus, vous pouvez utiliser git add --patch filename.txt

ou la forme abrégée git add -p filename.txt

… mais pour les fichiers déjà présents dans votre repository, il est préférable d’utiliser l’option –patch flag sur la commande commit (si vous utilisez une version assez récente de git): git commit --patch filename.txt

… ou, encore une fois, git commit -p filename.txt

… puis en utilisant les clés mentionnées (y / n, etc.), pour choisir les lignes à inclure dans le commit.

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

Utiliser Atom permet de travailler avec un thème qui a un arrière-plan sombre (par défaut, git gui a un arrière-plan blanc).

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

entrer la description de l'image ici

Comme vous le savez, les lignes commençant par + sont des additions, les lignes commençant par - sont des suppressions. Alors:

  • Pour ne pas mettre en scène un ajout, supprimez simplement cette ligne.
  • Pour ne pas exécuter une suppression, remplacez simplement - par un espace .

C’est ce que git add -h dit sur l’ajout de fichiers de cette façon (fichiers de correctifs):

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 place de leur suppression en convertissant le “-” en “” (espace).

contenu modifié: le contenu modifié est représenté par les lignes “-” (suppression de l’ancien contenu) suivies des lignes “+” (ajout du contenu de remplacement). Vous pouvez empêcher la mise en place de la modification en convertissant les lignes “-” en “” et en supprimant les lignes “+”. Attention, la modification de la moitié seulement de la paire risque d’introduire des modifications déroutantes dans l’index.

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

Si c’est sur la plate-forme Windows , à mon avis, git gui est le meilleur outil pour stage en stage / commit quelques lignes à partir d’ unstaged fichier non unstaged

1. Morceau:

  • Sélectionnez le fichier dans la section unstagged Changes
  • Cliquez avec le bouton droit de la souris sur le morceau de code qui doit être mis en scène
  • Sélectionnez Stage Hunk for commit

2. Ligne sage:

  • Sélectionnez le fichier dans la section unstagged Changes
  • Sélectionnez la ligne / les lignes à placer
  • Sélectionner des Stage Lines for commit

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

  • Sélectionnez le fichier dans la section unstagged Changes
  • Appuyez sur Ctrl+T (Stage file to commit)
  • Le fichier sélectionné passe maintenant à la section Staged Changes
  • Sélectionnez la ligne / les lignes à placer
  • Sélectionner des UnStage Lines for commit

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.