Commits parciais com Subversion

Dado o caso, fiz duas alterações independentes em um arquivo: por exemplo. adicionou um novo método e mudou outro método.

Freqüentemente, não quero comprometer ambas as alterações como um commit, mas como dois commits independentes.

Em um repositório git, eu usaria o modo interativo do git-add (1) para dividir o pedaço em outros menores:

 git add --patch

Qual é a maneira mais fácil de fazer isso com o Subversion? (Talvez até usando um plug-in Eclipse)

Atualização:
Em The Thing About Git , Ryan chama isso de: “The Tangled Working Copy Problem”.

Com git-svn você pode fazer um repositório GIT local do repositório SVN remoto, trabalhar com ele usando o conjunto completo de recursos GIT (incluindo commits parciais) e então enviar tudo de volta para o repositório SVN.

git-svn (1)

Tortoise SVN 1.8 agora suporta isso com seu recurso "Restaurar após confirmação". Isso permite que você faça edições em um arquivo, com todas as edições sendo desfeitas após a confirmação

Pela documentação:

Para comprometer apenas as partes do arquivo relacionadas a um problema específico:

1. na caixa de diálogo de confirmação, clique com o botão direito no arquivo e escolha "restaurar após confirmação"
2. edite o arquivo em, por exemplo, TortoiseMerge: desfaça as mudanças que você ainda não deseja enviar
3. Salve o arquivo
4. enviar o arquivo

Eu fiz isso usando o TortoiseSVN .

O utilitário de mesclagem embutido permite que você mostre uma diferença entre a versão do repositório e sua cópia de trabalho.

Use a função de criar backup do utilitário diff

1. Vá para cometer seu arquivo como se fosse enviar todas as suas alterações.
2. Na janela de confirmação, clique duas vezes no arquivo para mostrar uma comparação.
3. Nas configurações de diff, clique na opção para fazer backup do arquivo original .
4. Clique com o botão direito nas alterações que você não deseja e use selecionar usar outro bloco de texto .
5. Salve o diff exatamente uma vez . O backup será substituído sempre que você salvar. É por isso que você deseja salvar apenas uma vez.
6. Comprometa a mudança.
7. Substitua o original pelo arquivo .bak criado (que terá todas as alterações originais).
8. Confirme seu arquivo.

Agora você deve ter todas as suas alterações confirmadas, usando dois commits separados.

Tente usar e, em svn diff > out.patchseguida, copie o out.patcharquivo para out.patch.addeout.patch.modify

Somente quando você tiver um arquivo de patch funcionando, reverta o arquivo original usandosvn revert out.c .

Edite os arquivos de patch manualmente para que eles contenham apenas os pedaços para adicionar ou modificar. Aplique-os ao arquivo original usando o patchcomando, teste se a adição funcionou e, em seguida,svn commit a adição.

Repita o enxágue da lavagem para o out.patch.modify patch.

Se as alterações forem separadas no arquivo conforme sua pergunta inicial declarada - adicionado um novo método, alterado um método existente - isso funcionará

Esta é uma solução muito tediosa - embora eu não esteja convencido de que você deva ter algum motivo para separar seus commits.

Você também pode ter verificado várias cópias de trabalho da mesma fonte para aplicar seu trabalho:

svn co http://location/repository methodAdd

svn co http://location/repository methodModify

Certifique-se de fazer o svn upteste e verifique se está tudo bem.

Isso é possível usando TortoiseSvn (Windows) desde v1.8.

4.4.1. The Commit Dialog

Se a sua cópia de trabalho estiver atualizada e não houver conflitos, você está pronto para enviar suas alterações. Selecione qualquer arquivo e / ou pasta que você deseja submeter, então TortoiseSVN → Confirmar ....

<snip>

4.4.3. Confirmar apenas partes dos arquivos

Às vezes, você deseja confirmar apenas partes das alterações feitas em um arquivo. Essa situação geralmente acontece quando você está trabalhando em algo, mas uma correção urgente precisa ser confirmada, e essa correção está no mesmo arquivo em que você está trabalhando.

clique com o botão direito no arquivo e use Menu de contexto → Restaurar após o commit. Isso criará uma cópia do arquivo como ele está. Então você pode editar o arquivo, por exemplo, no TortoiseMerge e desfazer todas as mudanças que você não deseja submeter. Depois de salvar essas alterações, você pode confirmar o arquivo.

Após a confirmação, a cópia do arquivo é restaurada automaticamente e você tem o arquivo com todas as modificações que não foram confirmadas.

No Linux, eu daria uma chance ao http://webstaff.itn.liu.se/~karlu20/div/blog/2013-05-31_SVNPartialCommit.php . Não tentei sozinho, no entanto.

Eu costumava fazer isso:

• No meu editor (eu uso o vim), edite o arquivo para que apenas uma das alterações apareça
• Salve o arquivo (mas não saia do editor)
• Envie o arquivo alterado para svn
• Pressione "desfazer" no editor o suficiente para que o segundo conjunto de alterações reapareça
• Salve o arquivo novamente
• Confirme o segundo conjunto de alterações.

Essa é uma abordagem simplista que assume que um conjunto de alterações é razoavelmente fácil de desfazer. Para situações mais complexas, desistiria e cometeria as duas alterações sem me preocupar com isso.

Agora que uso o git, espero nunca mais ter que fazer isso!

Eu uso um repositório darcs local ou apenas mesclo as alterações gradualmente. Com a fusão (opendiff abre o FileMerge, um programa de fusão que vem com o Xcode; substitua pela sua ferramenta de fusão favorita):

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

mesclar as mudanças relacionadas, salvar a mesclagem, sair do programa de mesclagem

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

se houver mais de um pedaço não relacionado no arquivo, enxágue e repita (mas por que você esperaria tanto antes de confirmar ?!)

Além disso, se você conhece git, pode usar git-svn para manter um repositório git local e sincronizar seus commits para um servidor svn master; funciona muito bem na minha experiência limitada.

Experimente o VisualSVN para Visual Studio . A versão 6.1 mais recente apresenta o recurso QuickCommit. Você pode confirmar parcialmente as alterações selecionadas em um arquivo usando o novo Commit this Block e Commit Selection comandos do menu de contexto no editor do Visual Studio.

1. Abra todos os arquivos que deseja dividir no editor de escolha
2. Usando um conjunto de ferramentas diferente (no Win, use a sugestão de Spike (a versão antiga)), volte ao segundo conjunto
3. Comprometer
4. volte para o seu editor de escolha e salve todos os arquivos

É um pouco mais arriscado do que a sugestão completa de Spike, mas pode ser mais fácil de fazer. Além disso, certifique-se de tentar em outra coisa primeiro, pois alguns editores se recusarão a salvar um arquivo que foi alterado a menos que você recarregue esse arquivo (perdendo todas as suas alterações)

Acho que uma opção mais fácil do que gerar arquivos diff, revertendo, etc, seria ter duas cópias do repositório verificadas e usar uma ferramenta de diff visual como DeltaWalker para copiar pedaços de um para o outro.

A primeira cópia seria aquela em que você realmente trabalha, e a segunda seria apenas para esse propósito. Depois de fazer várias alterações na primeira, você pode copiar uma seção para a segunda, submetê-la, copiar outra seção, submetê-la, etc.

1. Copie todos os arquivos modificados em questão para cópias de backup.
2. Crie um patch do estado de trabalho usando svn diff .
3. Reverta os arquivos usando svn revert .
4. Reaplique as partes do patch que você deseja confirmar, usando o patch ferramenta, seja por edição manual, ou qualquer outra coisa.
5. Corre diff depois para comparar sua cópia de trabalho com seu backup para ter certeza de que aplicou as partes do patch corretamente.
6. Construa e teste.
7. Comprometa-se.
8. Copie suas cópias de backup de volta para o check-out do seu repositório.
9. Repita em 2. (não em 1.!) Até terminar.