Friday 13 April 2018

Estratégia de ramificação do subversion


Estratégia de ramificação de subversão
Se você não "rebase" (Fig. A), você acabará por entregar todo o conjunto de alterações de cada vez e efetivamente mesclar as mudanças que já foram mescladas. Mas se você fizer o rebase (Fig. B) - que é fundir tronco para o ramo de desenvolvimento imidiately, então a subversão é capaz de saber a diferença.
svn switch svn: // servidor / tronco svn: // server / branches / trunk / dev1.
Faça isso e cometer isso.
svn commit - m "Adicionado um diretório b"
Volte para o tronco e puxe as mudanças do ramo do dev.
svn merge svn: // servidor / tronco svn: // server / branches / trunk / dev1.
svn commit - m "empurrou dev1 para o tronco"
Agora volte a continuar o trabalho no ramo de desenvolvimento.
Aqui vem a solução muito importante para o desenvolvimento do ramo ignorância para o que aconteceu. Você simplesmente combina o tronco no ramo de desenvolvimento antes de continuar trabalhando.
E agora é seguro continuar usando o ramo de desenvolvimento - como você faria em git, Mercurial ou ClearCase.

Melhores Práticas do Subversion.
Este é um conjunto rápido de diretrizes para fazer o melhor uso do Subversion no seu trabalho de desenvolvimento de software do dia-a-dia.
Use um layout sano do repositório.
Existem várias maneiras de estabelecer seu repositório. Como as filiais e as tags são diretórios comuns, você precisará contabilizá-los na estrutura do repositório.
O projeto Subversion recomenda oficialmente a idéia de uma "raiz do projeto", que representa um ponto de ancoragem para um projeto. Uma "raiz do projeto" contém exatamente três subdiretórios: / tronco, / ramos e / tags. Um repositório pode conter apenas uma raiz do projeto, ou pode conter uma série delas.
Cometer conjuntos de mudanças lógicas.
Quando você comete uma alteração no repositório, verifique se sua alteração reflete um único propósito: a correção de um bug específico, a adição de um novo recurso ou alguma tarefa específica. Seu commit criará um novo número de revisão que pode ser usado para sempre como um "nome" para a mudança. Você pode mencionar este número de revisão em bancos de dados de bugs, ou usá-lo como um argumento para svn merge se desejar desfazer a alteração ou acessá-la para outra ramificação.
Use o rastreador de problemas com sabedoria.
Tente criar tantos links bidirecionais entre os conjuntos de mudanças do Subversion e seu banco de dados de rastreamento de problemas quanto possível:
Se possível, consulte um ID de problema específico em cada mensagem de log de confirmação. Ao anexar informações a um problema (para descrever o progresso ou fechar o problema), nomeie o (s) número (s) de revisão responsável pela mudança.
Fase de fusão manualmente.
Ao cometer o resultado de uma mesclagem, certifique-se de escrever uma mensagem de log descritiva que explica o que foi mesclado, algo como:
Compreenda cópias de trabalho de revisão mista.
Os diretórios e arquivos da sua cópia de trabalho podem estar em diferentes revisões "trabalhando": esta é uma característica deliberada que permite misturar e combinar versões antigas de coisas com novas. Mas há alguns fatos que você deve estar ciente:
Após cada svn commit, sua cópia de trabalho tem revisões misturadas. As coisas que você acabou de cometer estão agora na revisão HEAD, e tudo o resto está em uma revisão mais antiga. Certos compromissos não são permitidos: você não pode comprometer a exclusão de um arquivo ou diretório que não tenha uma revisão de trabalho da HEAD. Você não pode comprometer uma alteração de propriedade em um diretório que não tenha uma revisão de trabalho da HEAD. A atualização do svn trará toda a sua cópia de trabalho para uma revisão de trabalho e é a solução típica dos problemas mencionados no ponto 2.
Seja paciente com arquivos grandes.
Um bom recurso do Subversion é que, por design, não há limite para o tamanho dos arquivos que ele pode manipular. Os arquivos são enviados "de forma corrente" em ambos os sentidos entre o cliente e o servidor do Subversion, usando uma quantidade pequena e constante de memória em cada lado da rede.
Claro, há uma série de questões práticas a serem consideradas. Embora não haja necessidade de se preocupar com arquivos no intervalo de tamanho de kilobytes (por exemplo, arquivos de código-fonte típicos), cometer arquivos maiores pode levar uma tremenda quantidade de tempo e espaço (por exemplo, arquivos que são dezenas ou centenas de megabytes de tamanho grande).
Para começar, lembre-se de que sua cópia de trabalho do Subversion armazena cópias prístinas de todos os arquivos controlados por versão na. svn / base de texto / área. Isso significa que sua cópia de trabalho ocupa pelo menos duas vezes mais espaço em disco que o conjunto de dados original. Além disso, o cliente do Subversion segue um algoritmo (atualmente não ajustável) para cometer arquivos:
Copia o arquivo para. svn / tmp / (pode demorar um pouco e usa temporariamente espaço em disco extra)) Executa uma diferença binária entre o arquivo tmp e a cópia original, ou entre o arquivo tmp e um arquivo vazio se recém adicionado. (pode levar muito tempo para calcular, mesmo que apenas uma pequena quantidade de dados possa ser enviada pela rede) Envia o diff para o servidor e, em seguida, move o arquivo tmp para. svn / base de texto /
Portanto, enquanto não houver limite teórico para o tamanho de seus arquivos, você precisará estar ciente de que arquivos muito grandes podem exigir um pouco de paciente aguardando enquanto seu cliente se afasta. Você pode ter a certeza, no entanto, que ao contrário do CVS, seus arquivos grandes não incapacitarão o servidor ou afetarão outros usuários.
Saiba quando criar filiais.
Esta é uma questão muito debatida, e isso realmente depende da cultura do seu projeto de software. Em vez de prescrever uma política universal, descreveremos três comuns aqui.
O sistema Never-Branch.
(Muitas vezes usado por projetos nascentes que ainda não possuem código executável.)
Os usuários comprometem seu trabalho no dia-a-dia no tronco. Ocasionalmente / tronco "quebra" (não compila ou falha em testes funcionais) quando um usuário começa a cometer uma série de mudanças complicadas.
Prós: política muito fácil de seguir. Novos desenvolvedores têm baixa barreira para a entrada. Ninguém precisa aprender a se ramificar ou se fundir.
Contras: o desenvolvimento caótico, o código pode ser instável a qualquer momento.
Uma nota lateral: esse tipo de desenvolvimento é um pouco menos arriscado no Subversion do que no CVS. Como os compromissos do Subversion são atômicos, não é possível um check-out ou atualização para receber um commit "parcial" enquanto outra pessoa está no processo de cometer.
O sistema Always-Branch.
(Muitas vezes usado por projetos que favorecem a gestão e supervisão pesada).
Cada usuário cria / trabalha em um ramo privado para cada tarefa de codificação. Quando a codificação está completa, alguém (codificador original, par ou gerente) analisa todas as alterações das filiais privadas e as combina com / tronco.
Prós: / tronco é garantido para ser extremamente estável em todos os momentos.
Contras: os codificadores são artificialmente isolados uns dos outros, possivelmente criando mais conflitos de mesclagem do que o necessário. Requer usuários para fazer muita fusão extra.
O sistema Branch-When-Needed.
(Esse é o sistema usado pelo projeto Subversion.) Usuários comprometem seu trabalho no dia-a-dia no tronco. Regra # 1: / tronco deve compilar e passar testes de regressão em todos os momentos. Os engajadores que violam esta regra são publicamente humilhados. Regra # 2: um único commit (changeset) não deve ser tão grande para desencorajar a revisão por pares. Regra # 3: se as regras # 1 e # 2 entrarem em conflito (ou seja, é impossível fazer uma série de pequenos compromissos sem interromper o tronco), então o usuário deve criar um ramo e cometer uma série de conjuntos de mudanças menores lá. Isso permite a revisão por pares sem interromper a estabilidade do tronco.
Prós: / tronco é garantido para ser estável em todos os momentos. O motivo de ramificação / fusão é um pouco raro.
Contras: Adiciona um pouco de carga ao trabalho diário dos usuários: eles devem compilar e testar antes de cada commit.

Estratégia de ramificação de subversão
Uma das características dos sistemas de controle de versão é a capacidade de isolar as mudanças em uma linha separada de desenvolvimento. Esta linha é conhecida como uma filial. Os ramos costumam ser usados ​​para experimentar novos recursos sem perturbar a linha principal de desenvolvimento com erros e erros de compilação. Assim que o novo recurso é estável o suficiente, o ramo de desenvolvimento é mesclado novamente no ramo principal (tronco).
Outra característica dos sistemas de controle de versão é a capacidade de marcar revisões particulares (por exemplo, uma versão de lançamento), para que você possa, a qualquer momento, recriar uma determinada construção ou ambiente. Este processo é conhecido como marcação.
O Subversion não possui comandos especiais para ramificação ou marcação, mas usa assim chamadas "cópias baratas". As cópias baratas são semelhantes aos links rígidos no Unix, o que significa que, em vez de fazer uma cópia completa no repositório, é criado um link interno, apontando para uma árvore / revisão específica. Como resultado, as agências e as tags são muito rápidas de criar, e não ocupam quase nenhum espaço extra no repositório.
Criando um ramo ou uma etiqueta.
Se você importou seu projeto com a estrutura de diretório recomendada, criar uma versão de ramo ou tag é muito simples:
Figura 4.52. A caixa de diálogo Branch / Tag.
Selecione a pasta na sua cópia de trabalho que deseja copiar para uma ramificação ou uma etiqueta e selecione o comando TortoiseSVN → Branch / Tag. .
O URL de destino padrão para o novo ramo será o URL de origem no qual a sua cópia de trabalho se baseia. Você precisará editar esse URL para o novo caminho para sua ramificação / etiqueta. Então, em vez de.
agora você pode usar algo como.
Se você não se lembrar da convenção de nomenclatura que você usou na última vez, clique no botão à direita para abrir o navegador do repositório para que você possa visualizar a estrutura de repositório existente.
pastas intermediárias.
Quando você especifica o URL de destino, todas as pastas até a última já devem existir ou você receberá uma mensagem de erro. No exemplo acima, o URL svn. collab / repos / ProjectName / tags / deve existir para criar a marca Release_1.10.
No entanto, se você deseja criar uma ramificação / etiqueta para um URL que tenha pastas intermediárias que ainda não existem, você pode verificar a opção Criar pastas intermediárias na parte inferior da caixa de diálogo. Se essa opção for ativada, todas as pastas intermediárias serão criadas automaticamente.
Observe que esta opção está desativada por padrão para evitar erros de digitação. Por exemplo, se você digitou o URL de destino como svn. collab / repos / ProjectName / Tags / Release_1.10 em vez de svn. collab / repos / ProjectName / tags / Release_1.10, você obteria um erro com a opção desativada, mas com a opção habilitada uma pasta, as tags seriam criadas automaticamente e você terminaria com uma pasta Tags e uma etiqueta de pasta.
Agora você deve selecionar a fonte da cópia. Aqui você tem três opções:
O novo ramo é copiado diretamente no repositório da revisão HEAD. Nenhum dado precisa ser transferido da sua cópia de trabalho, e o ramo é criado muito rapidamente.
Revisão específica no repositório.
O novo ramo é copiado diretamente no repositório, mas você pode escolher uma revisão mais antiga. Isso é útil se você esqueceu de fazer uma marca quando você lançou seu projeto na semana passada. Se você não consegue lembrar o número da revisão, clique no botão à direita para mostrar o registro de revisão e selecione o número de revisão a partir daí. Novamente, nenhum dado é transferido da sua cópia de trabalho, e o ramo é criado muito rapidamente.
O novo ramo é uma cópia idêntica da sua cópia de trabalho local. Se você atualizou alguns arquivos para uma revisão mais antiga em seu WC, ou se você fez alterações locais, é exatamente isso que entra na cópia. Naturalmente, esse tipo de tag complexo pode envolver a transferência de dados do seu WC de volta para o repositório, se ele não existe lá.
Se desejar que a sua cópia de trabalho seja alterada automaticamente para o ramo recém-criado, use a opção Trocar a cópia de trabalho para novas filiais / tags. Mas se você fizer isso, primeiro certifique-se de que sua cópia de trabalho não contém modificações. Se o fizer, essas alterações serão incorporadas no branch WC quando você alternar.
Se a sua cópia de trabalho tiver outros projetos incluídos com svn: propriedades externas, esses externos serão listados na parte inferior da caixa de diálogo de ramificação / tag. Para cada externo, o caminho de destino eo URL de origem são mostrados.
Se você quiser certificar-se de que a nova tag esteja sempre em um estado consistente, verifique todos os externos para ter suas revisões fixadas. Se você não verificar os externos e esses externos apontam para uma revisão HEAD que pode mudar no futuro, verificar a nova etiqueta verificará se a revisão HEAD do externo e sua tag podem não compilar mais. Portanto, é sempre uma boa idéia configurar os externos para uma revisão explícita ao criar uma tag.
Os externos são automaticamente fixados na revisão HEAD atual ou na revisão BASE da cópia de trabalho, dependendo da fonte do ramo / tag:
Tabela 4.1. Revisão fixa.
externos dentro de externos.
Se um projeto que está incluído como externo, ele próprio incluiu externos, então esses não serão marcados! Apenas os elementos externos que são crianças diretas podem ser marcados.
Pressione OK para confirmar a nova cópia no repositório. Não esqueça de fornecer uma mensagem de log. Observe que a cópia é criada dentro do repositório.
Observe que, a menos que você tenha optado por trocar sua cópia de trabalho para o ramo recém-criado, criar um ramo ou etiqueta não afetará sua cópia de trabalho. Mesmo que você crie o ramo do seu WC, essas alterações estão comprometidas com o novo ramo, não com o tronco, de modo que seu banheiro ainda pode ser marcado como modificado em relação ao tronco.
Outras formas de criar um ramo ou uma etiqueta.
Você também pode criar uma ramificação ou etiqueta sem ter uma cópia de trabalho. Para fazer isso, abra o navegador do repositório. Você pode arrastar pastas para um novo local. Você deve manter pressionada a tecla Ctrl enquanto arrasta para criar uma cópia; caso contrário, a pasta é movida, não copiada.
Você também pode arrastar uma pasta com o botão direito do mouse. Depois de soltar o botão do mouse, você pode escolher no menu de contexto se deseja que a pasta seja movida ou copiada. Claro que para criar um ramo ou uma etiqueta, você deve copiar a pasta, não movê-la.
Mais uma vez é a partir do diálogo de log. Você pode mostrar a caixa de diálogo de log para e. tronco, selecione uma revisão (seja a revisão HEAD no topo ou uma revisão anterior), clique com o botão direito do mouse e escolha criar ramificação / etiqueta de revisão. .
Para efetuar o checkout ou mudar.
. Isso é (não realmente) a questão. Enquanto um checkout descarrega tudo do ramo desejado no repositório para seu diretório de trabalho, TortoiseSVN → Switch. apenas transfere os dados alterados para a sua cópia de trabalho. Bom para a carga da rede, bom para a sua paciência. :-)
Para poder trabalhar com seu ramo ou tag recentemente gerado, você tem várias maneiras de lidar com isso. Você pode:
TortoiseSVN → Checkout para fazer um novo checkout em uma pasta vazia. Você pode verificar para qualquer local em seu disco local e você pode criar tantas cópias funcionais do seu repositório como quiser.
Mude sua cópia de trabalho atual para a cópia recém-criada no repositório. Selecione novamente a pasta de nível superior do seu projeto e use TortoiseSVN → Switch. no menu de contexto.
Na próxima caixa de diálogo, insira o URL do ramo que você acabou de criar. Selecione o botão de opção Revisão principal e clique em OK. Sua cópia de trabalho é trocada para o novo ramo / etiqueta.
Switch funciona como Update, na medida em que nunca descarta as mudanças locais. Todas as alterações que você fez na sua cópia de trabalho que ainda não foram cometidas serão mescladas quando você fizer o Switch. Se você não quiser que isso aconteça, você deve confirmar as alterações antes de mudar ou reverter sua cópia de trabalho para uma revisão já comprometida (normalmente HEAD).
Se você quiser trabalhar no tronco e no ramo, mas não quer a despesa de uma nova compra, você pode usar o Windows Explorer para fazer uma cópia da sua caixa de entrada no tronco em outra pasta, então TortoiseSVN → Alternar. Essa cópia para sua nova filial.
Figura 4.53. The Switch Dialog.
Embora o próprio Subversion não faça distinção entre tags e ramos, a maneira como eles são normalmente usados ​​difere um pouco.
As tags normalmente são usadas para criar um instantâneo estático do projeto em uma determinada etapa. Como tal, eles normalmente não são usados ​​para o desenvolvimento - é por isso que os ramos são para, o que é o motivo pelo qual recomendamos a estrutura do repositório / tronco / ramos / tags em primeiro lugar. Trabalhar em uma revisão de tag não é uma boa idéia, mas porque seus arquivos locais não são protegidos contra gravação, não há nada para impedir que você faça isso por engano. No entanto, se você tentar se comprometer com um caminho no repositório que contém / tags /, o TortoiseSVN irá avisá-lo.
Pode ser que você precise fazer mais mudanças em um lançamento que você já marcou. A maneira correta de lidar com isso é criar um novo ramo da tag primeiro e confirmar o ramo. Faça suas alterações neste ramo e, em seguida, crie uma nova tag desse novo ramo, p. Ex. Versão_1.0.1.
Se você modificar uma cópia de trabalho criada de uma filial e confirmar, todas as alterações irão para o novo ramo e não o tronco. Somente as modificações são armazenadas. O resto continua sendo uma cópia barata.

Estratégia de ramificação de subversão
Esta documentação foi escrita para descrever a série 1.7.x do Apacheв "ў Subversion®. Se você estiver executando uma versão diferente do Subversion, você é fortemente encorajado a visitar svnbook / e, em vez disso, consulte a versão desta documentação apropriada para sua versão do Subversion.
Padrões comuns de ramificação.
Há muitos usos diferentes para ramificação e svn mesclar, e esta seção descreve o mais comum.
O controle de versão é usado com mais freqüência para o desenvolvimento de software, então é uma rápida olhada em dois dos padrões de ramificação / fusão mais comuns usados ​​por equipes de programadores. Se você não estiver usando o Subversion para desenvolvimento de software, sinta-se à vontade para ignorar esta seção. Se você é um desenvolvedor de software que usa o controle de versão pela primeira vez, preste muita atenção, pois esses padrões são muitas vezes considerados melhores práticas por pessoas experientes. Esses processos não são específicos do Subversion; eles são aplicáveis ​​a qualquer sistema de controle de versão. Ainda assim, pode ajudar a vê-los descritos nos termos do Subversion.
Ramos de publicação.
A maioria dos programas tem um ciclo de vida típico: código, teste, lançamento, repetição. Existem dois problemas com esse processo. Primeiro, os desenvolvedores precisam continuar escrevendo novos recursos, enquanto as equipes de garantia de qualidade levam tempo para testar versões supostamente estáveis ​​do software. O novo trabalho não pode parar enquanto o software é testado. Em segundo lugar, o time quase sempre precisa suportar versões de software mais antigas e lançadas; Se um bug for descoberto no código mais recente, provavelmente também existe em versões lançadas, e os clientes vão querer obter essa correção de bugs sem ter que esperar por uma nova versão importante.
Aqui é onde o controle de versão pode ajudar. O procedimento típico parece assim:
Os desenvolvedores comprometem todo o trabalho novo no tronco. As mudanças do dia-a-dia estão comprometidas com / tronco: novos recursos, correções de bugs, e assim por diante.
O tronco é copiado para um ramo de "liberação". Quando a equipe pensa que o software está pronto para a liberação (por exemplo, uma versão 1.0), o tronco pode ser copiado para /branches/1.0.
As equipes continuam a trabalhar em paralelo. Uma equipe começa testes rigorosos do ramo de lançamento, enquanto outra equipe continua um novo trabalho (digamos, para a versão 2.0) no / tronco. Se os erros forem descobertos em qualquer local, as correções serão carregadas para frente e para trás, conforme necessário. Em algum momento, no entanto, mesmo esse processo pára. O ramo está "congelado" para o teste final antes de um lançamento.
O ramo é marcado e liberado. Quando o teste estiver completo, /branches/1.0 é copiado para /tags/1.0.0 como um instantâneo de referência. A etiqueta é empacotada e lançada para clientes.
O ramo é mantido ao longo do tempo. Enquanto o trabalho continuar no / tronco para a versão 2.0, as correções de bugs continuam sendo portadas de / tronco para /branches/1.0. Quando suficientes correções de bugs se acumulam, o gerenciamento pode decidir fazer uma versão 1.0.1: /branches/1.0 é copiado para /tags/1.0.1 e a etiqueta é empacotada e liberada.
Todo esse processo se repete à medida que o software amadurece: quando o trabalho 2.0 estiver completo, um novo ramo de liberação 2.0 é criado, testado, etiquetado e eventualmente lançado. Depois de alguns anos, o repositório termina com vários ramos de lançamento no modo "manutenção", e uma série de tags que representam as versões enviadas.
Ramos de recursos.
Um ramo de recursos é o tipo de ramo que tem sido o exemplo dominante neste capítulo (aquele em que você trabalhou enquanto a Sally continua trabalhando no tronco). É um ramo temporário criado para trabalhar em uma mudança complexa sem interferir com a estabilidade do tronco. Ao contrário dos ramos de lançamento (que podem precisar ser suportados para sempre), os ramos de recursos nascem, usados ​​por um tempo, fundidos de volta ao tronco e, em seguida, excluídos. Eles têm um período finito de utilidade.
Novamente, as políticas de projetos variam amplamente sobre exatamente quando é apropriado criar um ramo de recursos. Alguns projetos nunca usam ramos de recursos: os compromissos para / tronco são gratuitos para todos. A vantagem desse sistema é que é simples: "ninguém precisa aprender sobre ramificação ou fusão. A desvantagem é que o código do tronco é muitas vezes instável ou inutilizável. Outros projetos usam ramos para um extremo: nenhuma mudança já foi comprometida com o tronco diretamente. Mesmo as mudanças mais triviais são criadas em um ramo de curta duração, cuidadosamente revisadas e fundidas no tronco. Em seguida, o ramo é excluído. Este sistema garante um tronco excepcionalmente estável e utilizável em todos os momentos, mas ao custo de uma enorme carga de processo.
A maioria dos projetos aborda a abordagem do meio-da-estrada. Eles geralmente insistem em que / compilar tronco e passar testes de regressão em todos os momentos. Um ramo de recursos é necessário apenas quando uma mudança requer um grande número de compromissos desestabilizadores. Uma boa regra geral é fazer esta pergunta: se o desenvolvedor trabalhou por dias isoladamente e depois comprometeu a grande mudança de uma só vez (de modo que o tronco nunca foi desestabilizado), seria uma grande mudança para revisão? Se a resposta a essa pergunta é "sim", a mudança deve ser desenvolvida em um ramo de recursos. À medida que o desenvolvedor compromete mudanças incrementais no ramo, eles podem ser facilmente revisados ​​por colegas.
Finalmente, há a questão de como manter melhor um ramo de recursos em "sincronização" com o tronco à medida que o trabalho avança. Como mencionamos anteriormente, há um grande risco de trabalhar em uma filial por semanas ou meses; as mudanças do tronco podem continuar a derramar, até o ponto em que as duas linhas de desenvolvimento diferem tanto que pode se tornar um pesadelo tentando unir o ramo de volta ao tronco.
Esta situação é melhor evitada através da fusão regular das mudanças no tronco para o ramo. Elimine uma política: uma vez por semana, combine o valor da semana passada de alterações no tronco para o ramo.
Quando você finalmente estiver pronto para mesclar o ramo de características sincronizadas do tronco, comece fazendo uma fusão final das últimas mudanças no tronco para o ramo. Quando isso for feito, as versões mais recentes do ramo e do tronco são absolutamente idênticas, exceto para as mudanças de sua filial. Em seguida, você combina novamente com a opção --reintegrar:
Outra maneira de pensar sobre esse padrão é que sua sincronização semanal do tronco para o ramo é análoga à execução da atualização do svn em uma cópia de trabalho, enquanto a etapa de mesclagem final é análoga à execução do commit do svn a partir de uma cópia de trabalho. Afinal, o que mais é uma cópia de trabalho, mas um ramo privado muito superficial? É um ramo que é capaz de armazenar apenas uma mudança por vez.
Você está lendo o Controle de Versão com Subversion (para Subversion 1.7), de Ben Collins-Sussman, Brian W. Fitzpatrick e C. Michael Pilato.

Capítulo 4. Â Ramificação e Fusão.
‐њ ђ ђ ђ њ њ њ њ њ (É sobre o Tronco que um cavalheiro trabalha).
Ramificação e fusão são aspectos fundamentais do controle de versão, simples o suficiente para explicar conceitualmente, mas oferecendo apenas complexidade e nuance suficientes para merecer seu próprio capítulo neste livro. Aqui, apresentamos as idéias gerais por trás dessas operações, bem como a abordagem algo única da Subversion. Se você não se familiarizou com os conceitos básicos do Subversion (encontrados no Capítulo 1, Conceitos Fundamentais), recomendamos que o faça antes de ler este capítulo.
Você está lendo o Controle de Versão com Subversion (para Subversion 1.7), de Ben Collins-Sussman, Brian W. Fitzpatrick e C. Michael Pilato.

No comments:

Post a Comment