version-control and - Git para iniciantes:o guia prático definitivo





github comando (25)


Um bom artigo para entender como o Git funciona é The Git Parable . Muito recomendado!

Ok, depois de ver este post por PJ Hyett , decidi pular para o final e ir com o Git .

Então, o que eu preciso é de um guia prático para iniciantes do Git. "Iniciante" sendo definido como alguém que sabe como lidar com seu compilador, entende em algum nível o que é um Makefile e tocou no controle de código-fonte sem compreendê-lo muito bem.

"Prático" sendo definido como essa pessoa não quer entrar em detalhes sobre o que o Git está fazendo em segundo plano, e nem se importa (ou sabe) que é distribuído. Suas respostas podem sugerir as possibilidades, mas tente apontar para o iniciante que deseja manter um repositório 'principal' em um 'servidor' que seja armazenado em backup e seguro, e tratar seu repositório local como meramente um recurso 'cliente'.

Assim:

Instalação / Configuração

Trabalhando com o código

Marcação, ramificação, releases, linhas de base

De outros

  • Descreva e crie um link para uma boa GUI, um plugin IDE, etc., que torne o Git um recurso de linha de não-comando, mas, por favor, liste suas limitações bem como as boas.
    • msysgit - Plataforma cruzada, incluída com o Git
    • msysgit - Visualizador de histórico entre plataformas, incluído no Git
    • msysgit - Mac OS X
    • msysgit - visualizador de histórico do Mac OS X
    • msysgit - Plataforma cruzada, comercial, beta
    • GUI do console do tig para Linux
    • qgit - GUI para Windows, Linux
    • msysgit - pacote para Windows, inclui amigável GUI
  • Quaisquer outras tarefas comuns que um iniciante deve saber?
  • Como trabalho efetivamente com um repositório subversion definido como minha fonte de controle de origem?

Outras referências do Git para iniciantes

Investigando no Git

Eu irei através das entradas de tempos em tempos e 'arrume' elas para que elas tenham uma aparência consistente e seja fácil escanear a lista - sinta-se à vontade para seguir um simples "cabeçalho - breve explicação - lista de instruções - dicas e informação extra "modelo. Eu também vou ligar para as entradas da lista de marcadores acima, então é fácil encontrá-las mais tarde.




git status é seu amigo, use-o com frequência. Bom para responder a perguntas como:

  • O que esse comando acabou de fazer?
  • Em que ramo estou?
  • Que mudanças estou prestes a cometer e esqueci-me de alguma coisa?
  • Eu estava no meio de algo da última vez que trabalhei neste projeto (dias, semanas ou talvez meses atrás)?

Ao contrário, digamos, o svn status , o svn status git status é executado quase instantaneamente, mesmo em grandes projetos. Muitas vezes eu achei reconfortante enquanto aprendia a usá-lo com frequência, para ter certeza de que meu modelo mental do que estava acontecendo era preciso. Agora eu principalmente uso para me lembrar o que eu mudei desde o meu último commit.

Obviamente, é muito mais útil se o seu .gitignore estiver bem configurado.




Como excluo uma ramificação em um repositório remoto?

Execute um empurrão no seu controle remoto usando :antes do nome do ramo

git push origin :mybranchname

sendo origino nome do seu controle remoto e mybranchnameo nome do ramo prestes a ser excluído

http://help.github.com/remotes/




Aqui está uma cópia da postagem de PJ Hyett, já que não está mais disponível:

Git não é difícil

23 de novembro de 2008

Quando nós dizemos às pessoas porque elas deveriam usar o Git através do Subversion, a linha de acesso é “O Git faz o Subversion melhor que o Subversion, mas faz muito mais do que isso”.

O “muito mais” é composto por um monte de coisas que fazem o Git realmente brilhar, mas pode ser bem impressionante para aqueles que vêm de outros SCMs como o Subversion.

Dito isso, não há nada que impeça você de usar o Git como você usa o Subversion enquanto faz a transição.

Supondo que você tenha instalado o software necessário e tenha um repositório remoto em algum lugar, é assim que você pegaria o código e enviaria suas alterações de volta com o Subversion:

$ svn checkout svn://foo.googlecode.com/svn/trunk foo
# make your changes
$ svn commit -m "my first commit"

E como você faria isso no Git:

$ git clone [email protected]:pjhyett/foo.git
# make your changes
$ git commit -a -m "my first commit"
$ git push

Mais um comando para que isso aconteça no Git. Esse comando extra tem grandes implicações, mas, para os propósitos deste post, é só isso que estamos falando, um comando extra.

Veja, realmente não é tão difícil.

Atualização: Eu seria omisso em não mencionar também que o equivalente a atualizar sua cópia local no Subversion comparado ao Git é svn update e git pull , respectivamente. Apenas um comando em ambos os casos.




Como você se ramifica?

A ramificação padrão em um repositório git é chamada master.

Para criar um novo uso de ramificação

git branch <branch-name>

Para ver uma lista de todas as ramificações no tipo de repositório atual

git branch

Se você quiser mudar para outro ramo, você pode usar

git checkout <branch-name>

Para criar uma nova ramificação e mudar para ela em uma única etapa

git checkout -b <branch-name>

Para excluir uma ramificação, use

git branch -d <branch-name>

Para criar uma ramificação com as alterações da ramificação atual, faça

git stash
git stash branch <branch-name>



Como você compara duas revisões de um arquivo ou seu arquivo atual e uma revisão anterior?

Compare o comando é git diff.

Para comparar duas revisões de um arquivo:

$ git diff <commit1> <commit2> <file_name>

Isso difere commit1 contra commit2; Se você alterar a ordem, os arquivos serão divididos ao contrário, o que pode não ser o esperado ...

Para comparar o arquivo preparado atualmente com o repositório:

$ git diff --staged <file_name>

Para comparar o arquivo atual não sincronizado com o repositório:

$ git diff <file_name>



Como configurá-lo para ignorar arquivos:

A habilidade de fazer com que o git ignore arquivos que você não deseja rastrear é muito útil.

Para ignorar um arquivo ou conjunto de arquivos, você fornece um padrão. A sintaxe padrão do git é bastante simples, mas poderosa. É aplicável a todos os três arquivos diferentes que mencionarei abaixo.

  • Uma linha em branco não ignora arquivos, geralmente é usada como um separador.
  • Linhas com # servem como comentários.
  • O ! prefixo é opcional e negará o padrão. Qualquer padrão negado que corresponda substituirá os padrões de precedência mais baixos.
  • Suporta expressões avançadas e curingas
    • Ex: O padrão: *. [Oa] irá ignorar todos os arquivos no repositório terminados em .o ou .a (arquivos de objetos e arquivos)
  • Se um padrão tiver um diretório que termine com um slit git, ele corresponderá apenas a esse diretório e a caminhos abaixo dele. Isso exclui arquivos regulares e links simbólicos da partida.
  • Uma barra inicial corresponderá a todos os arquivos nesse nome de caminho.
    • Ex: O padrão /*.c irá corresponder ao arquivo foo.c mas não bar / awesome.c

Ótimo exemplo da página gitignore(5) do gitignore(5) :

$ git status
[...]
# Untracked files:
[...]
#       Documentation/foo.html
#       Documentation/gitignore.html
#       file.o
#       lib.a
#       src/internal.o
[...]
$ cat .git/info/exclude
  # ignore objects and archives, anywhere in the tree.
  *.[oa]
$ cat Documentation/.gitignore
# ignore generated html files,
*.html
# except foo.html which is maintained by hand
!foo.html
$ git status
[...]
# Untracked files:
[...]
#       Documentation/foo.html
[...]

Geralmente, existem três maneiras diferentes de ignorar arquivos não acompanhados.

1) Ignorar para todos os usuários do repositório:

Adicione um arquivo chamado .gitignore à raiz da sua cópia de trabalho.

Edite .gitignore para corresponder às suas preferências para quais arquivos devem / não devem ser ignorados.

git add .gitignore 

e comprometer quando estiver pronto.

2) Ignore apenas sua cópia do repositório:

Adicione / Edite o arquivo $ GIT_DIR / info / exclude em sua cópia de trabalho, com seus padrões preferidos.

Ex: Minha cópia de trabalho é ~ / src / project1, então eu editaria ~ / src / project1 / .git / info / exclude

Você está feito!

3) Ignore em todas as situações, no seu sistema:

Global ignore padrões para o seu sistema pode ir em um arquivo chamado o que você quiser.

O meu pessoalmente é chamado ~ / .gitglobalignore

Eu posso então deixar o git saber deste arquivo editando meu arquivo ~ / .gitconfig com a seguinte linha:

core.excludesfile = ~/.gitglobalignore

Você está feito!

Eu acho a página man do gitignore(5) como o melhor recurso para mais informações.




Git Reset

Digamos que você faça um pull, mescle-o em seu código e decida que não gosta dele. Use o git-log, ou tig, e encontre o hash de onde quer que você queira voltar (provavelmente seu último commit antes do pull / merge) copie o hash, e faça:

# Revert to a previous commit by hash:
git-reset --hard <hash>

Em vez do hash, você pode usar HEAD ^ como um atalho para o commit anterior.

# Revert to previous commit:
git-reset --hard HEAD^



Como você mescla filiais?

Se você quiser mesclar uma ramificação (por exemplo, masterpara release), certifique-se de que sua ramificação atual seja a ramificação de destino na qual você deseja mesclar (use git branchou git statuspara ver sua ramificação atual).

Então use

git merge master

(onde masteré o nome do ramo que você deseja mesclar com o ramo atual).

Se houver algum conflito, você pode usar

git diff

para ver conflitos pendentes que você precisa resolver.




Como posso criar uma filial em um repositório remoto?

Supondo que você tenha clonado seu repositório remoto a partir de algum repositório remoto único.

# create a new branch locally
git branch name_of_branch
git checkout name_of_branch
# edit/add/remove files    
# ... 
# Commit your changes locally
git add fileName
git commit -m Message
# push changes and new branch to remote repository:
git push origin name_of_branch:name_of_branch



Como instalar o Git

No Windows:

Instale o msysgit

Existem vários downloads:

  • Git: Use isso, a menos que você especificamente precise de uma das outras opções abaixo.
  • PortableGit: Use isto se você quer rodar o Git em um PC sem instalar no PC (por exemplo, rodando o Git de um drive USB)
  • msysGit: Use isto se você quiser desenvolver o próprio Git. Se você quer apenas usar o Git para o seu código-fonte, mas não quer editar o código-fonte do Git , você não precisa disso.

Isto também instala um shell bash do Cygwin, assim você pode usar o git em um shell mais bonito (que o cmd.exe), e também inclui git-gui (acessível via git gui , ou o menu Start > All Programs > Git )

Mac OS X

Use o git-osx-installer , ou você também pode instalar a partir da fonte

Através de um gerenciador de pacotes

Instale o git usando seu gerenciador de pacotes nativo. Por exemplo, no Debian (ou Ubuntu):

apt-get install git-core

Ou no Mac OS X, via MacPorts :

sudo port install git-core+bash_completion+doc

… Ou fink:

fink install git

… Ou Homebrew :

brew install git

Em distribuições baseadas no Red Hat, como o Fedora:

yum install git

No Cygwin, o pacote Git pode ser encontrado na seção "devel"

Da fonte (Mac OS X / Linux / BSD / etc.)

No Mac OS X, se você tiver as Ferramentas de Desenvolvedor instaladas, poderá compilar o Git a partir do código-fonte com muita facilidade. Faça o download da versão mais recente do Git como .tar.bz ou .tar.gz de http://git-scm.com/ e extraia-a (clique duas vezes no Finder)

No Linux / BSD / etc. deveria ser o mesmo. Por exemplo, no Debian (e no Ubuntu), você precisa instalar o pacote build-essential via apt .

Em seguida, em um terminal, cd para onde você extraiu os arquivos (Running cd ~/Downloads/git*/ deve funcionar) e, em seguida, execute ..

./configure && make && sudo make install

Isto irá instalar o Git no lugar padrão ( /usr/local - assim o git estará em /usr/local/bin/git )

Ele solicitará que você digite sua senha (para sudo ), isso é para que ele possa gravar no /usr/local/ , que só pode ser acessado pelo usuário "root", então o sudo é necessário!

Se você quiser instalá-lo em algum lugar separado (para que os arquivos do Git não sejam misturados com outras ferramentas), use --prefix com o comando configure:

./configure --prefix=/usr/local/gitpath
make
sudo make install

Isto irá instalar o binário do git em /usr/local/bin/gitpath/bin/git - assim você não precisa digitar isso toda vez que você, você deve adicionar em seu $PATH adicionando a seguinte linha no seu ~/.profile :

export PATH="${PATH}:/usr/local/bin/gitpath/bin/"

Se você não tem acesso ao sudo, você pode usar --prefix=/Users/myusername/bin e instalar em seu diretório home. Lembre-se de adicionar ~/bin/ a $PATH

O script x-git-update-to-latest-version automatiza muito isso:

Este script atualiza meu clone local do repositório git (localy em ~/work/track/git ), e então configura, instala (em /usr/local/git - git describe ) e atualiza o link simbólico /usr/local/git .

Dessa forma, eu posso ter /usr/local/git/bin no meu PATH e estou sempre usando a última versão.

A versão mais recente deste script também instala as páginas do manual. Você precisa ajustar o seu MANPATH para incluir o /usr/local/git/share/man .




Empurre e puxe as mudanças

De uma forma simplificada, basta fazer git pushe git pull. As mudanças são mescladas e se houver um conflito, o git informará e você poderá resolvê-lo manualmente.

Quando você envia primeiro para um repositório remoto, você precisa fazer um git push origin master(mestre sendo o ramo mestre). A partir de então você apenas faz o git push.

Empurre tags com git push --tags.







UI do console - Tig

Instalação:

apt-get install tig

Uso

Enquanto dentro de um repositório git, digite 'tig', para visualizar um log interativo, pressione 'enter' em qualquer log para ver mais informações sobre ele. h para ajuda, que lista a funcionalidade básica.

Trivialidades

"Tig" é "Git" para trás.




Como você vê o histórico das revisões de um arquivo?

git log -- filename



Confirmar alterações

Depois de editar um arquivo, você precisa confirmar suas alterações no git. Quando você executa este comando, ele pede por uma mensagem de commit - que é apenas um simples pedaço de texto que diz a todos o que você mudou.

$ git commit source/main.c

Irá cometer o arquivo main.c no diretório ./source/

$ git commit -a # the -a flag pulls in all modified files

irá comprometer todos os arquivos alterados (mas não novos arquivos, eles precisam ser adicionados ao índice com git-add). Se você quer cometer apenas alguns arquivos, então você precisará encená-los primeiro com git-add e, em seguida, confirmar sem o sinalizador -a.

O commit apenas altera seu repositório local, embora não os repositórios remotos. Se você quiser enviar os commits para o repositório remoto, então você precisará fazer um push.

$ git push <remote> <branch> # push new commits to the <branch> on the <remote> repository

Para alguém vindo do CVS ou do SVN, isso é uma mudança, pois o commit no repositório central agora requer duas etapas.




Como você cria um novo projeto / repositório?

Um repositório git é simplesmente um diretório contendo um diretório especial .git .

Isso é diferente dos sistemas de controle de versão "centralizados" (como o subversion), em que um "repositório" é hospedado em um servidor remoto, que você checkout em um diretório "cópia de trabalho". Com o git, sua cópia de trabalho é o repositório.

Basta executar git init no diretório que contém os arquivos que você deseja rastrear.

Por exemplo,

cd ~/code/project001/
git init

Isso cria uma pasta .git (oculta) no diretório atual.

Para fazer um novo projeto, execute git init com um argumento adicional (o nome do diretório a ser criado):

git init project002

(This is equivalent to: mkdir project002 && cd project002 && git init)

Para verificar se o caminho atual atual está dentro de um repositório git, simplesmente execute git status - se não for um repositório, ele reportará "fatal: não um repositório git"

Você também pode listar o diretório .git e verificar se ele contém arquivos / diretórios semelhantes ao seguinte:

$ ls .git
HEAD         config       hooks/       objects/
branches/    description  info/        refs/

Se, por qualquer motivo, você desejar "desativar" um repositório (você deseja parar de usar o git para rastrear esse projeto). Simplesmente remova o diretório .git no nível base do repositório.

cd ~/code/project001/
rm -rf .git/

Cuidado: Isso destruirá todo o histórico de revisão, todas as suas tags, tudo que o git fez. Ele não tocará nos arquivos "atuais" (os arquivos que você pode ver no momento), mas as alterações anteriores, os arquivos excluídos e assim por diante serão irrecuperáveis!




Eu comecei com o tutorial oficial do Git . Eu acho que é prático o suficiente para iniciantes (eu era, e ainda sou, um iniciante, pela sua definição! Eu mal compreendo makefiles, eu apenas joguei um pouco com o Apache Subversion, etc.).




Como rastrear filiais remotas

Supondo que haja um repositório remoto do qual você clonou seu repositório local e também assumindo que existe uma ramificação chamada 'some_branch' nesse repositório remoto, veja como rastreá-lo localmente:

# list remote branches
git branch -r

# start tracking one remote branch
git branch --track some_branch origin/some_branch

# change to the branch locally
git checkout some_branch

# make changes and commit them locally
....

# push your changes to the remote repository:
git push



Por que ainda outro howto? Há realmente bons na net, como o guia git que é perfeito para começar. Ele tem bons links, incluindo o git book para o qual alguém pode contribuir (hospedado no git hub) e que é perfeito para essa tarefa coletiva.

No , eu realmente prefiro ver seus truques favoritos!

O meu, que eu descobri apenas ultimamente, é git stash, explicado here , o que lhe permite salvar seu trabalho atual e ir para outro ramo

EDIT: como o post anterior, se você realmente preferir o formato stackoverlow com posts como um wiki vou apagar esta resposta







Verificando Código

Primeiro, vá para um diretório vazio, use "git init" para torná-lo um repositório e, em seguida, clone o repositório remoto no seu próprio.

git clone [email protected]:/dir/to/repo

Onde quer que você inicialmente clonar é onde "git pull" irá puxar por padrão.




Obtendo o código mais recente

$ git pull <remote> <branch> # fetches the code and merges it into 
                             # your working directory
$ git fetch <remote> <branch> # fetches the code but does not merge
                              # it into your working directory

$ git pull --tag <remote> <branch> # same as above but fetch tags as well
$ git fetch --tag <remote> <branch> # you get the idea

Isso cobre praticamente todos os casos para obter a cópia mais recente do código do repositório remoto.




O livro gratuito Pro Git é definitivamente o meu favorito, especialmente para iniciantes.




Use reflog para encontrar um estado correto

git reflog

REFLOG ANTES DE REINICIAR

Selecione o reflog correto (f3cb6e2 no meu caso) e digite

git reset --hard f3cb6e2

Depois disso, o reporte HEAD será reposto para o HEADid LOG APÓS RESET

Finalmente o reflog parece com a imagem abaixo

REFLOG FINAL





git version-control