web-dev-qa-db-fra.com

Quel est l'équivalent Git pour le numéro de révision?

Nous utilisons SVN au travail, mais pour mes projets personnels, j'ai décidé d'utiliser Git. J'ai donc installé Git hier et je me demande quel est le numéro de révision équivalent dans Git.

Disons que nous travaillons sur la version 3.0.8 et que chaque correctif de bogue a son propre numéro de révision que nous pouvons utiliser lorsque nous parlons de ce correctif. Donc, si je marque le code dans Git en 3.0.8, que puis-je utiliser comme numéro de révision ou tout autre type d'identification plus détaillée? Je trouve le hash pas si convivial pour les humains.

gitversion-controlrevision-historyversion-numbering
220
Radek

Bonne ou mauvaise nouvelle pour vous, indiquez IS le numéro de révision. J'ai également eu des problèmes avec cela quand j'ai basculé de SVN à Git.

Vous pouvez utiliser "tagging" dans git pour marquer une révision donnée en tant que "version" pour une version spécifique, facilitant ainsi le renvoi à cette révision. Découvrez ce blog post .

La chose clé à comprendre est que git ne peut pas avoir de numéro de révision - pensez à la nature décentralisée. Si les utilisateurs A et B s'engagent tous deux dans leurs référentiels locaux, comment git peut-il attribuer de manière raisonnable un numéro de révision séquentiel? A n'a aucune connaissance de B avant de se pousser/de tirer les changements de l'autre.

Une autre chose à regarder est la création de branches simplifiées pour les branches de corrections de bogues:

Commencez avec une version: 3.0.8. Ensuite, après cette publication, procédez comme suit:

git branch bugfixes308

Cela créera une branche pour les corrections de bugs. Commander la branche:

git checkout bugfixes308

Maintenant, apportez les modifications de correction de bugs que vous souhaitez.

git commit -a

Engagez-les et revenez à la branche principale:

git checkout master

Puis insérez ces modifications de l'autre branche:

git merge bugfixes308

De cette façon, vous avez une branche de correction de bug distincte, spécifique à la version, mais vous continuez à extraire les modifications de correction de bug dans votre trunk principale de dev.

138
makdad

Avec Git moderne (1.8.3.4 dans mon cas) et sans utiliser de branches, vous pouvez faire:

$ git rev-list --count HEAD
68
149
max

La commande git describe crée un nom légèrement plus lisible par l'homme qui fait référence à un commit spécifique. Par exemple, à partir de la documentation:

Avec quelque chose comme l'arbre actuel de git.git, je reçois:

[torvalds@g5 git]$ git describe parent
v1.0.4-14-g2414721

c'est-à-dire que la tête actuelle de ma branche "parent" est basée sur la v1.0.4, mais comme elle comporte quelques commits, elle a ajouté le nombre de commits supplémentaires ("14") et un nom d'objet abrégé pour la validation. lui-même ("2414721") à la fin.

Tant que vous utilisez des balises bien nommées pour marquer des versions particulières, cela peut être considéré comme étant à peu près équivalent à un "numéro de révision" SVN.

95
Greg Hewgill

Les autres affiches ont raison, il n'y a pas de "numéro de révision".

Je pense que le meilleur moyen est d'utiliser les balises pour les "releases"!

Mais j’ai utilisé les éléments suivants pour de faux numéros de révision (uniquement pour que les clients puissent voir les révisions et les progrès réalisés, car ils souhaitaient avoir les mêmes révisions croissantes à partir de comme ils étaient habitués à Subversion).

Afficher la "révision actuelle" de "HEAD" est simulée en utilisant ceci:

git rev-list HEAD | wc -l

Mais que se passe-t-il si le client me dit qu'il y a un bogue dans "révision" 1302?

Pour cela, j'ai ajouté ce qui suit à la section [alias] de mon ~/.gitconfig:

show-rev-number = !sh -c 'git rev-list --reverse HEAD | nl | awk \"{ if(\\$1 == "$0") { print \\$2 }}\"'

en utilisant git show-rev-number 1302, vous imprimerez le hachage pour la "révision" :)

J'ai fait un Blog Post (en allemand) à propos de cette "technique" il y a quelque temps.

67
OderWat

Git n'a pas le même concept de numéros de révision que Subversion. À la place, chaque instantané donné créé avec une validation est marqué par une somme de contrôle SHA1. Pourquoi? L'exécution de revno dans un système de contrôle de version distribué pose plusieurs problèmes:

Premièrement, étant donné que le développement n’est pas linéaire du tout, l’attachement d’un nombre est plutôt difficile à résoudre de manière à satisfaire votre besoin de programmeur. Essayer de résoudre ce problème en ajoutant un numéro peut rapidement devenir problématique si le numéro ne se comporte pas comme prévu.

Deuxièmement, les numéros de révision peuvent être générés sur différentes machines. Cela rend la synchronisation des chiffres beaucoup plus difficile, d'autant plus que la connectivité est à sens unique; il est même possible que vous n'ayez pas accès à toutes les machines disposant du référentiel.

Troisièmement, dans git, un peu pionnier du système OpenCM maintenant disparu, le identité d'une validation (ce que la validation est) est équivalent à son nom _ (l'identifiant SHA ). Ce nommant = identité concept est très fort. Lorsque vous êtes assis avec un nom de commit en main, il identifie également le commit de manière infalsifiable. Cela vous permet à son tour de vérifier tous vos commits reviennent au premier initial} _ pour la corruption avec la commande git fsck.

Maintenant, puisque nous avons un DAG (Directed Acyclic Graph) de révisions et que celles-ci constituent l’arborescence actuelle, nous avons besoin d’outils pour résoudre le problème de {votre} _: comment discriminons-nous les différentes versions. Tout d'abord, vous pouvez omettre une partie du hachage si un préfixe donné, 1516bd _, identifie de manière unique votre commit. Mais c'est aussi assez artificiel. Au lieu de cela, l'astuce consiste à utiliser des balises et/ou des branches. Une étiquette ou une branche s'apparente à une "note jaune" que vous attachez à un commit SHA1-id donné. Les étiquettes sont, par essence, censées ne pas bouger, alors qu'une branche bougera quand de nouveaux commits seront faits à son HEAD. Il existe des moyens de faire référence à un commit autour d'une balise ou d'une branche, voir la page de manuel de git-rev-parse.

Généralement, si vous avez besoin de travailler sur un morceau de code spécifique, ce morceau est en cours de modification et devrait donc être une branche avec un nom de sujet. Créer un bon nombre de branches (20-30 par programmeur n’est pas inhabituel, avec quelques 4-5 publiées sur lesquelles travailler), c’est l’astuce d’un git efficace. Chaque travail doit commencer par sa propre branche, puis être fusionné lorsqu’il est testé. Les branches non publiées peuvent être entièrement réécrites et cette partie de la destruction de l’histoire est une force de git.

Lorsque le changement est accepté dans le maître il se fige quelque peu et devient de l'archéologie. À ce stade, vous pouvez le marquer, mais le plus souvent, une référence à un commit particulier est faite dans un suivi de bogues ou un suivi de problème via la somme sha1. Les balises ont tendance à être réservées aux bosses de version et aux points de branche pour les branches de maintenance (pour les anciennes versions).

25
I GIVE CRAP ANSWERS

Si cela vous intéresse, je gère automatiquement les numéros de version à partir de git infos ici sous le format 

<major>.<minor>.<patch>-b<build>

où build est le nombre total de commits. Vous verrez le code intéressant dans Makefile . Voici la partie pertinente pour accéder aux différentes parties du numéro de version:

LAST_TAG_COMMIT = $(Shell git rev-list --tags --max-count=1)
LAST_TAG = $(Shell git describe --tags $(LAST_TAG_COMMIT) )
TAG_PREFIX = "latex-tutorial-v"

VERSION  = $(Shell head VERSION)
# OR try to guess directly from the last git tag
#VERSION    = $(Shell  git describe --tags $(LAST_TAG_COMMIT) | sed "s/^$(TAG_PREFIX)//")
MAJOR      = $(Shell echo $(VERSION) | sed "s/^\([0-9]*\).*/\1/")
MINOR      = $(Shell echo $(VERSION) | sed "s/[0-9]*\.\([0-9]*\).*/\1/")
PATCH      = $(Shell echo $(VERSION) | sed "s/[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/")
# total number of commits       
BUILD      = $(Shell git log --oneline | wc -l | sed -e "s/[ \t]*//g")

#REVISION   = $(Shell git rev-list $(LAST_TAG).. --count)
#ROOTDIR    = $(Shell git rev-parse --show-toplevel)
NEXT_MAJOR_VERSION = $(Shell expr $(MAJOR) + 1).0.0-b$(BUILD)
NEXT_MINOR_VERSION = $(MAJOR).$(Shell expr $(MINOR) + 1).0-b$(BUILD)
NEXT_PATCH_VERSION = $(MAJOR).$(MINOR).$(Shell expr $(PATCH) + 1)-b$(BUILD)
17
Sebastien Varrette

Une fonction Bash:

git_rev ()
{
    d=`date +%Y%m%d`
    c=`git rev-list --full-history --all --abbrev-commit | wc -l | sed -e 's/^ *//'`
    h=`git rev-list --full-history --all --abbrev-commit | head -1`
    echo ${c}:${h}:${d}
}

sort quelque chose comme

$ git_rev
2:0f8e14e:20130220

C'est

commit_count:last_abbrev_commit:date_YYmmdd
9
siznax

Le hachage SHA1 de commit est équivalent à un numéro de révision Subversion.

8
Richard Fearn

C'est ce que j'ai fait dans mon makefile basé sur d'autres solutions. Notez que non seulement cela donne à votre code un numéro de révision, il ajoute également le hachage qui vous permet de recréer la version.

# Set the source control revision similar to Subversion to use in 'c'
# files as a define.
# You must build in the master branch otherwise the build branch will
# be prepended to the revision and/or "dirty" appended. This is to
# clearly ID developer builds.
REPO_REVISION_:=$(Shell git rev-list HEAD --count)
BUILD_BRANCH:=$(Shell git rev-parse --abbrev-ref HEAD)
BUILD_REV_ID:=$(Shell git rev-parse HEAD)
BUILD_REV_ID_SHORT:=$(Shell git describe --long --tags --dirty --always)
ifeq ($(BUILD_BRANCH), master)
REPO_REVISION:=$(REPO_REVISION_)_g$(BUILD_REV_ID_SHORT)
else
REPO_REVISION:=$(BUILD_BRANCH)_$(REPO_REVISION_)_r$(BUILD_REV_ID_SHORT)
endif
export REPO_REVISION
export BUILD_BRANCH
export BUILD_REV_ID
6
Ralph Williamson

J'ai écrit quelques utilitaires PowerShell pour récupérer les informations de version de Git et simplifier le marquage.

fonctions: Get-LastVersion, Get-Revision, Get-NextMajorVersion, Get-NextMinorVersion, TagNextMajorVersion, TagNextMinorVersion:

# Returns the last version by analysing existing tags,
# assumes an initial tag is present, and
# assumes tags are named v{major}.{minor}.[{revision}]
#
function Get-LastVersion(){
  $lastTagCommit = git rev-list --tags --max-count=1
  $lastTag = git describe --tags $lastTagCommit
  $tagPrefix = "v"
  $versionString = $lastTag -replace "$tagPrefix", ""
  Write-Host -NoNewline "last tagged commit "
  Write-Host -NoNewline -ForegroundColor "yellow" $lastTag
  Write-Host -NoNewline " revision "
  Write-Host -ForegroundColor "yellow" "$lastTagCommit"
  [reflection.Assembly]::LoadWithPartialName("System.Version")

  $version = New-Object System.Version($versionString)
  return $version;
}

# Returns current revision by counting the number of commits to HEAD
function Get-Revision(){
   $lastTagCommit = git rev-list HEAD
   $revs  = git rev-list $lastTagCommit |  Measure-Object -Line
   return $revs.Lines
}

# Returns the next major version {major}.{minor}.{revision}
function Get-NextMajorVersion(){
    $version = Get-LastVersion;
    [reflection.Assembly]::LoadWithPartialName("System.Version")
    [int] $major = $version.Major+1;
    $rev = Get-Revision
    $nextMajor = New-Object System.Version($major, 0, $rev);
    return $nextMajor;
}

# Returns the next minor version {major}.{minor}.{revision}
function Get-NextMinorVersion(){
    $version = Get-LastVersion;
    [reflection.Assembly]::LoadWithPartialName("System.Version")
    [int] $minor = $version.Minor+1;
    $rev = Get-Revision
    $next = New-Object System.Version($version.Major, $minor, $rev);
    return $next;
}

# Creates a tag with the next minor version
function TagNextMinorVersion($tagMessage){
    $version = Get-NextMinorVersion;
    $tagName = "v{0}" -f "$version".Trim();
    Write-Host -NoNewline "Tagging next minor version to ";
    Write-Host -ForegroundColor DarkYellow "$tagName";
    git tag -a $tagName -m $tagMessage
}

# Creates a tag with the next major version (minor version starts again at 0)
function TagNextMajorVersion($tagMessage){
    $version = Get-NextMajorVersion;
    $tagName = "v{0}" -f "$version".Trim();
    Write-Host -NoNewline "Tagging next majo version to ";
    Write-Host -ForegroundColor DarkYellow "$tagName";
    git tag -a $tagName -m $tagMessage
}
5
toeb

Le problème avec l’utilisation du hachage git comme numéro de construction est qu’il n’augmente pas de façon monotone. OSGi suggère d'utiliser un horodatage pour le numéro de build. Il semble que le nombre de commits dans la branche pourrait être utilisé à la place du numéro de changement Subversion ou forcé.

4
Jim Belton

Chaque commit a un hachage unique. Autre que cela, il n'y a pas de numéro de révision dans git. Vous devrez marquer vous-même si vous voulez plus de convivialité.

4
Core Xii

Je voudrais juste noter une autre approche possible - en utilisant gitgit-notes (1) }, existant depuis la v 1.6.6 ( Note to Self - Git ) (J'utilise git version 1.7.9.5).

Fondamentalement, j’ai utilisé git svn pour cloner un référentiel SVN avec un historique linéaire (pas de mise en page standard, pas de branches, pas de balises) et je voulais comparer les numéros de révision dans le référentiel git cloné. Ce clone git n'a pas de tags par défaut, je ne peux donc pas utiliser git describe. La stratégie ici ne fonctionnerait probablement que pour une histoire linéaire - sans savoir comment cela se passerait avec les fusions, etc. mais voici la stratégie de base:

  • Demandez à git rev-list la liste de tous les historiques de validation
    • Puisque rev-list est par défaut dans "l'ordre chronologique inverse", nous utiliserions son commutateur --reverse pour obtenir la liste des commits triés par ordre croissant.
  • Utilisez bash Shell pour
    • augmenter une variable de compteur sur chaque commit en tant que compteur de révision,
    • générer et ajouter une note "temporaire" pour chaque commit
  • Ensuite, parcourez le journal en utilisant git log avec --notes, qui dumpera également une note de validation, qui dans ce cas serait le "numéro de révision".
  • Une fois terminé, effacez les notes temporaires (NB: Je ne suis pas sûr si ces notes sont validées ou non; elles ne sont pas vraiment affichées dans git status)

Premièrement, notons que git a un emplacement par défaut de notes - mais vous pouvez également spécifier un ref (erence) pour les notes - qui les stockeraient dans un répertoire différent sous .git; Par exemple, lorsque vous êtes dans un dossier de dépôt git, vous pouvez appeler git notes get-ref pour voir quel répertoire sera:

$ git notes get-ref
refs/notes/commits
$ git notes --ref=whatever get-ref
refs/notes/whatever

La chose à noter est que si vous notes add avec un --ref, vous devez également utiliser cette référence ultérieurement, sinon vous risquez d'obtenir des erreurs du type "Aucune note trouvée pour l'objet XXX ...".

Pour cet exemple, j'ai choisi d'appeler "ref" des notes "linrev" (pour la révision linéaire) - cela signifie également qu'il est peu probable que la procédure interfère avec des notes déjà existantes. J'utilise également le commutateur --git-dir, étant donné que je suis un débutant git, j'ai eu quelques problèmes pour le comprendre. J'aimerais donc "me souvenir pour plus tard" :); et j'utilise aussi --no-pager pour supprimer la génération de less lorsque git log est utilisé.

Donc, en supposant que vous soyez dans un répertoire, avec un sous-dossier myrepo_git qui est un référentiel git; on pourrait faire:

### check for already existing notes:

$ git --git-dir=./myrepo_git/.git notes show
# error: No note found for object 04051f98ece25cff67e62d13c548dacbee6c1e33.
$ git --git-dir=./myrepo_git/.git notes --ref=linrev show
# error: No note found for object 04051f98ece25cff67e62d13c548dacbee6c1e33.

### iterate through rev-list three, oldest first,
### create a cmdline adding a revision count as note to each revision

$ ix=0; for ih in $(git --git-dir=./myrepo_git/.git rev-list --reverse HEAD); do \
  TCMD="git --git-dir=./myrepo_git/.git notes --ref linrev"; \
  TCMD="$TCMD add $ih -m \"(r$((++ix)))\""; \
  echo "$TCMD"; \
  eval "$TCMD"; \
done

# git --git-dir=./myrepo_git/.git notes --ref linrev add 6886bbb7be18e63fc4be68ba41917b48f02e09d7 -m "(r1)"
# git --git-dir=./myrepo_git/.git notes --ref linrev add f34910dbeeee33a40806d29dd956062d6ab3ad97 -m "(r2)"
# ...
# git --git-dir=./myrepo_git/.git notes --ref linrev add 04051f98ece25cff67e62d13c548dacbee6c1e33 -m "(r15)"

### check status - adding notes seem to not affect it:

$ cd myrepo_git/
$ git status
# # On branch master
# nothing to commit (working directory clean)
$ cd ../

### check notes again:

$ git --git-dir=./myrepo_git/.git notes show
# error: No note found for object 04051f98ece25cff67e62d13c548dacbee6c1e33.
$ git --git-dir=./myrepo_git/.git notes --ref=linrev show
# (r15)

### note is saved - now let's issue a `git log` command, using a format string and notes:

$ git --git-dir=./myrepo_git/.git --no-pager log --notes=linrev --format=format:"%h: %an: %ad:  >>%s<< %N" HEAD
# 04051f9: _user_: Sun Apr 21 18:29:02 2013 +0000:  >>test message 15 << (r15)
# 77f3902: _user_: Sun Apr 21 18:29:00 2013 +0000:  >>test message 14<< (r14)
# ...
# 6886bbb: _user_: Sun Apr 21 17:11:52 2013 +0000:  >>initial test message 1<< (r1)

### test git log with range:

$ git --git-dir=./myrepo_git/.git --no-pager log --notes=linrev --format=format:"%h: %an: %ad:  >>%s<< %N" HEAD^..HEAD
# 04051f9: _user_: Sun Apr 21 18:29:02 2013 +0000:  >>test message 15 << (r15)

### erase notes - again must iterate through rev-list

$ ix=0; for ih in $(git --git-dir=./myrepo_git/.git rev-list --reverse HEAD); do \
  TCMD="git --git-dir=./myrepo_git/.git notes --ref linrev"; \
  TCMD="$TCMD remove $ih"; \
  echo "$TCMD"; \
  eval "$TCMD"; \
done
# git --git-dir=./myrepo_git/.git notes --ref linrev remove 6886bbb7be18e63fc4be68ba41917b48f02e09d7
# Removing note for object 6886bbb7be18e63fc4be68ba41917b48f02e09d7
# git --git-dir=./myrepo_git/.git notes --ref linrev remove f34910dbeeee33a40806d29dd956062d6ab3ad97
# Removing note for object f34910dbeeee33a40806d29dd956062d6ab3ad97
# ...
# git --git-dir=./myrepo_git/.git notes --ref linrev remove 04051f98ece25cff67e62d13c548dacbee6c1e33
# Removing note for object 04051f98ece25cff67e62d13c548dacbee6c1e33

### check notes again:

$ git --git-dir=./myrepo_git/.git notes show
# error: No note found for object 04051f98ece25cff67e62d13c548dacbee6c1e33.
$ git --git-dir=./myrepo_git/.git notes --ref=linrev show
# error: No note found for object 04051f98ece25cff67e62d13c548dacbee6c1e33.

Ainsi, du moins dans mon cas spécifique d’historique entièrement linéaire sans branches, les numéros de révision semblent correspondre à cette approche. De plus, il semble que cette approche permette d’utiliser git log avec des plages de révision, tout en obtenant les bons numéros de révision - YMMV avec un contexte différent, cependant ...

J'espère que ça aide quelqu'un,
À votre santé!

EDIT: Ok, ici c'est un peu plus facile, avec les alias git pour les boucles ci-dessus, appelés setlinrev et unsetlinrev; dans votre dossier de référentiel git, faites (Notez le bash échappé méchant, voir aussi # 16136745 - Ajouter un alias Git contenant un point-virgule): 

cat >> .git/config <<"EOF"
[alias]
  setlinrev = "!bash -c 'ix=0; for ih in $(git rev-list --reverse HEAD); do \n\
      TCMD=\"git notes --ref linrev\"; \n\
      TCMD=\"$TCMD add $ih -m \\\"(r\\$((++ix)))\\\"\"; \n\
      #echo \"$TCMD\"; \n\
      eval \"$TCMD\"; \n\
    done; \n\
    echo \"Linear revision notes are set.\" '"

  unsetlinrev = "!bash -c 'ix=0; for ih in $(git rev-list --reverse HEAD); do \n\
      TCMD=\"git notes --ref linrev\"; \n\
      TCMD=\"$TCMD remove $ih\"; \n\
      #echo \"$TCMD\"; \n\
      eval \"$TCMD 2>/dev/null\"; \n\
    done; \n\
    echo \"Linear revision notes are unset.\" '"
EOF

... afin que vous puissiez simplement appeler git setlinrev avant d'essayer de créer un journal impliquant des notes de révision linéaire; et git unsetlinrev pour supprimer ces notes lorsque vous avez terminé; un exemple depuis le répertoire git repo:

$ git log --notes=linrev --format=format:"%h: %an: %ad:  >>%s<< %N" HEAD^..HEAD
04051f9: _user_: Sun Apr 21 18:29:02 2013 +0000:  >>test message 15 <<

$ git setlinrev
Linear revision notes are set.
$ git log --notes=linrev --format=format:"%h: %an: %ad:  >>%s<< %N" HEAD^..HEAD
04051f9: _user_: Sun Apr 21 18:29:02 2013 +0000:  >>test message 15 << (r15)
$ git unsetlinrev
Linear revision notes are unset.

$ git log --notes=linrev --format=format:"%h: %an: %ad:  >>%s<< %N" HEAD^..HEAD
04051f9: _user_: Sun Apr 21 18:29:02 2013 +0000:  >>test message 15 <<

Le temps qu'il faudrait au shell pour terminer ces alias dépend de la taille de l'historique du référentiel. 

3
sdaau

Pour les personnes ayant un processus Ant build, vous pouvez générer un numéro de version pour un projet sur git avec cette cible:

<target name="generate-version">

    <exec executable="git" outputproperty="version.revisions">
        <arg value="log"/>
        <arg value="--oneline"/>
    </exec>

    <resourcecount property="version.revision" count="0" when="eq">
        <tokens>
            <concat>
                <filterchain>
                    <tokenfilter>
                        <stringtokenizer delims="\r" />
                    </tokenfilter>
                </filterchain>
            <propertyresource name="version.revisions" />
            </concat>
        </tokens>
    </resourcecount>
    <echo>Revision : ${version.revision}</echo>

    <exec executable="git" outputproperty="version.hash">
        <arg value="rev-parse"/>
        <arg value="--short"/>
        <arg value="HEAD"/>
    </exec>
    <echo>Hash : ${version.hash}</echo>


    <exec executable="git" outputproperty="version.branch">
        <arg value="rev-parse"/>
        <arg value="--abbrev-ref"/>
        <arg value="HEAD"/>
    </exec>
    <echo>Branch : ${version.branch}</echo>

    <exec executable="git" outputproperty="version.diff">
        <arg value="diff"/>
    </exec>

    <condition property="version.dirty" value="" else="-dirty">
        <equals arg1="${version.diff}" arg2=""/>
    </condition>

    <tstamp>
        <format property="version.date" pattern="yyyy-mm-dd.HH:mm:ss" locale="en,US"/>
    </tstamp>
    <echo>Date : ${version.date}</echo>

    <property name="version" value="${version.revision}.${version.hash}.${version.branch}${version.dirty}.${version.date}" />

    <echo>Version : ${version}</echo>

    <echo file="version.properties" append="false">version = ${version}</echo>

</target>

Le résultat ressemble à ceci:

generate-version:
    [echo] Generate version
    [echo] Revision : 47
    [echo] Hash : 2af0b99
    [echo] Branch : master
    [echo] Date : 2015-04-20.15:04:03
    [echo] Version : 47.2af0b99.master-dirty.2015-04-20.15:04:03

Le fanion est présent lorsque vous avez des fichiers non validés lors de la génération du numéro de version. Parce que généralement, lorsque vous construisez/mettez en package votre application, chaque modification de code doit être dans le référentiel.

2
Fredo

Dans le manuel Git, les tags sont une réponse brillante à ce problème:

Créer une balise annotée dans Git est simple. Le moyen le plus simple est de spécifiez -a lorsque vous exécutez la commande tag:

$ git tag -a v1.4 -m 'my version 1.4'

$ git tag
v0.1
v1.3
v1.4

Check out 2.6 Principes de base de Git - Marquage

1
DJ Far

Avec l'identifiant SHA-1 du commit, la date et l'heure de l'heure du serveur auraient été utiles?

Quelque chose comme ça:

s’il s’est passé à 11:30:25 le 19 août 2013 s’afficherait sous la forme 6886bbb7be18e63fc4be68ba41917b48f02e09d7_19aug2013_113025

1
Manoranjan Sahu

Nous utilisons cette commande pour obtenir la version et la révision de git:

git describe --tags --exact-match 2> /dev/null || git describe --always

Il retourne

  • commit hachage en tant que révision quand aucun marquage n'est utilisé (par exemple, gcc7b71f)
  • nom de balise comme version lorsque vous vous trouvez sur une balise (par exemple, v2.1.0, utilisé pour les versions)
  • nom de la balise, numéro de révision depuis la dernière balise et validation avec hachage après une balise (par exemple v5.3.0-88-gcc7b71f)
1
thisismydesign

Evénement post-construction pour Visual Studio

echo  >RevisionNumber.cs static class Git { public static int RevisionNumber =
git  >>RevisionNumber.cs rev-list --count HEAD
echo >>RevisionNumber.cs ; }
0
Polluks

Après une longue recherche dans les dépôts en ligne, j'ai constaté que logiquement, il n'y avait aucune différence entre un numéro de révision et un numéro de validation dans Git.

0
Judith Francisca