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
Respostas:
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
git stash show "stash@{0}" -p > patchvez do segundo comando shell do OP.
stash@{0}..
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
git stash list --oneline), portanto, tecnicamente, você não precisa aplicar o stash a um novo objeto de confirmação. Em outras palavras, a criação de uma nova ramificação não é necessária. No entanto, empurrar um esconderijo diretamente para um controle remoto é complicado, para dizer o mínimo.
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.Aplique seu esconderijo e faça um commit
Clique no seu commit e faça um patch, leve o arquivo do patch com você.
Vá para um repositório diferente, selecione o mesmo ramo pai que você acabou de usar 1)
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
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:
stash_ + os números na ref stash lógica)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=$PWDNB: 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:
for ref in $refs; do git fetch $oldpath $ref; git stash store -m "$(git show -s --pretty=%s $ref)" $ref; done
git stash saveagora está obsoleto em favor degit stash push