Exportar um stash para outro computador

Preciso de uma maneira de exportar uma alteração oculta para outro computador.

No Computer1 eu fiz

$ git stash save feature

Estou tentando obter o patch oculto em um arquivo e importá-lo para outro computador

$ git stash show -p > patch

Este comando fornece um arquivo que eu posso mover para outro computador em que esse repositório é clonado, mas a questão é como importá-lo como um esconderijo novamente.

obrigado

Você pode aplicar um arquivo de correção (sem confirmar as alterações ainda) simplesmente executando

git apply patchfile

Em seguida, você pode simplesmente criar um novo stash a partir do diretório de trabalho atual:

git stash

Como alternativa, você pode criar uma ramificação a partir do seu esconderijo (no computador 1), usando

git stash branch stashed_changes_branch

comprometa suas alterações:

git commit -a

adicione-o como um controle remoto no computador 2:

git remote add pc1 user@computer1:/path/to/repo

agora você pode recuperar as informações remotas usando

git fetch pc1

agora você pode importar o commit da maneira que desejar; usando git cherry-pick , git rebase ou o que você quiser ... Se você quer que pareça que você acabou de aplicar o git stash ; você pode usar o git cherry-pick --no-commit.

Se você não tem conexão direta entre computer1 e computer2; você pode usar um controle remoto (como o github ou algo semelhante):

git push origin stashed_changes_branch

e no computer2:

git fetch

Como alternativa, você pode exportar os stashes locais inteiros para outro compter da seguinte maneira

• git pull no seu diretório antigo e novo, para garantir que ambos tenham as alterações mais recentes.
• copie a pasta .git do diretório git antigo para o novo repositório

Como exportar o Stash no SourceTree:

1. Faça um novo ramo "StashTransfer" a partir de um ramo em que você usará o seu Stash

2. Aplique seu esconderijo e faça um commit

3. Clique no seu commit e faça um patch, leve o arquivo do patch com você.

4. Vá para um repositório diferente, selecione o mesmo ramo pai que você acabou de usar 1)

5. Ações / Aplicar patch, selecione Modo: modificar arquivos de cópia de trabalho, pressione Aplicar patch agora que você tem modificações não confirmadas do patch no seu ambiente de trabalho atual

6. Faça um novo Stash para o repo atual

Você pode criar stash como arquivo de correção de uma máquina e depois compartilhar esse arquivo de correção com outras máquinas.

Criando o stash como um patch

$ git stash show "stash@{0}" -p > changes.patch

O "stash @ {0}" é o ref do stash. Ele criará um arquivo de patch com o stash mais recente. Se você deseja um diferente, use o comando $ git stash listpara ver sua lista de stashes e selecione qual deles deseja corrigir.

Aplicando o patch

Agora transfira esse esconderijo para outra máquina e cole-o na pasta raiz do seu projeto. Em seguida, execute este comando

$ git apply changes.patch

Se houver erro e você desejar reverter a alteração

$ git apply changes.patch --reverse

Outra opção é rsynca .gitpasta de um computador para outro. rsyncprocessa apenas alterações de arquivo (mais rápido que uma cópia).

Uma desvantagem dessa abordagem é que as configurações também seriam substituídas, o que pode não ser desejado se você executar configurações diferentes do .git entre as duas máquinas. Mas você pode superar isso excluindo arquivos com a --excludeopção emrsync .

No geral, acho que uma solução nativa do Git é mais limpa, mas esse rsynctruque pode ser bom para alguém com pressa que possa estar mais familiarizado com o rsync do que com o git.

O comando de inicialização da postagem original:

git stash show -p stash@{x} > patch_file

não funcionou para mim (por algum motivo, ele criou arquivos de correção inutilizáveis). Em vez disso, tive que:

git stash apply stash@{x}
git commit

para cada quantidade que eu queria transferir. Em seguida, coloquei o repositório 'pai' no arquivo: /// alcance do repositório 'filho' e fiz o seguinte para cada confirmação de stash:

git fetch file:///path_to_parent_git && git cherry-pick commit_sha
git reset --soft HEAD^
git stash save my_new_stash_on_child

Isso é mais complexo, mas fez o truque para mim.

Se você deseja mover suas alterações de uma máquina para outra, sempre pode confirmar as alterações na máquina e fazer uma reinicialização suave na máquina.

Escritório

git commit -m "-stash-"

Cozinha

git reset --soft HEAD~1

Um stash é um commit de mesclagem especial da árvore de trabalho entre o commit de base e o índice. Uma maneira poderia ser salvar cada um como patches separados, fazer check-out do primeiro pai do stash, restaurar o índice e a árvore de trabalho dos dois patches e finalmente restaurar o stash (parece que uma resposta é dessa maneira).

Isso é necessário para recriar completamente todas as informações do stash, e se você não se importa com isso, deve fazer o checkout mínimo do primeiro pai do stash antes de restaurar para evitar conflitos e acompanhar onde o stash foi criado.

Foi o que fiz para restaurar totalmente todos os stashes de um repositório para outro. Se você não puder tê-los no mesmo computador, poderá salvar as tags stash em um pacote configurável após criá-las e copiar a lista de referências e o pacote configurável no computador de destino.

Da raiz do repositório original:

1. Obtenha a lista de stash refs
2. Marque suas referências stash para poder recuperá-las com git fetch (os nomes das marcas não são importantes, altere-os se houver um conflito. stash_ + os números na ref stash lógica)
3. Converter as referências lógicas em hashes sha1 na ordem inversa - nós as usaremos mais tarde
4. Salve esse caminho de repo - também para mais tarde

refs=$(git stash list|cut -d: -f1)
for ref in $refs; do tag stash_${ref//[^0-9]} $ref; done
refs=$(git rev-parse $refs|tac)
oldpath=$PWD

NB: Isso requer shell bash ou compatível (ksh, zsh deve fazer ...) Você também pode incrementar uma variável, por exemplo, stash_$((i++))se seu shell não suportar${param//pattern}

Agora no novo repositório, para cada ref:

1. Busque a ref do repositório antigo (nem precisamos usar os nomes das tags, porque, se as etiquetamos, podemos recuperá-las com git fetch)
2. Reimporte o stash da ref, usando o assunto desse ref como a mensagem stash.

for ref in $refs; do git fetch $oldpath $ref; git stash store -m "$(git show -s --pretty=%s $ref)" $ref; done