Git rebase --continue reclama mesmo quando todos os conflitos de mesclagem forem resolvidos

Estou enfrentando um problema que não tenho certeza de como resolver.

Eu fiz um rebase contra o mestre de meu branch:

git rebase master

e obteve o seguinte erro

 First, rewinding head to replay your work on top of it...
 Applying: checkstyled.
 Using index info to reconstruct a base tree...
 Falling back to patching base and 3-way merge...
 Auto-merging AssetsLoader.java
 CONFLICT (content): Merge conflict in AssetsLoader.java
 Failed to merge in the changes.
 Patch failed at 0001 checkstyled.

Então fui ao meu editor favorito, consertei o conflito de 1 linha, salvei o arquivo e fiz um status git e obtive a seguinte saída:

 # Not currently on any branch.
 # Changes to be committed:
 #   (use "git reset HEAD <file>..." to unstage)
 #
 #  modified:   PassengerContactHandler.java
 #
 # Unmerged paths:
 #   (use "git reset HEAD <file>..." to unstage)
 #   (use "git add/rm <file>..." as appropriate to mark resolution)
 #
 #  both modified:      AssetsLoader.java
 #

Fiz um git add AssetsLoader.java e um git status e obtive o seguinte:

 # Not currently on any branch.
 # Changes to be committed:
 #   (use "git reset HEAD <file>..." to unstage)
 #
 #  modified:   AssetsLoader.java
 #  modified:   PassengerContactHandler.java
 #

e quando fiz git rebase --continue, recebo:

git rebase --continue
You must edit all merge conflicts and then
mark them as resolved using git add

Sei que posso pular o patch e continuar o rebase, mas não tenho certeza se as alterações em PassengerContactHandler.java serão rebaseadas em meu branch ou não.

então não tenho certeza, como devo proceder?

Edit: Será que o arquivo com o conflito resolvido é exatamente igual à versão original?

Muito obrigado lucas

Edite, aconteceu comigo de novo:

Aconteceu comigo de novo,

(307ac0d...)|REBASE)$ git status
# Not currently on any branch.
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   modified:   assets/world/level1/Level-1.xml
#   modified:   George.java
#   modified:   DefaultPassenger.java
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#   mb-art/originalAssets/27dec/

((307ac0d ...) | REBASE) $ git rebase --continue

You must edit all merge conflicts and then
mark them as resolved using git add

git --version

git version 1.7.1

Isso acontece porque ao consertar um conflito, você removeu todo o código do patch sendo aplicado ao branch no qual está fazendo o rebase. Use git rebase --skippara continuar.

Um pouco mais de detalhes:

Normalmente, ao consertar um conflito durante o rebase, você editará o arquivo conflitante, mantendo parte ou todo o código do patch atualmente sendo aplicado ao branch no qual você rebase. Depois de corrigir o patch e fazer

git add your/conflicted/file
git status

você obterá uma linha (geralmente verde) mostrando o arquivo modificado

modificado: seu / em conflito / arquivo

git rebase --continue funcionará bem nesta situação.

Às vezes, no entanto, ao resolver o conflito, você remove tudo em seu novo patch, mantendo apenas o código do branch no qual você fez o rebase. Agora, quando você adicionar o arquivo, ele será exatamente igual ao que você tentou usar no rebase. git status não mostrará nenhuma linha verde exibindo os arquivos modificados. Agora, se você fizer

git rebase --continue

git vai reclamar com

Sem alterações - você se esqueceu de usar 'git add'?

O que o git realmente quer que você faça nessa situação é usar

git rebase --skip

para pular o patch. Anteriormente, eu nunca fiz isso, pois sempre não tinha certeza do que realmente seria ignorado se o fizesse, não era óbvio para mim o que "pular este patch" realmente significava. Mas se você não obtiver linha verde com

modificado: seu / em conflito / arquivo

depois de editar o arquivo em conflito, adicioná-lo e executar o git status, você pode ter certeza de que removeu todo o patch e pode usar

git rebase --skip

continuar.

A postagem original dizia que isso às vezes funciona:

git add -A
git rebase --continue
# works magically?

... mas não confie nisso (e certifique-se de não adicionar arquivos restantes em suas pastas de repositório)

Parece ser um bug no Git 1.7

Aqui está um bom artigo sobre como resolver isso .

Basicamente, deve funcionar, se você fizer um

git diff

depois de resolver seus conflitos e então

git rebase --continue

Deveria trabalhar.

Recebi este aviso quando tinha arquivos não encenados. Certifique-se de não ter nenhum arquivo não encenado. Se você não quiser as alterações dos arquivos não testados, descarte as alterações com

git rm <filename>  

Tente executar isso em sua linha de comando:

$ git mergetool

Deve trazer um editor interativo permitindo que você resolva os conflitos. Mais fácil do que tentar fazer manualmente, e também o git reconhecerá quando você fizer a fusão. Também evitará situações em que você não funde totalmente por acidente, o que pode acontecer quando você tenta fazer isso manualmente.

Depois de corrigir o conflito, certifique-se de que os arquivos alterados sejam adicionados aos arquivos testados. Isso resolveu o problema para mim.

Você perdeu um conflito de mesclagem em AssetsLoader.java. Abra-o e procure por marcadores de conflito (">>>>", "====", "<<<<<") e então git add novamente. Faça um 'git diff --staged' se estiver tendo dificuldade em encontrá-lo.

Acabei de ter esse problema e, embora eu ache que pode haver algumas causas, aqui está a minha ...

Eu tinha um gancho de pré-commit do git que rejeitava os commits sob certas condições. Isso é bom ao fazer commit manualmente, já que exibirá a saída do gancho, e eu posso tanto consertar ou escolher ignorar usando commit --no-verify.

O problema parece ser que, ao fazer o rebase, o rebase --continue também chamará o gancho (a fim de confirmar a última rodada de alterações). Mas o rebase não exibirá a saída do gancho, ele apenas verá que falhou e, em seguida, exibirá um erro menos específico dizendo 'Você deve editar todos os conflitos de mesclagem e marcá-los como resolvidos usando git add'

Para consertá-lo, teste todas as suas alterações e, em vez de fazer 'git rebase --continue', tente um 'git commit'. Se você está sofrendo do mesmo problema de gancho, deve ver as razões por que ele está falhando.

Curiosamente, embora o git rebase não exiba a saída do git hook, ele aceita um --no-verify para contornar os hooks.

Depois de corrigir suas alterações, você pode esquecer de executar 'git add -A'

git add -A
git rebase --continue

Eu apenas tropecei no problema. Não o faria git rebase --skip porque git statusmostraria claramente modificações escalonadas, que queria manter. Embora eu tivesse alguns arquivos extras que vieram inesperadamente. Eu resolvi com

git checkout .

para remover modificações não marcadas, em seguida, git rebase --continueteve êxito.