Versões comparadas
Chave
- Esta linha foi adicionada.
- Esta linha foi removida.
- A formatação mudou.
O Git (site oficial) é um sistema de controle de versão
distribuído(em inglês: version control system - VCS) distribuído, rápido e escalável, usado principalmente para o controle de versão de software
, mas que também pode ser usado para registrar o histórico de qualquer outro tipo de arquivo. Criado em 2005 por Linus Torvalds
parapara o desenvolvimento
do kerneldo kernel Linux
e, logo a plataforma foi adotada por diversos outros projetos.
O Git (site oficial) é um softwareÉ um software livre, distribuído sob os termos da versão 2 da GNU General Public License.
Importando projeto de um repositório
Antes de começar é preciso ter certeza de que se tem um ambiente minimamente preparado para reproduzir o exemplo. Abaixo estão os requisitos principais.
Requisitos:
- Repositório criado em algum sistema de versionamento na nuvem (Git ou SVN).
Informações | ||
---|---|---|
| ||
Projetos criados fora da plataforma Cronapp e importados podem ter alguns componentes Low code não funcionais. Porém, será possível continuar o desenvolvendo em modo High code. |
A IDE Cronapp permite a importação de projetos a partir de um repositório SVN ou GIT. Para tanto, cria-se um novo projeto e selecione a opção O projeto está sob controle de versão? (Figura 1), dando um nome para seu projeto.
Image Removed
Figura 1 - Selecionando projeto com controle de versão
Configurando o controle de versão
Após clicar em finalizar o projeto, uma janela para inserir os dados do projeto versionado será será aberta.
Image Removed
Figura 2 - Configuração do controle de versão
- Protocolo: escolha do tipo de controle de versão, GIT ou SVN.
- URL do Repositório: campo onde deve ser colocado o link do repositório.
- Anônimo: habilitando esse campo, não será necessário informar usuário e senha.
- Usuário: o nome do seu usuário no repositório do projeto.
- Senha: a senha do seu usuário no repositório do projeto.
- Nome do Autor: nome que será exibido no commit.
- E-mail do Autor: e-mail que será exibido no commit.
- Branch: define qual branch será importada.
- Atualização: botão que realiza a consulta e exibe a lista com todas as branchs do projeto no campo de seleção.
Informações | ||
---|---|---|
| ||
Endereços de projetos GIT sempre terminam com a extensão ".git" e deve ser informado no campo URL do Repositório. |
Depois de todos os campos necessários preenchidos, clique em Importar e aguarde até que uma mensagem apareça informando que o projeto foi importado com sucesso.
Ao criar um novo projeto no Cronapp, você poderá exportá-lo para um repositório GIT. Para isso, clique com o botão direito do mouse sobre o nome do projeto e selecione a opção Exportar (Figura 3), em seguida escolher a opção Exportar para repositório git (Figura 4) e clique em Avançar.
Image Removed
Figura 3 - Exportando projeto para um repositório Git
Image Removed
Figura 4 - Escolhendo a opção Exportar para repositório git
Na tela seguinte, você deverá informar suas informações do GitHub, como mostra a Figura 5, e selecionar a opção Finalizar. Dessa forma, seu projeto estará no controle de versionamento, bastando somente verificar na página do repositório criado no GitHub.
Image Removed
Figura 5 - Preenchendo as informações para exportação do projeto
Informações | ||
---|---|---|
| ||
Endereços de projetos GIT sempre terminam com a extensão ".git" e deve ser informado no campo URL do Repositório. |
Com o projeto criado, é possível realizar diversas operações no repositório, para isso basta acessar a opção Equipe, clicando com o botão direito na raiz do projeto. A figura 6 mostra as operações do GIT que poderão ser utilizadas no seu projeto.
Image Removed
Figura 6 - Operações no repositório
Informações | ||
---|---|---|
| ||
Para mais informações sobre como usar essas operações acesse a Documentação oficial do GIT. |
Commit
A operação de commit apenas salva as alterações, para enviar pra o repositório GIT use a funcionalidade Push. Após realizar qualquer uma das operações, uma mensagem aparecerá informando que a operação foi realizada com sucesso.
Image Removed
Figura 7.1 - Realização da operação commit
Image Removed
Figura 7.2 - Depois e antes da mudança do arquivo
Pull
A operação pull faz com que seu repositório local seja atualizado com as modificações do repositório remoto feito por outras pessoas.
Fetch
Com essa operação você irá sincronizar o seu repositório local com o repositório remoto, semelhante ao pull, porém o comando fetch apenas traz os dados para o seu repositório local, portanto, ele não faz o merge automaticamente com o seus dados ou modifica o que você está trabalhando atualmente.
Push
Quando as modificações realizadas no seu projeto estiverem prontas para serem enviadas para o repositório remoto, você deverá utilizar a operação push. Essa operação poderá ser realizada após um commit ou no momento em que um commit está sendo feito.
Clean
Com essa operação você removerá todos os arquivos do seu projeto que não estarão sob o controle de versionamento. Uma mensagem de confirmação aparecerá perguntando se você deseja realizar a operação clean.
Reset
Com essa operação você poderá desfazer as alterações do último arquivo modificado. Uma mensagem de confirmação aparecerá perguntando se você deseja realizar a operação reset. Fique atento ao fato de quando realizada, ela não será mais desfeita.
Reset Hard
Essa operação faz com que o projeto volte para o estado original, apagando até as configurações que foram salvas.
Git Flow
Com essa opção você criará branchs que seguem as "regras do Gitflow".
Informações | ||
---|---|---|
| ||
Para saber mais sobre o Gitflow acesse: Trabalhando em equipe (conceitos Git Flow). |
Merge
Com essa operação você poderá fundir uma branch em outra. Para isso, basta escolher a branch para qual você deseja levar suas alterações (Figura 8).
Image Removed
Figura 8 - Escolhendo a branch para o merge
Reverter Alterações
Com essa opção você poderá reverter todas as alterações realizadas no seu último Commit. Ao selecionar essa opção você deverá informar em quais dos arquivos alterados você deseja aplicar essa operação (Figura 9).
Image Removed
Figura 9 - Escolhendo arquivos para reverter alterações
Trocar Branch
Nessa opção você poderá trocar para branches criadas anteriormente ou criar uma nova branch.
Image Removed
Figura 10 - Opções para branches
Informações | ||
---|---|---|
| ||
Para mais informações sobre como usar essas operações acesse a Documentação oficial do Git. |
Mostraremos alguns conceitos do Git e posteriormente mostraremos como o Cronapp simplifica os principais recursos de versionamento em seu projeto.
Principais recursos
O Git pode ser entendido como um serviço de gestão de arquivos definido por um protocolo, possui diversos recursos e dá suporte para que múltiplas pessoas trabalhem ao mesmo tempo no desenvolvimento de um projeto.
O Cronapp possui um terminal linux onde os comandos Git podem ser executados, porém veremos mais adiante que é possível executar os principais recursos de forma visual. Para abrir o terminal, clique no ícone destacado na figura 1.
Image Added
Figura 1.1 - Executando comandos Git via terminal
Repositórios
Cada desenvolvedor em um projeto no Git possui um ambiente local totalmente isolado, sendo necessário enviar e obter manualmente as atualizações. Se seu projeto estiver centralizado em um repositório remoto, cada participante deve criar um clone 'local' desse repositório.
Image Added
Figura 1.2 - Interação entre repositórios
Ao usar o comando git init
dentro do diretório, o git prepara esse local para ser versionado, na prática, o git cria um subdiretório oculto com a estrutura de dados usado pelo git. Mas não se preocupe com isso, qualquer projeto criado no Cronapp já possui essa estrutura de versionamento.
Bloco de código | ||
---|---|---|
| ||
$ git init |
Repositório local
Diferentemente do SVN, em que o comando git commit
envia as alterações para o repositório central, no Git, quem faz essa ação para o repositório de origem é o comando git push
. O git commit
tem a função de salvar localmente o estado atual (snapshot) dos arquivos alterados, dessa forma, é possível criar vários snapshots local antes de enviá-los para o repositório de origem.
O Git não cria uma cópia dos arquivos a cada nova versão, isso causaria uma enorme perda de espaço e lentidão. Ao invés disso, ele rastreia as alterações feitas e mantém o histórico de tudo.
O processo entre um commit e outro possui três estágios: Working Directory, Staging Area e Repository (Figura 3).
- Working Directory: logo após clonar um repositório ou aplicar um
git
commit
, o Git considera o Working Directory "limpo", ou seja, todos os arquivos estão rastreados (Tracked). Porém, ao adicionar um novo arquivo ou editar um existente, o Git passa a vê-lo como não rastreável (Untracked), isso significa que o arquivo não existia ou não está mais igual snapshot anterior. Staging Area: antes de criar um novo commit, é necessário informar ao Git quais arquivos farão parte desse snapshot, assim podemos usar o comando
git status
para ver o conteúdo não rastreado ou modificado e em seguida usar o comandogit add <arquivos>
(ougit add *
para adicionar todos) que prepara o conteúdo informado, indexando para a próxima etapa.Bloco de código language bash git status git add *
Repository: neste último estágio o Git passa a rastrear todas as alterações dos arquivos informado no estágio anterior, salvando e criando um histórico local dessas modificações. Essa ação é feita usando o comando
git commit
.Bloco de código language bash $ git commit -m "<mensagem de resumo para o commit>"
O comando git status
permite visualizar o estado atual de cada arquivo alterado.
Image Added
Figura 1.3 - Estágios e seus comandos
Repositório Remoto
Por ser um sistema de controle de versão distribuído, o repositório remoto é apenas um link de comunicação entre dois repositórios, onde o seu repositório é o local e o repositório remoto pode estar em outro domínio, normalmente nomeado como origin.
Podemos usar o git clone
para obter uma cópia local de um repositório remoto.
Bloco de código | ||
---|---|---|
| ||
$ git clone <endereço repositório remoto> |
Como podemos ver na figura 1.2, é possível estar conectado a mais de um repositório remoto. Isso permite que você possa ter acesso ao repositório local de um colega e contribuir antes dele enviar para o repositório central.
O comando abaixo adiciona um novo repositório remoto.
Bloco de código | ||
---|---|---|
| ||
$ git remote add <nome> <endereço repositório remoto> |
Uso de branchs
As ramificações (branchs) permitem "separar" o projeto a partir de um determinado snapshot criando duas linhas do tempo, realizar diversas alterações e posteriormente unir (merge
) o seu conteúdo. Assim, cada desenvolvedor pode trabalhar em um ramo próprio para, por exemplo, corrigir bugs ou criar novas funcionalidades sem impactar o fluxo principal até que o código esteja suficientemente maduro.
O primeiro comando abaixo cria uma ramificação baseada no branch atual, já o segundo, lista todos os branchs locais e remotos.
Bloco de código | ||
---|---|---|
| ||
$ git branch <nome branch>
$ git branch -a |
Image Added
Figura 1.4 - Processo de criação, implementação e mescla de uma branch
No Git, o ramo principal é conhecido como master e a partir dele que são geradas novos branchs. É possível trabalhar localmente com vários branchs, alternando entre eles de modo que um não interfira no outro até que será feito o merge. Use o comando abaixo para intercalar entre os branchs.
Bloco de código | ||
---|---|---|
| ||
$ git checkout <nome branch> |
Mesclar conteúdo
O git merge
faz o processo inverso ao git branch
, ou seja, unifica o conteúdo do ramo informado com o branch atual. Durante esse processo é feito um comparativo (git diff
) para verificar se existem diferenças entre as linhas de códigos, de modo geral essa mesclagem ocorre de forma automática, porém podem ocorrer conflito de conteúdo, onde é necessário ajustar manualmente.
Bloco de código | ||
---|---|---|
| ||
$ git merge <ramo que será mesclado com o branch atual> |
Os dois principais modos de mesclagem usados pelo Git são:
- Avanço rápido, usado quando ocorre uma situação parecida com a da Figura 1.4, em que o último commit do branch principal ocorreu por conta da bifurcação, dessa forma o Git não necessita comparar os históricos, apenas transfere o histórico da branch secundária para a principal.
- Três vias, ocorre quando há alterações nos dois fluxos, assim o Git compara o conteúdo do commit que gerou a bifurcação (base) com o conteúdo do último commit de cada branch, podendo gerar um dos quatro casos (Figura 1.5):
- (linha 11) O conteúdo base é igual ao conteúdo dos dois branchs, dessa forma não houve alterações e o conteúdo continua igual;
- (linha 20) O conteúdo base é igual a apenas um dos branchs, houve alteração e o conteúdo diferente (mais atual) será adicionado;
- (linha 27) O conteúdo só existe em um dos branchs bifurcados, foi inserido um novo conteúdo que será adicionado;
- (linha 71) O conteúdo dos dois branchs são diferentes da base, o Git informa o conflito que deve ser resolvido manualmente.
Image Added
Figura 1.5 - Situações que podem ocorrer durante o merge
Obter atualizações
O git possui dois comandos para obter novos conteúdos de um repositório:
O
git pull
baixa as atualizações e em seguida mescla o conteúdo com o do repositório local automaticamente.Bloco de código language bash $ git pull <nome do repositório remoto> <nome branch>
O
git fetch
baixa o conteúdo sem mesclar, assim é possível analisar primeiro se as atualizações estão seguras e só em seguida aplicar o merge manualmente.
Abaixo os comandos para baixar e verificar as diferenças entre o conteúdo do branch atual e o baixado:Bloco de código language bash $ git fetch $ git diff master Origin/master
Enviar atualizações
Após finalizar e "commitar" uma atividade em seu repositório local, podemos usar o comando git push
para enviar o seu conteúdo para o repositório remoto. Porém, é recomendado que primeiro seja baixado o conteúdo atual do repositório remoto, resolver os possíveis conflito com a sua versão local e só então enviar.
Bloco de código | ||
---|---|---|
| ||
$ git push |
Em seguida o Git solicitará o seu usuário e senha do repositório remoto.
Ignorar conteúdo
Não é interessante que arquivos compilados, de cache e outros sejam enviados para os repositórios remotos, assim, podemos utilizar o arquivo .gitignore
para informar ao Git o que não deve ser rastreado. Esse arquivo costuma ficar na raiz do projeto, contemplando toda a estrutura do projeto.
Cada linha do .gitignore
especifica um padrão, então podemos configurar padrões como: todos os arquivos de um subdiretório, todos os arquivos com uma determinada extensão, todos os arquivos que iniciam com uma sequência determinada de caracteres e outros.
Para mais detalhes sobre os padrões, acesse a documentação do .gitignore.
Pull Request
Uma solicitação Pull é um mecanismo muito utilizadas em ambientes corporativos e normalmente já vem integrado em sistemas com interface, como o Github, GitLab, etc. Ao inicializar uma pull request, é possível indicar equipes ou pessoas para validar o conteúdo a ser mesclado, nesse processo podemos discutir e revisar as possíveis alterações com os colaboradores, adicionando novos commits antes que as alterações sofram merge no branch base.
Requisições Pull normalmente trabalham em conjunto com o GitFlow e geralmente ocorre o seguinte processo:
- O desenvolvedor cria um ramo em seu repositório local e atua em uma nova funcionalidade ou correção de bug.
- Após concluir a atividade, o desenvolvedor envia o branch para um repositório que todos da equipe tenham acesso.
- Em seguida é criado o Pull Resquest.
- A equipe revisa o conteúdo, discute e realiza alterações, se for necessário.
- Por fim, o mantenedor do projeto mescla o conteúdo no repositório central e fecha a Requisição Pull.
Tags
As tags no Git são utilizadas para referenciar um momento específico na linha do tempo do seu projeto, normalmente estão muito atreladas ao lançamento de versões (v1, v1.1, etc). É uma boa prática utilizar as tags no branch principal para marcar os pontos de versão, isso será muito útil para facilitar o rastreio do que foi lançado, aplicar correções, voltar versões etc. Hoje muitos sistemas utilizam as tags para controlar versões, como por exemplo o node.
Utilize o comando abaixo para criar um marcador e informe em "<nome da tag>" um identificador semântico, ex,: "v1.0.4" ou "v1.0.4-rc".
Bloco de código | ||
---|---|---|
| ||
git tag -a <nome da tag> -m "<comentário sobre a versão>" |
Para listar todos os marcadores já criados, use o comando abaixo:
Bloco de código | ||
---|---|---|
| ||
git tag |
Versionamento no Cronapp
O Cronapp possui um ambiente preparado para facilitar o uso do Git em seus projetos. Mostraremos como executar os principais comando Git de forma visual.
Visão geral
Ao abrir um projeto no Cronapp é possível visualizar algumas informações sobre o seu versionamento: o nome do branch ativo é exibido ao lado do nome do projeto na raiz de arquivos (destaque 2 da figura 2.1), a quantidade de versões locais não enviadas para o repositório remoto é exibido ao lado do branch (destaque 2 da figura XXX) e os arquivos não rastreados pelo Git ficam com cores diferenciadas para informar sua situação atual:
- Verde: adicionado ou renomeado;
- Laranja: criado localmente;
- Azul: atualizado;
- Cinza: removido;
- Roxo: ausentes;
- Vermelho: arquivo com conflito.
Image Added
Figura 2.1 - Árvore de arquivos e janela para realizar o commit e push ou só commit
Importar projetos
Para clonar um projeto de um repositório Git para o Cronapp, clique no ícone Criar projeto para abrir a janela Novo Projeto (Figura 2.2) e siga os passos abaixo.
Image Added
Figura 2.2 - Importar projeto de um repositório Git
- Tipo do projeto: selecione o tipo do projeto a ser clonado
- Low-code: projeto Cronapp Web, mobile e servidor ou web e servidor.
- High-code: projeto nas plataformas Java, NodeJs, Python ou Plugin Cronapp.
- Nome do projeto: informe um nome para o projeto local, não é necessário ser o mesmo nome da versão remota.
- Origem: selecione a opção "O projeto está sob controle de versão?" e clique em Finalizar para abrir a janela Controle de versão,
- Janela Controle de versão: informe os dados do repositório Git a ser clonado.
- Protocolo: Atualmente o Cronapp só tem suporte nativo ao protocolo Git.
- URL do Repositório: endereço HTTP do repositório a ser clonado. Endereços de projetos Git sempre terminam com a extensão .git.
Anônimo?: marque essa opção para baixar repositórios públicos sem informar seu usuário e senha. Esses dados poderão ser requisitados ao fazer o
push
.- Usuário: seu usuário do serviço Git.
- Senha: sua senha do serviço Git.
- Nome do Autor: informado no conteúdo atualizado por você.
- Email do Autor: informado no conteúdo atualizado por você.
- Branch: selecione o ramo que será importado, posteriormente é possível baixar as demais branchs do projeto.
- Recarregar: atualiza a caixa de seleção do branch.
Exportar projetos
Para exportar um projeto no Cronapp para o Git, é preciso primeiro criar um repositório em um serviço Git, como Github, GitLab, Bitbucket ou outro qualquer. Com o endereço do repositório, basta seguir os passos abaixo.
Dica |
---|
Ao criar um repositório em serviços de terceiros, normalmente é dada a opção de já incluir o arquivo README.md, que é usado para apresentar informações sobre o projeto. Recomendamos não incluir esse arquivo para evitar conflitos, pois os projetos criados no Cronapp já possuem esse arquivo. |
Image Added
Figura 2.3 - Exportar projeto para um repositório Git
- Menu de contexto: clique com o botão direito sobre o nome do projeto na raiz da árvore de arquivos e selecione a opção "Exportar" para abrir a janela que configura o modo de exportação.
- Janela de seleção de formato: selecione a opção "Exportar para repositório Git" e clique em Avançar.
- Janela de configurações do repositório: preencha os dados solicitados para enviar seu projeto para o repositório informado.
- Usuário: seu usuário do serviço Git.
- Senha: sua senha do serviço Git.
- Nome do Autor: informado no conteúdo atualizado por você.
- Email do Autor: informado no conteúdo atualizado por você.
- Informe a mensagem de commit: esse processo fará o primeiro commit, assim, informe uma mensagem.
- URL do Repositório: endereço HTTP do repositório. Endereços de projetos Git sempre terminam com a extensão .git.
Ao final, clique em Finalizar e aguarde a mensagem "Operação efetuada com sucesso." aparecer.
Menu de opções
Após versionar um projeto, todas as ações low-code do Git devem ser feitas através do submenu Equipe, que se encontra no menu de contexto da arvore de arquivos (destaque 2 da figura 2.4). Abaixo vemos o menu de contexto da raiz da árvore hierárquica (nome do projeto).
Image Added
Figura 2.4 - Lista de ações do submenu Equipe
- Controle de versão: abre a janela Controle de versão (destaque 4 da Figura 2.2), onde é possível atualizar os campos Usuário, Senha, Nome do autor e Email do autor.
- Equipe:
- Commit: abre a janela que permite selecionar os arquivos que farão parte do commit, também é possível enviar para o repositório remoto através da opção commit/push.
- Pull: baixa e mescla as atualizações do repositório remoto.
- Fetch: baixa, porém não mescla as atualizações do repositório remoto. Uma janela com os arquivos a ser atualizados durante o merge será exibida.
- Push: envia para o repositório remoto todas as versões ainda não enviadas.
- Clean: essa operação removerá todos os arquivos criados ou adicionados e que ainda não foram rastreados pelo Git, ou seja, ainda estão no estágio Working Directory (Figura 1.3).
- Reset: mantêm as alterações que estão atualmente nos estágios Working Directory e Staging Area e retorna o ponteiro HEAD para antes do último commit.
- Reset Hard: exclui as alterações que estão nos estágios Working Directory e Staging Area e retorna o ponteiro HEAD para logo após o penúltimo commit.
- Git Flow: ações usadas para o Git flow.
- Iniciar Git flow: cria um branch develop e prepara o projeto para trabalhar com Git flow.
- Merge: abre uma janela para mesclar o conteúdo do branch selecionado no branch atual.
- Reverter alterações: abre uma janela onde é possível selecionar quais arquivos retornarão ao status do último commit.
- Trocar Branch: realiza ações relacionados aos branchs.
- Novo branch: abre a janela para criar novo branch.
- Lista de branch: exibe a lista dos branchs do projeto, selecione outro branch para carregá-lo.
- Outros: abre uma janela onde é possível realizar diversas ações com os branchs locais e remotos.
Você encontrará ações reduzidas ao abrir o menu de contexto de um arquivo ou diretório.
Image Added
Figura 2.5 - Menu de contexto de arquivos ou diretórios
- Commit: abre a janela que permite selecionar os arquivos para aplicar um commit ou um commit e push em seguida.
- Reverter alterações: abre uma janela onde é possível selecionar quais arquivos retornarão ao status do último commit.
Âncora | ||||
---|---|---|---|---|
|
Janela de revisões
Caso as ações merge ou pull apresentem conflito em pelo menos um dos arquivos, uma janela aparecerá informando o problema e os nomes desses arquivos (figura 2.6), será necessário que você resolva esse conflito antes de tentar executar a ação novamente.
Após fechar a mensagem de conflito, os arquivos com problema aparecerão destacados em vermelho, dê um duplo clique para abrir a janela de revisão de conflitos.
Image Added
Figura 2.6 - Detalhes da janela de revisões dos conflitos
- Revisão local: conteúdo do arquivo local e o ID do último commit.
- Revisão remota: conteúdo do arquivo remoto e o ID do último commit.
- Revisão base: conteúdo do último commit antes da bifurcação dos branchs.
- ↑↓: seleciona as demais diferenças entre os arquivos.
- Aplicar trecho: clique na seta da esquerda para aplicar o trecho de código da revisão loca, já a seta da direita aplicará o trecho remoto.
- Usar suas alterações: todos os trechos de código ainda em conflito serão resolvidos com base no código local.
- Usar a versão do servidor: todos os trechos de código ainda em conflito serão resolvidos com base no código remoto.
- Bloquear rolagem em conjunto: se ativo, ao rolar o código de uma das colunas, as outras duas rolam juntas.
Âncora | ||||
---|---|---|---|---|
|
Commit
A janela de commit permite adicionar uma mensagem, selecionar os arquivos que serão adicionados na próxima versão e dá a opção para apenas commit ou "commitar" e enviar o conteúdo para o servidor remoto.
Image Added
Figura 2.7 - Janela usada para criar versões
- Quantidade de arquivos adicionados, novos, atualizados, removidos e desaparecidos.
- Checkbox: selecione apenas os arquivos que farão parte da nova versão.
Ao dar um duplo clique sobre um dos arquivos que já foram rastreados anteriormente pelo Git, é possível abrir a janela de revisão com o conteúdo antigo e o novo. Acesse o tópico sobre a janela de revisão para mais detalhes.
Image Added
Figura 2.8 - Janela de revisão usada pra analisar as alterações do arquivo
Âncora | ||||
---|---|---|---|---|
|
Merge
Para aplicar o merge, você deve estar no branch que deseja atualizar e selecionar o branch que deseja obter o novo conteúdo. Se não houver conflitos, será exibido uma janela com os arquivos atualizados, caso contrário, aparecerá uma janela de erro com os arquivos em conflito. Após clicar em OK, os arquivos em conflito estarão em vermelho, dê um duplo clique para abrir a janela de revisão e resolver o conflito.
Image Added
Figura 2.9 - Mensagem de conflito durante o merge
Âncora | ||||
---|---|---|---|---|
|
Branch
A opção Outros no submenu Trocar Branch abre uma janela onde é possível realizar algumas ações em branchs locais, remotas e até tags.
Image Added
Figura 2.10 - Janela com a lista dos branchs
- Novo Branch: abre a janela para criar novo branch.
- Renomear Branch.
- Deletar Branch.
- Checkout: recarrega o branch selecionado, essa ação pode ser feita com um duplo clique sobre o nome do branch.
- Recarregar: verifica se existem novos branchs remotos e recarrega a lista.
- Cancelar: fecha a janela.
Âncora | ||||
---|---|---|---|---|
|
Novo Branch
Ao selecionar essa opção, uma janela será aberta permitindo definir um nome para o novo branch e algumas ações.
Image Added
Figura 2.11 - Criando novo ramo
- Fazer checkout: o novo branch é carregado e passa a ser o branch atual.
- Fazer push: o novo ramo é enviado automaticamente para o repositório remoto.
Nesta página
Índice |
---|
title | Nesta página |
---|
Índice |
---|