Passer de CVS à Git: équivalent $ Id $?

J'ai lu un tas de questions sur les outils de contrôle de code source simples et Git semblait être un choix raisonnable. Je l'ai opérationnel, et cela fonctionne bien jusqu'à présent. Un aspect que j'aime chez CVS est l'incrémentation automatique d'un numéro de version.

Je comprends que cela a moins de sens dans un référentiel distribué, mais en tant que développeur, je veux / ai besoin de quelque chose comme ça. Laissez-moi vous expliquer pourquoi:

J'utilise Emacs. Périodiquement, je passe en revue et cherche de nouvelles versions des fichiers source Lisp pour les paquets tiers. Disons que j'ai un fichier, foo.el, qui, selon l'en-tête, est la version 1.3; si je regarde la dernière version et vois que c'est 1.143 ou 2.6 ou autre, je sais que je suis assez loin derrière.

Si à la place je vois quelques hachages de 40 caractères, je ne saurai pas lequel est le plus tardif ou n'aurai aucune idée de combien de temps il est plus tard. Je détesterais absolument si je devais vérifier manuellement les ChangeLogs juste pour avoir une idée de mon dépassement.

En tant que développeur, je souhaite étendre cette courtoisie, telle que je la vois, aux personnes qui utilisent ma sortie (et peut-être que je me moque de moi, mais laissons cela de côté pendant un moment). Je ne veux pas avoir à me souvenir d'incrémenter moi-même ce foutu nombre à chaque fois, ou un horodatage ou quelque chose comme ça. C'est un vrai PITA, et je le sais par expérience.

Alors, quelles alternatives ai-je? Si je ne peux pas obtenir un équivalent $ Id: $, comment puis-je fournir ce que je recherche?

Je dois mentionner que je m'attends à ce que l'utilisateur final n'ait PAS installé Git et même s'il le fait, il n'aura pas de référentiel local (en effet, je m'attends à ne pas le rendre disponible de cette façon).

Le SHA n'est qu'une représentation d'une version (bien que canonique). La git describecommande en propose d'autres et le fait très bien.

Par exemple, lorsque je lance git describedans ma branche principale de ma source client Java Memcached , j'obtiens ceci:

2.2-16-gc0cd61a

Cela dit deux choses importantes:

1. Il y a eu exactement 16 commits dans cet arbre depuis la version 2.2
2. L' arbre source exact peut être affiché sur le clone de n'importe qui d'autre.

Disons, par exemple, que vous avez empaqueté un versionfichier avec la source (ou même réécrit tout le contenu pour la distribution) pour afficher ce numéro. Disons que la version packagée était 2.2-12-g6c4ae7a(pas une version, mais une version valide).

Vous pouvez maintenant voir exactement à quelle distance vous êtes (4 commits), et vous pouvez voir exactement quels 4 commits:

# The RHS of the .. can be origin/master or empty, or whatever you want.
% git log --pretty=format:"%h %an %s" 2.2-12-g6c4ae7a..2.2-16-gc0cd61a
c0cd61a Dustin Sallings More tries to get a timeout.
8c489ff Dustin Sallings Made the timeout test run on every protocol on every bui
fb326d5 Dustin Sallings Added a test for bug 35.
fba04e9 Valeri Felberg Support passing an expiration date into CAS operations.

À présent, il existe un support pour $ Id: $ dans Git. Pour l'activer pour le fichier README, vous devez mettre "README ident" dans .gitattributes . Les caractères génériques sur les noms de fichiers sont pris en charge. Voir man gitattributes pour plus de détails.

Ce n'est pas une demande déraisonnable de l'OP.

Mon cas d'utilisation est:

1. J'utilise Git pour mon propre code personnel, donc pas de collaboration avec les autres.
2. Je garde des scripts système Bash là-dedans qui pourraient entrer /usr/local/binquand ils sont prêts.

J'utilise trois machines distinctes avec le même référentiel Git. Ce serait bien de savoir dans quelle "version" du fichier j'ai actuellement /usr/local/binsans avoir à faire un manuel "diff -u <repo version> <version dans / usr / local / bin>".

Pour ceux d'entre vous qui sont négatifs, rappelez-vous qu'il existe d'autres cas d'utilisation. Tout le monde n'utilise pas Git pour un travail collaboratif, les fichiers du référentiel Git étant leur emplacement «final».

Quoi qu'il en soit, la façon dont je l'ai fait a été de créer un fichier d'attributs dans le référentiel comme ceci:

cat .git/info/attributes
# see man gitattributes
*.sh ident
*.pl ident
*.cgi ident

Ensuite, mettez $ Id $ quelque part dans le fichier (j'aime le mettre après le shebang).

Le commit. Notez que cela ne fait pas automatiquement l'expansion comme je m'y attendais. Vous devez recopier le fichier, par exemple,

git commit foo.sh
rm foo.sh
git co foo.sh

Et puis vous verrez l'extension, par exemple:

$ head foo.sh
#!/bin/sh

# $Id: e184834e6757aac77fd0f71344934b1cd774e6d4 $

Vous trouverez de bonnes informations dans Comment activer la chaîne d'identification pour un référentiel Git? .

Je ne suis pas sûr que ce sera jamais dans Git. Pour citer Linus :

"Toute la notion de substitution de mots-clés est totalement idiote. Il est trivial de faire" en dehors "du suivi de contenu réel, si vous voulez l'avoir lorsque vous faites des arbres de publication comme des boules tar, etc."

Cependant, il est assez facile de vérifier le journal - si vous suivez la branche stable de foo.el, vous pouvez voir quels nouveaux commits sont dans le journal de la branche stable qui ne sont pas dans votre copie locale. Si vous souhaitez simuler le numéro de version interne de CVS, vous pouvez comparer l'horodatage du dernier commit.

Edit: vous devez écrire ou utiliser les scripts de quelqu'un d'autre pour cela, bien sûr, ne pas le faire manuellement.

Comme je l' ai écrit avant :

Avoir des balises d'identification générées automatiquement qui montrent un numéro de version raisonnable est impossible à faire avec des outils DSCM comme Bazaar car la ligne de développement de chacun peut être différente de toutes les autres. Donc, quelqu'un pourrait se référer à la version "1.41" d'un fichier mais votre version "1.41" de ce fichier est différente.

Fondamentalement, $ Id $ n'a aucun sens avec Bazaar, Git et d'autres outils de gestion de code source distribués.

J'ai eu le même problème. J'avais besoin d'une version plus simple qu'une chaîne de hachage et disponible pour les personnes utilisant l'outil sans avoir besoin de se connecter au référentiel.

Je l'ai fait avec un hook de pré-commit Git et j'ai changé mon script pour pouvoir se mettre à jour automatiquement.

Je base la version sur le nombre de commits effectués. Il s'agit d'une légère condition de concurrence car deux personnes pourraient s'engager en même temps et toutes les deux pensent qu'elles commettent le même numéro de version, mais nous n'avons pas beaucoup de développeurs sur ce projet.

À titre d'exemple, j'ai un script que j'archive qui est en Ruby, et j'y ajoute ce code - c'est un code assez simple, il est donc facile de porter vers différentes langues si vous enregistrez quelque chose dans une langue différente (bien que évidemment cela ne fonctionnera pas facilement avec des archivages non exécutables tels que des fichiers texte). J'ai ajouté:

MYVERSION = '1.090'
## Call script to do updateVersion from .git/hooks/pre-commit
def updateVersion
  # We add 1 because the next commit is probably one more - though this is a race
  commits = %x[git log #{$0} | grep '^commit ' | wc -l].to_i + 1
  vers = "1.%0.3d" % commits

  t = File.read($0)
  t.gsub!(/^MYVERSION = '(.*)'$/, "MYVERSION = '#{vers}'")
  bak = $0+'.bak'
  File.open(bak,'w') { |f| f.puts t }
  perm = File.stat($0).mode & 0xfff
  File.rename(bak,$0)
  File.chmod(perm,$0)
  exit
end

Et puis j'ajoute une option de ligne de commande (-updateVersion) au script donc si je l'appelle comme "tool -updateVersion" alors il appelle juste updateVersion pour l'outil qui modifie la valeur "MYVERSION" en lui-même et puis quitte (vous pouvez faites-le également mettre à jour d'autres fichiers s'ils sont également ouverts si vous le souhaitez).

Une fois que c'est configuré, je vais à la tête de Git et crée un script bash exécutable sur une ligne dans .git/hooks/pre-commit.

Le script change simplement en tête du répertoire Git et appelle mon script avec -updateVersion.

Chaque fois que j'enregistre le script de pré-validation est exécuté qui exécute mon script avec -updateVersion, puis la variable MYVERSION est mise à jour en fonction du nombre de validations. La magie!

Si avoir $ Keywords $ est essentiel pour vous, alors peut-être pourriez-vous essayer de regarder Mercurial à la place? Il a une extension hgkeyword qui implémente ce que vous voulez. Mercurial est de toute façon intéressant en tant que DVCS.

Une chose qui est faite avec les référentiels Git est d'utiliser l' tagobjet. Cela peut être utilisé pour marquer un commit avec n'importe quel type de chaîne et peut être utilisé pour marquer des versions. Vous pouvez voir que les balises dans un référentiel avec legit tag commande, qui renvoie toutes les balises.

Il est facile de vérifier une balise. Par exemple, s'il existe une balise, v1.1vous pouvez récupérer cette balise dans une branche comme celle-ci:

git checkout -b v1.1

Comme il s'agit d'un objet de premier niveau, vous verrez tout l'historique de cette validation, ainsi que vous pourrez exécuter des différences, apporter des modifications et des fusions.

Non seulement cela, mais une balise persiste, même si la branche sur laquelle elle se trouvait a été supprimée sans être fusionnée dans la ligne principale.

Si je comprends bien, vous voulez essentiellement savoir combien de commits se sont produits sur un fichier donné depuis la dernière mise à jour.

Commencez par récupérer les modifications dans l'origine distante, mais ne les fusionnez pas dans votre masterbranche:

% git fetch

Ensuite, obtenez un journal des changements qui se sont produits sur un fichier donné entre votre mastersuccursale et la télécommande origin/master.

% git log master..origin/master foo.el

Cela vous donne les messages de journal de toutes les validations qui se sont produites dans le référentiel distant depuis votre dernière fusion origin/masterdans votre master.

Si vous voulez juste un décompte des modifications, dirigez-le vers wc. Dis, comme ceci:

% git rev-list master..origin/master foo.el | wc -l

Si vous voulez simplement que les gens puissent avoir une idée de leur dépassement, Git peut les informer de plusieurs manières assez simples. Ils comparent les dates du dernier commit sur leur coffre et votre coffre, par exemple. Ils peuvent utiliser git cherrypour voir combien de commits se sont produits dans votre coffre qui ne sont pas présents dans le leur.

Si c'est tout ce que vous voulez, je chercherais un moyen de le fournir sans numéro de version.

De plus, je ne prendrais pas la peine d'étendre la courtoisie à qui que ce soit à moins que vous ne soyez sûr qu'il le souhaite. :)

Pour appliquer l'expansion à tous les fichiers de tous les sous-répertoires du référentiel, ajoutez un .gitattributesfichier au répertoire de niveau supérieur du référentiel (c'est-à-dire où vous placez normalement le .gitignorefichier) contenant:

* ident

Pour voir cela en vigueur, vous devez d'abord effectuer une extraction efficace du ou des fichiers, par exemple en les supprimant ou en les modifiant de quelque manière que ce soit. Puis restaurez-les avec:

git checkout .

Et vous devriez voir $Id$remplacé par quelque chose comme:

$Id: ea701b0bb744c90c620f315e2438bc6b764cdb87 $

De man gitattributes:

ident

Lorsque l'attribut ident est défini pour un chemin, Git remplace $ Id $ dans l'objet blob par $ Id :, suivi du nom de l'objet blob hexadécimal à 40 caractères, suivi d'un signe dollar $ lors du paiement. Toute séquence d'octets commençant par $ Id: et se terminant par $ dans le fichier de l'arbre de travail est remplacée par $ Id $ lors de l'enregistrement.

Cet ID changera chaque fois qu'une nouvelle version du fichier est validée.

Les ID RCS sont bien pour les projets à un seul fichier, mais pour tous les autres, $ Id $ ne dit rien sur le projet (sauf si vous effectuez des vérifications forcées dans un fichier de version factice).

On pourrait néanmoins être intéressé par la façon d'obtenir les équivalents de $ Author $, $ Date $, $ Revision $, $ RCSfile $, etc. au niveau par fichier ou au niveau de la validation (comment les mettre là où se trouvent certains mots-clés en est une autre question). Je n'ai pas de réponse à ce sujet, mais je vois la nécessité de les mettre à jour, en particulier lorsque les fichiers (maintenant dans Git) proviennent de systèmes compatibles RCS (CVS).

De tels mots-clés peuvent être intéressants si les sources sont distribuées séparément de tout dépôt Git (c'est ce que je fais aussi). Ma solution est comme ceci:

Chaque projet a son propre répertoire et à la racine du projet, j'ai un fichier texte nommé .version dont le contenu décrit la version actuelle (le nom qui sera utilisé lors de l'exportation des sources).

Tout en travaillant pour la prochaine version, un script extrait ce .versionnuméro, un descripteur de version Git (comme git describe) et un numéro de build monotone dans .build(plus l'hôte et la date) dans un fichier source généré automatiquement qui est lié au programme final, afin que vous puissiez trouver de quelle source et quand il a été construit.

Je développe de nouvelles fonctionnalités dans des branches séparées, et la première chose que je fais est d'ajouter n(pour "next") à la .versionchaîne (plusieurs branches provenant de la même racine utiliseraient le même .versionnuméro temporaire ). Avant la sortie, je décide quelles branches fusionner (j'espère qu'elles ont toutes les mêmes .version). Avant de valider la fusion, je mets à jour .versionle numéro suivant ( mise à jour majeure ou mineure, selon les fonctionnalités fusionnées).

Si vous voulez que les informations git commit soient accessibles dans votre code, vous devez effectuer une étape de pré-construction pour y parvenir. Dans bash pour C / C ++, cela pourrait ressembler à ceci:

prebuild.sh

#!/bin/bash
commit=$(git rev-parse HEAD)
tag=$(git describe --tags --always ${commit})
cat <<EOF >version.c
#include "version.h"
const char* git_tag="${tag}";
const char* git_commit="${commit}";
EOF

avec version.hressemblant à:

#pragma once
const char* git_tag;
const char* git_commit;

Ensuite, partout où vous en avez besoin dans votre code #include "version.h"et référence git_tagou git_commitselon vos besoins.

Et vous Makefilepourriez avoir quelque chose comme ça:

all: package
version:
  ./prebuild.sh
package: version
  # the normal build stuff for your project

Cela a l'avantage de:

• obtenir les valeurs actuellement correctes pour cette version indépendamment de la ramification, de la fusion de la sélection de cerises et autres.

Cette implémentation de prepublish.shprésente les inconvénients de:

• forcer une recompilation même si le git_tag/git_commit n'a pas changé.
• il ne prend pas en compte les fichiers modifiés locaux qui n'ont pas été validés mais effectuent la construction.
  • utiliser git describe --tags --always --dirtypour attraper ce cas d'utilisation.
• pollue l'espace de noms global.

Un amateur prebuild.shqui pourrait éviter ces problèmes est laissé comme exercice pour le lecteur.

Je suis d'accord avec ceux qui pensent que le remplacement des jetons appartient aux outils de construction plutôt qu'aux outils de contrôle de version.

Vous devriez avoir un outil de publication automatisé pour définir les ID de version dans vos sources au moment où la publication est balisée.

Les noms de balises et autres informations associées peuvent désormais être édités directement dans des fichiers automatiquement par Git grâce à la export-substfonctionnalité de gitattributes(5). Cela nécessite bien sûr l'utilisation de git archivepour créer des versions, et les modifications de substitution ne seront visibles que dans le fichier tar résultant.

Par exemple, dans le .gitattributesfichier, mettez la ligne suivante:

* export-subst

Ensuite, dans les fichiers source, vous pouvez ajouter une ligne comme celle-ci:

#ident  "@(#)PROJECTNAME:FILENAME:$Format:%D:%ci:%cN:%h$"

Et il se développera pour ressembler à ceci dans une version créée par, par exemple git archive v1.2.0.90,:

#ident  "@(#)PROJECTNAME:FILENAME:HEAD -> master, tag: v1.2.0.90:2020-04-03 18:40:44 -0700:Greg A. Woods:e48f949"

Puisque vous utilisez Emacs, vous pourriez avoir de la chance :)

Je suis tombé sur cette question par coïncidence, et aussi par coïncidence, je suis tombé sur Lively il y a quelques jours, un paquet Emacs qui permet d'avoir des morceaux vivants d'Emacs Lisp dans votre document. Je n'ai pas essayé pour être honnête, mais cela m'est venu à l'esprit en lisant ceci.

Je suis également venu de SCCS, RCS et CVS ( %W% %G% %U%).

J'ai eu un défi similaire. Je voulais savoir quelle version était un morceau de code sur n'importe quel système qui l'exécutait. Le système peut ou non être connecté à un réseau. Le système peut avoir installé ou non Git. Le système peut ou non avoir le référentiel GitHub installé dessus.

Je voulais la même solution pour plusieurs types de code (.sh, .go, .yml, .xml, etc.). Je voulais que toute personne sans connaissance de Git ou GitHub puisse répondre à la question "Quelle version utilisez-vous?"

Donc, j'ai écrit ce que j'appelle un wrapper autour de quelques commandes Git. Je l'utilise pour marquer un fichier avec un numéro de version et quelques informations. Cela résout mon défi. Cela peut vous aider.

https://github.com/BradleyA/markit

git clone https://github.com/BradleyA/markit
cd markit

Pour résoudre ce problème par moi-même, j'ai créé un petit "hack" comme hook post-commit:

echo | tee --append *
git checkout *

Plus en détail documenté dans ce post sur mon blog .