Git - Meu primeiro commit

O Git é um VCS(Version Control System) ou popularmente dizendo uma ferramentas de versionamento, muito utilizada hoje em dia, pelo menos no mundo open-source, depois que o Kernel trocou DVCS BitKeeper e Linus Torvalds criou o Git, e vem sendo utilizado até hoje.

Para Linus Torvalds o novo sistema deveria atender:

Velocidade
Design simples
Suporte robusto a desenvolvimento não linear (milhares de branches paralelos)
Totalmente distribuído
Capaz de lidar eficientemente com grandes projetos como o kernel do Linux (velocidade e volume de dados)

Em todos projetos que trabalho hoje, 100% é utilizado o Git, para quem é familiarizado com terminal CLI é uma poderosíssima ferramenta, mas também tem a versão com Interface Gráfica, abaixo as versões free:

Mais opções em Git – GUI Clients.

Instalando o Git

Como ambiente para exemplos estarei realizando tudo em plataforma Linux, para outras Distribuições Linux e Sistemas Operacionais veja Git -Downloads, abaixo a instalação do sistema no Ubuntu.

$ sudo apt-get update ; sudo apt-get install git

Verificando a instalação:

$ git --version
git version 1.9.1

Configurando o Git

Apenas instalando o Git você já possui o ambiente apto para usar o sistema de versionamento, porém, uma configuração inicial e apenas uma unica vez é necessário, uma simples tarefa de incluir o seu usuário e e-mail que será o que lhe identificara durante o trabalho com o git local ou remoto.

Este arquivo de configuração ele pode estar em:

/etc/gitconfig: Irá ser o padrão para todos usuarios do Linux e repositorios

~/.gitconfig: Customizado para cada usuário do sistema, utilizo este.

.git/config: Para o repositório em questão

Para facilitar a configuração e administração podemos usar o git config, uma breve descrição de seu uso:

–system: Caso utilizar /etc/gitconfig

–global: Caso utilizar ~/.gitconfig

–list: Ira listar todas as configurações

–get: Obtem o valor de uma chave em especifico

–add: Adiciona um nova chave [valor]

–unset: Remove uma chave

Para mais informações digite git config ou git help config.

Vamos criar nosso ~/.gitconfig e testar algum dos parâmetros:

$ git config --list

$ git config --global user.name "Cleiton Bueno"
$ git config --global --add user.email "[email protected]"

$ git config --list
user.name=Cleiton Bueno
[email protected]
   
$ git config --get user.name 
Cleiton Bueno

$ git config --global --add user.alias "noteLinux17"

$ git config --list
user.name=Cleiton Bueno
[email protected]
user.alias=noteLinux17


$ git config --global --unset user.alias

$ git config --list
user.name=Cleiton Bueno
[email protected]

Algumas observações, para adicionar uma nova chave [valor] o –add pode ser omitido, onde houver alteração devemos especificar –global ou –system para /etc/gitconfig.

Uma dica bacana, é configurar um editor para usar, no caso, eu utilizo o vim, para configurar basta executar:

$ git config --global core.editor vim

Para abrir com o editor:

$ git config --global -e

Sendo assim segue como ficou a identidade do git do meu usuário:

$ git config --global --list
user.name=Cleiton Bueno
[email protected]
core.editor=vim

Primeiro código usando Git

Apenas para fim deste artigo, irei criar um projeto chamado hello-git no diretório /tmp, iremos iniciar o git, criar um código, realizar commit das modificações dos arquivos em questão, e toda alteração iremos adicionar e realizar commit, e assim por diante, então, vamos lá.

$ mkdir hello-git
$ cd hello-git/
/tmp/hello-git $ git init
Initialized empty Git repository in /tmp/hello-git/.git/

Após o git init dentro do diretório que iremos inserir os códigos, ele diz que criou um .git, este é um diretório oculto com uma estrutura de trabalho do git onde ele usa para “administrar” este repositório e armazena um histórico completo de todas modificações.

Antes de criarmos qualquer arquivos, um comando muito útil é o git status, onde iremos ter varias informações no decorrer da evolução do projeto como novos arquivos, arquivos modificados, arquivos que não receberam commits entre outras informações.

/tmp/hello-git $ git status
On branch master

Initial commit

nothing to commit (create/copy files and use "git add" to track)

Vamos criar o arquivo main.c e executar git status novamente.

/tmp/hello-git $ touch main.c
/tmp/hello-git $ git status
On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

	main.c

nothing added to commit but untracked files present (use "git add" to track)

Então, ele nos informa que existe um novo arquivo e não esta sendo “monitorado” pelo git, para isso devemos executar o comando git add <file>, vamos fazer isso e verificar o resultado.

/tmp/hello-git $ git add main.c 
cleiton@nb-bueno /tmp/hello-git $ git status
On branch master

Initial commit

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

	new file:   main.c

Agora vou realizar o primeiro commit em meu projeto.

/tmp/hello-git $ git commit -m "Adicionando arquivo main.c"
[master (root-commit) 60d288f] Adicionando arquivo main.c
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 main.c
/tmp/hello-git $ git status
On branch master
nothing to commit, working directory clean

Realizamos o commit e ele nos informa um pequena descrição do que foi feito, 1 arquivo modificado, 0 inserções, 0 remoções e o nome do arquivo criado, agora vamos criar um código simples, salvar, verificar com status e realizar um novo commit.

#include <stdio.h>

int main(void)
{
  printf("Olá Git\r\n");
  return 0;
}

/tmp/hello-git $ git status
On branch 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:   main.c

no changes added to commit (use "git add" and/or "git commit -a")

/tmp/hello-git $ git add main.c 
/tmp/hello-git $ git commit -m "Adicionado cabecalho stdio.h e um printf dizendo Ola Git"
[master 3ef0a66] Adicionado cabecalho stdio.h e um printf dizendo Ola Git
 1 file changed, 7 insertions(+)

Adicionamos o código no main.c e salvamos, executando o git status ele nos informa que o main.c foi modificado, e que podemos adicionar ele e realizar um commit ou descartar com git checkout — <file>, como podem ver, o git status ajuda muito e auxilia no fluxo do repositório.

Para finalizar, vamos ver como visualizar todos os commits, quem fez, data de alteração e demais informações usando git log.

/tmp/hello-git $ git log
commit 3ef0a666473d85c0a94612d1842c5b7adfe491a0
Author: Cleiton Bueno <[email protected]>
Date:   Mon Nov 7 22:01:16 2016 -0200

    Adicionado cabecalho stdio.h e um printf dizendo Ola Git

commit 60d288fd0c3a6f1378a171697bbd203c0e88b8e7
Author: Cleiton Bueno <[email protected]>
Date:   Mon Nov 7 21:56:41 2016 -0200

    Adicionando arquivo main.c

E agora temos nosso primeiro projeto ou melhor, arquivo sendo versionado com Git e realizando commits.

Considerações finais

Vimos apenas uma ponta desse imenso iceberg que é o Git, e nos limitamos apenas em criar um projeto e inicializar um Git, onde poderíamos ir além, de “clonar” um repositório até mesmo trabalhar com um git remoto como Bitbucket e GitHub entre diversos outros que iremos ver mais a frente.

A ferramenta é mantida sobre a licença GNU GPLv2, e quem tiver curiosidade sobre o nome acesse o Wikipedia que é bem interessante.