Qual è il modo migliore per avere un “temporaneo” impegnarsi in git?

Question

dice che ho un progetto con due rami master e dev. Ho un sacco di commit su dev per un evento speciale, che una volta testati sono fuse in master. Poi, dopo l'evento è finito voglio rimuovere il codice evento specifico. Tuttavia un reset git non farà in quanto altri commit sono stati fatti in quanto il codice evento è stato aggiunto.

Attualmente io uso git checkout alla cassa i file dalla prima dell'evento è stato fuso e quindi utilizzare diff git aggiungere nuovamente nei cambiamenti che sono stati fatti in quanto l'evento è stato commesso. Questo mi sembra un metodo molto disordinato a me.

Qualcuno ha una soluzione migliore per avere il codice temporaneo in un progetto?

Modifica: Per essere chiari i cambiamenti devono essere impegnati, spinti, non impegnati, spinto.

Answer 1

maestro Prendere e creare un ramo: git checkout -b special-event, make / applicare le modifiche. Una volta che l'evento è finito, è sufficiente tornare alla master e abbandono / eliminare il ramo.

Al fine di continuare a fare cambiamenti, li rendono il master e unirli nel ramo speciale, come si va. git checkout master ... modifica ... git checkout special-event; git merge master.

In alternativa, fare tutte le modifiche relative vostro speciale-evento in una commit, quindi utilizzare git revert quando si desidera rotolare fuori e specificare solo che commettono.

Answer 2

"codice temporaneo"? In git usiamo rami per questo. Commit sono molto leggeri in git, e rami, essendo a soli nomi (o riferimenti) per impegna con un po 'di logica in allegato, sono super leggero rispetto ad altri sistemi.

L'po 'di logica è proprio questo il riferimento viene aggiornato automaticamente all'ultimo commit. Questo è più o meno tutto quello che un ramo è. Ciò significa creare e distruggere rami in git è veloce, semplice e sicura anche, dal momento che nulla è davvero creato o eliminato. Dopo un eliminato è ancora possibile fare riferimento alla testa ramo per commettere-id (sì, è ancora lì fino a quando non di garbage collection e anche questo avviene solo se non c'è altro riferimento ad esso).

Quasi tutti i comandi in git prende i riferimenti a un commit come parametri. Questo è vero per il merge git pure. Non stai fusione rami, si sta fondendo commit. Sì, si digita 'git merge', ma ancora una volta, un ramo è solo un nome per un commit. Nulla di più di questo. E dal momento che tutto ciò che serve è il raggruppamento dei commit per l'evento insieme, solo dare loro un nome.

Quindi la cosa giusta da fare è quello di creare un ramo per l'evento. O forse, due: 'evento-master' e 'evento-dev'. Ora, si sviluppa codice per l'evento in 'evento-dev'. In caso di imbattersi in un bug che deve essere risolto nel codice principale, scorta e l'interruttore al vostro normale 'dev' ramo, il codice la correzione e commettono. Tornare alla 'evento-dev', unione da 'dev', e pop la scorta. Continuare a sviluppare, una volta fatto, commit e test. Se è ok, merge 'evento-dev' in 'evento-master'. Questo dovrebbe contenere anche la correzione. Si noti che la correzione non è in 'master' ancora.

Se è necessario la correzione fuse in 'master', basta farlo nel modo solito, come la correzione è in 'dev'.

Fondamentalmente in questa configurazione è possibile:

• sviluppare il codice principale, come al solito: si impegnano a 'dev', il test e si fondono in 'master';

• sviluppare il codice evento specifico in modo simile: si impegnano a 'evento-dev', il test e si fondono in 'evento-master'; è solo il flusso di lavoro stesso;

• mischiare i due flussi di lavoro; commit e ramo interruttore, o uso git scorta;

• rami di unione (quasi) liberamente; è possibile unire 'master' in 'evento-dev', se il master è in qualche modo aggiornato ed è necessario le modifiche per l'evento; è possibile unire 'dev' in 'evento-dev', se hai un disperato bisogno dei cambiamenti per l'evento e non può attendere per il consueto ciclo di test che li spinge verso 'master'. git avrebbe fatto questo per quanto riguarda le unioni sono pulite, che è a meno che non si è modificato lo stesso pezzo di codice in due modi diversi nei due rami -dev (questo naturalmente è un caso particolare che ha bisogno di essere gestite);

Se avete bisogno di maggiore flessibilità, creare più rami. Per la flessibilità eccellente, è possibile cherry-pick singoli impegna in un ramo, ma in consiglio mi generale contro che (farlo solo se davvero sa cosa si sta facendo).

Infine, vorrei sottolineare che questo flusso di lavoro è così naturale in git. In realtà, sviluppando in 'dev' e tirando le modifiche in 'master' non è anche la migliore in generale. E 'consuetudine per creare un ramo dev per ogni caratteristica o modulo si sta sviluppando, e unire quei rami in 'dev'.

Credo che la mentalità giusta quando si utilizza git è: "che cosa mi sento come a codice oggi caratteristica X. Bene, creiamo ramo 'caratteristica-x' e iniziare l'hacking?".. Quell'evento tuo non è diverso.

Ora, so che quello che ti sto dicendo è come si dovrebbe avere fatto cose fin dall'inizio, e che non aiuta molto in questo momento. È necessario risolvere il tuo albero, dal momento che - a quanto pare - si hanno i cambiamenti per l'evento mescolato con i normali cambiamenti nel tuo branch 'dev'. Quindi il problema è come creare correttamente 'evento-dev' con solo le modifiche per l'evento e rimuovere dal 'dev' allo stesso tempo.

È ora di riscrivere la storia. Come è difficile che sarà, dipende dalla natura dei cambiamenti. Ad esempio, se tutte le modificheappartengono a una singola directory, le cose possono essere più facile.

Ecco cosa farei (conoscendo meglio):

• esaminare la storia con git log;

• Trova il commit che è di destra prima del primo cambio specifico evento, prendere atto della sua commit-id: questo è il 'day-0' commit;

• creare un ramo di nome 'NewDev' indicando che commettono. Fate questo in un albero pulito, che è impegnarsi prima di fare questo: git checkout -b NewDev;

• creare 'evento-dev': git checkout -b evento-dev;

• tu hai ora due rami sia puntato verso il 'day-0' commit;

• ora guardare la storia di nuovo (git log dev), è necessario seguire è impegnarsi per commettere;

• Sto assumendo che ogni commit seguendo 'day-0' è o un commit che appartiene al codice principale, o uno che appartiene solo l'evento. Quello che devi fare è di loro cherry-pick nel ramo di destra, 'NewDev' se si tratta di codice principale, 'evento-dev' Se si tratta di eventi-code; farlo ancora una volta, nel giusto ordine (da 'day-0' ad oggi);

• se siete molto fortunati, senza commettere che finisce in 'NewDev' dipende impegna a 'evento-dev' e viceversa; Sei un po 'fatto; si consiglia di rinominare (tenerli in giro) il comandante attuale e dev per master-vecchio e dev-old, NewDev quindi rinominare per dev, creare maestro dev, evento-master dall'evento-dev, e siete a posto;

• se siete un po 'meno fortunato, a volte dovrete merge 'NewDev' in 'evento-dev', perché alcuni commit dipende da modifiche apportate nel codice principale, che va bene, tho ; se vi sentite audaci qui, è il momento di leggere su rebase git; ma rebase fare a meno che non si deve;

• o (peggio ancora) alcuni impegna a 'NewDev' dipendono dai cambiamenti nella 'evento-dev' ... oops, che il codice evento specifico si rivela essere non così evento-specifici, se i bisogni principali filiali esso. Alcuni merging necessario;

• o (male) un commit contiene entrambi i tipi di cambiamenti: divide et impera (è necessario separare le modifiche e applicarle al ramo a destra), che significa che stai splitting il commit in due;

• o qualcos'altro non riesco a immaginare ora, poiché non ho sufficienti informazioni circa il vostro albero.

Potrebbe essere un gioco da ragazzi o di un incubo. Ispezionare ogni commit in anticipo (mostra git, si può guardare come un cerotto), decidere cosa fare (finalmente non cherry-pick, solo modificando i file potrebbe essere più facile), se non è sicuro - indovinate un po '- creare un ramo , il lavoro in là, vedere cosa succede, unirla se felice, altrimenti cadere e riprovare.

Non ho parlato finora, ma naturalmente si può fare una copia di tutto l'albero, i file git inclusi, e lavorare sulla copia di essere al 100% sicuro.

Farlo fin dall'inizio è piuttosto facile. Fissaggio ora, beh, buona fortuna. :)

Answer 3

git checkout -b event

... fare il cambiamento evento specifico ...

git commit -am "specific event change"

... fare un altro cambiamento evento specifico ...

git commit -am "another specific event change"

A questo punto, il Master ramo è ancora intatta ed i cambiamenti evento specifico sono sul evento ramo. Se vengono apportate modifiche al ramo master che sono necessari anche nel evento ramo, utilizzo rebase ...

git rebase master

Un'altra risposta suggerita la fusione Master in evento , ma rebase è di solito l'approccio migliore. A rebase bucce i commit fatti sul ramo off topic, tira il aggiornato Master in avanti e poi riapplica i cambiamenti argomento ramo in alto ... come se i cambiamenti argomento ramo sono state fatte alla versione più recente di master.

Nel vostro scenario, quando l'evento è finito, è sufficiente eliminare il evento ramo.

Answer 4

Rimboccati le commit seguendo il mio metodo non-brevettato:

# work on a new branch
git checkout -b event-36
git commit -a -m "all broken dammit"
git commit -a -m "fixed that damn code"
git commit -a -m "almost ready, going to eat lunch"
git commit -a -m "It's done!"

# other people might be working on master in the meantime, so
git checkout master
git checkout -b erasemeImmediately
git merge event-36
git reset --soft master # THE KEY TO THE WHOLE THING: SOFT RESET!
git commit -a -m "Event 36, all code in one commit"

git checkout master
git merge erasemeImmediately

Si può fare questo con reflog, ma poi avrete bisogno di un recente laurea CS (cioè, è difficile da capire).

Ora il vostro commettere è una sola. Ora è possibile utilizzare Ripristina o fare cherry-pick buona strada per un ramo senza di essa.

Answer 5

git revert

E 'consente di eliminare ogni commit, o l'intervallo di commit che è necessario annullare. E 'anche sicuro di spingere ad un repo pubblico.

Answer 6

Nella mia esperienza, alcuni eventi speciali hanno un modo di ricorrenti. Quindi, una soluzione alternativa da considerare è quello di creare un opzione di configurazione per abilitare la gestione dell'evento speciale, in modo che possa essere attivata e disattivata come e quando necessario.

Answer 7

I beleive scorta fa quello che si vuole.