Como faço para ramificar um arquivo individual no SVN?

Question

O conceito de subversão de ramificação parece ser focado na criação de um [un] estável garfo de todo o repositório em que para fazer o desenvolvimento. Existe um mecanismo para a criação de ramos de arquivos individuais?

Para um caso de uso, pense em um arquivo de cabeçalho comum (* .h) que tem vários (* .c) implementações de código específico da plataforma. Este tipo de ramo é uma permanente. Todos esses ramos veria desenvolvimento contínuo com ocasionais fusão cross-galho. Isto está em nítido contraste com ramos versão de desenvolvimento / estáveis ??instáveis ??que geralmente têm uma vida útil limitada.

I não quer ramificar todo o repositório (barato ou não), uma vez que iria criar uma quantidade razoável de manutenção para fundir continuamente entre o tronco e todos os ramos. No momento eu estou usando ClearCase, que tem um conceito diferente de ramificação que torna isso fácil. Fui convidado a considerar a transição para o SVN, mas esta diferença paradigma é importante. Estou muito mais preocupado em ser capaz de facilmente criar versões alternativas para arquivos individuais do que com coisas como o corte de um ramo release estável.

Answer 1

Infelizmente, eu acho que a resposta real aqui é que ClearCase lida com esta situação muito melhor do que Subversion. Com a subversão, você tem que ramo tudo , mas ClearCase permite uma espécie de "ramo preguiçoso" ideia de que os meios apenas um determinado grupo de arquivos são ramificados, o resto deles ainda seguem o tronco (ou qualquer que seja o ramo você especificar).

As outras soluções fornecidas aqui realmente não funcionam como você pretende, eles estão apenas copiar o arquivo para um caminho diferente. Agora você tem que fazer coisas estranhas realmente usar esse arquivo.

Erm, desculpe. Isso não era realmente uma resposta muito boa. Mas não é uma boa solução para isso com Subversion. Seu modelo é filial e mesclagem.

Edit: OK, então ampliando o que crashmstr disse. Você poderia fazer isso:

svn cp $REP/trunk/file.h $REP/branched_files/file.h
svn co $REP/trunk
svn switch $REP/branched_files/file.h file.h

Mas wow !, é que propenso a erros. Sempre que você faz um svn st você verá isto:

svn st
    S  file.h

Um pouco barulhento isso. E quando você quer ramificar alguns arquivos ou módulos dentro de um grande repositório de origem ele vai começar a ficar muito confuso.

Na verdade, há provavelmente um projeto decente aqui para simular algo como arquivos ramificados do ClearCase com propriedades svn e comutação, escrevendo um invólucro em torno do cliente bog padrão svn para lidar com toda a confusão.

Answer 2

Você não precisa se ramificar todo o repositório. Você poderia fazer ramos de pastas em seu projeto (como um incluem pasta). Como outros já mencionado, você também pode fazer uma "cópia" de apenas um único arquivo. Uma vez que você tem uma cópia de um arquivo ou pasta, é "switch" para o arquivo ramificado ou pasta para o trabalho na versão ramo.

Se você criar um ramos separados pasta no repositório, você pode copiar seus arquivos ramificados lá através de comandos do lado do servidor:

svn copy svn://server/project/header.h svn://server/branched_files/header.h

Em seguida, você poderia mudar esse arquivo para usar o caminho do repositório branches_files

Answer 3

Aqui está como eu entendo o seu problema. Você tem a seguinte árvore:

time.h
time.c

e você precisa recusá-la para múltiplas arquiteturas:

time.h is comon
time.c (for x386), time.c (for ia64), time.c (for alpha),...

Também em seus VCS atuais você pode fazer isso através da criação de tantos ramos de time.c conforme necessário e quando você check-out dos arquivos dos VCS você verificar automaticamente a última time.h do tronco comum e o mais recente time.c do ramo que você está trabalhando.

O problema que você está preocupado com é que se você usar o SVN quando se verificar uma filial você terá que time.h merge de tronco muito frequentemente ou risco trabalhando em um arquivo mais antigo (em comparação com o tronco) que quantidade de sobrecarga não é aceitável para você.

Dependendo da estrutura de seu código-fonte, pode haver uma solução embora. imagine que você tem

 
/
/headers/
/headers/test.h
/source/
/source/test.c

Em seguida, você pode ramificar / e usar a svn: externals recurso para vincular seus cabeçalhos para a cabeça do tronco. Ele só funciona em diretórios e tem algumas limitações em relação a cometer volta para test.h (você tem que ir no diretório de cabeçalho para que ele funcione), mas ele poderia funcionar.

Answer 4

A Subversion "ramo" é apenas uma cópia de algo em seu repositório. Então, se você queria ramificar um arquivo que você tinha acabado de fazer:

svn copy myfile.c myfile_branch.c

Answer 5

Eu não acho que há muito ponto em ramificação um único arquivo? Não há nenhuma maneira de testá-lo com o código tronco?

Você poderia ter um patch em vez se você quiser desistir alterações e aplicá-las mais tarde.

Answer 6

Tem certeza de que realmente precisa deste recurso em seu VCS ?

Por que não usar o pré-processador C e #ifdef afastado o código que você não precisa? Ou qualquer outra ferramenta similar.

algo como:

// foo.h:
void Foo();

// foo_win32.c
#ifdef _WIN32
void Foo()
{
   ...
}
#endif

// foo_linux.c
#ifdef _GNUC
void Foo()
{
   ...
}
#endif

Às vezes, se ele não se encaixa bem, então não é a solução certa.

Answer 7

A filial no SVN é apenas uma cópia. Acredito que para fazê-lo da maneira que você está esperando, você teria que ter cada versão do arquivo em um diretório separado no repositório, e check-out em sua pasta de origem. OU SEJA tratar esse arquivo como um projeto separado.

Answer 8

A filial no Subversion é exatamente o que você está falando. Todos os arquivos são uma cópia exata do tronco, com exceção dos que você mudar. Esta é a metodologia "cópia barata" falado no livro SVN. A única ressalva é a necessidade de mesclar o tronco para o ramo de tempos em tempos para garantir que as alterações feitas não são refletidas no ramo. Claro que, se essas alterações não são desejados, sem trunk-> fusões filiais precisam acontecer.

Uma maneira fácil para permitir tronco muda a serem incorporadas automaticamente (que simula o paradigma caso claro) seria usar um script de gancho pre-commit para mesclar as alterações do tronco em antes da confirmação. (Na verdade, este é sempre uma boa estratégia para impedir a dispersão de código).