Spostando facilmente entrambe le direzioni del tempo durante un rebase

1

Dopo aver scritto alcune commit, molto spesso git rebase -i su di esse, per testarle, se necessario dividerle, prendere le parti da un commit e squash verso un altro, più appropriato.

Ma c'è un problema. Dite, oggi sto cercando un bug, che stanno provocando 5 recenti commit. Interagisco interattivamente sull'ultimo noto al lavoro (sopporta me, non usando git bisect per un motivo). Il prossimo commit introduce il bug, ma è un grosso casino un codice non correlato.

Quindi I git reset HEAD~ e quindi forma diversi commit logici internamente.

Ecco il problema. Non so quale sia il primo commit problematico. Quindi seleziono edit per tutti i commit durante il ribasso. Dopo che ho finito con il commit problematico, ho un paio di commit in passato, che vorrei testare ulteriormente.

Al momento, faccio git rebase --continue molte volte, finché il rebase non è completo, quindi rebase in modo interattivo di nuovo. Questo ha alcuni problemi:

  • È noioso. Per lo meno, vorrei un comando che rebase in cima al ramo, saltando tutti i edit dichiarato commit.
  • Neverending si unisce. Ho bisogno di unirmi spesso, e preferirei prima fare il lavoro significativo di dividere il commit originale, e solo dopo che git commit --ammend quest'ultimo commette per essere compatibile con la storia modificata.

TL; DR;

Come posso ottenere questa traversata bidirezionale su un ramo, mentre allo stesso tempo, creando, rimuovendo e modificando i commit? Oppure questo flusso di lavoro è concettualmente sbagliato?

    
posta Vorac 16.06.2014 - 17:45
fonte

1 risposta

2

Questa è la mia opinione, in base alla mia esperienza.

Il debug è un processo. La ridefinizione è un processo diverso. Se provi a combinare i due, ti capita di fare casino.

Al punto in cui avvii il rebase, dovresti avere un codice funzionante. Se non si dispone di codice funzionante, interrompere ciò che si sta facendo e correggere il codice. Se questo è il codice che ti è stato inviato da qualcun altro, questo è il loro problema, non il tuo. Se il tuo compito è quello di integrare il codice di altre persone, è perfettamente ragionevole restituire loro il problema. Altrimenti, fai più lavoro per te.

@Cupcake ha già chiesto perché non stai utilizzando git bisect . La tua risposta mi dice che stai lavorando su una porzione di codice troppo grande. "Grande" non è definito dal numero di linee, ma piuttosto dalla funzionalità. Se qualcuno ti sta inviando il codice da integrare, allora loro dovrebbero suddividerlo nei blocchi giusti, non tu. Se una parte del codice riguarda più funzionalità non correlate, allora è troppo grande. (Sto usando la parola "chunk" per indicare un changeset logico, che può includere più di un commit. Non c'è niente di sbagliato nel lavorare su più commit purché siano correlati logicamente.)

Personalmente non consiglierei il tuo flusso di lavoro. Penso che dovresti usare richieste pull . Lo uso nel mio lavoro diurno. Fondamentalmente una persona gestisce un repository e altre persone inviano richieste per aggiungere commit al repository. Se il manutentore approva la modifica, bene. Se no, no. Ogni richiesta deve essere autonoma e ogni richiesta deve aggiungere una funzionalità ben definita.

La cosa bella delle richieste pull (e la creazione di un repository) è che separa in modo molto chiaro chi è responsabile del fare cosa. Sembra che manchi la separazione dal flusso di lavoro corrente.

Se hai voglia di approfondire, ho trovato l'articolo di Vincent Driessen su Gitflow per essere molto utile.

Questo non è quello che hai chiesto, ma potresti anche voler esaminare i test unitari e l'integrazione continua. Queste cose renderanno più difficile nascondere gli errori e in definitiva ti faranno risparmiare un po 'di tempo.

Buona fortuna! Git può essere difficile da imparare e mi ci sono voluti mesi per sentirmi a mio agio.

    
risposta data 05.07.2014 - 02:26
fonte

Leggi altre domande sui tag