¿Cómo git-cherry-pick solo cambia a ciertos archivos?

Si quiero fusionarme en una rama de Git, los cambios realizados solo en algunos de los archivos cambiaron en una confirmación particular que incluye cambios en varios archivos, ¿cómo se puede lograr esto?

Supongamos que el git commit llamada stufftiene cambios en los archivos A, B, C, y Dpero quiero fusionar sólo stuffcambios 's a archivos Ay B. Suena como un trabajo para, git cherry-pickpero cherry-picksolo sabe cómo combinar confirmaciones completas, no un subconjunto de los archivos.

Lo haría con cherry-pick -n( --no-commit), que le permite inspeccionar (y modificar) el resultado antes de confirmar:

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 gran mayoría de las modificaciones son cosas que no desea, en lugar de verificar rutas individuales (el paso intermedio), puede restablecer todo y luego agregar lo que desee:

# 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 .

Los otros métodos no funcionaron para mí, ya que la confirmación tuvo muchos cambios y conflictos con muchos otros archivos. Lo que se me ocurrió fue simplemente

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

En realidad, no contiene addlos archivos ni realiza una confirmación por usted, por lo que es posible que deba seguir con

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

O si desea omitir el complemento, puede usar el --cachedargumento paragit apply

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

También puede hacer lo mismo para directorios completos

git show SHA -- dir1 dir2 | git apply -

Por lo general, uso la -pbandera con un pago git de la otra rama, que me parece más fácil y más detallado que la mayoría de los otros métodos que he encontrado.

En principio:

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

ejemplo:

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

Luego, aparece un cuadro de diálogo que le pregunta qué cambios desea en los "blobs", esto prácticamente funciona para cada fragmento de cambio continuo de código que luego puede señalar y(Sí) n(No), etc. para cada fragmento de código.

La opción -po patchfunciona para una variedad de comandos en git, incluido el git stash save -pque le permite elegir qué desea guardar de su trabajo actual

A veces uso esta técnica cuando he hecho mucho trabajo y me gustaría separarla y comprometerme en más confirmaciones basadas en temas usando git add -py eligiendo lo que quiero para cada confirmación :)

Quizás la ventaja de este método sobre la respuesta de Jefromi es que no tienes que recordar qué comportamiento de git reset es el correcto :)

 # 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

La selección de cereza es elegir cambios de un "compromiso" específico. La solución más simple es elegir todos los cambios de ciertos archivos es usar

 git checkout source_branch <paths>...

Por ejemplo:

$ 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

Fuentes y explicación completa http://jasonrudolph.com/blog/2009/02/25/git-tip-how-to-merge-specific-files-from-another-branch/

ACTUALIZAR:

Con este método, git no FUSIONARÁ el archivo, simplemente anulará cualquier otro cambio realizado en la rama de destino. Deberá fusionar los cambios manualmente:

$ git diff HEAD nombre de archivo

La situación:

Estás en tu rama, digamos mastery tienes tu compromiso en cualquier otra rama. Debe elegir solo un archivo de esa confirmación en particular.

El enfoque:

Paso 1: Pago en la sucursal requerida.

git checkout master

Paso 2: asegúrese de haber copiado el hash de confirmación requerido.

git checkout commit_hash path\to\file

Paso 3: Ahora tiene los cambios del archivo requerido en la rama deseada. Solo necesita agregarlos y confirmarlos.

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

Simplemente elegiría todo, luego haría esto:

git reset --soft HEAD^

Luego revertiría los cambios que no quiero y luego realizaría una nueva confirmación.

Use git merge --squash branch_nameesto para obtener todos los cambios de la otra rama y preparará una confirmación para usted. Ahora elimine todos los cambios innecesarios y deje el que desee. Y git no sabrá que hubo una fusión.

Encontré otra forma que evita cualquier fusión conflictiva en la selección de cerezas, que en mi opinión es algo fácil de recordar y entender. Dado que en realidad no está seleccionando una confirmación, sino parte de ella, primero debe dividirla y luego crear una confirmación que se adapte a sus necesidades y seleccionarla.

Primero cree una rama desde el commit que desea dividir y pruébela:

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

Luego revierte el commit anterior:

$ git reset HEAD~1

Luego agregue los archivos / cambios que desea seleccionar:

$ git add FILE

y comprometerlo:

$ git commit -m "pick me"

tenga en cuenta el hash de confirmación, llamémoslo PICK-SHA y regresemos a su rama principal, master, por ejemplo, forzando el pago:

$ git checkout -f master

y escoge el commit:

$ git cherry-pick PICK-SHA

ahora puedes eliminar la rama temporal:

$ git branch -d temp -f

Combine una rama en una nueva (squash) y elimine los archivos que no necesita:

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

En aras de la integridad, lo que funciona mejor para mí es:

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

git status

Hace exactamente lo que OP quiere. Resuelve conflictos cuando es necesario, de manera similar, ¿cómo lo mergehace? Lo hace addpero no committus nuevos cambios.

Puedes usar:

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

La notación <commit>^especifica el (primer) padre de <commit>. Por lo tanto, este comando diff selecciona los cambios realizados <path>en el commit <commit>.

Tenga en cuenta que esto todavía no confirmará nada (como lo git cherry-pickhace). Entonces, si quieres eso, tendrás que hacer:

git add <path>
git commit