// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Usando Suporte ao CVS no NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Usando Suporte ao CVS no NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Usando Suporte ao CVS no NetBeans IDE

O suporte CVS para o NetBeans IDE foi projetado para ajudar a racionalizar o processo de desenvolvimento para grupos trabalhando de um repositório compartilhado, permitindo executar tarefas de controle de versão diretamente de seu sistema de projetos dentro do IDE. O software cliente CVS está incorporado no NetBeans IDE, e nenhuma configuração especial é necessária para começar a usar o CVS.

Este documento demonstra como executar tarefas básicas de controle de versão no IDE orientando você pelo fluxo de trabalho padrão ao usar o software de controle de versão.

CVS, ou Concurrent Versions System, é um sistema de controle de versão de códigos-fonte aberto que mantém o rastreamento de alterações e de todo o trabalho em um conjunto de arquivos. Normalmente é usado durante a implementação de um projeto de software, permitindo que múltiplos desenvolvedores colaborem. Para obter mais informações sobre o CVS, consulte a link:http://ximbiot.com/cvs/[+documentação oficial+].

NOTE:  após o NetBeans IDE 7.0.1, o suporte CVS está disponível após a instalação do plug-in CVS a partir da Central de Atualização do NetBeans IDE. Consulte a página link:http://wiki.netbeans.org/CVSSupport[+FAQs do CVS+] para obter detalhes.


image::images/netbeans-stamp-80-74-73.png[title="O conteúdo desta página se aplica ao NetBeans IDE 6.9 e mais recente"]


*Para concluir este tutorial, você precisa dos seguintes recursos e softwares.*

|===
|Software ou Recurso |Versão Necessária 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |versão 6.x e posterior 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 6 ou posterior 
|===


== Sincronizando Arquivos Locais com um Repositório

Ao usar um sistema de controle de versão, você trabalha sincronizando arquivos locais com um repositório, fazendo alterações na cópia local e, a seguir, confirmando-as no repositório. A lista a seguir descreve diversas maneiras de sincronizar um projeto no NetBeans IDE, dependendo de sua situação específica:

* <<opening,Abrindo um Projeto CVS no IDE>>
* <<checking,Fazendo Check-out de Arquivos de um Repositório>>
* <<importing,Importando Arquivos para um Repositório>>


=== Abrindo um Projeto CVS no IDE

Caso já possua um projeto com controle de versão do CVS com o qual tem trabalhado fora do IDE, você pode abri-lo no IDE e as funcionalidades de controle de versão se tornam automaticamente disponíveis. O IDE varre seus projetos abertos e se eles contêm diretórios `CVS` , o status do arquivo e o suporte de acordo com o contexto se ativam automaticamente para os projetos CVS com controle de versão.


=== Fazendo Check-out de Arquivos de um Repositório

Caso deseje estabelecer conexão com um repositório remoto a partir do IDE, fazer check-out dos arquivos e começar a trabalhar imediatamente com eles, faça o seguinte:

1. No NetBeans IDE, escolha Equipe > CVS > Check-out no menu principal. O assistente de Check-out é aberto. 

NOTE: os menus drop-down do IDE se adaptam ao contexto, ou seja, as opções disponíveis dependem do item selecionado. Portanto, se você já estiver trabalhando dentro de um projeto CVS, poderá escolher Controle de Versão > Check-out no menu principal.

[start=2]
. No primeiro painel do assistente, insira a localização do repositório, que pode ser definido por `CVSROOT`: 

 O IDE suporta diversos formatos de `CVSROOT`, dependendo se o repositório CVS for local ou remoto, e qual método está sendo usado para se conectar ao mesmo: 

|===
|Método |Descrição |Exemplo 

|*pserver* |Servidor remoto de senha |`:pserver:username@hostname:/repository_path` 

|*ext* |Acesso usando o Remote Shell (RSH) ou o Secure Shell (SSH) |`:ext:username@hostname:/repository_path` 

|*local* |Acesso para um repositório local |`:local:/repository_path` 
[float-right]# (requires an external CVS executable)# 

|*fork* |Acesso para um repositório local usando um protocolo remoto |`:fork:/repository_path` 
[float-right]# (requires an external CVS executable)# 
|===

Dependendo do método utilizado, pode ser necessário especificar outras informações, como uma senha e definições de proxy para a conexão com um repositório remoto (exemplo, para um `pserver`). Clique em Próximo. 

NOTE:  caso esteja tentando definir uma autenticação SSH com chave pública, consulte: link:http://wiki.netbeans.org/wiki/view/FaqHowToSetUpSSHAuth[+como definir a autenticação SSH com chave pública?+]. 

Para obter ajuda sobre como acessar repositórios locais, consulte: link:http://wiki.netbeans.org/wiki/view/FaqHowToAccessLocalCVS[+Como posso acessar repositórios locais?+]


1. No painel Módulos para Check-out do assistente, especifique o módulo cujo check-out deseja no campo Módulo. Caso não saiba o nome do módulo ao qual deseja fazer check-out, clique no botão Procurar para exibir o conteúdo do repositório. Na caixa de diálogo Procurar por Módulo CVS, selecione quaisquer dos módulos listados e clique em OK. Sua seleção é então adicionada no campo Módulo:

[.feature]
--
image::images/cvs-checkout-small.png[role="left", link="images/cvs-checkout.png"]
--


1. No campo de texto Ramificação, insira o nome da ramificação para check-out. Clique no botão Procurar para abrir a caixa de diálogo Procurar Tags e pesquise as ramificações e tags disponíveis. Caso você não especifique uma ramificação ou uma tag, o _trunk_ será submetido a check-out.
2. No campo Pasta Local, insira um local em seu computador onde deseja fazer check-out dos arquivos e, em seguida, clique em Finalizar para iniciar o check-out de CVS. O IDE faz check-out dos códigos-fonte especificado e a barra de status do IDE indica o andamento do download dos arquivos do repositório para seu diretório de trabalho local. Você também pode exibir os arquivos que estão sendo submetidos a check-out na janela de Saída (Ctrl-4). 

NOTE: caso os códigos-fonte com check-out contenham projetos NetBeans, uma caixa de diálogo será exibida solicitando a abertura deles no IDE. Se os códigos-fonte não contiverem um projeto, aparecerá uma caixa de diálogo solicitando que você crie um novo projeto a partir dos códigos-fonte e, a seguir, que o abra no IDE. Caso você crie um novo projeto para tal código-fonte, selecione a categoria de projeto apropriada (ou sejam no assistente Novo Projeto), e a seguir use a opção Com Códigos-fonte existente dentro daquela categoria.


=== Importando Arquivos para um Repositório

Alternativamente, você pode importar um projeto no qual estava trabalhando no IDE para um repositório remoto, e a seguir continuar a trabalhar nele no IDE após ele ter sido sincronizado com o repositório CVS.

NOTE: apesar de que de fato você está _exportando_ arquivos do sistema, o termo 'importar" é usado nos sistemas de controle de versão para indicar que os arquivos estão sendo _importados em _um repositório.

Para importar um projeto para um repositório:

1. Na janela Projetos (Ctrl-1), selecione um projeto sem controle de versão e escolha Controle de Versão > Importar para o repositório CVS ao clicar com o botão direito do mouse no nó. O assistente Importação de CVS é aberto.
2. No painel Raiz CVS do assistente Importar, indique a localização do repositório, como definido pelo <<protocolTypes,`CVSROOT`>>. Dependendo do método utilizado, pode ser necessário especificar outras informações, como uma senha e definições de proxy para a conexão com um repositório remoto (exemplo, para um `pserver`). Clique em Próximo.
3. No painel Pasta a Importar, especifique a pasta local que deseja colocar no repositório. O nome de seu projeto lhe é sugerido por default no campo de texto Pasta a Importar:

[.feature]
--
image::images/folder-to-import-small.png[role="left", link="images/folder-to-import.png"]
--


1. Na área de texto Importar Mensagem, insira uma descrição do projeto que está importando no repositório.
2. Especifique a localização no repositório onde deseja importar o projeto ao digitar o caminho no campo de texto Pasta do Repositório. Se preferir, clique no botão Procurar para navegar para uma localização específica no repositório. Clique em Finalizar para iniciar a importação. O IDE fará upload dos arquivos do projeto para o repositório e a janela de Saída será aberta e exibirá o andamento.

NOTE: por default o cliente CVS não trata importações de arquivos binários. A prática recomendada para importação códigos-fonte binários é criar um arquivo `cvswrappers` dentro do repositório. Consulte link:http://wiki.netbeans.org/FaqCVSHowToImportBinaries[+Como Importar Corretamente Arquivos Binários+]para obter mais detalhes.


== Editando Códigos-fonte

Após ter um projeto com controle de versão CVS aberto no IDE, é possível começar a fazer alterações nos códigos-fonte. Como acontece com qualquer projeto aberto no NetBeans IDE, é possível abrir os arquivos no Editor de Código-fonte clicando duas vezes em seus nós, conforme eles aparecem nas janelas do IDE (ou seja, janelas Projetos (Ctrl-1), Arquivos (Ctrl-2) e Favoritos (Ctrl-3)).

Quando você trabalha com códigos-fonte no IDE, há vários componentes de UI à sua disposição, o que ajuda a exibir e usar os comandos de controle de versão:

* <<viewingChanges,Exibindo Alterações no Editor de Código-fonte>>
* <<viewingFileStatus,Exibindo Informações de Status do Arquivo>>
* <<comparing,Comparando Revisões de Arquivos>>
* <<merging,Mesclando Revisões de Arquivos>>


=== Exibindo alterações no Editor de Código-fonte

Ao abrir um arquivo com controle de versão no Editor de Código-fonte do IDE, você pode ver as alterações em tempo real acontecendo no seu arquivo à medida que ele é modificado em relação à versão anterior cujo check-out do repositório foi efeito. Conforme você trabalha, o IDE usa a codificação de cor nas margens do Editor de Código-fonte para fornecer as seguintes informações:

|===
|*Azul* (       ) |Indica as linhas alteradas desde a revisão anterior. 

|*Verde* (       ) |Indica as linhas adicionadas desde a revisão anterior. 

|*Vermelho* (       ) |Indica as linhas removidas desde a revisão anterior. 
|===

A margem esquerda do Editor de Código-fonte mostra as alterações que ocorrem linha por linha. Quando você modifica uma determinada linha, as alterações são imediatamente mostradas na margem esquerda.

É possível clicar em um agrupamento colorido na margem para chamar os comandos de controle de versão. Por exemplo, a captura de tela inferior esquerda mostra os widgets disponíveis quando você clica em um ícone vermelho, indicando que linhas foram removidas de sua cópia local.

A margem direita do Editor de Código-fonte fornece uma visão geral que exibe as alterações feitas no arquivo como um todo, do início ao fim. A codificação de cor é gerada imediatamente quando você altera o arquivo.

Observe que você pode clicar em um ponto específico na margem para trazer imediatamente o seu cursor in-line para esse local no arquivo. Para exibir o número de linhas afetadas, passe o mouse sobre os ícones coloridos na margem direita:

|===
|[.feature]
--
image::images/left-ui-small.png[role="left", link="images/left-ui.png"]
--
 
*Margem esquerda* |image::images/right-ui.png[title="a codificação de cor do controle de versão é exibida na margem direita do editor"] 
*Margem direita* 
|===


=== Exibindo Informações de Status do Arquivo

Quando você está trabalhando nas janelas Projetos (Ctrl-1), Arquivos (Ctrl-2), Favoritos (Ctrl-3) ou de Controle de Versão, o IDE fornece várias funcionalidades visuais que ajudam a exibir as informações de status sobre seus arquivos. No exemplo a seguir, observe como o emblema (por exemplo, image::images/blue-badge.png[]), cor do nome do arquivo, e label de status adjacente, todos coincidem com outros para fornecer a você uma maneira efetiva e simples para controlar informações sobre seus arquivos de controle de versão:

image::images/badge-example.png[]

Os emblemas, a codificação de cor, os labels de status do arquivo e, talvez o mais importante, a janela de Controle de Versão ajudam a exibir e gerenciar de forma eficiente as informações de controle de versão no IDE.

* <<badges,Emblemas e Codificação de Cor>>
* <<fileStatus,Labels de Status do Arquivo>>
* <<versioning,A Janela de Controle de Versão>>


==== Emblemas e Codificação de Cor

Os emblemas são aplicados ao projeto, pasta e nós do pacote e informam o status dos arquivos contidos nesse nó:

A tabela a seguir exibe o esquema de cores usado nos emblemas:

|===
|Componente de IU |Descrição 

|*Emblema Azul* (image::images/blue-badge.png[]) |Indica a presença de arquivos que foram localmente modificados, adicionados ou deletados. No caso de pacotes, esse emblema se aplica somente ao pacote em si, e não aos seus subpacotes. Para projetos ou pastas, o emblema indica as alterações nesse item, ou em qualquer uma das subpastas contidas. 

|*Emblema Vermelho* (image::images/red-badge.png[]) |Marque os projetos, pastas ou pacotes que tenham arquivos _conflitantes_ (isto é, versões locais que apresentam conflito com as versões do repositório). No caso de pacotes, esse emblema se aplica somente ao pacote em si, e não aos seus subpacotes. Para projetos ou pastas, o emblema indica os conflitos nesse item ou em qualquer uma das subpastas contidas. 
|===


A codificação de cor é aplicada aos nomes de arquivo para indicar seu status atual em relação ao repositório:

|===
|Cor |Exemplo |Descrição 

|*Azul* |image::images/blue-text.png[] |Indica que o arquivo foi modificado localmente. 

|*Verde* |image::images/green-text.png[] |Indica que o arquivo foi adicionado localmente. 

|*Vermelho* |image::images/red-text.png[] |Indica que o arquivo contém conflitos entre sua cópia local de trabalho e a versão no repositório. 

|*Cinza* |image::images/gray-text.png[] |Indica que os arquivo é ignorado pelo CVS e não será incluído nos comandos de controle de versão (ou seja, Atualizar e Confirmar). Os arquivos só podem ser ignorados caso ainda não tenham tido controle de versão. 

|*Tachado* |image::images/strike-through-text.png[] |Indica que o arquivo foi excluído das operações de confirmação. O texto tachado aparece somente em locais específicos, como na janela de Controle de Versão ou na caixa de diálogo Confirmar, quando você decide excluir arquivos individuais de uma ação de confirmação. Tais arquivos ainda são afetados por outros comandos do CVS, tais como Atualizar. 
|===


==== Labels de Status do Arquivo

Os labels de status do arquivo fornecem uma indicação textual do status dos arquivos com controle de versão nas janelas do IDE. Por default, o IDE exibe as informações de status (novo, modificado, ignorado, etc.) em texto cinza à direita dos arquivos, como estão listados nas janelas. Entretanto, você pode modificar esse formato para que se adeque às suas necessidades. Por exemplo, se você quiser adicionar números de revisão aos labels de status, faça o seguinte:

1. Escolha Ferramentas > Opções (NetBeans > Preferências no Mac) no menu principal. A janela Opções é aberta.
2. Selecione o botão Diversos na parte superior da janela e clique na guia Controle de Versão abaixo dela. Garanta que CVS esteja selecionado abaixo de Sistemas de Controle de Versão no painel esquerdo:

[.feature]
--
image::images/cvs-options-small.png[role="left", link="images/cvs-options.png"]
--


1. Clique no botão Adicionar Variável à direita do campo de texto Formato do Label de Status. Na caixa de diálogo Adicionar Variável que é exibida, selecione a variável `{revision}` e clique em OK. A variável revision é adicionada ao campo de texto Formato do label de status.
2. Para reformatar os labels de status de forma que somente o seletor de status e de revisão seja exibido à direita dos arquivos, reorganize o conteúdo do campo de texto Formato do label de status para o seguinte:

[source,java]
----

[{status}; {revision}]
----
Clique em OK. Os labels de status agora listam o status e os números de revisão do arquivo (onde aplicável):

image::images/cvs-file-labels.png[]

Os labels de status do arquivo podem ser ativados e desativados, selecionando Exibir > Mostrar Labels de Controle de Versão no menu principal.


==== A Janela de Controle de Versão

A janela de Controle de Versão de CVS fornece uma lista em tempo real de todas as alterações feitas nos arquivos em uma pasta selecionada da sua cópia de trabalho local. Ela é aberta por default no painel inferior do IDE, listando os arquivos adicionados, deletados ou modificados.

Para abrir a janela de Controle de Versão, selecione um arquivo ou pasta com controle de versão (ou seja, na janela Projetos, Arquivos ou Favoritos) e escolha CVS > Mostrar Alterações com o menu de contexto, ou escolha Controle de Versão > Mostrar Alterações no menu principal. A janela seguinte aparece na parte inferior do IDE:

[.feature]
--
image::images/cvs-versioning-window-small.png[role="left", link="images/cvs-versioning-window.png"]
--

Por default, a janela Controle de Versão exibe uma lista de todos os arquivos modificados dentro do pacote ou pasta selecionado. Usando os botões na barra de ferramentas, é possível optar por exibir todas as alterações ou limitar a lista de arquivos exibidos a arquivos modificados local ou remotamente. É possível clicar nos cabeçalhos das colunas acima dos arquivos listados para classificá-los por nome, status ou local.

A barra de ferramentas da janela de Controle de Versão também inclui botões que permitem chamar as tarefas mais comuns do CVS em todos os arquivos exibidos na lista. A tabela a seguir lista os comandos do CVS disponíveis na barra de ferramentas da janela de Controle de Versão:

|===
|Ícone |Nome |Função 

|image::images/refresh.png[] |*Atualizar Status* |Atualiza o status dos arquivos e pastas selecionados. Os arquivos exibidos na janela de Controle de Versão podem ser atualizados para refletir quaisquer alterações feitas externamente. 

|image::images/diff.png[] |*Diferenciar Tudo* |Abre o Visualizador de Diferenciação que fornece uma comparação lado a lado de suas cópias locais e das versões mantidas no repositório. 

|image::images/update.png[] |*Atualizar Todos* |Atualiza todos os arquivos selecionados no repositório. 

|image::images/commit.png[] |*Confirmar Tudo* |Permite que você confirme todas as atualizações locais no repositório. 
|===

Você pode acessar outros comandos do CVS na janela de controle de versão, selecionando uma linha da tabela que corresponde a um arquivo modificado, e escolhendo um comando do menu de contexto:

image::images/cvs-right-click.png[]

Por exemplo, execute as ações a seguir em um arquivo:

|===
|* *Mostrar Anotações*: 

Exibe o autor e as informações do número da revisão na margem esquerda dos arquivos abertos no Editor de Código-fonte.
 |image::images/annotations.png[] 

|* *Pesquisar Histórico*: 

Permite que você procure e compare várias revisões do arquivo selecionado no Exibidor de Histórico do IDE. No Visualizador de Históricos também é possível executar uma <<comparing,comparação>> ou restaurar sua cópia local para a revisão selecionada.
 |[.feature]
--
image::images/history-viewer-small.png[role="left", link="images/history-viewer.png"]
--
 

|* *Excluir da Confirmação*: 

Permite que você marque o arquivo para ser excluído ao executar uma confirmação.
 |[.feature]
--
image::images/exclude-from-commit-small.png[role="left", link="images/exclude-from-commit.png"]
--
 

|* *Reverter Modificações*: 

Abre a caixa de diálogo Confirmar Substituição que permite reverter quaisquer ações que tenham sido confirmadas para arquivos em sua cópia local de trabalho.
 |[.feature]
--
image::images/cvs-confirm-overwrite-small.png[role="left", link="images/cvs-confirm-overwrite.png"]
--
 
|===


=== Comparando Revisões de Arquivos

Comparar revisões de arquivos é uma tarefa comum ao se trabalhar com projetos com controle de versão. O IDE permite que você compare versões, usando o comando Diferenciar, que está disponível no menu de contexto de um item selecionado (CVS > Diferenciar), assim como na janela de controle de versão. Na janela de Controle de Versão, você pode executar diferenciais clicando duas vezes em um arquivo listado, caso contrário, você pode clicar no ícone Diferenciar Todos (image::images/diff.png[]) localizado na barra de ferramentas no topo.

Quando você faz uma diferenciação, um Visualizador de Diferenciação gráfico é aberto para os arquivos e revisões selecionados na janela principal do IDE. O Visualizador de Diferenciação exibe duas cópias nos painéis lado a lado. A cópia mais atual aparece no lado direito, portanto, se você estiver comparando uma revisão do repositório com sua cópia de trabalho, a cópia de trabalho é exibida no painel direito:

[.feature]
--
image::images/diff-viewer-small.png[role="left", link="images/diff-viewer.png"]
--

O visualizador de Diferenciação usa a mesma <<viewingChanges,codificação de cor>> usada para exibir alterações de controle de versão. Na captura de tela exibida acima, o bloco verde indica o conteúdo que foi adicionado à revisão mais atual. O bloco vermelho indica que o conteúdo da revisão anterior foi removido da última revisão. Azul indica que as alterações ocorreram na(s) linha(s) realçada(s).

Além disso, ao executar uma diferenciação em um grupo de arquivos, como em um projeto, pacote ou pasta, ou quando clicar em diferenciar todos (image::images/diff.png[]), você pode alternar entre diferenciais clicando em arquivos listados na região superior do Visualizador de Diferenciação.

A ferramenta Visualizador de Diferenciação fornece a seguinte funcionalidade:

* <<makeChanges,Fazer Alterações em sua Cópia de Trabalho Local>>
* <<navigateDifferences,Navegar entre as Diferenças>>
* <<changeViewCriteria,Alterar os Critérios de Exibição>>


==== Fazer Alterações em sua Cópia de Trabalho Local

Se você estiver executando uma diferenciação em sua cópia de trabalho local, o IDE permite fazer alterações diretamente no Visualizador de Diferenciação. Para fazer isso, você pode colocar o cursor no painel direito do Visualizador de Diferenciação e modificar seu arquivo adequadamente, caso contrário, use os ícones in-line exibidos ao lado de cada alteração realçada:

|===
|*Substituir* (image::images/insert.png[]): |Insere o texto realçado da revisão anterior na revisão atual 

|*Mover Todos* (image::images/arrow.png[]): |Reverte a revisão atual do arquivo para o estado da revisão anterior selecionada 

|*Remover* (image::images/remove.png[]): |Remove o texto realçado da revisão atual para que ela espelhe a revisão anterior 
|===


==== Navegar nas Diferenças entre Arquivos Comparados

Se a sua comparação contém várias diferenças, você pode navegar nelas, usando os ícones de seta exibidos na barra de ferramentas. Os ícones de seta permitem que você exiba as diferenças conforme elas aparecem na parte do início ao fim:

|===
|*Anterior* (image::images/diff-prev.png[]): |Vai para a diferença anterior exibida na diferenciação 

|*Próximo* (image::images/diff-next.png[]): |Vai para a próxima diferença exibida na diferenciação 
|===


==== Alterar os Critérios de Exibição

Você pode optar por exibir os arquivos que contêm alterações na cópia de trabalho local, no repositório ou em ambos simultaneamente:

|===
|*Local* ( image::images/locally-mod.png[] ): |Exibe apenas os arquivos modificados localmente 

|*Remoto* ( image::images/remotely-mod.png[] ): |Exibe apenas os arquivos modificados remotamente 

|*Ambos* ( image::images/both-mod.png[] ): |Exibe os arquivos modificados local e remotamente 
|===


=== Mesclando Revisões de Arquivos

O NetBeans IDE permite mesclar alterações feitas em diferentes ramificações do repositório com sua cópia local de trabalho. Usando a caixa de diálogo Mesclar CVS, somente é necessário especificar o critério que indica quais códigos-fonte no repositório você deseja mesclar com sua cópia local de trabalho.

O caso de uso simples a seguir demonstra como você pode aplicar a caixa de diálogo Mesclar para mesclar toda uma ramificação no início do tronco:


|===
|*Caso de uso:* |Há uma solicitação para iniciar o desenvolvimento de uma nova funcionalidade para o projeto, portanto, uma nova ramificação é criada a partir do estado atual do tronco do projeto. Após todo o trabalho necessário ter sido feito e o código está bem estável na ramificação, você integra a nova funcionalidade com o tronco. 
|===

1. Crie a nova ramificação para o projeto ao clicar com o botão direito do mouse no nó do projeto e escolha CVS > Ramificação. Na caixa de diálogo Ramificação, insira `new_feature` como o nome da ramificação, e certifique-se de que a opção Ramificar Posteriormente esteja selecionada:

[.feature]
--
image::images/cvs-branch-dialog-small.png[role="left", link="images/cvs-branch-dialog.png"]
--

Clique no botão Ramificar. Uma nova ramificação é criada no repositório, e o IDE alterna sua localização de repositório de destino para a nova ramificação. Na janela Projetos, o nome da nova ramificação é exibido em texto cinza junto aos arquivos com controle de versão, indicando que você agora está trabalhando a partir da ramificação.

NOTE: certifique-se de que os <<fileStatus,labels de status de arquivo>> estejam ativados (selecione Exibir > Mostrar Labels de Controle de Versão a partir do menu principal).


1. Editar arquivos, adicionar arquivos, deletar arquivos. Confirmar todas as alterações.
2. Quando a nova funcionalidade estiver pronta, alterne de volta para o tronco. Você precisa estar trabalhando na ramificação de destino (ou seja, o tronco neste caso) ao desejar executar uma mesclagem entre as duas ramificações. Clique com o botão direito do mouse no nó do projeto e escolha CVS > Alternar para a Ramificação. Na caixa de diálogo que é exibida, selecione Alternar para o Tronco e clique em Alternar. 

O IDE alterna a localização do repositório de destino para o tronco. Na janela Projetos, observe que os labels de status do arquivo são automaticamente atualizados para refletir seu novo local de trabalho.


1. Para executar a mesclagem, clique com o botão direito do mouse no nó do projeto e escolha CVS > Mesclar Alterações da Ramificação. Na caixa de diálogo que é exibida, observe que o campo Mesclar Alterações para Ramificação de Trabalho contém `Tronco`, indicando sua localização de trabalho atual. 

Na caixa de diálogo, especifique os seguintes critérios:
* Deixe a opção Iniciando de, definida como Ponto da Ramificação/Raiz da Ramificação, porque você deseja mesclar todas as alterações desde a criação da ramificação.
* Para a opção Até, selecione Início da Ramificação, e digite o nome da ramificação que deseja mesclar no tronco. Você também pode clicar em Procurar para pesquisar entre as ramificações existentes no repositório.
* Caso deseje identificar as versões após a mescla, selecione Identificar Tronco após a mesclagem, e insira um nome de tag de sua escolha.

[.feature]
--
image::images/cvs-merge-branches-small.png[role="left", link="images/cvs-merge-branches.png"]
--

Clique em Mesclar. O IDE incorpora a ramificação com o tronco. Caso surjam conflitos no processo, o status do projeto é atualizado para <<resolving,Conflito de Mesclagem>> para indicar isso.

NOTE: depois de mesclar as alterações do arquivo de uma ramificação com o diretório de trabalho local, ainda é necessário confirmar as alterações usando o comando Confirmar, para adicionar as alterações ao repositório.


== Confirmando Códigos-fonte em um Repositório

Depois de fazer alterações no código-fonte, você as confirma no repositório. Normalmente, é recomendado atualizar todas as cópias que você tenha no repositório antes de executar a confirmação para garantir que não surjam conflitos. No entanto, podem ocorrer conflitos, que devem ser considerados como um evento natural quando vários desenvolvedores trabalham simultaneamente em um projeto. O IDE fornece um suporte flexível que permite executar todas essas funções. Ele também fornece um Resolvedor de Conflitos que permite tratar com segurança quaisquer conflitos à medida que ocorrerem.

* <<updating,Atualizando Cópias Locais>>
* <<resolving,Resolvendo Conflitos>>
* <<performing,Executando a Confirmação>>


=== Atualizando Cópias Locais

Você pode executar alterações ao escolher CVS > Atualizar ao clicar com o botão direito do mouse em qualquer item com controle de versão nas janela Projetos, Arquivo ou Favoritos. Ao trabalhar diretamente na janela Controle de Versão, basta clicar com o botão direito do mouse em um arquivo listado e escolher Atualizar.

Para executar uma atualização em códigos-fonte que você modificou, você pode clicar no ícone Atualizar Tudo (image::images/update.png[]), que exibe as barras de ferramentas localizada na parte superior do <<versioning,Controle de Versão>> e no Visualizador de Diferenciação<<comparing,. Quaisquer alterações que possam ter ocorrido no repositório são exibidas na janela de Saída de Controle de Versão.>>

<<comparing, >>


=== Resolvendo Conflitos

Quando você executa uma atualização ou confirmação, o suporte CVS do IDE compara seus arquivos com os códigos-fonte no repositório para assegurar que outras alterações já não ocorreram nos mesmos locais. Quando seu check-out (ou atualização) anterior não mais coincide com o _HEAD_ do repositório (ou seja, a versão mais atual), _e_ as alterações aplicadas na sua cópia local de trabalho coincidem com áreas no HEAD que também mudaram, sua atualização ou confirmação resulta em um _conflito_.

Conforme indicado em <<badges,Emblemas e Codificação de Cor>>, os conflitos são exibidos no IDE com texto vermelho e são acompanhado por um emblema vermelho (image::images/red-badge.png[]) quando visualizada nas janelas Projetos, Arquivos ou Favoritos. Quando você trabalha na janela Controle de Versão, os conflitos também são indicados por um status de arquivo:

image::images/cvs-conflict-versioning-win.png[]

Quaisquer conflitos que surjam precisam ser resolvidos antes de confirmar os arquivos no repositório. Você pode resolver os conflitos no IDE usando o Resolvedor de Conflitos de Mesclagem O Resolvedor de Conflitos de Mesclagem fornece uma interface intuitiva que permite endereçar conflitos individuais sequencialmente enquanto exibe a saída mesclada ao efetuar alterações. Você pode acessar o Resolvedor de Conflitos de Mesclagem em um arquivo que esteja em conflito ao clicar com o botão direito do mouse naquele arquivo e ao escolher CVS > Resolver Conflitos.

O Resolvedor de Conflitos de Mesclagem exibe as duas revisões em conflito lado a lado no painel superior, com as áreas conflitantes realçadas. O painel inferior mostra o arquivo da forma como aparece durante mesclagens de conflitos entre as duas revisões:

[.feature]
--
image::images/conflict-resolver-small.png[role="left", link="images/conflict-resolver.png"]
--

Você resolver um conflito ao aceitar uma das duas revisões exibidas no painel superior. Clique no botão Aceitar da revisão que deseja aceitar. O IDE mescla a revisão aceita com o arquivo de origem e você pode imediatamente ver os resultados da mesclagem no painel inferior do Resolvedor de Conflitos de Mesclagem. Depois de resolver todos os conflitos, clique em OK para sair do Resolvedor de Conflitos de Mesclagem e salvar o arquivo modificado. O emblema de conflito é removido e agora é possível confirmar o arquivo modificado no repositório.


=== Executando a Confirmação

Após editar os arquivos de origem, executar uma atualização e resolver quaisquer conflitos, você confirma os arquivos de sua cópia local de trabalho no repositório. O IDE permite que você chame o comando de confirmação das seguintes formas:

* Nas janelas Projetos, Arquivos ou Favoritos, clique com o botão direito do mouse nos itens novos ou modificados e escolha CVS > Confirmar.
* Na janela Visualizador de Controle de Versão ou de Diferenciação, clique no botão Confirmar Tudo (image::images/commit.png[]) localizado na barra de ferramentas.

A caixa de diálogo Confirmar é aberta, exibindo os arquivos que estão prestes a serem confirmados no repositório:

[.feature]
--
image::images/cvs-commit-dialog-small.png[role="left", link="images/cvs-commit-dialog.png"]
--

A caixa de diálogo Confirmar lista:

* todos os arquivos modificados localmente
* todos os arquivos deletados localmente
* todos os arquivos novos (ou seja, arquivos que ainda não existem no repositório)
* todos os arquivos que você renomeou. O CVS trata os arquivos renomeados deletando o arquivo original e criando uma cópia com o novo nome.

Na caixa de diálogo Confirmar, é possível especificar se arquivos individuais devem ser excluídos da confirmação. Para fazer isso, clique na coluna Ação de Confirmação de um arquivo selecionado e escolha Excluir da confirmação na lista drop-down.

Quando novos arquivos binários são incluídos, tal como arquivos de imagens, eles são automaticamente detectados como arquivos binários. Você pode especificar o tipo MIME de um arquivo ao escolher Adicionar como binário ou Adicionar como Texto na lista drop-down dentro da coluna de Ação de Confirmação.

Para executar a confirmação:

1. Digite uma mensagem de confirmação na área de texto Mensagem de Confirmação. Se preferir, clique no ícone de Mensagens Recentes (image::images/recent-msgs.png[]) localizado no canto superior direito para ver e selecionar de uma lista de mensagens que você usou anteriormente existente.
2. Depois de especificar ações para arquivos individuais, clique em Confirmar. O IDE executa a confirmação e envia suas alterações locais para o repositório. A barra de status do IDE, localizada na parte inferior direita da interface, é exibida conforme a ação de confirmação ocorre. Com uma confirmação bem-sucedida, as identificações de controle de versão desaparecem nas janelas Projetos, Arquivos e Favoritos e a codificação de cor dos arquivos confirmados volta a ser preta.
link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20CVS%20Support%20in%20NetBeans%20IDE[+Enviar Feedback neste Tutorial+]


== Consulte Também

Isso conclui o Tour Guiado do CVS para o NetBeans IDE. Este documento demonstra como executar tarefas de controle de versão básicas no IDE ao guiá-lo por meio do fluxo de trabalho padrão ao usar o suporte CVS do IDE. Ele mostrou como configurar um projeto com controle de versão e como executar tarefas básicas em arquivos com controle de versão e apresentando-o algumas das novas funcionalidades do CVS incluídos no IDE.

Para documentos relacionados, consulte os seguintes recursos:

* link:http://wiki.netbeans.org/NetBeansUserFAQ#CVS[+FAQ do Suporte CVS para o NetBeans IDE+]. Um documento contendo perguntas frequentes descrevendo a configuração e o uso do CVS no NetBeans IDE.
* link:git.html[+Usando Suporte Git no NetBeans IDE+]. Um guia introdutório para o uso do cliente de controle de versão Git no NetBeans IDE.
* link:mercurial.html[+Usando Suporte ao Mercurial no NetBeans IDE+]. Um guia introdutório para o uso do cliente de controle de versão do Mercurial no NetBeans IDE.
* link:subversion.html[+Usando Suporte ao Subversion no NetBeans IDE+]. Um guia introdutório para o uso do controle de versão do Subversion no NetBeans IDE 6.x.
* link:clearcase.html[+Usando o Suporte de ClearCase no NetBeans IDE+]. Uma introdução ao uso das funcionalidades de controle de versão do ClearCase no IDE.
* link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG234[+Aplicando Controle de Versão às Aplicações com Controle de Versão+] em _Desenvolvendo Aplicações com o NetBeans IDE_.