segunda-feira, 19 de outubro de 2015

Git - GitHub - Controle de Versão - Primeiros Passos

Git é um controle de versão open source, desenvolvido pelo mestre Linus Torvalds.
Caso não tenha idéia do que é um controle de versão, recomendo começar do básico pela wikipedia. Clique aqui.
Este meu post será voltado em primeiros passos na linha de comando com o Git utilizando o serviço do GitHub.

Verificando o client instalado na sua máquina.
Abrindo o terminal da sua máquina, neste tutorial usarei um MAC OSX.
Digite o comando abaixo para verificar a versão do Git instalado em sua máquina.
 $ git --version  

O resultado será parecido com o print abaixo, caso tenha o git instalado em sua máquina.

Sempre é bom atualizar com a versão recente do Git.
Entrei no site do Git e verifiquei a última versão, como o retorno indica que a versão instalada é a de 2.3.8 e a atual é a de 2.5.3, abaixei o pacote da nova versão e realizei a instalação.
Caso não tenha o Git, entre no site para realizar o download ou atualizar a versão.
Site para download do Git: http://git-scm.com/downloads
Depois do Git corretamente instalado, vamos realizar algumas configurações.

Configuração de Identidade do Usuário.
Estas configurações são para quando realizamos o commit dos arquivos e mostrar o nome do usuário e e-mail corretamente nas informações do commit.
 $ git config --global user.name "SEU NOME"  
 $ git config --global user.email "SEU EMAIL"  

Depois destas configurações de identidades estarem feitas, podemos verificar as configurações utilizando o seguinte comando:
 $ git config --list  


Iniciando um repositório.

Utilizando o Clone de um repositório remoto, no caso no GitHub.
Com o comando abaixo, iremos pegar o repositório remoto no GitHub e criaremos ele na sua máquina.
 $ git clone https://github.com/dsromerobr/TesteStoryBoard.git  
 Cloning into 'TesteStoryBoard'...  
 remote: Counting objects: 55, done.  
 remote: Compressing objects: 100% (26/26), done.  
 remote: Total 55 (delta 5), reused 0 (delta 0), pack-reused 25  
 Unpacking objects: 100% (55/55), done.  
 Checking connectivity... done.  
 $   

Mostrando alterações.
Caso você altere um arquivo, podemos ver os status dos arquivos com o seguinte comando:
 $ git status  
 On branch master  
 Your branch is up-to-date with 'origin/master'.  
 Changes not staged for commit:  
  (use "git add <file>..." to update what will be committed)  
  (use "git checkout -- <file>..." to discard changes in working directory)  
      modified:  TesteStoryBoard/Base.lproj/Main.storyboard  
      modified:  TesteStoryBoard/ViewController.m  
 Untracked files:  
  (use "git add <file>..." to include in what will be committed)  
      TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/  
 no changes added to commit (use "git add" and/or "git commit -a")  

Status dos Arquivos.
Os arquivos podem estar em um desses dois status inicialmente.
untracked: arquivo não monitorado pelo git, deve ter sido criado ou movido recentemente para a pasta.
tracked: arquivo monitorado pelo git.

Sendo um arquivo tracked:
unmodified: Arquivo que não foi modificado.
modified: Arquivo que foi modificado.
staged: Arquivo que foi selecionado.

Este ciclo de Status dos arquivos é extremamente importante ter ele em mente.




A imagem acima demonstra exatamente este ciclo de vida.

Verificando o retorno do comando git status, identificamos os arquivos que foram modificados, saindo do status unmodified para modified.
  Changes not staged for commit:   
  (use "git add <file>..." to update what will be committed)   
  (use "git checkout -- <file>..." to discard changes in working directory)   
    modified: TesteStoryBoard/Base.lproj/Main.storyboard   
    modified: TesteStoryBoard/ViewController.m   

Adicionado Arquivos.
Agora vamos adicionar esses arquivos para Staged.
Adicionei somente o arquivo TesteStoryBoard/Base.lproj/Main.storyboard, utilizando o git add, o comando add serve para sempre alterar os alterar os status dos arquivos.
Executamos o git add e depois o git status para verificar o status. Agora temos arquivos em três status, o adicionado recentemente como staged o ViewController.m como modified e o arquivo xcuserdata como untracked.
$ git add TesteStoryBoard/Base.lproj/Main.storyboard   
$ git status  
 On branch master  
 Your branch is up-to-date with 'origin/master'.  
 Changes to be committed:  
  (use "git reset HEAD <file>..." to unstage)  
      modified:  TesteStoryBoard/Base.lproj/Main.storyboard  
 Changes not staged for commit:  
  (use "git add <file>..." to update what will be committed)  
  (use "git checkout -- <file>..." to discard changes in working directory)  
      modified:  TesteStoryBoard/ViewController.m  
 Untracked files:  
  (use "git add <file>..." to include in what will be committed)  
      TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/  

Para adicionar todos os arquivos, podemos executar o seguinte comando:
 $ git add .   

Depois de executar o comando, vejamos o resultados utilizando o git status.
 $ git status  
 On branch master  
 Your branch is up-to-date with 'origin/master'.  
 Changes to be committed:  
  (use "git reset HEAD <file>..." to unstage)  
      new file:  TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/douglasromero.xcuserdatad/UserInterfaceState.xcuserstate  
      modified:  TesteStoryBoard/Base.lproj/Main.storyboard  
      modified:  TesteStoryBoard/ViewController.m  

Agora todas as modificações estão prontas para serem consolidadas.

Removendo Arquivos.
Para remover um arquivo, temos o comando git rm.
No exemplo, não queremos adicionar o arquivo da pasta xcuserdata.
Utilizando o comando rm, deleta o arquivo fisicamente.
No caso, não queremos que o arquivo seja monitorado, para isso, utilizamos o parametro --cached.
$ git rm --cached TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/douglasromero.xcuserdatad/UserInterfaceState.xcuserstate   
 rm 'TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/douglasromero.xcuserdatad/UserInterfaceState.xcuserstate'  
 MacMiniRomero:TesteStoryBoard douglasromero$ git status  
 On branch master  
 Your branch is up-to-date with 'origin/master'.  
 Changes to be committed:  
  (use "git reset HEAD <file>..." to unstage)  
      modified:  TesteStoryBoard/Base.lproj/Main.storyboard  
      modified:  TesteStoryBoard/ViewController.m  
 Untracked files:  
  (use "git add <file>..." to include in what will be committed)  
      TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/  

Commit dos Arquivos.
Executando o comando git commit, irá abrir o vim com o texto para o commit, depois de editado, o commit será realizado.
 $ git commit  
 [master aa3945a] Commit com alterações do exemplo de GIT. Inclusão de uma property na primeira tela.  
  2 files changed, 4 insertions(+)  

Também tem a opção de realizar o commit com a mensagem já especificada, sem ter que abrir o vim.
 $ git commit -m "MENSAGEM DO COMMIT"  

Ignorando Arquivos.
Podemos criar um arquivo na raiz do projeto, .gitignore, este arquivo especifica os arquivos que não vão ser monitorados, com isso, evitamos de versionar arquivos que não interessam, como arquivos de logs ou de configurações pessoais, como no caso o arquivo de configuração pessoal do xcode, por exemplo os arquivos na pasta xcuserdata.
Exemplo do arquivo .gitignore, interessante para um projeto em IOS.
 $ cat .gitignore  
 TesteStoryBoard.xcodeproj/xcuserdata/  
 TesteStoryBoard.xcodeproj/project.xcworkspace/xcuserdata/  

Listando os Commits Realizados.

Agora uma série de comandos para listar os commits realizados.
 $ git log --pretty=oneline  
 ecf769af853777e7009623fe002879ea4ed517e1 Deletando arquivos de configuração de usuário.  
 aa3945abbb203307eac1b333c331fba6540e8f2d Commit com alterações do exemplo de GIT. Inclusão de uma property na primeira tela.  
 2128d14bb86584fe370bb6bce91893595777567f Segunda Parte do Tutorial  
 7eda7033bcc848f39fc73f643a0b6babe153af3e Initial Commit  

O git log, com o -p, mostra o diff entre os últimos commits.
O parâmetro -2, lista os últimos 2 commits, podendo alterar conforme a sua necessidade.
 $ git log -p -2  

O retorno será parecido com o abaixo:


Uma ferramenta interessante para ver os commits é a ferramenta gitk, que já vem instalada com o git.
Para isso, digite no terminal no repositório: gitk
 $ gitk  
Abrirá uma tela como a baixo, que tem diversas opções de visualizações.


Refazendo último commit.
Caso tenha esquecido de adicionar algum arquivo ou queira alterar a descrição do seu último commit, podemos utilizar o parâmetro --amend, caso não tenha alterado nada nos arquivos e somente queira alterar a descrição do commit, abrirá o vi e altere a descrição. Caso queria adicionar um novo arquivo, execute o git add e depois o git commit --amend.
 $ git commit --amend  

Agora foram explicados os comandos básicos no Git.
Acompanhe a segunda parte do artigo, trabalhando com servidores remotos.

Deixo um link de um excelente livro sobre GIT:
http://git-scm.com/book/pt-br/v1/Primeiros-passos


Nenhum comentário:

Postar um comentário

 

Cadastrar Email

Sobre o Blog

Neste blog irei compartilhar as minhas experiências e observações. Os temas serão variados, mas com ênfase em tecnologia. Inscreva-se nos nossos canais para receber atualizações.