Série Git na Prática:Descartando alterações no working directory

Olá Pessoal,

No post de hoje veremos como descartar alterações quando ainda estamos no working directory.

Lets go..

 Starting…

Algo muito comum é você fazer alteração no arquivo e depois ver que não seria necessário mais aquela alteração e quer descartar. Mas, o que fazer? Ao modificar o arquivo o git vai informar assim:

Então antes de ir para o INDEX queremos descartar as mudanças feitas e deixar o arquivo como antes. Como proceder?

Simples! Basta executarmos o seguinte comando:

git checkout <nome do arquivo>

Se executarmos novamente o git status veremos que não há nada alterado e se abrirmos o arquivo, ele estará como antes.

Só isso. Simples, não? Não é. O git que é fácil.  🙂

See ya!! Abraços.

Git na prática: Entendendo o rebase

Olá Pessoal,

No post de hoje vamos entender o rebase que temos no git.  Acho umas das mais importantes features do git.

Lets go…

Starting …

O rebase é algo tão comum quanto tomar café todos os dias. Na prática, precisamos dele quando estamos trabalhando na branch e sabemos que o repositório master foi atualizado por outros desenvolvedores e precisamos ter nosso branch atualizado, concorda? Não  é nada legal ficarmos trabalhando na branch com o código de 2 dias atrás. Podemos ter problemas e sérios conflitos aqui na hora do merge, o melhor é que se for ter conflito que seja pequeno e de imediato.

In practice

Considerando o cenário dos posts anteriores onde temos a branch development, vamos supor que ficamos trabalhando na branch por alguns dias e a master sofreu alteração, alguém adicionou um novo arquivo lá e fez o commit.

E agora precisamos trazer esse novo arquivo para o branch, assim vamos garantir que nossa branch está igual à master.

Para isso:

1      Vamos na branch git checkout development

2      Dizer para realizar um rebase da branch master

git rebase master

E o que acontece aqui?

Simples, o git se encarrega de colocar os commit que foram feitos na branch em uma branch temporária e pega os commits da master e coloca na branch, depois ele pega os commit que ele mesmo colocou na branch temporária e coloca de volta na branch development. Aqui ele valida commit por commit, ou seja, é possível ter conflito e teremos que resolver manualmente. Veja como ficou o branch com o novo arquivo que tínhamos apenas na master:

A seguir o ciclo:

E depois que terminamos de trabalhar com a branch podemos fazer um merge, como vimos nesse post. E termos a master atualizada, conforme podemos ver na última imagem (de cima para baixo).

Esse é o rebase. Simples, não?

See ya !! Abraços.

Série Git na Prática: Trabalhando com branch

Olá Pessoal,

Mais um post da série git na prática. Hoje veremos como trabalhar com branches no git. É tão fácil quanto roubar doce de um recém nascido:  ). Claro que será tudo via linha de comando.

Lets go…

Starting…

Considerando o repositório criado no post anterior, vamos criar uma branch. Mas, pra que?

Bem, o ideal é que você não trabalhe na branch master que é criada no seu primeiro commit pelo Git, e busque usar a master  para fazer push com o seu repositório remoto e seu código em desenvolvimento, coloque em uma branch. Em outras palavras, leve apenas códigos estáveis para o master. Nada impede de você fazer tudo na master, para o git pouco importa isso, o que falei acima é apenas uma sugestão. Talvez se você tiver trabalhando sozinho não vai ver a importância de ter uma branch (mesmo assim eu acho que tem), mas se tiver em equipe verá que é uma mão na roda.

In Practice

Digitando git branch sabemos quais branches temos no nosso repositório

Para criar uma nova branch é bem simples: git branch <nome da branch> então seria

git branch development 

Assim criamos uma branch chamada development e podemos ver a seguir:

O * informa em que branch estamos. Observe que não estamos na development, mas para irmos é bem simples

git checkout development

Assim sabemos onde onde estamos

git status



Sabemos que estamos na branch e nesse caso não há nada para ser committed.

Agora vamos commit arquivos na branch apenas. Portanto criei o arquivo a seguir no repositório:

E vou dizer ao git que esse arquivo vai para branch. Considerando que estou na branch de development, basta:

git add <nome file>

E agora realizar o commit

git commit –m ‘adicionando arquivo na branch’

Verificando alteração na branch

Para verificar se o arquivo realmente foi para branch, vamos ver o log da branch

git log

Observe as alterações feitas na branch. Para conferir que a master não sabe disso, vamos ver o log da master:

git checkout master

git log

Veja que a master nem sabe o que aconteceu na branch.

Simples, não? No próximo post veremos como fazer o merge, ou seja, o que está na branch ir para master.

See ya!!! 

Série Git:Utilizando o GIT via command line Windows

Olá Pessoal,

No post de hoje vamos ver como  usar o git via linha de comando no Windows. Acredito que é a melhor forma de usar o git. Quem vem do SVN e está acostumado com plugins e ferramentas pode se sentir um pouco desconfortável, mas é uma questão de tempo. Apesar de que já há ferramentas GUI para o git disponíveis, porém eu já tive problemas em não conseguir fazer commit ou conectar a repositório remoto etc.

Lets go…

Starting…

Vou considerar que você já tem o git for Windows instalado na máquina, se não tiver, dá uma olhada nos links a seguir e faça a instalação que é super simples:

http://git-scm.com/downloads 

Após ter instalado, é hora de criamos uma pasta que será o nosso repositório no git, no meu caso criei uma para exemplo conforme a seguir:



 

Se você fez a instalação na sua área de trabalho deve ter o git Shell, abra ele para que os comandos do git sejam reconhecidos. Quando instalou o git havia uma opção de pode usar o comando git dentro do prompt do Windows, eu particularmente não gosto, prefiro usar o git Shell, porque ele fica colorido seguindo uma formatação do git e acho que ajuda no dia-dia.

Agora vamos dizer que a pasta que criamos é um repositório git, basta digitarmos git init e uma pasta .git é criada dentro do repositório. Se ela não aparecer no Windows Explorer, veja se as configurações do seu Windows não está para não exibir arquivos ocultos, pois essa pasta é criada como “oculto”.

Vamos adicionar  um arquivo no repositório

 

Agora com os arquivos, vamos ver o status do nosso repositório com git status

 

Observe que o git nos retorna como está o nosso repositório, não há nada para commit. Antes precisamos criar um usuário global para  que possamos identificar de quem foi o commit.

Git config –global user.name “Camilo Lopes”

Git config –global user.email camilo@camilolopes.com.br

 

Fazendo track do arquivo

Agora precisamos dizer ao git para cuidar do track desse arquivo:

git add <nome do arquivo>

 

É isso ai. O pulo do gato é que quando isso acontece o arquivo vai para o INDEX do git, ele ainda não foi comitado, apenas é candidato para ser comitado. E toda vez que o arquivo for modificado, vamos executar esse comando novamente para dizer que ele é candidato para ser comitado. A diferença aqui é que se eu modificar um arquivo e não dar um add para ser candidato ao commit, simplesmente o git ignora o  arquivo modificado e só commit o que é candidate. Percebeu  a diferença?

Depois do INDEX quando o arquivo é comitado vai para o HEAD.

Se executarmos git status agora veremos os arquivos candidate (em verde)

 

Comitando

Para comitar é bem simples git commit –m ‘bla bla’

Somos obrigados a colocar uma mensagem no commit, se não colocar o –m, o git vai abrir uma tela pedindo para informamos. Então não tem como escapar.

Verificando histórico de commit

Agora vamos ver o histórico dos commit

Git log

Nos mostra todo histórico do repositório.

Pronto. Simples, não?

Observe que trabalhamos offline o tempo todo. Uma das vantagens do git.

Vou ficando por aqui…

see ya!! 

Série Git:Usando Git no Windows

olá Pessoal,

O post de hoje, vamos ver como configurar o Git no Windows. É muito simples e rápido. Vou me limitar apenas a essa parte neste post, no próximo vamos ver como fazer no nosso repositório local conversar com o GitHub.

Lets go…

Instalando Git

Passo 1

            Primeiramente vá no site do Git http://git-scm.com/ e baixe: a versão mais recente: Git.1.7.x.

Passo 2

            Execute o arquivo o arquivo e deixe a sua tela assim:

A opção “Git bash here” possibilita eu abrir a linha de comando do Git em qualquer diretorio.Basta clicar com o botão direito e escolher “Git Bash Here”.

A ultima opção nos possibilita põe uma fonte melhorzinha para o prompt de comandos.

Clique em next

Passo 3

Nesta tela eu prefiro a primeira opção. Pois, a segunda diz que o Git usará o prompt padrão do Windows, mas não os comandos Unix. A terceira, diz que alguns comandos Windows serão substituidos por comandos Unix. E a primeira permite usar comandos Git e outros comandos Unix apenas no Git Bash.

 

 

Passo 4

A próxima tela, é sobre quebra-linhas. Como sabemos os OS possuem formatos diferentes de quebra-linhas em aquivos de texto.O objetivo dessa opção é normalizar isso. A primeira opção converte para o padrão Windows quando os arquivos chega para você. E quando você comita ele converte para o formato Unix.  A segunda não faz nenhuma conversão quando o arquivo chega, apenas converte para Unix quando comitamos e a terceira, não faz nenhum tipo de conversão.Eu prefiro a segunda

 

Dê next…até finish. Feito Git instalado :).

Passo 5 Criando o Repositório

Agora vamos testar nosso repositório Git. Crie uma pasta onde você achar melhor. Exemplo c:\GitRepositorio.

Clique com o botão direito sobre a pasta e escolha Git Bash Here. Aguarde o prompt de comando do Git ser aberto.

 

Passo 6 Configurando

Agora vamos configurar os dados, para que os commit possam ser identificados, portanto digite:

git config –global user.name “Nome Sobrenome”

git config –global user.email “seu_email@email.com”

 

 

Passo 7

Precisamos inicializar o repositório Git. Então digite:

git init

O “master” que aparece entre parênteses indica que estamos no repositório Git.

Passo 8

Vamos criar um arquivo .txt vazio e commit só para ver se tá tudo ok.

Primeiro criamos o arquivo touch testegit.txt

Em seguida versionei o arquivo ao git usando o comando add

E por ultimo fiz o commit.

 

Git GUI

O Git possui uma versão Git Gui que você encontra iniciar >> programas >> Git >> Git GUI. Se você não gosta de usar o command line, sinta-se à vontade em usar Git GUI.

 

Ao abrir você tem três opções, no nosso caso, vamos escolher abrir um repositório existente

Na tela a seguir informe o diretorio que definimos como repositório Git.

E ai você terá as modificações no repositório poder commitar, salvar para revisão, ver histórico etc. Para fazer um teste simples adicionei mais um arquivo no seu repositório e depois clique em “Atualizar” em Git GUI.

E commit atualização.

Livros

Há muito material na net sobre Git.Porém, há dois livros que recomendo caso queira se aprofundar mais. São esses:

Pro-Git e Getting Good with Git

Vou ficando por aqui. No próximo post veremos como  subir nossos commits locais para o GitHub.

Abracos!! See ya!