Faça o download de uma tag específica com o Git

Eu estou tentando descobrir como eu posso baixar uma tag específica de um repository Git – é uma versão por trás da versão atual.

Eu vi que havia uma tag para a versão anterior na página web do git, com o nome do object de algo longo número hexadecimal.

Mas o nome da versão é ” Tagged release 1.1.5 ” de acordo com o site.

Eu tentei um comando como este (com nomes alterados):

 git clone http://git.abc.net/git/abc.git my_abc 

E eu consegui algo – um diretório, um monte de subdiretórios, etc.

Se é todo o repository, como obtenho a versão que estou procurando? Se não, como faço para baixar essa versão específica?

 $ git clone 

lhe dará todo o repository.

Após o clone, você pode listar as tags com $ git tag -l e, em seguida, fazer checkout de uma tag específica:

 $ git checkout tags/ 

Melhor ainda, faça o checkout e crie um branch (caso contrário, você estará em um branch com o nome do número de revisão do tag):

 $ git checkout tags/ -b  
 git clone --branch my_abc http://git.abc.net/git/abc.git 

Clonará o repository e deixará você na tag em que você está interessado.

Documentação para 1.8.0 dos estados do clone git .

–branch também pode pegar tags e desappend o HEAD naquele commit no repository resultante.

Eu não sou um especialista em git, mas acho que isso deve funcionar:

 git clone http://git.abc.net/git/abc.git cd abc git checkout my_abc 

OU

 git clone http://git.abc.net/git/abc.git cd abc git checkout -b new_branch my_abc 

A segunda variação estabelece uma nova ramificação baseada na tag, que permite evitar uma ‘HEAD desconectada’. (manual do git-checkout)

Cada git repo contém todo o histórico de revisões, portanto clonar o repo dá access ao commit mais recente, além de tudo que veio antes, incluindo a tag que você está procurando.

Para verificar apenas uma determinada tag para implantação, eu uso, por exemplo:

 git clone -b 'v2.0' --single-branch --depth 1 https://github.com/git/git.git 

Esta parece ser a maneira mais rápida de verificar o código de um repository remoto se tivermos apenas interesse no código mais recente em vez de em um repository completo. Desta forma, assemelha-se ao comando ‘svn co’.

Você pode usar o git archive para fazer o download de uma tarball para uma tag ou commit id:

 git archive --format=tar --remote=[hostname]:[path to repo] [tag name] > tagged_version.tar 

Você também pode exportar um arquivo zip de uma tag.

  1. Listar tags:

     git tag 0.0.1 0.1.0 
  2. Exportar uma tag:

     git archive -o /tmp/my-repo-0.1.0.zip --prefix=my-repo-0.1.0/ 0.1.0 
  3. Notas:

    • Você não precisa especificar o formato. Ele será escolhido pelo nome do arquivo de saída.
    • Especificar o prefixo fará seu código exportar para um diretório (se você include uma barra à direita).

Use o switch --single-branch (disponível a partir do Git 1.7.10) . A syntax é:

 git clone -b  --single-branch  [] 

Por exemplo:

 git clone -b 'v1.9.5' --single-branch https://github.com/git/git.git git-1.9.5 

O benefício: o Git receberá objects e (precisará) resolver deltas apenas para o ramo / tag especificado – enquanto verifica a mesma quantidade exata de arquivos! Dependendo do repository de origem, isso economizará muito espaço em disco. (Além disso, vai ser muito mais rápido.)

primeiro buscar todas as tags nesse remoto específico

 git fetch  'refs/tags/*:refs/tags/*' 

ou simplesmente digite

 git fetch  

Em seguida, verifique as tags disponíveis

 git tag -l 

em seguida, mude para essa tag específica usando o comando abaixo

 git checkout tags/ 

Espero que isso ajude você!

Eu verifiquei a documentação do checkout git , revelou uma coisa interessante:

git checkout -b , onde o é o nome de uma confirmação na qual iniciar a nova ramificação; Padrões para HEAD

Então, podemos mencionar o nome da tag (como tag não é nada, mas um nome de um commit) como, digamos:

>> git checkout -b 1.0.2_branch 1.0.2
mais tarde, modifique alguns arquivos
>> git push –tags

PS: No Git, você não pode atualizar uma tag diretamente (desde que a tag é apenas um label para um commit), você precisa fazer o checkout da mesma tag como uma ramificação e depois se comprometer com ela e então criar uma tag separada.

Se suas tags forem classificáveis ​​usando o comando linux sort , use isto:

 git tag | sort -n | tail -1 

por exemplo. se a git tag retornar:

 v1.0.1 v1.0.2 v1.0.5 v1.0.4 

git tag | sort -n | tail -1 git tag | sort -n | tail -1 irá produzir:

 v1.0.5 

git tag | sort -n | tail -2 | head -1 git tag | sort -n | tail -2 | head -1 produzirá:

 v1.0.4 

(porque você pediu a segunda tag mais recente)

para fazer o checkout da tag, primeiro clone o repository e digite:

 git checkout v1.0.4 

..ou qualquer tag que você precisa.

 git fetch  : 

===================================

Eu apenas fiz isso. Primeiro, certifiquei-me de que sabia a ortografia do nome da etiqueta.

 git ls-remote --tags gitserver; : or origin, whatever your remote is called 

Isso me deu uma lista de tags no meu servidor git para escolher. O cartaz original já sabia o nome da sua tag, portanto, essa etapa não é necessária para todos. A saída parecia assim, embora a lista real fosse mais longa.

 8acb6864d10caa9baf25cc1e4857371efb01f7cd refs/tags/v5.2.2.2 f4ba9d79e3d760f1990c2117187b5010e92e1ea2 refs/tags/v5.2.3.1 8dd05466201b51fcaf4ca85897347d82fcb29518 refs/tags/Fix_109 9b5087090d9077c10ba22d99d5ce90d8a45c50a3 refs/tags/Fix_110 

Eu escolhi a tag que queria e peguei e nada mais como segue.

 git fetch gitserver Fix_110 

Eu então marquei isso na minha máquina local, dando à minha tag o mesmo nome.

 git tag Fix_110 FETCH_HEAD 

Eu não queria clonar o repository remoto como outras pessoas sugeriram, já que o projeto em que estou trabalhando é grande e quero desenvolvê-lo em um ambiente limpo e agradável. Eu sinto que isso está mais próximo das questões originais “Estou tentando descobrir como fazer o download de um TAG PARTICULAR” do que a solução que sugere a clonagem de todo o repository. Não vejo por que alguém precisaria ter uma cópia do código-fonte do Windows NT e do Windows 8.1 se quiserem ver o código-fonte DOS 0.1 (por exemplo).

Eu também não queria usar check-out como outros sugeriram. Eu tinha um ramo de check-out e não queria afetar isso. Minha intenção era buscar o software que eu queria para que eu pudesse escolher algo e acrescentar isso ao meu desenvolvimento.

Provavelmente, existe uma maneira de buscar a tag em vez de apenas uma cópia da confirmação que foi marcada. Eu tive que marcar o compromisso buscado eu mesmo. EDIT: Ah sim, eu encontrei agora.

 git fetch gitserver Fix_110:Fix_110 

Onde você vê os dois pontos, isso é nome-remoto: nome-local e aqui estão os nomes das tags. Isso funciona sem atrapalhar a tree de trabalho, etc. Parece copiar o material do controle remoto para a máquina local para que você tenha sua própria cópia.

 git fetch gitserver --dry-run Fix_110:Fix_110 

com a opção –dry-run adicionada permitirá que você veja o que o comando faria, se você quer verificar o que você quer. Então eu acho que um simples

 git fetch gitserver remotetag:localtag 

é a resposta real.

=

Uma nota separada sobre tags … Quando eu começo algo novo, eu costumo marcar o repository vazio depois do git init, já que

 git rebase -i XXXXX 

requer um commit, e surge a pergunta “como você faz o rebase de mudanças que incluem sua primeira mudança de software?” Então, quando eu começo a trabalhar, eu faço

 git init touch .gitignore [then add it and commit it, and finally] git tag EMPTY 

ou seja, criar um commit antes da minha primeira mudança real e depois usar

 git rebase -i EMPTY 

se eu quiser rebase todo o meu trabalho, incluindo a primeira mudança .

Trabalhando com a resposta de Peter Johnson, criei um aliaszinho legal para mim:

 alias gcolt="git checkout \`git tag | sort -V | tail -1\`" 

também conhecido como ‘git checkout latest tag’.

Isso depende da versão GNU do tipo, que lida adequadamente com situações como a que lOranger apontou:

 v1.0.1 ... v1.0.9 v1.0.10 

Se você estiver em um mac, brew install coreutils e, em seguida, chame gsort.

experimentar:

 git clone -b    

Verificando tags

Se você quiser ver as versões dos arquivos para os quais uma tag está apontando, você pode fazer um checkout git, embora isso coloque seu repository no estado “HEAD desanexado”, que tem alguns efeitos colaterais ruins:

 $ git checkout 2.0.0 Note: checking out '2.0.0'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this state without impacting any branches by performing another checkout. If you want to create a new branch to retain commits you create, you may do so (now or later) by using -b with the checkout command again. Example: git checkout -b  HEAD is now at 99ada87... Merge pull request #89 from schacon/appendix-final $ git checkout 2.0-beta-0.1 Previous HEAD position was 99ada87... Merge pull request #89 from schacon/appendix-final HEAD is now at df3f601... add atlas.json and cover image 

No estado “HEAD separado”, se você fizer alterações e, em seguida, criar um commit, a tag permanecerá a mesma, mas seu novo commit não pertencerá a nenhum branch e ficará inacessível, exceto pelo hash de commit exato. Assim, se você precisar fazer alterações – por exemplo, corrigir um bug em uma versão mais antiga, por exemplo – geralmente você desejará criar uma ramificação:

 $ git checkout -b version2 v2.0.0 Switched to a new branch 'version2' 

Se você fizer isso e fizer um commit, sua ramificação da versão 2 será um pouco diferente da sua tag v2.0.0, já que ela avançará com as novas alterações, portanto, tenha cuidado.

Eu faço isso através da API do github:

 curl -H "Authorization: token %(access_token)s" -sL -o /tmp/repo.tar.gz "http://api.github.com/repos/%(organisation)s/%(repo)s/tarball/%(tag)s" ;\ tar xfz /tmp/repo.tar.gz -C /tmp/repo --strip-components=1 ; \ 

Clonar com a opção -b também ajuda: git clone https://git01.codeplex.com/aspnetwebstack.git -b v2.0

A postagem a seguir usa a opção acima para fazer o download do asp.net mvc: http://vijayt.com/Post/Setting-up-aspnet-mvc-for-debugging-in-your-system