Git commit non terminé mais ne peut pas continuer sur cette machine

Parfois, je rencontre le problème d'avoir du code non engagé sur un poste de travail qui n'est pas prêt pour une validation mais doit être complété sur un autre poste de travail ou ordinateur portable.

Quelqu'un at-il une solution à ce problème, comme un «soft commit» ou une autre façon de transférer les modifications sur une autre machine pour les travailler ailleurs?

Je préférerais ne pas être obligé de valider et de pousser des changements qui ne sont pas correctement mis en œuvre.

Ce qui suit suppose que votre dépôt local est un clone d'un dépôt sur un autre serveur, par exemple github; et que vous avez le droit d'apporter des modifications au serveur en amont. Dans mon exemple, j'ai appelé ce dépôt en amont «origine». Exécutez git remote showpour répertorier les autres référentiels, cela peut vous donner un indice sur son nom.

Je suggérerais de créer une branche, alors vous pouvez vérifier la branche sur une autre machine. En fait, si vous créez une branche dès que vous commencez à travailler, vous pouvez "valider" votre branche, avoir une trace et une sauvegarde de votre travail, sans avoir à avoir un jeu de codes stable. Une fois que vous êtes satisfait de votre travail, vous pouvez le fusionner à nouveau dans votre branche "maître".

• Pour brancher votre référentiel: git checkout -b MyNewBranch
• Pour pousser les changements engagés de votre nouvelle branche: git push origin MyNewBranch
• Pour vérifier une branche sur une autre machine: git checkout MyNewBranch
• Pour passer à une autre branche (par exemple "maître"): git checkout master
• Une fois en master, pour fusionner MyNewBranch dans: git merge MyNewBranch
• Pour répertorier les branches: git branch

Vous pouvez utiliser git diffpour créer un patch puis l'appliquer sur une autre machine. Ou vous pouvez créer un commit temporaire, puis le retirer d'une autre machine. Vous pouvez même créer une branche temporaire sur une autre machine, y pousser votre commit temporaire, puis supprimer la branche.

Ma méthode préférée est la deuxième: créer un commit temporaire, puis aller sur une autre machine et faire quelque chose comme ceci:

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

Je le commets . Le je le pousse à la branche personnelle , vérifiez de l'autre côté et modifiez. Et supprimez la branche personnelle lorsque vous avez terminé.

Bien sûr, vous pouvez pousser directement entre les dépôts, vous pouvez utiliser le bundle ou format-patch/ am, mais une branche personnelle est de loin la solution la plus simple. Et réécrire l'histoire n'est pas un gros problème tant qu'il n'est poussé vers aucune branche partagée. Dans de nombreux projets, les gens sont censés rembobiner les branches de fonctionnalités pour les rendre plus faciles à comprendre pour la révision.

L'approche facile est celle que vous décrivez: copiez le .gitrépertoire caché et les fichiers de projet sur une autre machine où vous pouvez soit valider et terminer, soit simplement continuer à travailler.

Le .gitrépertoire est l'endroit où votre historique git est conservé, donc le conserver avec les fichiers réels conserve l'intégralité de l'historique de votre projet.

Si vous avez définitivement terminé d'utiliser la machine d'origine, je recommanderais probablement cette approche.

Comme d'autres l'ont répondu, avec Git, vous ne devriez pas vous soucier du code non fini dans vos branches personnelles. Cependant, si pour une raison quelconque, vous ne voulez vraiment vraiment pas que votre travail inachevé touche le référentiel principal, vous pouvez utiliser la nature distribuée de Git!

Il existe un outil simple nommé git bundlequi peut vous aider à transmettre facilement les modifications sans référentiel central. Tout d'abord, clonez le dépôt:

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

apporter des modifications et les valider dans une branche temporaire:

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

Maintenant, regroupez les modifications:

git bundle create ../tmp.bundle tmp_branch

Vous avez maintenant un fichier groupé que vous pouvez envoyer à votre nouvelle machine. Comment l'utilisez-vous là-bas? Créons une nouvelle copie de travail:

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

nous devons traiter notre bundle comme une autre télécommande, afin que nous puissions récupérer les modifications

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

puisque le but était de transférer les modifications sans laisser de trace, nous voulons les écraser dans la copie de travail afin de perdre la validation temporaire:

git merge tmp/tmp_branch --squash

et tout ce qui reste est de supprimer la télécommande temporaire:

git remote remove tmp

ALTO! Les modifications ont été transférées dans la nouvelle copie de travail sans laisser de trace ni de branche ni de commit!

Mais vraiment - ce processus est assez long et lourd. C'est Git, pas SVN - il ne devrait vraiment pas y avoir de raison de ne pas pousser votre branche personnelle vers le référentiel central.