Git commit non terminato ma non può continuare su quella macchina

A volte mi imbatto nel problema di avere il codice senza commit su una workstation che non è pronto per un commit ma deve essere completato su una workstation o laptop diverso.

Qualcuno ha una soluzione per questo problema, come un "soft commit" o qualche altro modo di trasferire le modifiche su un'altra macchina per lavorarci su altrove?

Preferirei non essere costretto a impegnarmi e spingere cambiamenti che non sono stati implementati correttamente.

Di seguito si presuppone che il proprio repository locale sia un clone di un repository su un altro server, ad esempio github; e che si dispone dei diritti per apportare modifiche al server upstream. Nel mio esempio, ho chiamato questo repository upstream "origine". Esegui git remote showper elencare altri repository, questo potrebbe darti un suggerimento su come si chiama.

Suggerirei di creare un ramo, quindi puoi controllare il ramo su un'altra macchina. Infatti, se si crea una succursale non appena si inizia a lavorare, è possibile "impegnarsi" nella propria succursale, avere una traccia e un backup del proprio lavoro, senza dover disporre di un set di codici stabile. Una volta che sei soddisfatto del tuo lavoro, puoi rimetterlo nel tuo ramo "master".

• Per ramificare il tuo repository: git checkout -b MyNewBranch
• Per inviare modifiche impegnate nella nuova filiale: git push origin MyNewBranch
• Per verificare un ramo su un altro computer: git checkout MyNewBranch
• Per passare a un altro ramo (ad es. "Master"): git checkout master
• In master, per ricollegare MyNewBranch in: git merge MyNewBranch
• Per elencare i rami: git branch

È possibile utilizzare git diffper creare una patch e quindi applicarla su un altro computer. Oppure puoi creare un commit temporaneo, quindi estrarlo da un'altra macchina. Puoi persino creare un ramo temporaneo su qualche altra macchina, spingere lì il tuo commit temporaneo, quindi eliminare il ramo.

Il mio metodo preferito è il secondo: creare un commit temporaneo, quindi andare su un'altra macchina e fare qualcosa del genere:

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

Lo commetto . Lo spingo nella filiale personale , controllo dall'altra parte e modifica. Ed eliminare il ramo personale al termine.

Ovviamente puoi spingere direttamente tra i repository, puoi usare bundle o format-patch/ am, ma un ramo personale è di gran lunga la soluzione più semplice. E riscrivere la storia non è un grosso problema fintanto che non è spinta a nessun ramo condiviso. In molti progetti le persone dovrebbero riavvolgere i rami delle funzionalità per renderli più facili da comprendere per la revisione.

L'approccio semplice è quello che descrivi: copia la .gitdirectory nascosta e i file di progetto su un altro computer in cui è possibile eseguire il commit e il completamento o semplicemente continuare a lavorare.

La .gitdirectory è dove viene conservata la cronologia di git, quindi preservarla insieme ai file effettivi mantiene intatta l'intera cronologia del progetto.

Se hai finito definitivamente di usare la macchina originale, probabilmente consiglierei questo approccio.

Come altri hanno risposto, con Git non dovresti preoccuparti del codice non finito nelle tue filiali personali. Tuttavia, se per qualche motivo, davvero non vuoi davvero che il tuo lavoro incompiuto tocchi mai il repository principale, puoi utilizzare la natura distribuita di Git!

Esiste un semplice strumento chiamato git bundleche può aiutarti a passare facilmente le modifiche senza un repository centrale. Innanzitutto, clonare il repository:

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

apportare alcune modifiche e impegnarle in un ramo temporaneo:

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

Ora, raggruppa le modifiche:

git bundle create ../tmp.bundle tmp_branch

Ora hai un file bundle che puoi spedire al tuo nuovo computer. Come lo usi lì? Creiamo una nuova copia di lavoro:

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

dobbiamo considerare il nostro bundle come un altro telecomando, in modo da poter recuperare le modifiche da esso

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

dal momento che il punto era trasferire le modifiche senza lasciare traccia, vorremmo schiacciarle nella copia di lavoro per perdere il commit temporaneo:

git merge tmp/tmp_branch --squash

e tutto ciò che rimane è rimuovere il telecomando temporaneo:

git remote remove tmp

VIOLA! Le modifiche sono state trasferite nella nuova copia di lavoro senza lasciare traccia né di diramazione né commit!

Ma davvero - questo processo è piuttosto lungo e complicato. Questo è Git, non SVN: in realtà non dovrebbe esserci alcun motivo per non spingere il proprio ramo personale nel repository centrale.