// 
//     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 Git 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 Git no NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Usando Suporte Git no NetBeans IDE

O NetBeans IDE fornece o suporte ao cliente de controle de versão GIT. O Suporte ao Git do IDE permite executar tarefas de controle de versão diretamente de seu projeto dentro do IDE. 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.

O Git é um sistema de controle de versão gratuito e de código-fonte aberto, projetado para tratar de tudo de um projeto pequeno a muito grande com rapidez e eficiência. Cada clone do Git é um repositório com todos os recursos com histórico completo e recursos completos de rastreamento da revisão, não dependente de acesso à rede ou de um servidor central. A ramificação e a mesclagem são rápidas e fáceis de serem feitas. O Git é usado para o controle de versão de arquivos, de forma similar a ferramentas como Mercurial, Subversion, CVS, Perforce etc.


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


== Requisitos

*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 7.4 ou 8.0 

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


== Inicializando um Repositório Git

Para inicializar um repositório Git de arquivos existentes que ainda não estão sob o controle de versão, é preciso completar as seguintes etapas:

1. Na janela Projetos, selecione um projeto sem controle de versão e clique com o botão direito do mouse no nome do projeto.
2. No menu de contexto, escolha  ``Controle de Versão``  >  ``Inicializar o Repositório Git``  (alternativamente, no menu principal escolha  ``Equipe``  >  ``Git``  >  ``Inicializar`` ).

[.feature]
--
image::images/initialize-git-repo-small.png[role="left", link="images/initialize-git-repo.png"]
--

[start=3]
1. Especifique o caminho para o repositório em que você armazenará seus arquivos com controle de versão na caixa de diálogo  ``Inicializar Repositório do Git``  ou clique em Procurar e navegue para o diretório necessário.
2. Clique em OK.

Uma subpasta  ``.git``  é criada na pasta especificada na etapa 3 acima (sua pasta do projeto NetBeans por default), que é seu repositório Git onde todos os dados dos snapshots de seu projeto são armazenados. O Git inicia o controle de versão de todos os arquivos na pasta que você especificou.
Você pode abrir  ``Janela``  >  ``Saída``  >  ``Saída``  para exibir o relatório do IDE sobre o andamento da criação do repositório sob seu diretório local de trabalho.

image::images/output-init.png[]

Todos os projetos são marcados como  ``Adicionados``  em sua Árvore de Trabalho. Para exibir o <<viewFileStatus,status>> de um arquivo, coloque o cursor sobre o nome do arquivo na janela Projetos. O status do arquivo na Árvore de Trabalho é exibido em verde na direita da barra, como mostrado na figura a seguir.

image::images/new-locally.png[]

Após ter inicializado o repositório Git, você <<add,adiciona>> arquivos ou <<committing,confirma-os>> diretamente no repositório Git.


== Clonando um Repositório Git

Para obter uma cópia de um repositório Git já existente, é preciso cloná-lo. Assegure que você conheça o URL do repositório Git antes de iniciar o assistente Clonar Repositório no IDE.

1. Escolha  ``Equipe``  >  ``Git``  >  ``Clonar``  no menu principal. O Assistente Clonar Repositório é Exibido.

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

[start=2]
1. Na página Repositório, especifique o caminho da localização do repositório Git, o nome de usuário e senha (você pode salvá-los para uso futura se necessário).
2. (Opcional) Clique em Configuração de Proxy para exibir a caixa de diálogo Opções e especificar as definições do servidor proxy. Clique em OK quando finalizar.
3. Clique em Próximo para ir para a próxima etapa do assistente.
4. Na página Ramificações Remotas, selecione as ramificações de repositório a serem extraídas (por download) para seu repositório local. Clique em Próximo.
5. Na página Diretório de Destino, especifique o seguinte:
* No campo Diretório-Pai, o caminho do diretório desejado para o repositório clonado em seu disco rígido (alternativamente, clique no botão Procurar e navegue para o diretório).
O campo Diretório-Pai é preenchido com o caminho para o diretório default  ``NetBeansProjects``  onde todos os projetos do NetBeans são armazenados.
* No campo Nome do Clone, o nome da pasta local onde o projeto original será clonado.
Por default, o Nome do Clone é preenchido com o nome real do repositório Git.
* No campo Efetuar Check-out da Ramificação, selecione a ramificação cujo check-out deverá se feito na árvore de trabalho.
* No campo Nome Remoto, o nome que representa o repositório original sendo clonado.
 ``origin``  é o apelido default do repositório sendo clonado. Esse é o valor recomendado.
* Deixe selecionada a caixa de seleção Varrer por projetos do NetBeans após clonar para ativar a pós-varredura assim que a clonagem finalizar. (O plug-in pesquisa projetos NetBeans nos recursos clonados e se oferece para abrir os projetos encontrados).
6. Clique em Finalizar.
Após o repositório do Git ser clonado, a pasta de metadados  ``.git``  é criada dentro da pasta selecionada no assistente.


=== Clonando um repositório a partir do GitHub por meio do Protocolo SSH

Para clonar um repositório por meio do GitHub usando o Protocolo SSH, faça o seguinte:

NOTE:  é preciso ter uma conta do GitHub e ser membro do projeto para poder clonar por meio de SSH.

1. Escolha  ``Equipe``  >  ``Git``  >  ``Clonar``  no menu principal. O Assistente Clonar Repositório é Exibido.
2. Na página Repositório Remoto do assistente Clonar Repositório, especifique o caminho para o repositório requerido no campo URL do Repositório, por exemplo,  ``git@github.com:tstupka/koliba.git`` .
3. Verifique se  ``git``  está especificado no campo de texto Nome de Usuário.
4. Selecione a opção Chave privada/pública.
5. (*Ignorar se usar o agente SSH ou Pageant para acesso SSH automatizado para o servidor Git.*) Conclua as seguintes etapas para acessar o servidor Git usando a chave SSH privada e uma frase-senha:

[start=1]
1. Especifique o caminho para o arquivo da chave, por exemplo  ``C:\Users\key`` .

NOTE:  o formato da chave privada openssh é necessário. Chaves geradas por PuTTYgen para Microsoft Windows deve ser convertido para o formato openssh antes de usá-los no IDE.

[start=2]
1. Insira a senha para o arquivo da chave, por exemplo  ``abcd`` .
2. (Opcional) Selecione a opção Salvar Senha, se necessário.

[start=6]
1. (*Aplica-se se usar o agente SSH ou Pageant para acesso de SSH automatizado para o servidor Git.*) Deixe os campos Arquivo de Chave Privada e Frase-Senha vazios para obter acesso autenticado do IDE para o servidor Git, por meior de agente SSH ou Pageant configurado.
2. (Opcional) Clique em Configuração de Proxy para exibir a caixa de diálogo Opções e especificar as definições do servidor proxy. Clique em OK quando finalizar.

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

[start=8]
1. Clique em Próximo.
2. Na página Ramificações Remotas, selecione as ramificações de repositório a serem extraídas (por download) para seu repositório local; por exemplo,  ``master`` .

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

[start=10]
. Clique em Próximo.
. Na página Diretório de Destino, especifique o seguinte:
* No campo Diretório-Pai, o caminho do diretório desejado para o repositório clonado em seu disco rígido (alternativamente, clique no botão Procurar e navegue para o diretório).
O campo Diretório-Pai é preenchido com o caminho para o diretório default  ``NetBeansProjects``  onde todos os projetos do NetBeans são armazenados.
* No campo Nome do Clone, o nome da pasta local onde o projeto original será clonado.
Por default, o Nome do Clone é preenchido com o nome real do repositório Git.
* No campo Efetuar Check-out da Ramificação, selecione a ramificação cujo check-out deverá se feito na árvore de trabalho.
* No campo Nome Remoto, o nome que representa o repositório original sendo clonado.
 ``origin``  é o apelido default do repositório sendo clonado. Esse é o valor recomendado.
* Deixe selecionada a caixa de seleção Varrer por projetos do NetBeans após clonar para ativar a pós-varredura assim que a clonagem finalizar. (O plug-in pesquisa projetos NetBeans nos recursos clonados e se oferece para abrir os projetos encontrados).

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

[start=12]
. Clique em Finalizar.
Após o repositório ter sido clonado, a mensagem Clonagem Concluída é exibida.

image::images/clone-completed.png[]

[start=13]
. Escolha a opção desejada.


== Adicionando Arquivos em um Repositório Git

 Para começar a rastrear um novo arquivo e também colocar em armazenamento temporário as alterações de um arquivo já rastreado no repositório do Git, é preciso adicioná-lo no repositório.

Quando você adiciona arquivos em um repositório do Git, o IDE compõe e salva snapshots primeiro de seu projeto no Índice. Após você executar a confirmação, o IDE salva estes snapshots no HEAD. O IDE permite escolher entre os dois fluxos de trabalho descritos na tabela a seguir.

|===
|Descrição do Fluxo de Trabalho |Adicione explicitamente arquivos novos ou modificados ao Índice e confirme somente os arquivos em armazenamento temporário no Índice para o HEAD |Ignore a adição de arquivos novos ou modificados para o Índice e confirme os arquivos requeridos diretamente para o HEAD 

|Etapas a Seguir no Fluxo de Trabalho  |

1. Na janela Projetos, clique com o botão direito do mouse no arquivo que deseja adicionar.
2. No menu de contexto, escolha  ``Git``  >  ``Adicionar`` .  Esse procedimento adiciona o conteúdo do arquivo ao Índice antes de confirmá-lo.
3. Na janela Projetos, clique com o botão direito do mouse no arquivo que deseja confirmar.
4. Na caixa de diálogo Confirmar, selecione as alterações entre o botão de alternância HEAD e índice (image::images/changes-head-index.png[]).  Isso exibe uma lista dos arquivos que já estão em armazenamento temporário.
5. Confirme os arquivos como descrito na seção <<committing,Confirmando Código-fonte em um Repositório>> abaixo.
 |

1. Na janela Projetos, clique com o botão direito do mouse no arquivo que deseja confirmar.
2. No menu de contexto, escolha  ``Git``  >  ``Confirmar`` .
3. Na caixa de diálogo Confirmar, marque Selecionar as Alterações entre o botão de alternância Índice e Árvore de Trabalho (image::images/changes-head-wt.png[]). 
Isso exibe uma lista dos arquivos que não estão em armazenamento temporário.
4. Confirme os arquivos como descrito na seção <<committing,Confirmando Código-fonte em um Repositório>> abaixo.
 
|===

NOTE:  o <<viewFileStatus,status>> do arquivo no HEAD é exibido em verde na esquerda da barra, como mostrado na figura a seguir.

image::images/new.png[]

A ação funciona de forma recursiva se chamada em pastas enquanto respeita a estrutura de conteúdo de pasta plana do NetBeans IDE.


== Editando Arquivos

Após ter um projeto com controle de versão Git 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 IU a sua disposição, o que ajuda a exibir e usar os comandos de controle de versão:

* <<viewChanges,Exibindo Alterações no Editor de Código-fonte>>
* <<viewFileStatus,Exibindo Informações de Status do Arquivo>>
* <<revert,Revertendo Alterações>>


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

Quando abre um arquivo com controle de versão no Editor de Código-fonte do IDE, você pode ver alterações em tempo real acontecendo em seu arquivo, conforme ele é modificado em relação à versão base do repositório do Git. 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.

image::images/left-margin.png[]

NOTE:  você pode clicar em um agrupamento colorido na margem para chamar todos os comandos de controle de versão. Por exemplo, a figura abaixo mostra os widgets disponíveis quando você clica em um ícone vermelho, indicando que linhas foram removidas de sua cópia local:

image::images/left-widgets.png[]

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.

image::images/right-margin.png[]

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

image::images/right-lines-number.png[]


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

Quando você está trabalhando nas janelas Projetos (Ctrl-1), Arquivos (Ctrl-2), Favoritos (Ctrl-3) ou nas views de Controle de Versão, o IDE fornece algumas 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/file-status.png[]

Os emblemas, a codificação de cor, as legendas de status do arquivo e, talvez o mais importante, o Visualizador de Diferenciação Git, ajudam você a exibir e gerenciar as informações de controle de versão no IDE.

* <<badges,Emblemas e Codificação de Cor>>
* <<fileStatus,Labels de Status do Arquivo>>
* <<versioningView,View Controle de Versão do Git>>


==== 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 modificados, adicionados ou deletados de sua árvore de trabalho. 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[]) |Marca projetos, pastas ou pacotes que contêm arquivos _conflitantes_. 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 

|*Sem cor específica (preto)* |image::images/black-text.png[] |Indica que o arquivo não tem alterações. 

|*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 tem conflito de mesclagem. 

|*Cinza* |image::images/gray-text.png[] |Indica que os arquivo é ignorado pelo Git e não será incluído nos comandos de controle de versão (ou seja, Atualizar e Confirmar). Os arquivos não podem ser ignorados se estiverem sob controle de versão. 
|===


==== Labels de Status do Arquivo

O IDE exibe dois valores de status para um arquivo:

* Um status que descreve as diferenças entre os arquivos na Árvore de Trabalho e no estado de Índice,
* Um status que descreve as diferenças entre os arquivos no estado de Índice e a confirmação atual no HEAD.

Os labels de status do arquivo fornecem uma indicação textual do status dos arquivos com controle de versão nas janelas do IDE:

|===
|Label do Status |Significado 

|*-* |Não modificado 

|*A* |Adicionado 

|*U* |Atualizado mas não mesclado 

|*M* |Modificado 

|*D* |Deletado 

|*I* |Ignorado 

|*R* |Renomeado 
|===

Por default, o IDE exibe as informações de status (novo, modificado, ignorado etc.) e de pastas em texto cinza à direita dos arquivos, à medida que eles são listados em janelas.

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

Os arquivos com a funcionalidade de conflito de mesclagem têm o status de não mesclado que é normalmente anotado em vermelho até que os arquivos não sejam resolvidos por sua ação explícita. O label de de status para arquivos não mesclados depende do cenário (por exemplo,  ``A/A``  - não mesclado, ambos adicionados).

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


==== View Controle de Versão do Git

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

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

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

Por default, a view Controle de Versão exibe uma lista de todos os arquivos modificados no pacote ou pasta selecionada na Árvore de Trabalho. Usando o botões da barra de ferramentas, é possível optar por exibir a lista de arquivos que têm diferenças entre o Índice e o HEAD, entre a Árvore de Trabalho e o Índice ou entre a Árvore de Trabalho e o HEAD. É 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 view Controle de Versão também inclui botões que permitem que você chame as tarefas Git mais comuns em todos os arquivos exibidos na lista. A tabela a seguir lista os comandos do Git disponíveis na barra de ferramentas da view Controle de Versão:

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

|image::images/changes-head-wt.png[] |*Alterações entre HEAD e Árvore de Trabalho* |Exibe uma lista de arquivos que já estão em armazenamento temporário ou somente modificados/criados e ainda não estão em armazenamento temporário. 

|image::images/changes-head-index.png[] |*Alterações entre HEAD e Índice* |Exibe uma lista de arquivos que estão em armazenamento temporário. 

|image::images/changes-index-wt.png[] |*Alterações entre o Índice e a Árvore de Trabalho* |Exibe os arquivos que têm diferenças entre seus estados de armazenamento temporário e na Árvore de Trabalho. 

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

|image::images/open-diff.png[] |*Abrir Diferença* |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[] |*Reverter Modificações* |Exibe a caixa de diálogo <<revertdialog,Reverter Modificações>>. 

|image::images/commit-button.png[] |*Confirmar Alterações* |Exibe a caixa de diálogo <<commitdialog,Confirmar>>. 
|===

Você pode acessar outros comandos do Git na view Controle de Versão, selecionando uma linha da tabela que corresponde a um arquivo modificado, e escolhendo um comando do menu com o botão direito do mouse:

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


=== Comparando Revisões de Arquivos

Comparar versões de arquivo é uma tarefa comum ao se trabalhar com projetos com controle de versão. O IDE permite comparar versões ao usar o comando Diferenciar:

NOTE:  vários modos de comparação - Diff To HEAD, Diff To Tracked e Diff To - estão disponíveis no IDE.

1. Selecione um arquivo ou pasta com versão (por exemplo, na janela  ``Projetos`` ,  ``Arquivos``  ou  ``Favoritos`` ).
2. Escolha  ``Team``  >  ``Diff``  >  ``Diff to HEAD``  no menu principal.
Um Visualizador gráfico de Diferenciação é aberto para os arquivos selecionados na janela principal do IDE. O Visualizador de Diferenciação exibe duas cópias nos painéis lado a lado. Quanto mais atual a cópia aparecer no lado direito, ou seja, você está comparando uma revisão no repositório contra sua árvore de trabalho, a árvore 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 <<color-coding-table,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).

NOTE:  outras revisões podem ser selecionadas para listas drop-down  ``Diff``  e  ``to``  abaixo da barra de ferramentas Visualizador de Diferenciação.

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

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

|image::images/changes-head-wt.png[] |*Alterações entre HEAD e Árvore de Trabalho* |Exibe uma lista de arquivos que já estão em armazenamento temporário ou somente modificados/criados e ainda não estão em armazenamento temporário. 

|image::images/changes-head-index.png[] |*Alterações entre HEAD e Índice* |Exibe uma lista de arquivos que estão em armazenamento temporário. 

|image::images/changes-index-wt.png[] |*Alterações entre o Índice e a Árvore de Trabalho* |Exibe os arquivos que têm diferenças entre seus estados de armazenamento temporário e na árvore de trabalho. 

|image::images/nextdiff.png[] |*Ir para a Próxima Diferença* |Exibe a próxima diferença no arquivo. 

|image::images/prevdiff.png[] |*Ir para a Diferença Anterior* |Exibe a diferença anterior no arquivo. 

|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/update.png[] |*Reverter Modificações* |Exibe a caixa de diálogo <<revertdialog,Reverter Modificações>>. 

|image::images/commit-button.png[] |*Confirmar Alterações* |Exibe a caixa de diálogo <<commitdialog,Confirmar>>. 
|===

Se você estiver executando uma diferença 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:

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

|image::images/insert.png[] |*Substituir* |Insere o texto realçado em sua cópia da Árvore de Trabalho. 

|image::images/arrow.png[] |*Mover Todos* |Reverte toda a cópia local da Árvore de Trabalho. 

|image::images/remove.png[] |*Remover* |Remove o texto realçado da cópia local da Área de Trabalho. 
|===


=== Revertendo Alterações

Para descartar as alterações locais feitas nos arquivos selecionados em sua árvore de trabalho e substituir os arquivos usando os que estejam no Índice ou HEAD:

1. Selecione um arquivo ou pasta com versão (por exemplo, na janela  ``Projetos`` ,  ``Arquivos``  ou  ``Favoritos`` ).
2. Escolha  ``Equipe``  >  ``Reverter Modificações``  no menu principal.
A caixa de diálogo  ``Reverter Modificações``  é exibida.

image::images/revert.png[]

[start=3]
. Especificar opções adicionais (por exemplo,  ``Reverter Somente as Alterações Não Confirmadas no Índice para o HEAD`` ) .
. Clique em Reverter.

O IDE substitui os arquivos selecionados pelos usando os especificados na <<three,etapa 3>> acima.


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

Para confirmar arquivos para o repositório Git:

1. Na janela  ``Projetos`` , clique com o botão direito do mouse no arquivo que deseja confirmar.
2. No menu de contexto, escolha  ``Git``  >  ``Confirmar`` .

A caixa de diálogo  ``Confirmar``  é exibida.

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

A caixa de diálogo  ``Confirmar``  contém os seguintes componentes:

* A área de texto  ``Mensagem de Confirmação``  descreve a alteração que está sendo confirmada
* As listas drop-down  ``Autor``  e  ``Confirmador``  permitem distinguir entre quem fez a alteração e quem confirmou fisicamente o arquivo, se necessário.
* A seção  ``Arquivos a serem Confirmados``  que lista:
* todos os arquivos modificados,
* todos os arquivos que foram deletados da Árvore de Trabalho (localmente),
* todos os arquivos novos (ou seja, arquivos que ainda não existem no repositório Git),
* todos os arquivos que você renomeou.

Dois botões de alternância que alternam o modo no qual a confirmação deve ser executada estão aqui disponíveis:

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

|image::images/changes-head-index.png[] |*Alterações entre HEAD e Índice* |Exibe uma lista de arquivos que estão em armazenamento temporário. 

|image::images/changes-head-wt.png[] |*Alterações entre HEAD e Árvore de Trabalho* |Exibe uma lista de arquivos que já estão em armazenamento temporário ou somente modificados/criados e ainda não estão em armazenamento temporário. 
|===

*Observação*: para especificar se os arquivos individuais devem ser excluídos da confirmação, cancele a seleção da caixa de seleção na primeira coluna denominada  ``Confirmar``  ou clique com o botão direito do mouse em uma linha de arquivo na coluna  ``Ação de Confirmação``  e escolha  ``Excluir da confirmação``  no menu pop-up. Para exibir aqui o Visualizador de Diferenciação, clique com o botão direito do mouse em uma linha de arquivo na coluna  ``Ação de Confirmação``  e escolha  ``Diferenciar``  no menu pop-up.

* A seção  ``Atualizar Problema``  acompanha os problemas relativos à alteração que está sendo confirmada.

*Observação*: é preciso instalar o plug-in JIRA ou Subversion para iniciar o rastreamento de problemas no IDE.

[start=3]
. Digite uma mensagem de confirmação na área de texto  ``Mensagem de Confirmação`` . Alternativamente, você pode executar um dos seguintes procedimentos:
* clique no ícone  ``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.
* Clique no ícone  ``Carregar Modelo``  (image::images/msg-template.png[]) localizado no canto superior direito para selecionar um modelo de mensagem.
. Depois de especificar ações para arquivos individuais, clique em  ``Confirmar`` . 
O IDE executa a confirmação e armazena seus snapshots no 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, os emblemas 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.


== Trabalhando com Ramificações

O suporte ao Git do IDE permite manter diferentes versões de toda uma base de códigos usando ramificações.

Quando você trabalha com ramificações no IDE, as seguintes ações são suportadas:

* <<branchCreate,Criando>>
* <<branchCheckOut,Fazendo check-out>>
* <<branchMerge,Mesclando>>
* <<branchDelete,Deletando>>


=== Criando uma Ramificação

Para criar uma ramificação local, caso deseje trabalhar em uma versão separada de seu sistema de arquivos para fins de estabilização ou experimento sem perturbar o tronco principal, complete as seguintes etapas:

1. Na janela Projetos ou Arquivos, escolha um projeto ou pasta do repositório no qual deseja criar a ramificação.
2. No menu principal, escolha Equipe >Ramificação/Tag > Criar Ramificação.

NOTE:  como alternativa, clique com o botão direito do mouse no projeto ou pasta com controle de versão e escolha Git > Ramificação/Tag > Criar Ramificação no menu pop-up.

A caixa de diálogo Criar Ramificação é exibida.

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

[start=3]
. No campo Nome da Ramificação, insira o nome da ramificação que está sendo criada.
. Especifique a revisão necessária ao inserir um ID de confirmação, ramificação existente, ou nome da tag no campo Revisão, ou pressione Selecionar para exibir uma lista das revisões mantidas no repositório.
. (Opcional) Na caixa de diálogo Selecionar Revisão, expanda Ramificações e escolha a ramificação necessária, especifique o ID de confirmar na lista adjacente e pressione Selecionar.
. Reveja as informações dos campos ID da Confirmação, Autor e Mensagem específicos da revisão sendo ramificada.
A ramificação é adicionada à pasta  ``Ramificações/Local``  do repositório Git.

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


=== Fazendo Check-out

Se precisar editar arquivos em uma ramificação existente, você pode fazer check-out da ramificação para copiar os arquivos para sua Árvore de Trabalho.

Para fazer check-out de uma versão, proceda da seguinte forma:

1. Escolha Equipe > Check-out > Fazer Check-out da Revisão no menu principal. 
A caixa de diálogo Fazer Check-out da Revisão Selecionada é exibida.

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

[start=2]
. Especifique a revisão necessária ao inserir um ID de confirmação, uma ramificação existente ou o nome da tag no campo Revisão, ou pressione Selecionar para exibir uma lista das revisões mantidas no repositório.
. Ignore se você não pressionou Selecionar na etapa anterior. Na caixa de diálogo Selecionar Revisão, expanda Ramificações e escolha a ramificação necessária, especifique o ID de confirmação na lista adjacente, se necessário, e pressione Selecionar.

NOTE:  se a revisão especificada se refere a uma confirmação válida que não esteja marcada com um nome de ramificação, seu HEAD se torna desanexado e você não mais está em nenhum ramificação.

[start=4]
. Reveja as informações dos campos ID de Confirmação, Autor e Mensagem específicos da revisão cujo check-out está sendo feito.
. Para criar uma nova ramificação da versão submetida a check-out, escolha a opção Efetuar Check-out como uma Nova Ramificação e insira o nome no campo Nome da Ramificação.
. Pressione Check-out para fazer check-out da revisão.
Os arquivos na Árvore de Trabalho e no Índice são atualizados para coincidirem com a versão na revisão especificada.

NOTE:  caso deseje alternar seus arquivos para uma ramificação existente (por exemplo, para uma confirmação que não esteja no topo de uma de suas ramificações), você pode usar o comando Equipe > Git > Ramificação > Alternar para a Ramificação, especificar a ramificação na caixa de diálogo Alternar para a Ramificação Selecionada, fazer check-out como uma nova ramificação (opcionalmente) e pressionar Alternar.

O IDE suporta check-out contextual de arquivos, pastas ou projetos no momento selecionados no IDE. Para fazer check-out de alguns arquivos (e não de uma ramificação), siga as seguintes etapas:

1. Escolha Equipe > Check-out > Fazer Check-out de Arquivos no menu principal. 
A caixa de diálogo Fazer Check-out dos Caminhos Selecionados é exibida.

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

[start=2]
. Escolha a opção Atualizar Índice com Entradas da Revisão Selecionada.
Caso selecionado, o Índice é atualizado com o estado da revisão selecionada antes do check-out do arquivo (ou seja, os arquivos selecionados na Árvore de Trabalho e Índice são atualizados).
. Especifique a revisão necessária ao inserir um ID de confirmação, uma ramificação existente ou o nome da tag no campo Revisão, ou pressione Selecionar para exibir uma lista das revisões mantidas no repositório.
. Ignore se você não pressionou Selecionar na etapa anterior. Na caixa de diálogo Selecionar Revisão, expanda Ramificações e escolha a ramificação necessária, especifique o número da revisão na lista adjacente se necessário e pressione Selecionar.
. Pressione Check-out para concluir o check-out.


=== Mesclando

Para portar as modificações de uma revisão do repositório para a Árvore de Trabalho, faça o seguinte:

1. Escolha Equipe > Ramificação/Tag > Mesclar Revisão no menu principal.
A caixa de diálogo Mesclar Revisão é exibida.

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

[start=2]
. Especifique a revisão necessária ao inserir um ID de confirmação, uma ramificação existente ou o nome da tag no campo Revisão, ou pressione Selecionar para exibir uma lista das revisões mantidas no repositório.
. Ignore se você não pressionou Selecionar na etapa anterior. Na caixa de diálogo Selecionar Revisão, expanda Ramificações e escolha a ramificação necessária, especifique o ID de confirmação na lista adjacente, se necessário, e pressione Selecionar.
. Pressione Mesclar.
Uma mesclagem de três vias entre a ramificação atual, o conteúdo de sua Árvore de Trabalho e a ramificação especificada é feita.

NOTE:  caso ocorra um conflito de mesclagem, o arquivo conflitante é marcado com um <<badges,emblema vermelho>> para indicar isso.

NOTE:  depois da mesclagem, ainda é necessário <<committing,confirmar>> as alterações para que sejam adicionadas ao HEAD.


=== Deletando uma Ramificação

Para deletar uma ramificação local desnecessária, conclua as seguintes etapas:

1. Escolha Equipe > Browser de Repositório no menu principal.
2. No Browser de Repositório Git, escolha a ramificação a ser deletada.

NOTE:  a ramificação precisa estar inativa, ou seja, não deve ter tido check-out na Árvore de Trabalho.

[start=3]
. Clique com o botão direito do mouse na ramificação selecionada e escolha Deletar Ramificação a partir do menu pop-up.
. Na caixa de diálogo Deletar Ramificação, pressione OK para confirmar a exclusão da ramificação.
A ramificação é removida do repositório local, assim como do Browser de Repositório Git.


== Trabalhando com Repositórios Remotos

Quando você trabalha com outros desenvolvedores precisa compartilhar seu trabalho, o que envolve extrair, inserir e obter dados em relação aos repositórios remotos hospedados na Internet ou em uma rede.

* <<fetch,Extraindo>>
* <<pull,Extraindo>>
* <<push,Expandindo>>


=== Extraindo

A extração recebe as alterações do repositório remoto original que você ainda não tem. Ela nunca altera quaisquer de suas ramificações locais. A extração recebe todas as ramificações dos repositórios remotos, que você pode mesclar com sua ramificação ou apenas inspecionar a qualquer momento.

Para extrair as atualizações, faça o seguinte:

1. Escolha Equipe > Remoto > Extrair.
O assistente Extrair do Repositório Remoto é exibido.

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

[start=2]
. Na página Repositório Remoto do assistente, selecione a opção Repositório configurado (para usar o caminho para o repositório anteriormente configurado) ou a opção Especificar Local do Repositório Git (para definir o caminho para um repositório remoto que ainda não foi acessado, seu nome, e login e senha, e qualquer configuração de proxy necessária) e clique em Próximo.
. Na página Ramificações Remotas do assistente, escolha as ramificações para obter as alterações e clique em Finalizar.
Uma cópia local da ramificação remota é criada. A ramificação selecionada é atualizada no diretório  ``Ramificações``  >  ``Remotas``  no Browser de Repositório Git.
Em seguida, as atualizações extraídas podem ser mescladas em uma ramificação local.


=== Extraindo

Durante a obtenção de algumas atualizações de um repositório Git remoto, as alterações são extraídas dele mesmo e mescladas no HEAD atual de seu repositório local.
Para executar a extração, conclua as seguintes etapas:

1. Escolha Equipe > Remoto > Extrair.
O assistente Extrair do Repositório Remoto é exibido.

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

[start=2]
. Na página Repositório Remoto do assistente, selecione a opção Repositório configurado (para usar o caminho do repositório anteriormente configurado) ou Especificar a Localização do Repositório Git: (para definir o caminho de um repositório remoto que ainda não foi acessado, seu nome, log-in e senha, se necessário) e clique em Próximo.
. Na página Ramificações Remotas do assistente, escolha as ramificações a serem extraídas com as alterações e clique em Finalizar.
Seu repositório local é sincronizado com o repositório de origem.


=== Expandindo

Para contribuir com alterações de seu repositório Git local para um repositório Git local, execute as seguintes etapas:

1. Escolha Equipe > Remoto > Expandir.
O assistente Expandir para o Repositório Remoto é exibido.

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

[start=2]
. Na página Repositório Remoto do assistente, selecione a opção Repositório configurado (para usar o caminho do repositório anteriormente configurado) ou Especificar a Localização do Repositório Git: (para definir o caminho de um repositório remoto que ainda não foi acessado, seu nome, log-in e senha, se necessário) e clique em Próximo.
. Na página Selecionar Ramificações Locais, escolha as ramificações de onde serão extraídas suas edições e clique em Próximo.
. Na página Atualizar Referências Locais, escolha as ramificações a serem atualizadas no diretório Remoto de seu repositório local e clique em Finalizar.
A ramificação do repositório remoto especificada é atualizada com o estado mais recente de sua ramificação local.


== Resumo

Este tutorial demonstrou como executar tarefas de controle de versão básicas no IDE ao guiá-lo pelo fluxo de trabalho padrão ao usar o suporte Git 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 Git incluídos no IDE.

link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20Git%20Support%20in%20NetBeans%20IDE[+Enviar Feedback neste Tutorial+]


== Consulte Também

Para ver o material relacionado, consulte os seguintes documentos:

* link:clearcase.html[+Usando o Suporte de ClearCase no NetBeans IDE+]
* link:subversion.html[+Usando Suporte ao Subversion no NetBeans IDE+]
* link:mercurial.html[+Usando Suporte ao Mercurial no NetBeans IDE+]
* link:cvs.html[+Usando Suporte ao CVS no NetBeans 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_