Estou tentando mesclar 2 commits em 1, então segui “squashing commits with rebase” do git ready .

Eu corri

git rebase --interactive HEAD~2

No editor resultante, mudo pickpara squashe, em seguida, salve-saia, mas a rebase falha com o erro

Não é possível 'squash' sem uma confirmação anterior

Agora que minha árvore de trabalho atingiu esse estado, estou tendo problemas para me recuperar.

O comando git rebase --interactive HEAD~2falha com:

O rebase interativo já foi iniciado

e git rebase --continuefalha com

Não é possível 'squash' sem uma confirmação anterior

Sumário

A mensagem de erro

Não é possível 'squash' sem uma confirmação anterior

significa que você provavelmente tentou "esmagar para baixo". O Git sempre coloca uma confirmação mais recente em uma confirmação mais antiga ou "para cima", conforme exibido na lista de tarefas de rebase interativa, ou seja, em uma confirmação na linha anterior. Alterar o comando na primeira linha da sua lista de tarefas squashsempre produzirá esse erro, pois não há nada para o primeiro commit ser compactado.

O conserto

Primeiro volte para onde você começou

$ git rebase --abort

Diga que sua história é

$ git log --pretty=oneline
a931ac7c808e2471b22b5bd20f0cad046b1c5d0d c
b76d157d507e819d7511132bdb5a80dd421d854f b
df239176e1a2ffac927d8b496ea00d5488481db5 a

Ou seja, a foi o primeiro commit, depois b e finalmente c. Depois de confirmar c, decidimos esmagar bec juntos:

(Nota: A execução git logdireciona sua saída para um pager, lesspor padrão na maioria das plataformas. Para sair do pager e retornar ao prompt de comando, pressione a qtecla.)

A execução git rebase --interactive HEAD~2fornece um editor com

pick b76d157 b
pick a931ac7 c

# Rebase df23917..a931ac7 onto df23917
#
# Commands:
#  p, pick = use commit
#  r, reword = use commit, but edit the commit message
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#  f, fixup = like "squash", but discard this commit's log message
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#

(Observe que esta lista de tarefas está na ordem inversa em comparação com a saída de git log.)

Alterar b's pickpara squashresultará no erro que você viu, mas, em vez disso, você esmaga c em b (confirmação mais recente na mais antiga ou “esmaga para cima”) alterando a lista de tarefas para

pick   b76d157 b
squash a931ac7 c

e salvar seu editor, você receberá outro editor cujo conteúdo é

# This is a combination of 2 commits.
# The first commit's message is:

b

# This is the 2nd commit message:

c

Quando você salva e sai, o conteúdo do arquivo editado se torna uma mensagem de confirmação da nova confirmação combinada:

$ git log --pretty=oneline
18fd73d3ce748f2a58d1b566c03dd9dafe0b6b4f b and c
df239176e1a2ffac927d8b496ea00d5488481db5 a

Nota sobre como reescrever o histórico

O rebase interativo reescreve o histórico. Tentar enviar para um controle remoto que contém o histórico antigo falhará porque não é um avanço rápido.

Se a ramificação que você reformulou for uma ramificação de tópico ou recurso na qual você está trabalhando sozinho , não é grande coisa. Enviar para outro repositório exigirá a --forceopção ou, alternativamente, você poderá, dependendo das permissões do repositório remoto, primeiro excluir a ramificação antiga e depois enviar a versão rebaseada. Exemplos desses comandos que potencialmente destruirão o trabalho estão fora do escopo desta resposta.

Reescrever o histórico já publicado em uma ramificação na qual você está trabalhando com outras pessoas sem uma boa razão, como deixar uma senha ou outros detalhes sensíveis forçar o trabalho de seus colaboradores e é antissocial e incomodará outros desenvolvedores. A seção “Recuperando de uma rebase upstream” na git rebasedocumentação explica, com ênfase adicional.

Reprocessar (ou qualquer outra forma de reescrita) uma ramificação na qual outros se basearam é uma má idéia: qualquer pessoa a jusante é forçada a corrigir manualmente seu histórico. Esta seção explica como fazer a correção do ponto de vista do downstream. A solução real, no entanto, seria evitar rebasear o upstream em primeiro lugar. …

Se houver várias confirmações, você pode usar git rebase -ipara esmagar duas confirmações em uma.

Se houver apenas duas confirmações que você deseja mesclar e elas forem as "duas mais recentes", os seguintes comandos poderão ser usados ​​para combinar as duas confirmações em uma:

git reset --soft "HEAD^"
git commit --amend

Rebase: você não precisará disso:

Uma maneira mais simples para o cenário mais frequente.

Na maioria dos casos:

Na verdade, se tudo o que você deseja é simplesmente combinar vários commits recentes em um, mas não precisa drop, reworde outro trabalho de rebase.

você pode simplesmente fazer:

git reset --soft "HEAD~n"

• Supondo que ~né o número de commits para suavemente un-commit (ou seja ~1, ~2...)

Em seguida, use o seguinte comando para modificar a mensagem de confirmação.

git commit --amend

que é praticamente o mesmo que um longo intervalo de squashe um pick.

E funciona para n confirmações, mas não apenas duas confirmações, conforme a resposta acima solicitada.

Primeiro você deve verificar quantas confirmações possui:

git log

Existem dois status:

Uma é que existem apenas dois commits:

Por exemplo:

commit A
commit B

(Nesse caso, você não pode usar o git rebase para fazer), você precisa fazer o seguinte.

$ git reset --soft HEAD^1

$ git commit --amend

Outra é que existem mais de dois commits; você deseja mesclar commit C e D.

Por exemplo:

commit A
commit B
commit C
commit D

(sob essa condição, você pode usar o git rebase)

git rebase -i B

E do que usar "squash" para fazer. O resto é muito fácil. Se você ainda não sabe, leia http://zerodie.github.io/blog/2012/01/19/git-rebase-i/

Supondo que você estivesse em seu próprio ramo de tópico. Se você deseja mesclar os dois últimos commits em um e parecer um herói, ramifique o commit pouco antes de fazer os dois últimos commits.

git checkout -b temp_branch HEAD^2

Em seguida, o squash confirma o outro ramo neste novo ramo:

git merge branch_with_two_commits --squash

Isso trará as mudanças, mas não as comprometerá. Então, apenas os comprometa e pronto.

git commit -m "my message"

Agora você pode mesclar esse novo ramo de tópico novamente no ramo principal.

você pode cancelar o rebase com

git rebase --abort

e quando você executa o comando rebase interativo novamente, o 'squash; commit deve estar abaixo do pick commit na lista

Eu costumo usar o git reset --mixed para reverter uma versão base antes de vários commits que você deseja mesclar, então eu faço um novo commit, para que o seu commit seja mais recente, garanta que a sua versão seja HEAD depois de enviar para o servidor.

commit ac72a4308ba70cc42aace47509a5e
Author: <[email protected]>
Date:   Tue Jun 11 10:23:07 2013 +0500

    Added algorithms for Cosine-similarity

commit 77df2a40e53136c7a2d58fd847372
Author: <[email protected]>
Date:   Tue Jun 11 13:02:14 2013 -0700

    Set stage for similar objects

commit 249cf9392da197573a17c8426c282
Author: Ralph <[email protected]>
Date:   Thu Jun 13 16:44:12 2013 -0700

    Fixed a bug in space world automation

Se eu quiser mesclar a cabeça dois commits em um, primeiro eu uso:

git reset --mixed 249cf9392da197573a17c8426c282

"249cf9392da197573a17c8426c282" era a terceira versão, também é a sua versão base antes de mesclar, depois disso, faço um novo commit:

git add .
git commit -m 'some commit message'

É tudo, a esperança é outro caminho para todos.

FYI, de git reset --help:

 --mixed
     Resets the index but not the working tree (i.e., the changed files are
     preserved but not marked for commit) and reports what has not been
     updated. This is the default action.

$ git rebase --abort

Execute esse código a qualquer momento, se você quiser desfazer o git rebase

$ git rebase -i HEAD~2

Reaplicar os últimos dois commits. O comando acima abrirá um editor de código

• [ A confirmação mais recente estará na parte inferior ]. Altere a última confirmação para squash (s). Como o squash se fundirá com o commit anterior.
• Em seguida, pressione a tecla esc e digite: wq para salvar e fechar

After: wq você estará no modo rebase ativo

Nota : Você receberá outro editor se não houver mensagens de aviso / erro. Se houver um erro ou aviso de que outro editor não será exibido, você pode abortar executando $ git rebase --abort se encontrar um erro ou aviso, caso contrário, continue executando$ git rebase --continue

Você verá sua 2 mensagem de confirmação. Escolha uma ou escreva sua própria mensagem de confirmação, salve e saia [: wq]

Nota 2: pode ser necessário forçar o envio de alterações ao repositório remoto se você executar o comando rebase

$ git push -f

$ git push -f origin master

Desde que eu uso git cherry-pick quase tudo, para mim é natural fazê-lo mesmo aqui.

Como fiz o branchXcheck-out e há dois commits na ponta, dos quais desejo criar um commit combinando seu conteúdo, faço o seguinte:

git checkout HEAD^ // Checkout the privious commit
git cherry-pick --no-commit branchX // Cherry pick the content of the second commit
git commit --amend // Create a new commit with their combined content

Se eu quiser atualizar branchXtambém (e acho que esse é o lado negativo deste método), também tenho que:

git checkout branchX
git reset --hard <the_new_commit>

Se o seu ramo principal se git logparece com o seguinte:

commit ac72a4308ba70cc42aace47509a5e
Author: <[email protected]>
Date:   Tue Jun 11 10:23:07 2013 +0500

    Added algorithms for Cosine-similarity

commit 77df2a40e53136c7a2d58fd847372
Author: <[email protected]>
Date:   Tue Jun 11 13:02:14 2013 -0700

    Set stage for similar objects

commit 249cf9392da197573a17c8426c282
Author: Ralph <[email protected]>
Date:   Thu Jun 13 16:44:12 2013 -0700

    Fixed a bug in space world automation

e você deseja mesclar as duas confirmações principais, siga estas etapas simples:

1. O primeiro a fazer checkout pelo lado seguro, o segundo último commit em um ramo separado. Você pode nomear o ramo como qualquer coisa.git checkout 77df2a40e53136c7a2d58fd847372 -b merged-commits
2. Agora, basta escolher suas alterações desde o último commit neste novo ramo como: git cherry-pick -n -x ac72a4308ba70cc42aace47509a5e . (Resolva conflitos, se houver)
3. Portanto, agora, suas alterações no último commit estão no seu segundo último commit. Mas você ainda precisa confirmar, primeiro adicione as alterações que você escolheu e depois execute git commit --amend.

É isso aí. Você pode enviar esta versão mesclada na ramificação "fusões-confirmações", se desejar.

Além disso, você pode descartar as duas confirmações consecutivas em sua ramificação mestre agora. Atualize seu ramo principal como:

git checkout master
git reset --hard origin/master (CAUTION: This command will remove any local changes to your master branch)
git pull

Se você deseja combinar as duas confirmações mais recentes e usar apenas a mensagem da confirmação mais antiga, pode automatizar o processo usando expect.

Eu assumo:

• Você está usando o vi como seu editor
• Seus commits são de uma linha cada

Eu testei com git version 2.14.3 (Apple Git-98).

#!/usr/bin/env expect
spawn git rebase -i HEAD~2

# change the second "pick" to "squash"
# down, delete word, insert 's' (for squash), Escape, save and quit
send "jdwis \033:wq\r"

expect "# This is a"

# skip past first commit message (assumed to be one line), delete rest of file
# down 4, delete remaining lines, save and quit
send "4jdG\r:wq\r"

interact