Como mesclar alterações em um único arquivo, em vez de mesclar confirmações?

Tenho duas ramificações (A e B) e quero mesclar um único arquivo da ramificação A com um arquivo único correspondente da ramificação B.

Me deparei com o mesmo problema. Para ser mais preciso, tenho duas ramificações Ae Bos mesmos arquivos, mas uma interface de programação diferente em alguns arquivos. Agora, os métodos de arquivo f, que são independentes das diferenças de interface nos dois ramos, foram alterados no ramo B, mas a alteração é importante para os dois ramos. Assim, eu preciso mesclar apenas arquivo fde ramificação Bem arquivo fde ramificação A.

Um comando simples já resolveu o problema para mim se eu assumir que todas as alterações foram confirmadas nos dois ramos Ae B:

git checkout A

git checkout --patch B f

O primeiro comando muda para ramificação A, para onde eu quero mesclar Ba versão do arquivo f. O segundo comando corrige o arquivo fcom fde HEADde B. Você pode até aceitar / descartar partes únicas do patch. Em vez de Bvocê pode especificar qualquer confirmação aqui, não precisa ser HEAD.

Edição na comunidade : se o arquivo fativado Bainda não existir A, omita a --patchopção. Caso contrário, você receberá uma "Sem alteração". mensagem.

Aqui está o que eu faço nessas situações. É uma confusão, mas funciona muito bem para mim.

1. Crie outro ramo com base no seu ramo de trabalho.
2. O git pull / git mescla a revisão (SHA1) que contém o arquivo que você deseja copiar. Portanto, isso mesclará todas as suas alterações, mas estamos usando apenas esse ramo para obter o único arquivo.
3. Corrija quaisquer conflitos, etc. investigue seu arquivo.
4. confira seu ramo de trabalho
5. Faça o check-out do arquivo confirmado por sua mesclagem.
6. Comprometa-o.

Tentei aplicar patches e minha situação era muito feia para isso. Então, resumindo, ficaria assim:

Filial de Trabalho: Uma Filial Experimental: B (contém file.txt que possui as alterações que eu quero incluir.)

git checkout A

Crie uma nova ramificação com base em A:

git checkout -b tempAB

Mesclar B no tempAB

git merge B

Copie o hash sha1 da mesclagem:

git log

commit 8dad944210dfb901695975886737dc35614fa94e
Merge: ea3aec1 0f76e61
Author: matthewe <matthewe@matthewe.com>
Date:   Wed Oct 3 15:13:24 2012 -0700

Merge branch 'B' into tempAB

Faça o checkout do seu ramo de trabalho:

git checkout A

Faça o checkout do seu arquivo corrigido:

git checkout 7e65b5a52e5f8b1979d75dffbbe4f7ee7dad5017 file.txt

E aí você deve tê-lo. Confirme seu resultado.

Isso usa o difftool interno do git. Talvez um pouco de trabalho para fazer, mas para a frente.

#First checkout the branch you want to merge into
git checkout <branch_to_merge_into>

#Then checkout the file from the branch you want to merge from
git checkout <branch_to_merge_from> -- <file> 

#Then you have to unstage that file to be able to use difftool
git reset HEAD <file> 

#Now use difftool to chose which lines to keep. Click on the mergebutton in difftool
git difftool

#Save the file in difftool and you should be done.

Achei essa abordagem simples e útil: Como "mesclar" arquivos específicos de outro ramo

Como se vê, estamos tentando demais. Nosso bom amigo check-out git é a ferramenta certa para o trabalho.

git checkout source_branch <paths>...

Podemos simplesmente fornecer ao git checkout o nome do ramo de recursos A e os caminhos para os arquivos específicos que queremos adicionar ao nosso ramo mestre.

Por favor, leia o artigo inteiro para mais compreensão

Você poderia usar:

    git merge-file

Dica: https://www.kernel.org/pub/software/scm/git/docs/git-merge-file.html

O comando a seguir irá (1) comparar o arquivo da ramificação correta, para dominar (2) interativamente, perguntar quais modificações aplicar.

git checkout - mestre de patches

Minha edição foi rejeitada, por isso estou anexando como lidar com a fusão de alterações de uma ramificação remota aqui.

Se você precisar fazer isso após uma mesclagem incorreta, poderá fazer algo assim:

# If you did a git pull and it broke something, do this first
# Find the one before the merge, copy the SHA1
git reflog
git reset --hard <sha1>

# Get remote updates but DONT auto merge it
git fetch github 

# Checkout to your mainline so your branch is correct.
git checkout develop 

# Make a new branch where you'll be applying matches
git checkout -b manual-merge-github-develop

# Apply your patches
git checkout --patch github/develop path/to/file
...

# Merge changes back in
git checkout develop
git merge manual-merge-github-develop # optionally add --no-ff

# You'll probably have to
git push -f # make sure you know what you're doing.

Supondo que B é o ramo atual:

$ git diff A <file-path> > patch.tmp
$ git apply patch.tmp -R

Observe que isso aplica apenas alterações ao arquivo local. Você precisará confirmar depois.

Você pode fazer o check-out da versão antiga do arquivo para mesclar, salvando-o com um nome diferente e executar a ferramenta de mesclagem nos dois arquivos.

por exemplo.

git show B:src/common/store.ts > /tmp/store.ts (onde B é o nome da filial / confirmação / tag)

meld src/common/store.ts /tmp/store.ts

Vou fazer isso como

git format-patch branch_old..branch_new file

isso produzirá um patch para o arquivo.

Aplicar patch no alvo branch_old

git am blahblah.patch