Ok, depois de ver este post de PJ Hyett , decidi pular para o final e seguir 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 origem sem entendê-lo muito bem.

"Prático" sendo definido, pois essa pessoa não deseja obter muitos detalhes sobre o que o Git está fazendo em segundo plano e nem se importa (ou sabe) que ele é distribuído. Suas respostas podem sugerir as possibilidades, mas tente apontar para o iniciante que deseja manter um repositório 'principal' em um 'servidor' com backup e segurança, e tratar o repositório local como apenas um recurso 'cliente'.

Assim:

Instalação / Configuração

• Como instalar o Git
• Como você configura o Git? Tente cobrir o Linux, Windows, Mac e pense na mentalidade de 'cliente / servidor'.
  • Configurar servidor GIT com Msysgit no Windows
• Como você cria um novo projeto / repositório?
• Como você o configura para ignorar arquivos (.obj, .user, etc) que não fazem realmente parte da base de código?

Trabalhando com o código

• Como você obtém o código mais recente?
• Como você verifica o código?
• Como você confirma alterações?
• Como você vê o que não foi confirmado ou o status da sua base de código atual?
• Como você destrói confirmações indesejadas?
• Como você compara duas revisões de um arquivo ou seu arquivo atual e uma revisão anterior?
• Como você vê o histórico de revisões em um arquivo?
• Como você lida com arquivos binários (documentos do Visio, por exemplo, ou ambientes de compilador)?
• Como você mescla arquivos alterados ao "mesmo tempo"?
• Como você desfaz (reverte ou redefine) uma confirmação?

Etiquetagem, ramificação, lançamentos, linhas de base

• Como você 'marca' 'marca' ou 'libera' um conjunto específico de revisões para um conjunto específico de arquivos, para que você possa fazer isso posteriormente mais tarde?
• Como você puxa um 'release' específico?
• Como você se ramifica?
• Como você mescla ramificações?
• Como você resolve conflitos e conclui a mesclagem?
• Como você mescla partes de um ramo em outro ramo?
• O que é rebasing?
• Como rastreio ramificações remotas?
• Como posso criar uma ramificação em um repositório remoto?
• Como faço para excluir uma ramificação em um repositório remoto?
• Exemplos de fluxo de trabalho Git

De outros

• Descreva e vincule a uma boa interface gráfica do usuário, plug-in IDE etc. que faça do Git um recurso que não seja da linha de comando, mas liste suas limitações e suas vantagens.
  • msysgit - Plataforma cruzada, incluída no Git
  • gitk - Visualizador de histórico de várias plataformas, incluído no Git
  • gitnub - Mac OS X
  • gitx - Visualizador de histórico do Mac OS X
  • smartgit - Plataforma cruzada, comercial, beta
  • tig - GUI do console para Linux
  • qgit - GUI para Windows, Linux
  • Extensões Git - pacote para Windows, inclui interface gráfica amigável
• Quaisquer outras tarefas comuns que um iniciante deve saber?
  • O Status do Git informa o que você acabou de fazer, qual filial você possui e outras informações úteis
• Como trabalho efetivamente com um repositório do subversion definido como minha fonte de controle de origem?

Outras referências para iniciantes do Git

• Guia Git
• Livro Git
• Git magic
• gitcasts
• Guias do GitHub
• Tutorial do Git
• Progit - livro de Scott Chacon
• Git - Curso de Bater SVN
• Git de baixo para cima
• Pronto para Git
• gitref.org
• Cheatsheet visual do Git

Investigando o Git

• Entendendo o Git conceitualmente
• Git para cientistas da computação (e outra versão )

Examinarei as entradas de vez em quando e as arrumo para que elas tenham uma aparência consistente e seja fácil escanear a lista - fique à vontade para seguir um simples "cabeçalho - breve explicação - lista de instruções - dicas e truques e modelo de informação extra ". Também vou vincular as entradas da lista de marcadores acima, para que seja fácil encontrá-las mais tarde.

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

Um repositório git é simplesmente um diretório que contém um .gitdiretório especial .

Isso é diferente dos sistemas de controle de versão "centralizados" (como o subversion), onde um "repositório" está hospedado em um servidor remoto, no qual você fica no checkoutdiretório "cópia de trabalho". Com o git, sua cópia de trabalho é o repositório.

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

Por exemplo,

cd ~/code/project001/
git init

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

Para criar um novo projeto, execute git initcom 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, basta executar git status- se não for um repositório, ele relatará "fatal: Não é um repositório git"

Você também pode listar o .gitdiretório 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 "desgit" um repositório (você deseja parar de usar o git para rastrear esse projeto). Simplesmente remova o .gitdiretório no nível base do repositório.

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

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

GUIs para git

GUI do Git

Incluído no git - Execute a git guipartir da linha de comando e o instalador do msysgit do Windows o adiciona ao menu Iniciar.

A GUI do Git pode fazer a maioria do que você precisa fazer com o git. Incluindo mudanças de estágio, configurar git e repositórios, enviar alterações, criar / efetuar checkout / excluir ramificações, mesclar e muitas outras coisas.

Um dos meus recursos favoritos é o atalho "line line" e "stage hunk" no menu do botão direito do mouse, que permite confirmar partes específicas de um arquivo. Você pode conseguir o mesmo via git add -i, mas acho mais fácil de usar.

Não é o aplicativo mais bonito, mas funciona em quase todas as plataformas (baseado no Tcl / Tk)

Screenshots | um screencast

GitK

Também incluído no git. É um visualizador de histórico do git e permite visualizar o histórico de um repositório (incluindo ramificações, quando elas são criadas e mescladas). Você pode visualizar e pesquisar confirmações.

Combina bem com o git-gui.

Gitnub

Aplicativo Mac OS X. Principalmente equivalente git log, mas possui alguma integração com o github (como a "Visualização de rede").

Parece bonito e se encaixa no Mac OS X. Você pode pesquisar repositórios. A maior crítica do Gitnub é que ele mostra a história de maneira linear (um único ramo de cada vez) - ele não visualiza ramificações e mesclagens, o que pode ser importante com o git, embora essa seja uma melhoria planejada.

Links para download, registro de alterações e capturas de tela | repositório git

GitX

Pretende ser um "clone do gitk para OS X".

Ele pode visualizar o histórico de ramificações não lineares, executar confirmações, visualizar e pesquisar confirmações e possui alguns outros recursos interessantes, como "Quicklook" de qualquer arquivo em qualquer revisão (espaço de imprensa na exibição da lista de arquivos), exportar qualquer arquivo (via arrastar e soltar).

É muito melhor integrado ao OS X do que git-gui/ gitke é rápido e estável, mesmo com repositórios excepcionalmente grandes.

O pieter original do repositório git não foi atualizado recentemente (mais de um ano no momento da escrita). Uma ramificação com manutenção mais ativa está disponível no brotherbard / gitx - ele adiciona "barra lateral, busca, puxa, empurra, adiciona controle remoto, mescla, seleciona cereja, rebase, clona, ​​clona para"

Download | Screenshots | repositório git | garfo irmãozinho | garfo de laullon

SmartGit

Na página inicial:

O SmartGit é um front-end para o sistema de controle de versão distribuído Git e é executado no Windows, Mac OS X e Linux. O SmartGit é destinado a desenvolvedores que preferem uma interface gráfica do usuário a um cliente de linha de comando, para serem ainda mais produtivos com o Git - o DVCS mais poderoso da atualidade.

Você pode baixá-lo no site deles .

Baixar

TortoiseGit

Versão do TortoiseSVN Git para usuários do Windows.

Ele está portando o TortoiseSVN para o TortoiseGit A versão mais recente 1.2.1.0 Esta versão pode concluir tarefas regulares, como commit, show log, diff duas versões, criação de ramo e tag, criação de patch e assim por diante. Veja ReleaseNotes para detalhes. Bem-vindo a contribuir com este projeto.

Baixar

QGit

O QGit é um visualizador da GUI do git, construído em Qt / C ++.

Com o qgit, você poderá navegar no histórico de revisões, visualizar o conteúdo do patch e os arquivos alterados, seguindo graficamente diferentes ramos de desenvolvimento.

Baixar

gitg

O gitg é um visualizador de repositório git direcionado ao gtk + / GNOME. Um de seus principais objetivos é fornecer uma experiência de usuário mais unificada para front-ends do git em vários desktops. Isso não é escrever um aplicativo de plataforma cruzada, mas colaborar estreitamente com clientes semelhantes para outros sistemas operacionais (como o GitX for OS X).

Recursos

• Navegue pelo histórico de revisões.
• Manipule repositórios grandes (carrega o repositório linux, mais de 17000 revisões, em menos de 1 segundo).
• Confirmar as alterações.
• Encenar / desmontar pedaços individuais.
• Reverter alterações.
• Mostrar diferenças coloridas das alterações nas revisões.
• Navegue na árvore para uma determinada revisão.
• Exporte partes da árvore de uma determinada revisão.
• Forneça qualquer refspec que um comando como 'git log' possa entender para construir o histórico.
• Mostrar e alternar entre ramificações na exibição do histórico.

Download: releases ou fonte

Gitbox

O Gitbox é uma interface gráfica do Mac OS X para o sistema de controle de versão do Git. Em uma única janela, você vê ramificações, histórico e status do diretório de trabalho.

As operações diárias são fáceis: mudanças de palco e de palco com uma caixa de seleção. Confirmar, puxar, mesclar e empurrar com um único clique. Clique duas vezes em uma alteração para mostrar um diff com FileMerge.app.

Baixar

Gity

O site da Gity não tem muita informação, mas a partir das capturas de tela, parece ser um recurso rico em código aberto do OS X git gui.

Download ou fonte

Meld

Meld é uma ferramenta visual de diferenças e mesclagem. Você pode comparar dois ou três arquivos e editá-los no local (as atualizações diferem dinamicamente). Você pode comparar duas ou três pastas e iniciar comparações de arquivos. Você pode navegar e visualizar uma cópia de trabalho de sistemas populares de controle de versão, como CVS, Subversion, Bazaar-ng e Mercurial [ e Git ].

Transferências

Katana

Uma GUI do Git para OSX de Steve Dekorte.

De relance, veja quais ramificações remotas têm alterações para puxar e repositórios locais têm alterações para empurrar. As operações git de adicionar, confirmar, empurrar, puxar, marcar e redefinir são suportadas, bem como diferenças visuais e navegação visual da hierarquia do projeto que destaca alterações e adições locais.

Grátis para 1 repositório, US $ 25 para mais.

Baixar

Sprout (anteriormente GitMac)

Concentra-se em tornar o Git fácil de usar. Apresenta uma interface de usuário nativa do Cocoa (semelhante a mac), navegação rápida no repositório, clonagem, push / pull, ramificação / fusão, visual diff, ramificações remotas, fácil acesso ao Terminal e muito mais.

Ao tornar as ações do Git mais usadas intuitivas e fáceis de executar, o Sprout (anteriormente GitMac) torna o Git fácil de usar. Compatível com a maioria dos fluxos de trabalho do Git, o Sprout é ótimo para designers e desenvolvedores, colaboração em equipe e usuários avançados e iniciantes.

Download | Local na rede Internet

Torre

Uma GUI Git rica em recursos para Mac OSX. Avaliação gratuita de 30 dias, US $ 59USD para uma licença de usuário único.

Download | Local na rede Internet

EGit

EGit é um provedor Eclipse Team para o sistema de controle de versão Git. O Git é um SCM distribuído, o que significa que todo desenvolvedor tem uma cópia completa de todo o histórico de todas as revisões do código, fazendo consultas contra o histórico muito rápido e versátil.

O projeto EGit está implementando as ferramentas Eclipse sobre a implementação JGit Java do Git.

Download | Local na rede Internet

Extensões Git

Código aberto para Windows - instala tudo o que você precisa para trabalhar com o Git em um único pacote, fácil de usar.

O Git Extensions é um kit de ferramentas para tornar o trabalho com o Git no Windows mais intuitivo. A extensão do shell será integrada no Windows Explorer e apresenta um menu de contexto em arquivos e diretórios. Há também um plug-in do Visual Studio para usar o git do Visual Studio.

Baixar

Muito obrigado ao dbr por elaborar o material do git gui.

SourceTree

O SourceTree é um cliente Mac gratuito para Git, Mercurial e SVN. Construído pela Atlassian, o pessoal por trás do BitBucket, parece funcionar igualmente bem com qualquer sistema de VC, o que permite que você domine uma única ferramenta para uso em todos os seus projetos, no entanto, eles são controlados por versão. Cheio de recursos e GRÁTIS.

Pronto para especialistas e com muitos recursos para usuários iniciantes e avançados:

Analise os conjuntos de alterações enviados e recebidos. Escolha uma cereja entre os galhos. Manuseio de patch, rebase, stash / shelve e muito mais.

Download | Local na rede Internet

Bem, apesar de você ter solicitado que não "simplesmente" vinculássemos a outros recursos, é uma tolice quando já existe um recurso de comunidade (e crescente) realmente bom: o Git Community Book . Sério, essas 20 perguntas em uma pergunta serão concisas e consistentes. O Git Community Book está disponível como HTML e PDF e responde a muitas de suas perguntas com respostas claras, bem formatadas e revisadas por pares e em um formato que permite que você pule diretamente para o seu problema em questão.

Infelizmente, se minha postagem realmente o incomoda, eu a excluirei. Apenas diga então.

Como configurá-lo para ignorar arquivos:

A capacidade de o git ignorar arquivos que você não deseja que ele rastreie é muito útil.

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

• Uma linha em branco ignora nenhum arquivo, geralmente é usada como um separador.
• As linhas que começam com # servem como comentários.
• O !O prefixo é opcional e negará o padrão. Qualquer padrão negado que corresponda substituirá os padrões de precedência mais baixa.
• Suporta expressões avançadas e curingas
  • Ex: O padrão: *. [Oa] ignorará todos os arquivos no repositório que terminam em .o ou .a (objetos e arquivos archive)
• Se um padrão tiver um diretório que termina com uma barra, o git corresponderá apenas a esse diretório e 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 corresponderá ao arquivo foo.c, mas não bar / awesome.c

Ótimo exemplo da página do manual 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 rastreados.

1) Ignore 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 comprometa-se quando terminar.

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ê Terminou!

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

Os padrões globais de ignorância para o seu sistema podem incluir um arquivo com o nome que você desejar.

O meu pessoalmente se chama ~ / .gitglobalignore

Posso então informar o git desse arquivo editando meu arquivo ~ / .gitconfig com a seguinte linha:

core.excludesfile = ~/.gitglobalignore

Você Terminou!

Acho que a página de manual gitignore é o melhor recurso para obter mais informações.

Como você 'codifica' um conjunto específico de revisões

Como você 'marca' 'marca' ou 'libera' um conjunto específico de revisões para um conjunto específico de arquivos, para que você possa fazer isso posteriormente mais tarde?

Usando o git tag comando

Para simplesmente "marcar" a revisão atual, basta executar ..

git tag -a thetagname
git tag -a 0.1
git tag -a 2.6.1-rc1 -m 'Released on 01/02/03'

Para listar as tags atuais, basta executar git tagsem argumentos ou -l(L minúsculo):

$ git tag -a thetagname # and enter a message, or use -m 'My tag annotation'
$ git tag -l
thetagname

Para excluir uma tag, use o -dsinalizador:

$ git tag -d thetagname 
Deleted tag 'thetagname'
$ git tag
[no output]

Para marcar um commit (anterior) específico, basta fazer ..

git tag [tag name] [revision SHA1 hash]

Por exemplo:

git tag 1.1.1 81b15a68c6c3e71f72e766931df4e6499990385b

Nota: por padrão, o git cria uma tag "leve" (basicamente uma referência a uma revisão específica). O caminho "certo" é usar a -abandeira. Isso iniciará seu editor solicitando uma mensagem de marca (idêntico a pedir uma mensagem de confirmação, você também pode usar o -msinalizador para fornecer a mensagem de marca na linha de comando). O uso de uma tag anotada cria um objeto com seu próprio ID, data, etiquetador (autor) e, opcionalmente, uma assinatura GPG (usando a -stag). Para mais informações sobre isso, consulte este post

git tag mytagwithmsg -a -m 'This is a tag, with message'

E para listar as tags com anotações, use o -n1sinalizador para mostrar 1 linha de cada mensagem de tag ( -n245para mostrar as primeiras 245 linhas de cada anotação e assim por diante):

$ git tag -l -n1
mytagwithmsg    This is a tag, with message

Para mais informações, consulte a página de manual git-tag (1)

Exemplo de fluxo de trabalho com GIT.

O Git é extremamente flexível e se adapta bem a qualquer fluxo de trabalho, mas a não imposição de um fluxo de trabalho específico pode ter o efeito negativo de dificultar a compreensão do que você pode fazer com o git além do fluxo de trabalho linear de "backup" e como a ramificação útil pode ser .

Esta postagem do blog explica muito bem um fluxo de trabalho muito simples, mas eficaz, que é realmente fácil de configurar usando o git.

citando a postagem do blog: Consideramos origem / mestre como o principal ramo em que o código fonte do HEAD sempre reflete um estado pronto para produção:

O fluxo de trabalho tornou-se popular o suficiente para criar um projeto que implementa esse fluxo de trabalho: git-flow

Bela ilustração de um fluxo de trabalho simples, no qual você faz todas as alterações no desenvolvimento e só empurra para o mestre quando o código está em um estado de produção:

Agora, digamos que você queira trabalhar em um novo recurso ou na refatoração de um módulo. Você pode criar um novo ramo, o que poderíamos chamar de ramo "recurso", algo que levará algum tempo e poderá quebrar algum código. Depois que seu recurso estiver "suficientemente estável" e desejar movê-lo para "mais perto" da produção, você mesclará seu ramo de recursos em desenvolvimento. Quando todos os bugs são resolvidos após a mesclagem e seu código passa em todos os testes sólidos, você coloca suas alterações no master.

Durante todo esse processo, você encontra um terrível bug de segurança, que precisa ser corrigido imediatamente. Você pode ter um ramo chamado hotfixes, que faz alterações que são empurradas mais rapidamente para a produção do que o ramo "desenvolvimento" normal.

Aqui você tem uma ilustração de como esse fluxo de trabalho de recurso / hotfix / desenvolvimento / produção pode parecer (bem explicado na postagem do blog, e repito, a postagem do blog explica todo o processo com muito mais detalhes e muito melhor do que eu) .

Aqui está uma cópia do post de PJ Hyett, pois ele não está mais disponível:

Git não é difícil

23 Nov 2008

Quando dizemos às pessoas por que elas deveriam usar o Git sobre o Subversion, a linha seguinte é: "O Git faz o Subversion melhor que o Subversion, mas faz muito mais que isso".

O "muito mais" é composto por um monte de coisas que fazem o Git realmente brilhar, mas pode ser bastante impressionante para quem vem de outros SCMs como o Subversion.

Dito isto, não há nada que o impeça de usar o Git, assim como você usa o Subversion enquanto está fazendo a transição.

Supondo que você instalou o software necessário e tenha um repositório remoto em algum lugar, é assim que você pegaria o código e faria as alterações 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 git@github.com: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, é disso que estamos falando, um comando extra.

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

Atualização: seria negligente também não mencionar que o equivalente a atualizar sua cópia local no Subversion em comparação com o Git é svn updatee git pull, respectivamente. Apenas um comando nos dois casos.

Como instalar o Git

No Windows:

Instale o msysgit

Existem vários downloads:

• Git: use isso, a menos que você precise especificamente de uma das outras opções abaixo.
• PortableGit: use-o se desejar executar o Git em um PC sem instalá-lo (por exemplo, executando o Git a partir de uma unidade USB)
• msysGit: use isso se você quiser desenvolver o próprio Git. Se você deseja apenas usar o Git para o seu código-fonte, mas não deseja editar o código-fonte do Git , não precisa disso.

Isso também instala um shell bash do Cygwin, para que você possa usá-lo gitem um shell mais agradável (que cmd.exe) e também inclui git-gui (acessível via git guicomando ou Start > All Programs > Gitmenu)

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 gitusando 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

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

yum install git

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

De origem (Mac OS X / Linux / BSD / etc.)

No Mac OS X, se você tiver as Ferramentas do Desenvolvedor instaladas, poderá compilar o Git a partir da fonte com muita facilidade. Baixar a última versão do Git como um .tar.bzou .tar.gzde http://git-scm.com/ , e extraí-lo (clique duas vezes no Finder)

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

Em seguida, em um terminal, cdpara onde você extraiu os arquivos (a execução cd ~/Downloads/git*/deve funcionar) e execute ..

./configure && make && sudo make install

Isso instalará o Git no local padrão ( /usr/local- gitestará em/usr/local/bin/git )

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

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

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

Isso instalará o gitbinário no /usr/local/bin/gitpath/bin/git- para que você não precise digitar isso toda vez que for necessário, adicione ao seu $PATHadicionando a seguinte linha ao seu ~/.profile:

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

Se você não tiver acesso ao sudo, poderá usar --prefix=/Users/myusername/bine instalar em seu diretório pessoal. Lembre-se de adicionar ~/bin/a$PATH

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

Esse script atualiza meu clone local do repositório git (localmente em ~/work/track/git) e, em seguida, configura, instala (at /usr/local/git- git describe) e atualiza o /usr/local/gitlink simbólico.

Dessa forma, posso ter /usr/local/git/binno meu PATHe estou sempre usando a versão mais recente.

A versão mais recente desse script também instala as páginas de manual. Você precisa ajustar o seu MANPATHpara incluir o /usr/local/git/share/mandiretório.

Git Reset

Digamos que você faça um puxão, junte-o ao seu código e decida que não gosta. Use git-log, ou tig, e encontre o hash de onde você deseja voltar (provavelmente seu último commit antes da extração / mesclagem), 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ê configura um repositório de equipe compartilhado?

Como configurar um repositório normal é descrito aqui - mas como você configura um repositório de equipe para que todos possam acessar e enviar?

Usando um sistema de arquivos NFS compartilhado

Supondo que sua equipe já tenha, por exemplo, uma associação de grupo compartilhado que possa ser usada.

mkdir /your/share/folder/project.git
cd /your/share/folder/project.git
newgrp yourteamgroup # if necessary
git init --bare --shared

Para começar a usar este repositório, a coisa mais fácil é iniciar a partir de um repositório local que você já esteja usando:

cd your/local/workspace/project
git remote add origin /your/share/folder/project.git
git push origin master

Outros agora podem clonar isso e começar a trabalhar:

cd your/local/workspace
git clone /your/share/folder/project.git

Usando SSH

Configure uma conta de usuário no servidor de destino. Se você usa uma conta sem senha, uma conta com uma senha ou usa authorized_keysrealmente, depende do nível de segurança necessário. Dê uma olhada em Configurando Git sobre SSH para obter mais informações.

Se todos os desenvolvedores usarem a mesma conta para acessar este repositório compartilhado, você não precisará usar a --sharedopção acima.

Depois de inicializar o repositório da mesma maneira que acima, faça o push inicial como este:

cd your/local/workspace/project
git remote add origin user@server:/path/to/project.git
git push origin master

Veja a semelhança com o acima? A única coisa que pode acontecer além disso é o SSH solicitar uma senha se a conta tiver uma senha. Se você receber esse prompt em uma conta sem senha, o servidor SSH provavelmente desabilitouPermitEmptyPasswords .

A clonagem agora se parece com isso:

cd your/local/workspace
git clone user@server:/path/to/project.git

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

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

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

Obviamente, é muito mais útil se o seu .gitignore estiver configurado com segurança.

Confirmar as alterações

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

$ git commit source/main.c

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

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

confirmará todos os arquivos alterados (mas não os novos arquivos, eles precisam ser adicionados ao índice com o git-add). Se você deseja confirmar apenas alguns arquivos, precisará prepará-los primeiro com o git-add e depois confirmar sem o sinalizador -a.

A confirmação apenas altera seu repositório local, embora não os repositórios remotos. Se você deseja enviar as confirmações para o repositório remoto, 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 SVN, isso é uma alteração, pois o commit no repositório central agora requer duas etapas.

Como você se ramifica?

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

Para criar uma nova ramificação, use

git branch <branch-name>

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

git branch

Se você deseja mudar para outro ramo, pode usar

git checkout <branch-name>

Para criar uma nova ramificação e alternar para ela em uma 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>

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 abrange 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.

Git Magic é tudo que você precisa. Garantido ou seu dinheiro de volta!

Como você mescla ramificações?

Se você deseja mesclar uma ramificação (por exemplo, masterpara release), verifique se sua ramificação atual é 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 da ramificação que você deseja mesclar com a ramificação atual).

Se houver algum conflito, você pode usar

git diff

para ver conflitos pendentes que você precisa resolver.

Eu também achei o Git Internals muito útil. Foi escrito por Scott Chacon (autor do Pro Git e mantenedor do Git Community Book). O que eu mais gosto no Git Internals é que ele se concentra nos conceitos primeiro e depois nos comandos , e sendo que são ~ 100 páginas pequenas, é rapidamente digerível.

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

git log -- filename

Como rastrear ramificações remotas

Supondo que exista um repositório remoto do qual você tenha clonado o repositório local e também assumindo que haja uma ramificação chamada 'some_branch' nesse repositório remoto, veja como rastrear 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

Um artigo realmente bom para entender como o Git funciona é A Parábola do Git . Muito recomendado!

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

O comando Comparar é 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 alterados de outra maneira, o que pode não ser o que você espera ...

Para comparar o arquivo intermediário atual com o repositório:

$ git diff --staged <file_name>

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

$ git diff <file_name>

Por que mais um howto? Existem realmente bons na rede, como o guia git, que é perfeito para começar. Tem bons links, incluindo o livro git para o qual se pode contribuir (hospedado no git hub) e que é perfeito para essa tarefa coletiva.

No stackoverflow, eu realmente preferiria ver seus truques favoritos!

A minha, que descobri recentemente, é git stashexplicada aqui , o que permite que você salve seu emprego atual e vá para outro ramo

EDIT: como no post anterior, se você realmente prefere o formato stackoverlow com posts como wiki, excluirei esta resposta

Interface do usuário do console - Tig

Instalação:

apt-get install tig

Uso

Enquanto estiver 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 obter ajuda, que lista a funcionalidade básica.

Curiosidades

"Tig" é "Git" ao contrário.

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

Supondo que você tenha clonado seu repositório remoto 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

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

Como faço para excluir uma ramificação em um repositório remoto?

Faça um push no controle remoto usando :antes do nome da ramificação

git push origin :mybranchname

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

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

Alterações push e pull

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

Quando você envia pela primeira vez para um repositório remoto, é necessário 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.

Verificando o 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 em seu próprio país.

git clone user@host.com:/dir/to/repo

De onde você clonar inicialmente é de onde o "git pull" será puxado por padrão.

Gity: http://macendeavor.com/gity