Como o git-cherry-pick altera apenas alguns arquivos?

Se eu quiser mesclar em uma ramificação Git, as alterações feitas apenas em alguns dos arquivos alterados em uma confirmação específica que inclui alterações em vários arquivos, como isso pode ser alcançado?

Suponha que o git commit chamada stufftem alterações em arquivos A, B, C, e D, mas eu quero fundir apenas stuffmudanças 's para arquivos Ae B. Parece um trabalho para, git cherry-pickmas cherry-picksó sabe mesclar confirmações inteiras, não um subconjunto dos arquivos.

Eu faria isso com cherry-pick -n( --no-commit), que permite inspecionar (e modificar) o 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

Se a grande maioria das modificações são coisas que você não deseja, em vez de verificar caminhos individuais (a etapa do meio), você pode redefinir tudo de volta e adicionar o que deseja:

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

Os outros métodos não funcionaram para mim, pois o commit teve muitas alterações e conflitos em muitos outros arquivos. O que eu vim com foi simplesmente

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

Na verdade, ele não copia addos arquivos ou faz um commit para você; portanto, talvez seja necessário segui-lo

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

Ou, se você quiser pular a adição, use o --cachedargumento paragit apply

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

Você também pode fazer o mesmo por diretórios inteiros

git show SHA -- dir1 dir2 | git apply -

Normalmente, uso a -pflag com um checkout git do outro ramo, que acho mais fácil e mais granular do que a maioria dos outros métodos que encontrei.

Em princípio:

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

exemplo:

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

Você então recebe uma caixa de diálogo perguntando quais alterações você deseja em "blobs", isso praticamente funciona em cada parte da mudança contínua de código que você pode sinalizar y(Sim) n(Não) etc para cada parte do código.

A opção -pou patchfunciona para uma variedade de comandos no git, incluindo o git stash save -pque permite que você escolha o que deseja esconder do seu trabalho atual

Às vezes uso essa técnica quando tenho feito muito trabalho e gostaria de separá-la e confirmar em mais confirmações baseadas em tópicos, usando git add -pe escolhendo o que eu quero para cada confirmação :)

Talvez a vantagem desse método sobre a resposta de Jefromi seja que você não precisa se lembrar de qual comportamento do git reset é o correto :)

 # 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

Escolha de cereja é escolher as alterações de um "commit" específico. A solução mais simples é escolher todas as alterações de determinados arquivos é usar

 git checkout source_branch <paths>...

No exemplo:

$ 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

Fontes e explicação completa http://jasonrudolph.com/blog/2009/02/25/git-tip-how-to-merge-specific-files-from-another-branch/

ATUALIZAR:

Com esse método, o git não MERGE o arquivo, substituirá qualquer outra alteração feita na ramificação de destino. Você precisará mesclar as alterações manualmente:

Nome do arquivo $ git diff HEAD

A situação:

Você está no seu ramo, digamos, mastere você tem seu commit em qualquer outro ramo. Você precisa escolher apenas um arquivo dessa confirmação específica.

A abordagem:

Etapa 1: finalize a compra na filial necessária.

git checkout master

Etapa 2: verifique se você copiou o hash de confirmação necessário.

git checkout commit_hash path\to\file

Etapa 3: Agora você tem as alterações do arquivo necessário no seu ramo desejado. Você só precisa adicionar e confirmar.

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

Gostaria apenas de escolher tudo de cereja e fazer o seguinte:

git reset --soft HEAD^

Depois, reverteria as alterações que não quero e, em seguida, faria um novo commit.

Use git merge --squash branch_nameisso para obter todas as alterações do outro ramo e preparará uma confirmação para você. Agora remova todas as alterações desnecessárias e deixe a que você deseja. E o git não saberá que houve uma fusão.

Eu encontrei uma outra maneira que impede qualquer fusão conflitante na escolha da cereja, que é fácil de lembrar e entender da IMO. Como na verdade você não escolhe um commit, mas faz parte dele, é necessário dividi-lo primeiro e depois criar um commit que atenda às suas necessidades e selecioná-lo.

Primeiro, crie uma ramificação a partir do commit que você deseja dividir e faça o checkout:

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

Reverta a confirmação anterior:

$ git reset HEAD~1

Em seguida, adicione os arquivos / alterações que deseja escolher:

$ git add FILE

e comprometa-o:

$ git commit -m "pick me"

observe o hash de confirmação, vamos chamá-lo de PICK-SHA e voltar para sua ramificação principal, mestre por exemplo, forçando o checkout:

$ git checkout -f master

e escolha a submissão:

$ git cherry-pick PICK-SHA

agora você pode excluir o ramo temporário:

$ git branch -d temp -f

Mesclar uma ramificação em uma nova (squash) e remover os arquivos não necessários:

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

Por uma questão de completude, o que funciona melhor para mim é:

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

git status

Faz exatamente o que o OP quer. Faz a resolução de conflitos quando necessário, da mesma forma que mergefaz. Faz, addmas não commitsuas novas alterações.

Você pode usar:

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

A notação <commit>^especifica o (primeiro) pai de <commit>. Portanto, este comando diff seleciona as alterações feitas <path>no commit <commit>.

Observe que isso ainda não confirma nada (como git cherry-pickfaz). Então, se você quiser, terá que fazer:

git add <path>
git commit