Versão ALPHA! Este artigo está em versão 'Alpha' e, portanto, não foi ainda revisado corretamente

Adicionando arquivos

Introdução

O principal objetivo do Github é lidar com os arquivos enviados pelos desenvolvedores de software. Nada adianta ter uma conta no Github e não saber adicionar arquivos, seja imagem, classes JAVA, arquivos HTML, entre outros.
Mostraremos os procedimentos para inserir um arquivo em um repositório do Github.

Praticando

Depois de ter feito um fork do projeto, antes de adicionarmos arquivos, vamos começar criando uma branch.
Certifique-se de que você está no diretório do projeto: /kdo/projetos/objectos-dojo.

Criando Branches

Podemos entender o conceito de branch, como se traduz do inglês, algo como “ramo” ou “braço do projeto”.

Vamos criar uma branch:

$ git branch novafuncionalidade

Muito bem, sua primeira branch está criada. É importante destacar que no nome da branch sempre deve ter seu login de rede + o número da “atividade” ficando claro o que ela faz.
Exemplo: Usuario_01: novafuncionalidade. Para os exemplos a seguir, omitiremos o nome do usuário.

Agora, execute:

$ git branch

Podemos ver que o comando acima lista todas as branches existentes, e a branch atual aparece com um asterisco. Isso significa que não estamos na branch que acabamos de criar, então vamos trocar de branch:

* master
novafuncionalidade

Para trocar a branch faça:

$ git checkout novafuncionalidade

Para confirmar se estamos nessa branch mesmo, execute novamente:

$ git branch
master
* novafuncionalidade

Agora sim, estamos na branch que desejamos, e podemos trabalhar.

Há como cria a branch e já deixá-la selecionada para uso, assim fazemos os dois passos acima usando apenas uma linha!

$ `git checkout -b novafuncionalidade`

Criando arquivos

Vamos então criar um novo diretório, onde vamos adicionar arquivos. Esse diretório deve ter o nome do projeto, seguido do seu nome de usuário, conforme o comando abaixo. (Execute o comando trocando apenas o nome de usuário, que no meu caso é hescarate)

$ mkdir objectos-dojo-hescarate

Agora entre nesse diretório para adicionarmos arquivos.

$ cd objectos-dojo-hescarate/

É importante que fique claro, que os exercícios que estamos fazendo simulam as atividades básicas do nosso dia-a-dia, criar branches, inserir arquivos em projetos, são coisas que precisamos estar “afiadas”, pois vamos fazer isto com muita frequência. Vamos adicionar um novo arquivo:

$ vi config.txt

Nota: Caso você tenha dificuldades com o VIM. Leia mais aqui.

Digite o código abaixo:

$ git status

Como podemos ver na mensagem abaixo, o git status nos mostra o status do diretório em que estamos trabalhando.

# On branch novafuncionalidade
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	./
nothing added to commit but untracked files present (use "git add" to track)

Podemos ver que existem arquivos que ainda não foram adicionados ao controle de versão, então precisamos adicioná-los:

$ git add config.txt

Agora execute novamente o comando git status:

$ git status
# On branch novafuncionalidade
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	new file:   config.txt
#

Podemos observar então que o arquivo config.txt foi adicionado ao controle de versão, e que existem mudanças a serem enviadas.

NOta: Existe também o git add -i. Com ele você receberá um menu como esse:

*** Commands ***
  1: [s]tatus	  2: [u]pdate	  3: [r]evert	  4: [a]dd untracked
  5: [p]atch	  6: [d]iff	  7: [q]uit	  8: [h]elp
What now> 
           staged     unstaged path

É muito mais interativo executar as operações comuns do git como status, add e diff.

É importante frisar que usá-lo, você terá um maior controle do que será colocado no stage.

Bom, veremos algumas funcionalidades dele ao longo dos artigos Git. No momento utilize a opção 4: [a]dd untracked para ver o seguinte menu:

*** Commands ***
  1: [s]tatus	  2: [u]pdate	  3: [r]evert	  4: [a]dd untracked
  5: [p]atch	  6: [d]iff	  7: [q]uit	  8: [h]elp
What now> 4
  1: [c]onfig.txt
Add untracked>>  

Selecione 1: [c]onfig.txt ou * para adicionar o arquivo ao controle de versão, Aperte Enter e use o q para sair do menu.

Vamos então executar o commit

$ git commit -m "criado o arquivo config.txt"

Mas pra que serve o commit?

O commit seria algo como consolidar ou efetivar as nossas atualizações.

Um detalhe muito importante é o parâmetro -m, que permite inserir uma mensagem no commit.

Mas porque inserir uma mensagem no commit?

Imagine muitos programadores, mandando a toda hora uma atualização para o projeto. Quando você olhar as atualizações de cada um, como será identificado o que cada atualização (commit) fez no projeto?

Para isso, colocamos uma mensagem na hora de fazer o commit. Dessa forma, especificamos o que aquela determinada atualização fez, assim como no commit que fizemos agora a pouco, na mensagem colocamos “criado o arquivo config.txt”, então, se listarmos os commits saberemos exatamente o que cada atualização fez.

Vamos ao Github no fork do nosso projeto. Veja se aparece esse arquivo que acabamos de criar, o config.txt.

Não esqueça que você precisa selecionar a branch na qual está fazendo essas atualizações, como podemos observar na imagem abaixo, provavelmente a branch selecionada deve ser a master, então escolha a branch novaFuncionalidade

selecionando branch

Agora que você selecionou a branch correta, veja se aparece o novo diretório que criamos (objectos-dojo-seu_usuario), e dentro dele o novo arquivo (o config.txt).

Não aparece!?

Porque!?

Bem, como não entramos muito em detalhes sobre o git, provavelmente não citamos que ele é um DVCS (Distributed Version Control Systems), em português, Sistema de Controle de Versão Distribuído. Diferente do Subversion, por exemplo, que é centralizado, os commits que efetuamos no git são apenas locais, ou seja, só na sua máquina.

Mas então, como atualizar com o repositório?

Esse é o nosso próximo passo!

Adicionando arquivos ao Github

Pra adicionar as alterações e/ou criações de arquivos, precisamos do add, commit e push:

$ git push origin novafuncionalidade

Importante: Ao realizar o git push a senha cadastrada anteriormente será solicitada. Digite-a para concluir o push.

Como vc pode observar no comando acima, estamos especificando que o push deve ser apenas na branch novafuncionalidade. Dessa forma o fork original que fizemos do projeto não será alterado, apenas a branch novafuncionalidade.

Agora volte ao Github, e confira se realmente essas atualizações aparecem!

Faça o seguinte, insira uma linha nesse arquivo config.txt

$ echo "inserindo a primeira linha no arquivo" > config.txt

Você lembra qual o próximo passo que devemos dar?

Isso mesmo, verificar o status:

$ git status
# On branch novafuncionalidade
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   config.txt
#
no changes added to commit (use "git add" and/or "git commit -a")

Se preferir, use aqui o git add -i e verá no menu:

           staged     unstaged path
  1:    unchanged        +1/-0 config.txt

*** Commands ***
  1: [s]tatus	  2: [u]pdate	  3: [r]evert	  4: [a]dd untracked
  5: [p]atch	  6: [d]iff	      7: [q]uit	      8: [h]elp
What now> 

Podemos observar que no status aparece que esse arquivo foi modificado, e então precisamos adicionar essa alteração:

$ git add config.txt 

Ou, usando o git add -i, selecione 2: [u]pdate depois aperte Enter para:

*** Commands ***
  1: [s]tatus	  2: [u]pdate	  3: [r]evert	  4: [a]dd untracked
  5: [p]atch	  6: [d]iff	      7: [q]uit	      8: [h]elp
What now> 2
           staged     unstaged path
  1:    unchanged        +1/-0 [c]onfig.txt
Update>> 

E 1 ou * para mandar o config.txt para o sistema seguido de Enter e depois q para finalizar.

Execute o git status novamente:

$ git status
# On branch novafuncionalidade
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	modified:   config.txt

Podemos observar então que as alterações foram adicionadas e podemos efetuar o commit:

$ git commit -m "inserindo a primeira linha no arquivo config.txt"

Lembrando que a mensagem deve ser clara, mostrando o que estamos fazendo nesse commit.

Mas e agora, essa atualização já está disponível lá no Github?

Não? Então o que precisamos fazer em seguida?

Isso mesmo, executar o push:

$ git push origin novafuncionalidade

E agora, se você verificar no Github está atualizado, ok?

Vamos então inserir mais uma linha no arquivo config.txt. Para inserir uma linha depois da última linha que estiver no arquivo, use dois sinais de maior, conforme o comando abaixo:

$ echo "inserindo a segunda linha" >> config.txt

Se você abrir o arquivo, vai observar que a linha inserida ficou abaixo da linha que já estava no arquivo.

Agora, faça os procedimentos que você acabou de aprender, adicione a modificação, faça o commit e envie as alterações através do push.

Adicione agora, uma terceira linha no arquivo:

$ echo "essa é a terceira linha que vou adicionar" >> config.txt 

Se você abrir novamente o arquivo, vai perceber que a nova linha foi inserida abaixo da segunda linha.

E então execute os procedimentos novamente.

Trabalhando em equipe: Adicionando arquivos

Em um ambiente de desenvolvimento de software, várias pessoas podem estar alterando o mesmo projeto no qual você está trabalhando, e uma forma de evitar um pouco os conflitos é trazer essas atualizações do projeto original para o seu fork do projeto, no qual você está trabalhando, antes de implementar novas funcionalidades.

Para ficar mais claro, peça para alguém da sua equipe inserir um novo arquivo no projeto original, que deve ser chamado de novafuncionalidade.txt, seguido do nome de usuário de quem for criar esse arquivo (no meu caso ficou novafuncionalidade_hescarate.txt).

A idéia de inserir esse arquivo, é simular como se realmente fosse uma nova funcionalidade no projeto, como uma nova classe, interface, etc. Como comentamos acima, num ambiente de desenvolvimento de software isto acontece com muita frequência, pois várias pessoas estão trabalhando em um projeto ao mesmo tempo.

Feito isso, vamos usar o pull, para trazer as novas atualizações do projeto original para o nosso fork do projeto.

Como estamos trabalhando com a branch novafuncionalidade, se executamos o pull, receberemos as atualizações do nosso próprio fork do projeto, e esse não é o nosso objetivo agora, e sim trazer as atualizações do projeto original.

Vamos então para a branch master ( fork do nosso projeto):

$ git checkout master

E como então trazer as atualizações do projeto original?

Pra isso, é necessário adicionar um outro repositório remoto, que vamos dar o nome de objectos, e a url de onde essas atualizações serão buscadas (do projeto original, de onde fizemos o fork)

$ git remote add objectos git@github.com:objectos/objectos-dojo.git

Em seguida, vamos usar o pull informando que queremos trazer as atualizações do projeto original ( objectos ) para a nossa branch master (o fork que demos do projeto original).

$ git pull objectos master

Agora as atualizações do projeto original vieram para o nosso fork do projeto.

Certo, mas como ficam as atualizações que eu fiz na branch novafuncionalidade (quando criamos o arquivo config.txt)?

Esse é o nosso próximo passo!

Volte então para a branch novafuncionalidade:

$ git checkout novafuncionalidade

Agora precisamos atualizar o fork do projeto ( master ) com a nova funcionalidade criada na branch novafuncionalidade, pra isso vamos usar o merge:

$ git merge master
Updating e78af0d..91ab9cd
Fast-forward
novafuncionalidade_usuário.txt |    3 +++
1 files changed, 3 insertions(+), 0 deletions(-)
create mode 100644 config.txt

O merge converte as mudanças feitas na branch, nesse caso a master, para a branch a qual que você está executando o comando.

Agora se você verificar os arquivos contidos na branch novafuncionalidade, vai ver que a nova funcionalidade inserida lá no projeto original pelo seu colega de equipe (o arquivo novafuncionalidade_usuário.txt) aparece na sua branch, pois usamos o merge.

Vá ao Github, no fork do seu projeto, e veja se as atualizações da branch novafuncionalidade (novo diretório criado objectos-dojo-seu-usuário mais o arquivo config.txt) estão na sua branch master.

Não? Porque?

É necessário agora fazer um merge da master com novafuncionalidade, e um push dele para origin (a fork do projeto).

Vamos então voltar para a branch master:

$ git checkout master

E então vamos fazer o merge:

$ git merge novafuncionalidade

Por fim, vamos mandar as atualizações da nossa branch master.

$ git push origin master

Vá ao Github e veja se as atualizações realmente estão na branch master.

Certo, agora que você fez o merge, não vamos mais precisar da branch novafuncionalidade. Então podemos excluí-la.

Primeiro vamos excluir localmente, mas pra isso você precisa ir para a branch master, caso não esteja nela:

$ git branch -d novafuncionalidade
Deleted branch novafuncionalidade (was cb80eee).

E agora vamos excluir remotamente:

$ git push origin :novafuncionalidade
To git@github.com:hescarate/objectos-dojo.git
 - [deleted]         novafuncionalidade

Pronto, sua branch foi excluída!


 
 

objectos, Fábrica de Software LTDA

  • R. Demóstenes, 627. cj 123
  • 04614-013 - Campo Belo
  • São Paulo - SP - Brasil
  • +55 11 5093-8640
  • +55 11 2359-8699
  • contato@objectos.com.br