objectos dojô :: Adicionando arquivos
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.
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.
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.
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:
novafuncionalidade
Para trocar a branch faça:
$ git checkout novafuncionalidade
Para confirmar se estamos nessa branch mesmo, execute novamente:
* 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`
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:
Nota: Caso você tenha dificuldades com o VIM. Leia mais aqui.
Como podemos ver na mensagem abaixo, o git status nos mostra o status do diretório em que estamos trabalhando.
# On branch novafuncionalidade
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:
#	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:
É 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:
1: [c]onfig.txt
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
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!?
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:
#	modified:   config.txt
Se preferir, use aqui o git add -i e verá no menu:
1:    unchanged        +1/-0 config.txt
5: [p]atch	  6: [d]iff	      7: [q]uit	      8: [h]elp
Podemos observar que no status aparece que esse arquivo foi modificado, e então precisamos adicionar essa alteração:
Ou, usando o git add -i, selecione 2: [u]pdate depois aperte Enter para:
1:    unchanged        +1/-0 [c]onfig.txt
E 1 ou * para mandar o config.txt para o sistema seguido de Enter e depois q para finalizar.
Execute o git status novamente:
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:
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):
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)?
Volte então para a branch novafuncionalidade:
Agora precisamos atualizar o fork do projeto ( master ) com a nova funcionalidade criada na branch novafuncionalidade, pra isso vamos usar o merge:
Updating e78af0d..91ab9cd
novafuncionalidade_usuário.txt |    3 +++
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.
É 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:
E então vamos fazer o merge:
$ git merge novafuncionalidade
Por fim, vamos mandar as atualizações da nossa branch 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: