Comment git-cherry-pick uniquement les modifications apportées à certains fichiers?

Si je souhaite fusionner dans une branche Git les modifications apportées uniquement à certains des fichiers modifiés dans un commit particulier qui inclut des modifications sur plusieurs fichiers, comment cela peut-il être réalisé?

Supposons que le git commit appelé stuffa des modifications aux fichiers A, B, Cet , Dmais je veux fusionner seulement des stuffchangements de » aux fichiers Aet B. Cela ressemble à un travail git cherry-pickmais cherry-pickne sait que fusionner des validations entières, pas un sous-ensemble des fichiers.

Je le ferais avec cherry-pick -n( --no-commit) qui vous permet d'inspecter (et de modifier) ​​le résultat avant de valider:

git cherry-pick -n <commit>

# unstage modifications you don't want to keep, and remove the
# modifications from the work tree as well.
# this does work recursively!
git checkout HEAD <path>

# commit; the message will have been stored for you by cherry-pick
git commit

Si la grande majorité des modifications sont des choses que vous ne voulez pas, au lieu de vérifier les chemins individuels (étape intermédiaire), vous pouvez tout réinitialiser, puis ajouter ce que vous voulez:

# unstage everything
git reset HEAD

# stage the modifications you do want
git add <path>

# make the work tree match the index
# (do this from the top level of the repo)
git checkout .

Les autres méthodes n'ont pas fonctionné pour moi car le commit a eu beaucoup de changements et de conflits avec beaucoup d'autres fichiers. Ce que j'ai trouvé, c'était simplement

git show SHA -- file1.txt file2.txt | git apply -

Il ne s'agit pas réellement adddes fichiers ou ne fait pas de commit pour vous, vous devrez donc peut-être le suivre avec

git add file1.txt file2.txt
git commit -c SHA

Ou si vous souhaitez ignorer l'ajout, vous pouvez utiliser l' --cachedargument pourgit apply

git show SHA -- file1.txt file2.txt | git apply --cached -

Vous pouvez également faire la même chose pour des répertoires entiers

git show SHA -- dir1 dir2 | git apply -

J'utilise généralement le -pdrapeau avec une vérification git de l'autre branche que je trouve plus facile et plus granulaire que la plupart des autres méthodes que j'ai rencontrées.

En principe:

git checkout <other_branch_name> <files/to/grab in/list/separated/by/spaces> -p

exemple:

git checkout mybranch config/important.yml app/models/important.rb -p

Vous obtenez alors une boîte de dialogue vous demandant quelles modifications vous voulez dans les "blobs", cela fonctionne à peu près à chaque bloc de changement de code continu que vous pouvez ensuite signaler y(Oui) n(Non), etc. pour chaque bloc de code.

L' option -pou patchfonctionne pour une variété de commandes dans git notamment git stash save -pqui vous permet de choisir ce que vous voulez cacher de votre travail actuel

J'utilise parfois cette technique lorsque j'ai fait beaucoup de travail et que je voudrais le séparer et effectuer des validations basées sur des sujets en utilisant git add -pet en choisissant ce que je veux pour chaque validation :)

L'avantage de cette méthode par rapport à la réponse de Jefromi est peut-être que vous n'avez pas à vous rappeler quel comportement de git reset est le bon :)

 # Create a branch to throw away, on which we'll do the cherry-pick:
 git checkout -b to-discard

 # Do the cherry-pick:
 git cherry-pick stuff

 # Switch back to the branch you were previously on:
 git checkout -

 # Update the working tree and the index with the versions of A and B
 # from the to-discard branch:
 git checkout to-discard -- A B

 # Commit those changes:
 git commit -m "Cherry-picked changes to A and B from [stuff]"

 # Delete the temporary branch:
 git branch -D to-discard

Cherry pick consiste à sélectionner les modifications à partir d'un "commit" spécifique. La solution la plus simple consiste à sélectionner toutes les modifications de certains fichiers est d'utiliser

 git checkout source_branch <paths>...

Par exemple:

$ git branch
* master
  twitter_integration
$ git checkout twitter_integration app/models/avatar.rb db/migrate/20090223104419_create_avatars.rb test/unit/models/avatar_test.rb test/functional/models/avatar_test.rb
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   new file:   app/models/avatar.rb
#   new file:   db/migrate/20090223104419_create_avatars.rb
#   new file:   test/functional/models/avatar_test.rb
#   new file:   test/unit/models/avatar_test.rb
#
$ git commit -m "'Merge' avatar code from 'twitter_integration' branch"
[master]: created 4d3e37b: "'Merge' avatar code from 'twitter_integration' branch"
4 files changed, 72 insertions(+), 0 deletions(-)
create mode 100644 app/models/avatar.rb
create mode 100644 db/migrate/20090223104419_create_avatars.rb
create mode 100644 test/functional/models/avatar_test.rb
create mode 100644 test/unit/models/avatar_test.rb

Sources et explication complète http://jasonrudolph.com/blog/2009/02/25/git-tip-how-to-merge-specific-files-from-another-branch/

MISE À JOUR:

Avec cette méthode, git ne fusionnera pas le fichier, il remplacera simplement toute autre modification effectuée sur la branche de destination. Vous devrez fusionner les modifications manuellement:

$ git diff HEAD nom de fichier

La situation:

Vous êtes sur votre branche, disons masteret vous avez votre engagement sur une autre branche. Vous devez choisir un seul fichier de ce commit particulier.

L'approche:

Étape 1: Caisse sur la branche requise.

git checkout master

Étape 2: assurez-vous d'avoir copié le hachage de validation requis.

git checkout commit_hash path\to\file

Étape 3: Vous avez maintenant les modifications du fichier requis sur la branche souhaitée. Il vous suffit de les ajouter et de les valider.

git add path\to\file
git commit -m "Your commit message"

Je choisirais simplement tout, puis je ferais ceci:

git reset --soft HEAD^

Ensuite, je reviendrais sur les modifications que je ne veux pas, puis je ferais un nouveau commit.

Utilisez git merge --squash branch_namececi pour obtenir toutes les modifications de l'autre branche et préparer un commit pour vous. Maintenant, supprimez toutes les modifications inutiles et laissez celle que vous souhaitez. Et git ne saura pas qu'il y a eu une fusion.

J'ai trouvé un autre moyen qui empêche toute fusion conflictuelle sur la cueillette des cerises dont l'OMI est assez facile à retenir et à comprendre. Étant donné que vous n'êtes pas en train de choisir un commit, mais une partie de celui-ci, vous devez d'abord le diviser, puis créer un commit qui conviendra à vos besoins et le choisir.

Créez d'abord une branche à partir du commit que vous souhaitez fractionner et extrayez-la:

$ git checkout COMMIT-TO-SPLIT-SHA -b temp

Revenez ensuite au commit précédent:

$ git reset HEAD~1

Ajoutez ensuite les fichiers / modifications que vous souhaitez sélectionner:

$ git add FILE

et engagez-le:

$ git commit -m "pick me"

notez le hachage de validation, appelons-le PICK-SHA et revenons à votre branche principale, master forçant par exemple le checkout:

$ git checkout -f master

et choisissez le commit:

$ git cherry-pick PICK-SHA

vous pouvez maintenant supprimer la branche temporaire:

$ git branch -d temp -f

Fusionnez une branche en une nouvelle (squash) et supprimez les fichiers inutiles:

git checkout master
git checkout -b <branch>
git merge --squash <source-branch-with-many-commits>
git reset HEAD <not-needed-file-1>
git checkout -- <not-needed-file-1>
git reset HEAD <not-needed-file-2>
git checkout -- <not-needed-file-2>
git commit

Par souci d'exhaustivité, ce qui fonctionne le mieux pour moi est:

git show YOURHASH --no-color -- file1.txt file2.txt dir3 dir4 | git apply -3 --index -

git status

Il fait exactement ce que souhaite OP. Il résout les conflits en cas de besoin, de la même manière merge. Ce n'est addpas commitle cas mais pas vos nouveaux changements.

Vous pouvez utiliser:

git diff <commit>^ <commit> -- <path> | git apply

La notation <commit>^spécifie le (premier) parent de <commit>. Par conséquent, cette commande diff sélectionne les modifications apportées au <path>commit <commit>.

Notez que cela git cherry-pickn'engagera rien encore (comme le fait). Donc, si vous le souhaitez, vous devrez faire:

git add <path>
git commit