Exporter une cachette vers un autre ordinateur

J'ai besoin d'un moyen d'exporter une modification cachée vers un autre ordinateur.

Sur Computer1 je l'ai fait

$ git stash save feature

J'essaie d'obtenir le correctif caché dans un fichier, puis de l'importer sur un autre ordinateur

$ git stash show -p > patch

Cette commande me donne un fichier que je peux déplacer vers un autre ordinateur où ce dépôt est cloné, mais la question est de savoir comment l'importer à nouveau en tant que stash.

Merci

Vous pouvez appliquer un fichier de correctif (sans encore valider les modifications) en exécutant simplement

git apply patchfile

Ensuite, vous pouvez simplement créer une nouvelle cachette à partir du répertoire de travail actuel:

git stash

vous pouvez également créer une branche à partir de votre stash (sur l'ordinateur 1), en utilisant

git stash branch stashed_changes_branch

Validez vos modifications:

git commit -a

puis ajoutez-le en tant que télécommande sur l'ordinateur 2:

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

vous pouvez maintenant récupérer les informations à distance en utilisant

git fetch pc1

vous pouvez maintenant importer le commit comme vous le souhaitez; en utilisant git cherry-pick , git rebase ou tout ce que vous voulez ... Si vous voulez qu'il ressemble à ce que vous venez de faire git stash appliquer ; vous pouvez utiliser git cherry-pick --no-commit.

Si vous n'avez pas de connexion directe entre ordinateur1 et ordinateur2; vous pouvez utiliser une télécommande (comme github ou quelque chose de similaire):

git push origin stashed_changes_branch

et sur ordinateur2:

git fetch

Vous pouvez également exporter la totalité des stashes locaux vers un autre compte comme suit

• git pull sur votre ancien et nouveau répertoire git pour vous assurer que les deux ont les dernières modifications.
• copiez le dossier .git de l'ancien répertoire git vers le nouveau référentiel

Comment exporter Stash dans SourceTree:

1. Faire une nouvelle branche "StashTransfer" à partir d'une branche où vous allez utiliser votre Stash

2. Appliquez-y votre cachette et faites un commit

3. Cliquez sur votre commit et faites-en un patch, emportez le fichier patch avec vous.

4. Accédez à un autre référentiel, sélectionnez la même branche parent que celle que vous venez d'utiliser dans 1)

5. Actions / Appliquer le correctif, sélectionnez Mode: modifier les fichiers de copie de travail, appuyez sur Appliquer le correctif maintenant que vous avez des modifications non validées du correctif dans votre environnement de travail actuel

6. Créer un nouveau Stash pour le dépôt actuel

Vous pouvez créer une cachette en tant que fichier de correctif à partir d'une machine, puis partager ce fichier de correctif avec d'autres machines.

Création de la cachette en tant que patch

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

Le "stash @ {0}" est la référence du stash. Il créera un fichier patch avec le dernier stash. Si vous souhaitez utiliser une commande différente $ git stash listpour voir votre liste de masques et sélectionner celui que vous souhaitez corriger.

Application du patch

Transférez maintenant cette cachette sur une autre machine et collez-la dans le dossier racine de votre projet. Exécutez ensuite cette commande

$ git apply changes.patch

S'il y a une erreur et que vous souhaitez inverser le changement

$ git apply changes.patch --reverse

Une autre option consiste à accéder rsyncau .gitdossier d'un ordinateur à un autre ordinateur. rsynctraite uniquement les modifications de fichiers (plus rapide qu'une copie).

Un inconvénient de cette approche est que les configurations seraient également écrasées, ce qui peut ne pas être souhaitable si vous exécutez différentes configurations .git entre les deux machines. Mais vous pouvez surmonter cela en excluant les fichiers avec l' --excludeoption in rsync.

Dans l'ensemble, je pense qu'une solution native Git est plus propre, mais ce rsynchack pourrait être bien pour quelqu'un pressé qui pourrait être plus familier avec rsync que git.

La commande de démarrage du post d'origine:

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

n'a pas fonctionné pour moi (pour une raison quelconque, il a créé des fichiers correctifs inutilisables). Au lieu de cela, j'ai dû:

git stash apply stash@{x}
git commit

pour chaque stash que je voulais transférer. Ensuite, j'ai placé le référentiel «parent» dans le fichier: /// portée du référentiel «enfant», et j'ai fait ce qui suit, pour chaque validation de stockage:

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

C'est plus complexe mais ça a fait l'affaire pour moi.

Si vous souhaitez déplacer vos modifications d'une machine à une autre, vous pouvez toujours valider vos modifications sur votre machine, puis effectuer une réinitialisation logicielle sur leur machine.

Bureau

git commit -m "-stash-"

Cuisine

git reset --soft HEAD~1

Une stash est une validation de fusion spéciale de l'arborescence de travail entre la validation de base et l'index. Une façon pourrait être de les enregistrer chacun sous forme de correctifs séparés, de retirer le premier parent de la cachette, de restaurer l'index et l'arborescence de travail des deux correctifs et enfin de restaurer la cachette (il semble qu'une réponse va dans ce sens).

Cela est nécessaire pour recréer entièrement toutes les informations de la cachette, et si vous ne vous souciez pas de cela, vous devez au moins extraire le premier parent de la cachette avant de restaurer pour éviter les conflits et garder une trace de l'endroit où la cachette a été créée.

C'est ce que j'ai fait pour restaurer complètement toutes les cachettes d'un dépôt à un autre. Si vous ne pouvez pas les avoir sur le même ordinateur, vous pouvez enregistrer les balises de dissimulation dans un ensemble après les avoir créées et copier la liste des références et l'ensemble sur l'ordinateur cible.

De la racine du dépôt d'origine:

1. Obtenez la liste des références cachées
2. Balisez vos références de sauvegarde afin que vous puissiez les récupérer avec git fetch (les noms de balises ne correspondent pas, modifiez-les en cas de conflit. J'ai utilisé stash_+ le (s) nombre (s) dans la référence de sauvegarde logique)
3. Convertissez les références logiques en hachages sha1 dans l'ordre inverse - nous les utiliserons plus tard
4. Enregistrez ce chemin de dépôt - également pour plus tard

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: Cela nécessite bash ou un shell compatible (ksh, zsh devrait faire ...) Vous pouvez également incrémenter une variable, ex stash_$((i++))si votre shell ne supporte pas${param//pattern}

Maintenant dans le nouveau repo, pour chaque ref:

1. Récupérer la référence de l'ancien dépôt (nous n'avons même pas besoin d'utiliser les noms des balises, car nous les avons marqués, nous pouvons les récupérer avec git fetch)
2. Réimportez la cachette de la référence, en utilisant le sujet de cette référence comme message de cachette.

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