`qrefresh` è considerato dannoso?

Question

Il comando qrefresh nell'estensione MQ non ha senso per me. Spiegherò la mia ipotesi:

1. Se non si sa su quale revisione applicare una determinata patch, essa ha un valore molto basso. Non puoi teoricamente sapere che cosa significano gli scarti. E anche se non ci sono scarti su una determinata revisione, non sei sicuro che l'intera revisione possa essere compilata.
2. Una volta eseguita la patch della patch nella patch qrefresh, si sta effettivamente perdendo la parent della patch successiva nella coda. In modo che senza il tuo intervento questa prossima patch sia/potrebbe essere inutile.
3. Per correggere la patch successiva, è preferibile unirla anziché modificare manualmente i file .rej. Non solo per gli strumenti migliori, se hai la patch originale un-qrefresh, hai più informazioni, lo qrefresh ti ha fatto perdere le informazioni di cui hai effettivamente bisogno per rendere significativa la modifica apportata alla patch.

Quindi non capisco perché uno vorrebbe mai usare questo comando.

Un'alternativa migliore è applicare tutte le patch, quindi hg update al genitore della patch che si desidera modificare, quindi, hg revert la directory di lavoro alla patch che si desidera modificare. Cambia questa patch, esegui il commit su una nuova revisione e quindi rebase tutte le altre patch in questa nuova revisione.

Semplicemente non capisco quando qrefresh è rilevante quando non si sta modificando una singola patch. Sembra che l'approccio di git (applicare la patch a un ramo locale) abbia molto più senso di una coda di patch.

Sono corretto, e sarebbe meglio usare rebase? C'è qualcosa che ho perso?

migrati da kiln.se.com causa della mancata risposta e dal basso tasso di

Answer 1

EDIT: dopo aver scritto la risposta qui sotto, sono incappato il chapter about patches di Mercurial The Definitive Guide . Dice più o meno lo stesso ma è molto più dettagliato che la mia risposta. Anche lo suggerisce un modo (un po 'contorto per il mio gusto , ma comunque) per usare l'unione a 3 vie con le patch mentre l'OP stava cercando per.

Forse vedete mq solo come strumento di importazione patch? Questo non è il mio uso principale, e per me qrefresh è molto utile. Il tipico caso d'uso per me è quando lavoro sopra la parte superiore del repository pubblicato.

Di solito lavoro con una serie di patch che sto scrivendo allo stesso tempo. Inizio creando una nuova patch vuota. Quando ritengo che alcune funzionalità (parte di) siano state completate, ho aggiunto la patch superiore a qrefresh per includere tutte le modifiche apportate dal tempo di creazione delle patch (o l'ultimo qrefresh). Quindi creo una nuova patch vuota e continuo a scrivere il codice che appartiene alla prossima patch.

Se in un secondo momento quando si lavora su un altro patch, vedo alcune modifiche che dovrebbero essere apportate all'interno di una patch precedente (perché a essa appartiene logicamente), non apporto la modifica nella patch superiore né creo una nuova patch . Innanzitutto I qrefresh la patch corrente, quindi qpop alla patch precedente a cui appartengono le modifiche, quindi apportare le modifiche. Al termine, reinvia la patch precedente a qrefresh, quindi a qpush dove lavoravo e così via.

Quando si lavora in questo modo, le unioni sono in genere molto semplici e non riesco quasi a rifiutare qpop ing e qpush in giro.

Quando credo che la serie completa di patch sia pronta per essere pubblicata, I qfinish l'intera serie e ricomincio con un nuovo stack di patch vuoto.

È possibile fare lo stesso tipo di cose con rebase, ma poi avresti bisogno di funzionalità come git rebase interattivo.

L'intero punto su come lavorare con le patch è che le patch non sono ancora impegnate, quindi possono essere facilmente modificate, e per questo è necessario qrefresh. Bene, potrei ottenere lo stesso risultato creando nuove patch e qfold, ma non ci sarebbe davvero nessun punto per farlo, solo due comandi invece di uno.

Ora, quando le patch sono contributi esterni, come main maintener al mio progetto, i contributi sono inclusi dalle patch fornite dai contributori e non arrivano mai direttamente al repository. Prima entrano nella mia pila di patch principale. Se apportano modifiche alle stesse parti del programma su cui sto lavorando, è probabile che causino scarti (e se così fosse basicamente non lo inserisco affatto, è probabile che causi il caos). Se si applicano ad altre parti del programma che non sono attualmente modificate, si fondono praticamente senza alcun problema e possono essere importate in qualsiasi punto dello stack di patch, senza l'obbligo di inserirle in una revisione specifica. Ma leggo sempre i cambiamenti e molto spesso cambio leggermente il codice fornito. Poi di nuovo uso qrefresh per aggiornare la patch esterna a ciò che credo che dovrebbe essere.

Answer 2

Si consiglia di scegliere la risposta di kriss, s/egli spiega tutto molto bene, ma qui è un documento sul software che ha ispirato la funzionalità di gestione delle patch sia mercuriale e git, trapunta:

http://www.suse.de/~agruen/quilt.pdf