Téléchargez un tag spécifique avec Git

J'essaie de comprendre comment je peux télécharger une balise particulière d'un référentiel Git - c'est une version derrière la version actuelle.

J'ai vu qu'il y avait une balise pour la version précédente sur la page Web de git, avec un nom d'objet quelque chose de long hexadécimal.

Mais le nom de la version est " Tagged release 1.1.5" selon le site.

J'ai essayé une commande comme celle-ci (avec des noms modifiés):

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

Et j'ai obtenu quelque chose - un répertoire, un tas de sous-répertoires, etc.

Si c'est l'ensemble du référentiel, comment puis-je obtenir la version que je recherche? Sinon, comment télécharger cette version particulière?

$ git clone

vous donnera l'ensemble du référentiel.

Après le clone, vous pouvez répertorier les balises avec $ git tag -lpuis extraire une balise spécifique:

$ git checkout tags/<tag_name>

Encore mieux, passez à la caisse et créez une branche (sinon vous serez sur une branche nommée d'après le numéro de révision de la balise):

$ git checkout tags/<tag_name> -b <branch_name>

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

Clonera le dépôt et vous laissera sur le tag qui vous intéresse.

Documentation pour 1.8.0 des états du clone git .

--branch peut également prendre des balises et détacher le HEAD lors de cette validation dans le référentiel résultant.

Pour vérifier uniquement une balise donnée pour le déploiement, j'utilise par exemple:

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

Cela semble être le moyen le plus rapide d'extraire le code d'un référentiel distant si l'on ne s'intéresse qu'au code le plus récent au lieu d'un référentiel complet. De cette façon, il ressemble à la commande «svn co».

Remarque: Selon le manuel de Git , le passage du --depthdrapeau implique --single-branchpar défaut.

--profondeur

Créez un clone superficiel avec un historique tronqué au nombre spécifié de validations. Implique --single-branch sauf si --no-single-branch est donné pour récupérer les historiques près des pointes de toutes les branches. Si vous souhaitez cloner des sous-modules de manière superficielle, passez également --shallow-submodules.

Je ne suis pas un expert git, mais je pense que cela devrait fonctionner:

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

La deuxième variante établit une nouvelle branche basée sur la balise, ce qui vous permet d'éviter une «tête détachée». (manuel git-checkout)

Chaque dépôt git contient l'historique complet des révisions, donc le clonage du dépôt vous donne accès à la dernière validation, ainsi qu'à tout ce qui précède, y compris la balise que vous recherchez.

Vous pouvez utiliser git archive pour télécharger une boule tar pour une balise donnée ou un id de commit:

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

Vous pouvez également exporter une archive zip d'une balise.

1. Étiquettes de liste:

   git tag
   
   0.0.1
   0.1.0
   

2. Exporter une balise:

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

3. Remarques:

   • Vous n'avez pas besoin de spécifier le format. Il sera récupéré par le nom du fichier de sortie.
   • La spécification du préfixe fera exporter votre code vers un répertoire (si vous incluez une barre oblique de fin).

Utilisez le --single-branchcommutateur (disponible à partir de Git 1.7.10) . La syntaxe est:

git clone -b <tag_name> --single-branch <repo_url> [<dest_dir>] 

Par exemple:

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

L'avantage: Git recevra des objets et (devra) résoudre les deltas pour la branche / balise spécifiée uniquement - tout en vérifiant exactement la même quantité de fichiers! Selon le référentiel source, cela vous fera économiser beaucoup d'espace disque. (De plus, ce sera beaucoup plus rapide.)

récupérer d'abord toutes les balises de cette télécommande spécifique

git fetch <remote> 'refs/tags/*:refs/tags/*'

ou tapez simplement

git fetch <remote>

Vérifiez ensuite les balises disponibles

git tag -l

puis passez à cette balise spécifique en utilisant la commande ci-dessous

git checkout tags/<tag_name>

J'espère que cela vous aidera!

Si vos balises sont triables à l'aide de la sortcommande linux , utilisez ceci:

git tag | sort -n | tail -1

par exemple. si git tagretourne:

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

git tag | sort -n | tail -1 affichera:

v1.0.5

git tag | sort -n | tail -2 | head -1 affichera:

v1.0.4

(parce que vous avez demandé la deuxième balise la plus récente)

pour retirer la balise, clonez d'abord le dépôt, puis tapez:

git checkout v1.0.4

..ou quelle que soit la balise dont vous avez besoin.

J'ai vérifié la documentation de git checkout , cela a révélé une chose intéressante:

git checkout -b <new_branch_name> <start_point>, où <start_point> est le nom d'un commit auquel démarrer la nouvelle branche; Par défaut à HEAD

Nous pouvons donc mentionner le nom de la balise (car la balise n'est rien d'autre qu'un nom de commit) comme, par exemple:

>> git checkout -b 1.0.2_branch 1.0.2
plus tard, modifiez certains fichiers
>> git push --tags

PS: Dans Git, vous ne pouvez pas mettre à jour une balise directement (car la balise n'est qu'une étiquette pour une validation), vous devez extraire la même balise qu'une branche, puis vous y engager, puis créer une balise séparée.

git fetch <gitserver> <remotetag>:<localtag>

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

Je viens de faire ça. Je me suis d'abord assuré que je connaissais l'orthographe du nom de la balise.

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

Cela m'a donné une liste de balises sur mon serveur git à choisir. L'affiche originale connaissait déjà le nom de son tag, donc cette étape n'est pas nécessaire pour tout le monde. La sortie ressemblait à ceci, bien que la vraie liste soit plus longue.

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

J'ai choisi la balise que je voulais et je l'ai récupérée et rien de plus comme suit.

git fetch gitserver Fix_110

J'ai ensuite marqué cela sur ma machine locale, donnant à ma balise le même nom.

git tag Fix_110 FETCH_HEAD

Je ne voulais pas cloner le référentiel distant comme d'autres personnes l'ont suggéré, car le projet sur lequel je travaille est grand et je veux développer dans un environnement propre et agréable. Je pense que cela est plus proche des questions originales "J'essaie de comprendre comment télécharger UN ÉTIQUETTE PARTICULIÈRE" que la solution qui suggère de cloner l'ensemble du référentiel. Je ne vois pas pourquoi quelqu'un devrait avoir une copie du code source de Windows NT et Windows 8.1 s'ils veulent regarder le code source DOS 0.1 (par exemple).

Je ne voulais pas non plus utiliser CHECKOUT comme d'autres l'ont suggéré. J'ai fait vérifier une succursale et je ne voulais pas affecter cela. Mon intention était de récupérer le logiciel que je voulais pour pouvoir choisir quelque chose et l'ajouter à mon développement.

Il existe probablement un moyen de récupérer la balise elle-même plutôt qu'une simple copie de la validation qui a été balisée. J'ai dû marquer moi-même le commit récupéré. EDIT: Ah oui, je l'ai trouvé maintenant.

git fetch gitserver Fix_110:Fix_110

Où vous voyez les deux points, c'est nom-distant: nom-local et ici ce sont les noms des balises. Cela fonctionne sans perturber l'arborescence de travail, etc. Il semble simplement copier des éléments de la télécommande vers la machine locale afin que vous ayez votre propre copie.

git fetch gitserver --dry-run Fix_110:Fix_110

avec l'option --dry-run ajoutée, vous pourrez voir ce que la commande ferait si vous voulez vérifier ce que vous voulez. Donc je suppose qu'un simple

git fetch gitserver remotetag:localtag

est la vraie réponse.

=

Une note séparée sur les balises ... Quand je commence quelque chose de nouveau, je marque généralement le référentiel vide après git init, car

git rebase -i XXXXX 

nécessite un commit, et la question se pose "comment pouvez-vous rebaser les changements qui incluent votre premier changement de logiciel?" Donc, quand je commence à travailler, je le fais

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

c'est-à-dire créer un commit avant mon premier vrai changement et ensuite l'utiliser plus tard

git rebase -i EMPTY 

si je veux rebaser tout mon travail, y compris le premier changement .

À partir de la réponse de Peter Johnson, je me suis créé un joli petit alias:

alias gcolt="git checkout $(git tag | sort -V | tail -1)"

alias «dernière balise git checkout».

Cela s'appuie sur la version GNU, qui gère de manière appropriée des situations comme celle que lOranger a souligné:

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

Si vous êtes sur un Mac, brew install coreutilspuis appelez gsort à la place.

essayer:

git clone -b <name_of_the_tag> <repository_url> <destination>

Extraire les balises

Si vous souhaitez afficher les versions des fichiers vers lesquels pointe une balise, vous pouvez effectuer une extraction git, bien que cela place votre référentiel dans l'état "HEAD détaché", ce qui a des effets secondaires néfastes:

$ 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 <new-branch-name>

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

Dans l'état "HEAD détaché", si vous apportez des modifications puis créez une validation, la balise restera la même, mais votre nouvelle validation n'appartiendra à aucune branche et sera inaccessible, sauf par le hachage de validation exact. Ainsi, si vous devez apporter des modifications (par exemple, si vous corrigez un bogue sur une ancienne version), vous souhaiterez généralement créer une branche:

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

Si vous faites cela et faites un commit, votre branche version2 sera légèrement différente de votre balise v2.0.0 car elle avancera avec vos nouvelles modifications, alors soyez prudent.

Je le fais via l'API 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 ; \