O commit do Git não terminou, mas não pode continuar nessa máquina

Às vezes, encontro o problema de ter código não confirmado em uma estação de trabalho que não está pronta para uma confirmação, mas precisa ser concluída em uma estação de trabalho ou laptop diferente.

Alguém tem uma solução para esse problema, como um "commit suave" ou alguma outra maneira de transferir as alterações para outra máquina para trabalhar com elas em outro lugar?

Eu preferiria não ser forçado a confirmar e enviar alterações que não foram implementadas adequadamente.

O seguinte pressupõe que seu repositório local é um clone de um repositório em outro servidor, por exemplo, github; e que você tem direitos para fazer alterações no servidor upstream. No meu exemplo, chamei esse repositório upstream de "origem". Corra git remote showpara listar outros repositórios, isso pode lhe dar uma dica sobre como ele é chamado.

Eu sugeriria fazer uma filial, então você pode conferir a filial em outra máquina. De fato, se você criar uma ramificação assim que começar a trabalhar, poderá "confirmar" sua ramificação, rastrear e fazer backup do seu trabalho, sem ter que ter um conjunto de códigos estável. Quando estiver satisfeito com o seu trabalho, você poderá mesclá-lo novamente ao seu ramo "mestre".

• Para ramificar seu repositório: git checkout -b MyNewBranch
• Para enviar alterações confirmadas de sua nova ramificação: git push origin MyNewBranch
• Para verificar uma ramificação em outra máquina: git checkout MyNewBranch
• Para mudar para outra ramificação (por exemplo, "mestre"): git checkout master
• Quando estiver no mestre, para mesclar MyNewBranch novamente: git merge MyNewBranch
• Para listar ramificações: git branch

Você pode usar git diffpara criar um patch e aplicá-lo em outra máquina. Ou você pode criar uma confirmação temporária e puxá-la de outra máquina. Você pode até criar uma ramificação temporária em alguma outra máquina, enviar sua confirmação temporária para lá e excluir a ramificação.

Meu método favorito é o segundo: criar uma confirmação temporária, depois ir para outra máquina e fazer algo assim:

$ git fetch ssh://first_machine/path/to/repo whatever_branch_i_was_working_on
$ git reset --hard FETCH_HEAD
$ git reset HEAD^

Eu comprometo . O empurrão para o ramo pessoal , confira do outro lado e altere. E exclua o ramo pessoal quando terminar.

É claro que você pode enviar diretamente entre os repositórios, pode usar o pacote ou format-patch/ am, mas um ramo pessoal é de longe a solução mais fácil. E reescrever o histórico não é grande coisa, desde que não seja enviado a nenhum ramo compartilhado. Em muitos projetos, as pessoas devem retroceder as ramificações dos recursos para mantê-las mais fáceis de entender para revisão.

A abordagem fácil é a que você descreve: copie o .gitdiretório oculto e os arquivos do projeto para outra máquina onde você pode confirmar e finalizar, ou simplesmente continuar trabalhando.

O .gitdiretório é onde seu histórico do git é mantido, portanto, preservá-lo junto com os arquivos reais mantém todo o histórico do projeto intacto.

Se você estiver usando a máquina original de forma permanente, provavelmente recomendo essa abordagem.

Como outros responderam, com o Git, você não deve se importar com o código não finalizado em seus ramos pessoais. No entanto, se por algum motivo, você realmente não quer que seu trabalho inacabado toque o repositório principal, você pode utilizar a natureza distribuída do Git!

Existe uma ferramenta simples chamada git bundleque pode ajudá-lo a passar facilmente as mudanças sem um repositório central. Primeiro, clone o repositório:

git clone https://github.com/octocat/Spoon-Knife.git working_copy_1
cd working_copy_1

faça algumas alterações e as comprometa em uma ramificação temporária:

git checkout -b tmp_branch
git commit -a -m "temporary changes"

Agora, agrupe as alterações:

git bundle create ../tmp.bundle tmp_branch

Agora você tem um arquivo de pacote configurável que pode ser enviado para sua nova máquina. Como você usa isso aí? Vamos criar uma nova cópia de trabalho:

cd ..
git clone https://github.com/octocat/Spoon-Knife.git working_copy_2
cd working_copy_2

precisamos tratar nosso pacote como outro controle remoto, para que possamos buscar as alterações nele

git remote add tmp ../tmp.bundle
git fetch tmp

Como o objetivo principal era transferir as alterações sem deixar rastro, queremos compactá-las na cópia de trabalho para perder a confirmação temporária:

git merge tmp/tmp_branch --squash

e tudo o que resta é remover o controle remoto temporário:

git remote remove tmp

VIOLA! As alterações foram transferidas para a nova cópia de trabalho sem deixar rastro de ramificação nem confirmação!

Mas realmente - esse processo é bastante longo e complicado. Este é o Git, não o SVN - realmente não deve haver nenhuma razão para não levar seu ramo pessoal ao repositório central.