Impegni parziali con Subversion

Dato il caso ho apportato due modifiche indipendenti in un file: es. aggiunto un nuovo metodo e cambiato un altro metodo.

Spesso non desidero eseguire il commit di entrambe le modifiche come un commit, ma come due commit indipendenti.

Su un repository git utilizzerei la modalità interattiva di git-add (1) per dividere il pezzo in pezzi più piccoli:

 git add --patch

Qual è il modo più semplice per farlo con Subversion? (Forse anche utilizzando un plug-in Eclipse)

Aggiornamento:
In The Thing About Git , Ryan lo chiama: "The Tangled Working Copy Problem".

Con git-svn è possibile creare un repository GIT locale del repository SVN remoto, lavorarci utilizzando il set completo di funzionalità GIT (inclusi i commit parziali) e quindi rimandarlo tutto al repository SVN.

git-svn (1)

Tortoise SVN 1.8 ora lo supporta con la sua funzione "Restore after commit". Ciò consente di apportare modifiche a un file, con tutte le modifiche annullate dopo il commit

Secondo la documentazione:

Per eseguire il commit solo delle parti del file relative a un problema specifico:

1. nella finestra di dialogo di commit, fai clic con il pulsante destro del mouse sul file, scegli "ripristina dopo il commit"
2. modifica il file ad es. TortoiseMerge: annulla le modifiche che non vuoi ancora applicare
3. salva il file
4. eseguire il commit del file

L'ho fatto usando TortoiseSVN .

L'utilità di unione incorporata ti consente di mostrare una differenza tra la versione del repository e la tua copia di lavoro.

Usa la funzione di creazione di backup dell'utilità diff

1. Vai a eseguire il commit del file come se stessi per eseguire il commit di tutte le modifiche.
2. Nella finestra di commit, fai doppio clic sul file per mostrare un diff.
3. Nelle impostazioni delle differenze, fare clic sull'opzione per eseguire il backup del file originale .
4. Fai clic con il pulsante destro del mouse sulle modifiche che non desideri e usa seleziona usa un altro blocco di testo .
5. Salva il diff esattamente una volta . Il backup verrà sovrascritto ogni volta che salvi. Questo è il motivo per cui vuoi salvare solo una volta.
6. Commetti il ​​cambiamento.
7. Sovrascrivi l'originale con il file .bak creato (che conterrà tutte le modifiche originali).
8. Salva il tuo file.

Ora dovresti avere eseguito il commit di tutte le modifiche, utilizzando due commit separati.

Prova a utilizzare, svn diff > out.patchquindi copia il out.patchfile in out.patch.addeout.patch.modify

Solo quando si dispone di un file patch funzionante, ripristinare il file originale utilizzando svn revert out.c.

Modificare manualmente i file di patch in modo che contengano solo gli hunk per l'aggiunta o la modifica. Applicali al file originale utilizzando il patchcomando, verifica se l'aggiunta ha funzionato, quindi svn commitl'aggiunta.

Lavare la ripetizione del risciacquo per il out.patch.modifycerotto.

Se le modifiche sono separate nel file come affermato dalla tua domanda iniziale - aggiunto un nuovo metodo, modificato un metodo esistente - funzionerà

Questa è una soluzione molto noiosa, anche se non sono convinto che dovresti avere alcun motivo per separare i tuoi commit.

Potresti anche aver estratto più copie di lavoro della stessa fonte per applicare il tuo lavoro contro:

svn co http://location/repository methodAdd

svn co http://location/repository methodModify

Assicurati di farlo svn upe prova per assicurarti che tutto vada bene.

Ciò è possibile utilizzando TortoiseSvn (Windows) dalla v1.8.

4.4.1. La finestra di dialogo Commit

Se la tua copia di lavoro è aggiornata e non ci sono conflitti, sei pronto per confermare le modifiche. Seleziona qualsiasi file e / o cartella che desideri eseguire il commit, quindi TortoiseSVN → Commit ....

<Snip>

4.4.3. Esegui il commit solo di parti di file

A volte si desidera eseguire il commit solo di parti delle modifiche apportate a un file. Una situazione del genere di solito si verifica quando si lavora su qualcosa, ma è necessario eseguire una correzione urgente e quella correzione si trova nello stesso file su cui si sta lavorando.

fare clic con il pulsante destro del mouse sul file e utilizzare il menu contestuale → Ripristina dopo il commit. Questo creerà una copia del file così com'è. Quindi puoi modificare il file, ad esempio in TortoiseMerge e annullare tutte le modifiche che non vuoi applicare. Dopo aver salvato queste modifiche puoi eseguire il commit del file.

Dopo che il commit è stato eseguito, la copia del file viene ripristinata automaticamente e hai il file con tutte le modifiche che non sono state sottoposte a commit.

Su Linux, proverei http://webstaff.itn.liu.se/~karlu20/div/blog/2013-05-31_SVNPartialCommit.php . Non l'ho provato io stesso, però.

Ho usato per fare questo:

• Nel mio editor (io uso vim), modifica il file in modo che appaia solo una delle modifiche
• Salva il file (ma non chiudere l'editor)
• Salva il file modificato in svn
• Premi "annulla" nell'editor abbastanza volte da far ricomparire il secondo gruppo di modifiche
• Salva di nuovo il file
• Conferma la seconda serie di modifiche.

Questo è un approccio semplicistico che presuppone che una serie di modifiche sia ragionevolmente facile da annullare. Per situazioni più complesse, rinuncerei e impegnerei entrambe le modifiche senza preoccuparmene.

Ora che uso git, questo è qualcosa che spero di non doverlo fare mai più!

Uso un repository darcs locale o semplicemente unisco le modifiche gradualmente. Con l'unione (opendiff apre FileMerge, un programma di unione fornito con Xcode; sostituisci con il tuo strumento di unione preferito):

cp file file.new
svn revert file
opendiff file.new file -merge file

unire le modifiche correlate, salvare l'unione, chiudere il programma di unione

svn ci -m 'first hunk' file
mv file.new file
svn ci -m 'second hunk' file

se più di un pezzo non correlato nel file, risciacqua e ripeti (ma perché dovresti aspettare così tanto prima di eseguire il commit ?!)

Inoltre, se conosci git, puoi usare git-svn per mantenere un repository git locale e sincronizzare i tuoi commit su un server master svn; funziona alla grande nella mia esperienza limitata.

Prova VisualSVN per Visual Studio . L' ultima versione 6.1 introduce la funzione QuickCommit. È possibile eseguire il commit parziale delle modifiche selezionate in un file utilizzando i nuovi comandi del menu di scelta rapida Salva questo blocco e Salva selezione nell'editor di Visual Studio.

1. Apri tutti i file che desideri dividere nell'editor di scelta
2. Usando un set di strumenti diverso (su Win, usa il suggerimento di Spike (la vecchia versione)) ritira il secondo set
3. Commettere
4. torna al tuo editor preferito e salva tutti i file

È un po 'più rischioso del suggerimento completo di Spike, ma può essere più facile da fare. Assicurati anche di provarlo prima su qualcos'altro poiché alcuni editor si rifiuteranno di salvare su un file che è cambiato da sotto di loro a meno che tu non ricarichi quel file (perdendo tutte le modifiche)

Penso che un'opzione più semplice rispetto alla generazione di file diff, al ripristino, ecc., Sarebbe quella di avere due copie del repository estratte e utilizzare uno strumento di differenze visive come DeltaWalker per copiare hunk dall'una all'altra.

La prima copia sarebbe quella su cui lavori effettivamente, e la seconda sarebbe solo per questo scopo. Dopo aver apportato un sacco di modifiche alla prima, puoi copiare una sezione nella seconda, eseguirne il commit, copiare un'altra sezione, eseguirne il commit, ecc.

1. Copiare tutti i file modificati interessati nelle copie di backup.
2. Crea una patch dello stato di lavoro usando svn diff.
3. Ripristina i file usando svn revert.
4. Riapplicare le parti della patch su cui si desidera eseguire il commit, utilizzando lo patchstrumento o modificando manualmente o qualsiasi altra cosa.
5. Esegui in diffseguito per confrontare la tua copia di lavoro con il backup per assicurarti di aver applicato correttamente le parti di patch.
6. Costruisci e prova.
7. Commettere.
8. Copia le copie di backup di nuovo nel check-out del repository.
9. Ripeti in 2. (non in 1.!) Fino al termine.