Relatórios de mesclagem do Git "Já atualizados", embora exista uma diferença

Eu tenho um repositório git com 2 ramos: master e test.

Existem diferenças entre os ramos mestre e teste.

Ambas as ramificações têm todas as alterações confirmadas.

Se eu fizer:

mestre de verificação geral do git

teste git diff

Uma tela cheia de alterações aparece mostrando as diferenças. Quero mesclar as alterações na ramificação de teste e o mesmo:

teste de mesclagem git

Mas receba a mensagem "Já atualizado"

No entanto, examinar arquivos em cada ramificação diferente mostra claramente as diferenças.

Qual é o problema aqui e como resolvo isso?

A mensagem "Já atualizado" significa que todas as alterações da ramificação que você está tentando mesclar já foram mescladas à ramificação em que você está atualmente. Mais especificamente, significa que o ramo que você está tentando mesclar é o pai do seu ramo atual . Parabéns, essa é a fusão mais fácil que você já fez. :)

Use gitkpara dar uma olhada no seu repositório. O rótulo do ramo "teste" deve estar em algum lugar abaixo do rótulo do ramo "mestre".

Sua filial está atualizada em relação ao pai. De acordo com a mesclagem, não há novas alterações no pai desde a última mesclagem. Isso não significa que as ramificações são as mesmas, porque você pode ter muitas alterações em sua ramificação de trabalho e parece que sim.

Editar 10/12/2019:

Por Charles Drake, no comentário a esta resposta, uma solução para remediar o problema é:

git checkout master
git reset --hard test

Isso o traz de volta ao nível 'teste'.

Então faça:

git push --force origin master

para forçar as alterações de volta ao repositório central.

Isso geralmente acontece comigo quando eu sei que há alterações no mestre remoto, então tento mesclá-las usando git merge master. No entanto, isso não se mescla com o mestre remoto, mas com o mestre local.

Portanto, antes de fazer a mesclagem, faça o checkout master e depois git pulllá. Então, você poderá mesclar as novas alterações em seu ramo.

Digamos que você tenha uma ramificação mastercom o seguinte histórico de consolidação:

A -- B -- C -- D

Agora, você cria um teste de ramificação, trabalha nele e faz 4 confirmações:

                 E -- F -- G -- H
                /
A -- B -- C -- D

masterA cabeça de D aponta para D e a cabeça de D testaponta para H.

A mensagem "Já atualizado" é exibida quando o HEAD da ramificação na qual você está mesclando é um pai da cadeia de confirmações da ramificação que você deseja mesclar. Esse é o caso, aqui: Dé pai de E.

Não há nada para mesclar test para master, pois nada mudou masterdesde então. O que você quer fazer aqui é literalmente dizer ao Git que tenha mastera cabeça para apontar para H, para que o ramo do mestre tenha o seguinte histórico de confirmações:

A -- B -- C -- D -- E -- F -- G -- H

Este é um trabalho para o comando Git reset. Você também quer que o diretório de trabalho para reflectir esta alteração, então você vai fazer um disco de redefinição:

git reset --hard H

O que funciona para mim, digamos que você tem branch1 e deseja mesclá-lo em branch2.

Você abre a linha de comando git, vá para a pasta raiz do branch2 e digite:

git checkout branch1
git pull branch1
git checkout branch2
git merge branch1
git push

Se você tiver conflitos, não precisará executar git push, mas primeiro resolva os conflitos e, em seguida, pressione.

Uma mesclagem está sempre entre o HEAD atual e uma ou mais confirmações (geralmente, cabeçalho ou tag de ramificação),
e o arquivo de índice deve corresponder à árvore da confirmação HEAD (ou seja, o conteúdo da última confirmação) quando é iniciado.
Em outras palavras, não git diff --cached HEADdeve relatar alterações.

A consolidação mesclada já está contida HEAD. Este é o caso mais simples, chamado "Já atualizado".

Isso deveria significar que as confirmações no teste já foram mescladas no mestre, mas, como outras confirmações são feitas no mestre, git diff testainda assim haveria algumas diferenças.

Isso acontece porque sua cópia local da ramificação que você deseja mesclar está desatualizada. Chamei meu ramo MyBranche quero fundi-lo ProjectMaster.

_>git status
On branch MyBranch-Issue2
Your branch is up-to-date with 'origin/MyBranch-Issue2'.

nothing to commit, working tree clean

_>git merge ProjectMaster
Already up-to-date.

Mas eu sei que existem mudanças que precisam ser mescladas!

Aqui está a coisa, quando eu digito git merge ProjectMaster, o git examina minha cópia local desse ramo, que pode não estar atual . Para ver se é esse o caso, primeiro digo ao Git para verificar se meus ramos estão desatualizados e buscar quaisquer alterações, se houver, usando fetch. Então eu pulo para o ramo que quero mesclar para ver o que está acontecendo lá ...

_>git fetch origin

_>git checkout ProjectMaster
Switched to branch ProjectMaster
**Your branch is behind 'origin/ProjectMaster' by 85 commits, and can be fast-forwarded.**
  (use "git pull" to update your local branch)

Ah-ha! Minha cópia local está obsoleta por 85 commits, o que explica tudo! Agora, Pulldescrevo as alterações que estão faltando, depois pulo para MyBranche tente a mesclagem novamente.

_>git pull
Updating 669f825..5b49912
Fast-forward

_>git checkout MyBranch-Issue2
Switched to branch MyBranch-Issue2
Your branch is up-to-date with 'origin/MyBranch-Issue2'.

_>git merge ProjectMaster
Auto-merging Runbooks/File1.ps1
CONFLICT (content): Merge conflict in Runbooks/Runbooks/File1.ps1

Automatic merge failed; fix conflicts and then commit the result.

E agora tenho outro problema para corrigir ...

Isso aconteceu comigo porque, estranhamente, o GIT achou que o ramo local era diferente do ramo remoto. Isso era visível no gráfico da ramificação: exibia duas ramificações diferentes: controles remotos / origem / nome_da_ ramificação e nome da ramificação.

A solução foi simplesmente remover o repositório local e cloná-lo novamente do controle remoto. Dessa forma, o GIT entenderia que controles remotos / origin / branch_name> e branch_name são realmente os mesmos, e eu poderia emitir o git merge branch_name.

rm <my_repo>
git clone <my_repo>
cd <my_repo>
git checkout <branch_name>
git pull
git checkout master
git merge <branch_name>

git merge origin/masterem vez disso, git merge mastertrabalhou para mim. Portanto, para mesclar o mestre no ramo de recursos, você pode usar:

git checkout feature_branch
git merge origin/master

Certifique-se de fazer o checkout do ramo que deseja mesclar primeiro e depois puxá-lo (para que sua versão local corresponda à versão remota).

Em seguida, faça o checkout de volta ao seu ramo em que você deseja fazer a mesclagem e sua mesclagem git deve funcionar.

aconteceu comigo e foi enviado para esta página, não tendo certeza se eu tinha o mesmo cenário, mas o meu era eu tentando "mesclar novamente" essa ramificação "teste".

Portanto, eu o mesclei anteriormente, mas intencionalmente excluo algumas alterações específicas durante essa mesclagem, para que haja claramente alguma diferença entre os ramos. Eu estava tentando refazer a mesclagem porque percebi / esqueci que deveria e desejei adicionar uma alteração / arquivo específico que eu excluí anteriormente e esperava que, se eu fizesse uma mesclagem novamente, mostrasse todas as alterações excluídas antes , mas eu estava errado e recebo a mensagem "Já atualizado".

Ao ler o comentário / resposta de @ Bombe, ele está certo, e acho que o git se comporta dessa maneira, então o que fiz foi fazer um backup dos arquivos no ramo de teste, fazer check-out do ramo mestre e colar manualmente os arquivos nele e confirmar como se fossem novas mudanças.

não tenho certeza se esse é o caminho certo ou pode ajudar outras pessoas com o mesmo problema, mas forneceu uma solução para o meu caso em particular.

Se a mesclagem da ramificação A na ramificação B relatar "Já atualizado", o reverso nem sempre será verdadeiro. É verdade somente se o ramo B é descendente do ramo A, caso contrário, o ramo B simplesmente pode ter alterações que não estão em A.

Exemplo:

1. Você cria ramificações A e B fora do mestre
2. Você faz algumas alterações no mestre e as mescla apenas na ramificação B (não atualizando ou esquecendo de atualizar a ramificação A).
3. Você faz algumas alterações na ramificação A e mescla A para B.

Nesse momento, a mesclagem dos relatórios A a B "Já está atualizada", mas as ramificações são diferentes porque a ramificação B tem atualizações do mestre, enquanto a ramificação A não.

Enfrentou esse cenário usando o Git Bash.

Nosso repositório possui várias ramificações e cada ramificação tem um ciclo de consolidação diferente e a mesclagem acontece de vez em quando. Old_Branch foi usado como pai de New_Branch

Old_Branch foi atualizado com algumas alterações que precisavam ser mescladas com New_Branch

Estava usando o comando pull abaixo sem nenhuma ramificação para obter todas as fontes de todas as ramificações.

origem do git pull

Estranhamente, isso não tira todos os commits de todos os ramos. Tinha pensado assim, como o indicado mostra quase todos os ramos e tags.

Então, para corrigir isso, o Old_Branch retirou o mais recente usando

git checkout Old_Branch

origem do pull do git Old_Branch

Agora check-out New_Branch

git checkout New_Branch

Puxou para ter certeza

origem git pull New_Branch

git merge Old_Branch

E a viola conseguiu resolver conflitos de Old_Branch para New_Branch :), o que era esperado

O mesmo aconteceu comigo. Mas o cenário era um pouco diferente, eu tinha o ramo principal e eu criei o release_1 (digamos) dele. Fez algumas alterações no ramo release_1 e o fundiu na origem. então eu fiz o ssh e, no servidor remoto, saio novamente do release_1 usando o comando git checkout -b release_1 - que na verdade cria uma nova versão do ramo_! do mestre em vez de verificar a ramificação já existente release_1 de origem. Resolvido o problema removendo a opção "-b"

Eu tive o mesmo problema. Eu tive alterações no controle remoto e ele ainda estava mostrando "Já atualizado". Reclonar o repositório corrigiu o problema para mim.

Bobo, mas pode acontecer. Suponha que o nome da sua filial seja prefixado com uma referência de problema (por exemplo #91-fix-html-markup), se você fizer isso:

$ git merge #91-fix-html-markup

não funcionará como pretendido, porque tudo depois do #é ignorado, porque# inicia um comentário embutido.

Neste caso, você pode renomear o omitindo ramo #ou usar aspas simples para cercar o nome de ramo: git merge '#91-fix-html-markup'.