A volte mi imbatto nel problema di avere codice non eseguito su una workstation che non è pronta per un commit ma deve essere completata su una workstation o un laptop differente.
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 altrove?
Preferirei non essere obbligato a impegnare e spingere le modifiche che non sono implementate correttamente.
Quanto segue assume che il repository locale sia un clone di un repository su un altro server, ad es. GitHub; e che si dispone dei diritti per apportare modifiche al server upstream. Nel mio esempio, ho chiamato questo repository "origine" upstream. Esegui git remote show per elencare altri reposli, questo potrebbe darti un suggerimento su come viene chiamato.
Suggerirei di creare un ramo, quindi puoi controllare il ramo su un'altra macchina. Infatti, se fai un ramo non appena inizi a lavorare, puoi "impegnarti" nel tuo ramo, avere una traccia e un backup del tuo lavoro, senza dover disporre di un codeset stabile. Una volta che sei soddisfatto del tuo lavoro, puoi reinserirlo nel tuo ramo "master".
git checkout -b MyNewBranch
git push origin MyNewBranch
git checkout MyNewBranch
git checkout master
git merge MyNewBranch
git branch
Puoi usare git diff per creare una patch e poi applicarla su un'altra macchina. Oppure puoi creare un commit temporaneo, quindi estrarlo da un altro computer. Puoi anche creare un ramo temporaneo su un'altra macchina, spingere il tuo commit temporaneo lì, quindi eliminare il ramo.
Il mio metodo preferito è il secondo: creare un commit temporaneo, quindi andare su un altro computer 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^
I impegno . Il spingo a ramo personale , controlla dall'altra parte e modifica. Ed elimina il ramo personale quando finito.
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 la riscrittura della cronologia non è un grosso problema finché non viene spinto a nessun ramo condiviso. In molti progetti le persone sono supposte per riavvolgere i rami delle funzioni per renderle più facili da comprendere per la revisione.
L'approccio semplice è quello che descrivi: copia la directory .git nascosta e proietta i file su un'altra macchina in cui puoi eseguire il commit e terminare, o semplicemente continuare a lavorare.
La directory .git è dove viene conservata la cronologia git, quindi preservarla insieme ai file reali mantiene intatta l'intera cronologia del tuo progetto.
Se utilizzi definitivamente la macchina originale, probabilmente ti consiglierei questo approccio.
Come gli altri hanno risposto, con Git non dovresti preoccuparti del codice non finito nelle tue filiali personali. Tuttavia, se per qualche motivo, davvero davvero non vuoi che il tuo lavoro incompiuto tocchi mai il repository principale, puoi utilizzare la natura distribuita di Git!
C'è un semplice strumento chiamato git bundle che può aiutarti a passare facilmente le modifiche senza un repository centrale. In primo luogo, clonare il repository:
git clone https://github.com/octocat/Spoon-Knife.git working_copy_1
cd working_copy_1
apporta alcune modifiche e inseriscile 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 alla tua nuova macchina. 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 trattare il nostro bundle come un altro telecomando, quindi possiamo recuperarne le modifiche
git remote add tmp ../tmp.bundle
git fetch tmp
dal momento che l'intero punto era di 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 alla nuova copia di lavoro senza lasciare traccia né di ramo né commit!
Ma davvero - questo processo è piuttosto lungo e macchinoso. Questo è Git, non SVN: non ci dovrebbe essere alcun motivo per non spingere il tuo ramo personale al repository centrale.
Leggi altre domande sui tag git