Revizyon numarası için Git eşdeğeri nedir?

İşyerinde SVN kullanıyoruz, ancak kişisel projelerim için Git'i kullanmaya karar verdim. Bu yüzden dün Git yüklü ve ben ne olduğunu merak revizyon numarası eşdeğer Git'te .

Diyelim ki 3.0.8 sürümü üzerinde çalışıyoruz ve her hata düzeltmesinin bu hata düzeltmesi hakkında konuşurken kullanabileceğimiz kendi revizyon numarası var. Git 3.0.8 kodunu etiketlemek durumunda ne bir revizyon numarası ya da daha ayrıntılı bir tanımlama türü olarak kullanabilirsiniz? Hash'i insanlar için çok kullanıcı dostu bulmuyorum.

Senin için iyi ya da kötü haber, bu hash revizyon numarası. SVN'den git'e geçiş yaptığımda da bu konuda sorun yaşadım.

Belirli bir sürümü belirli bir sürümü "sürüm" olarak etiketlemek için git'teki "etiketleme" yi kullanarak bu düzeltmeyi ifade etmeyi kolaylaştırabilirsiniz. Bu blog yayınına göz atın .

Anlaşılması gereken en önemli şey, git'in revizyon numaralarına sahip olamayacağıdır - merkezi olmayan doğayı düşünün. Hem A hem de B kullanıcıları yerel depolarına bağlılık gösteriyorsa, git makul bir şekilde sıralı revizyon numarası nasıl atayabilir? A'nın birbirlerinin değişikliklerini itmeden / çekmeden önce B hakkında bilgisi yoktur.

Bakılacak başka bir şey, bugfix dalları için basitleştirilmiş dallanma:

Bir sürümle başlayın: 3.0.8. Ardından, bu sürümden sonra şunu yapın:

git branch bugfixes308

Bu, hata düzeltmeleri için bir dal oluşturur. Şubeye göz at:

git checkout bugfixes308

Şimdi istediğiniz hata düzeltme değişikliklerini yapın.

git commit -a

Onları taahhüt edin ve ana şubeye geri dönün:

git checkout master

Ardından bu değişiklikleri diğer şubeden çekin:

git merge bugfixes308

Bu şekilde, ayrı bir sürüme özgü hata düzeltme dalınız olur, ancak hata düzeltme değişikliklerini ana geliştirici bagajınıza çekmeye devam edersiniz.

Modern Git (benim durumumda 1.8.3.4) ve şubeleri kullanmadan şunları yapabilirsiniz:

$ git rev-list --count HEAD
68

git describeKomut Belli bir bölüme işlemek anlamına gelir biraz daha insan okunabilir adını oluşturur. Örneğin, belgelerden:

Geçerli ağaç git.git gibi bir şeyle:

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

yani "ana" dalımın şu anki başkanı v1.0.4'e dayanıyor, ancak bunun üzerinde birkaç taahhüt bulunduğundan, açıklama ek taahhütlerin sayısını ("14") ve taahhüt için kısaltılmış bir nesne adını ekledi kendisi ("2414721").

Belirli sürümleri etiketlemek için makul şekilde adlandırılmış etiketler kullandığınız sürece, bunun kabaca bir SVN "revizyon numarası" na eşdeğer olduğu düşünülebilir.

Diğer posterler haklı, "revizyon numarası" yok.

Bence en iyi yol "sürümler" için Etiketler kullanmaktır!

Ancak sahte revizyon numaralarını yapmak için aşağıdakileri kullandım (sadece müşterilerin revizyonları ve ilerlemeyi görmeleri, git'ten yıkım ile kullandıkları yerlerde gittikçe artan revizyonlara sahip olmak istedikleri için).

"HEAD" ifadesinin "geçerli revizyonu" nu şu şekilde simüle ettiğini göster:

git rev-list HEAD | wc -l

Peki ya müşteri "revizyon" 1302'de bir hata olduğunu söylese ne olur?

Bunun için ~ / .gitconfig [takma ad] bölümüne aşağıdakileri ekledim:

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

kullanarak " karma " git show-rev-number 1302için karma yazdırır :)

Bir süre önce bu "teknik" hakkında bir blog yazısı (Almanca) yaptım .

Git, alt sürümle aynı revizyon numarası kavramına sahip değildir. Bunun yerine, bir taahhüt ile yapılan her bir anlık görüntü bir SHA1 sağlama toplamı ile etiketlenir. Neden? Dağıtılmış bir sürüm kontrol sisteminde çalışan bir revno ile ilgili birkaç sorun vardır:

Birincisi, gelişme hiç doğrusal olmadığı için, bir sayının eklenmesi, bir programcı olarak ihtiyacınızı karşılayacak bir şekilde çözülmesi bir problem olarak oldukça zordur. Bir sayı ekleyerek bunu düzeltmeye çalışmak, sayı beklediğiniz gibi davranmadığında hızla sorunlu hale gelebilir.

İkinci olarak, revizyon numaraları farklı makinelerde üretilebilir. Bu, özellikle bağlantı tek yönlü olduğu için sayıların senkronizasyonunu çok daha zorlaştırır; depoya sahip tüm makinelere erişemeyebilirsiniz.

Üçüncüsü, git'te, şu anda geçersiz olan OpenCM sistemi tarafından öncülük edildiğinde, bir taahhüdün kimliği (taahhüdün ne olduğu) adına (SHA kimliği) eşdeğerdir . Bu adlandırma = kimlik kavramı çok güçlü. Elinizde bir taahhüt adı ile oturduğunuzda, taahhüdü unutulmaz bir şekilde de tanımlar. Bu da, komutta yolsuzluk olup olmadığını kontrol etmek için ilk taahhütlerinize geri dönmenizi sağlargit fsck .

Şimdi, DAG (Yönlendirilmiş Asiklik Grafiği) elimizde olduğu ve bunlar mevcut ağacı oluşturduğundan, sorununuzu çözmek için bazı araçlara ihtiyacımız var : Farklı sürümleri nasıl ayırt ederiz. İlk olarak, verilen bir önek, 1516bd der ki, taahhüdünüzü benzersiz bir şekilde tanımlarsa , karma işleminin bir kısmını atlayabilirsiniz . Ancak bu da oldukça çelişkilidir. Bunun yerine, hile etiketleri ve veya dalları kullanmaktır. Bir etiket veya dal, belirli bir SHA1 kimliğine eklediğiniz "sarı renkli bir çubuk not" a benzer. Etiketler, özünde, hareketsiz olması anlamına gelirken, HEAD'a yeni taahhütler verildiğinde bir şube hareket edecektir. Bir etiketin veya dalın çevresindeki bir taahhüde başvurmanın yolları vardır, git-rev-ayrıştırma kılavuz sayfasına bakın.

Genellikle, belirli bir kod parçası üzerinde çalışmanız gerekiyorsa, bu parça değişikliklere uğrar ve söz konusu konu adı olan bir dal olmalıdır. Çok sayıda şube oluşturmak (programcı başına 20-30 duyulmamış, diğerlerinin çalışması için 4-5 yayınlanmış) etkili git için hile. Her çalışma kendi dalı olarak başlamalı ve daha sonra test edildiğinde birleştirilmelidir. Yayımlanmamış dallar tamamen yeniden yazılabilir ve tarihi yok etmenin bu kısmı bir git gücüdür.

Değişim üstadı olarak kabul edildiğinde , biraz donar ve arkeoloji olur. Bu noktada, etiketleyebilirsiniz, ancak daha sıklıkla, belirli bir işleme bir sha1 toplamı aracılığıyla bir hata izleyici veya sorun izleyicide bir referans yapılır. Etiketler bakım dalları için sürüm tümenleri ve dallanma noktaları için ayrılma eğilimindedir (eski sürümler için).

İlgileniyorsanız, sürüm numaralarını burada git infos'tan otomatik olarak biçim altında yönettim

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

burada yapı toplam taahhüt sayısıdır. İlginç kodu göreceksiniz Makefile. Sürüm numarasının farklı kısmına erişmek için ilgili bölüm:

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)

Bir Bash işlevi:

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

gibi bir şey çıktılar

$ git_rev
2:0f8e14e:20130220

Yani

commit_count:last_abbrev_commit:date_YYmmdd

Taahhüt SHA1 karma Subversion sürüm numarası eşdeğerdir.

Diğer çözümlere dayanarak marka dosyamda yaptığım şey bu. Bu sadece kodunuza bir revizyon numarası vermekle kalmaz, aynı zamanda sürümü yeniden oluşturmanıza izin veren karmayı da ekler.

# 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

Git karmasını yapı numarası olarak kullanmanın sorunu monoton olarak artmamasıdır. OSGi, yapı numarası için bir zaman damgası kullanmanızı önerir. Şubeye verilen taahhütlerin sayısı, alt sürüm veya performans değişikliği sayısı yerine kullanılabilecek gibi görünüyor.

Git'ten sürüm bilgilerini almak ve etiketlemeyi basitleştirmek için bazı PowerShell yardımcı programları yazdım

fonksiyonları: Get-LastVersion, Get-Revizyon, 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
}

Her bir taahhüdün kendine has bir karması vardır. Bunun dışında git'te revizyon numarası yok. Daha fazla kullanıcı dostu olmak istiyorsanız etiketlerinizi kendiniz etiketlemeniz gerekir.

Sadece başka bir olası yaklaşımı not etmek istiyorum - ve v- 1.6.6'dan beri var olan git git-notes (1) kullanarak ( Self-Git'e Not ) ( git1.7.9.5 sürümünü kullanıyorum).

Temel olarak, git svnbir SVN deposunu doğrusal geçmişe sahip klonladım (standart düzen yok, dal yok, etiket yok) ve klonlanmış gitdepodaki revizyon numaralarını karşılaştırmak istedim . Bu git klonu varsayılan olarak etiket içermiyor, bu yüzden kullanamıyorum git describe. Buradaki strateji muhtemelen sadece doğrusal tarih için işe yarayacaktır - birleşme vb. İle nasıl sonuçlanacağından emin değil; ancak temel strateji şöyledir:

• git rev-listTüm taahhüt geçmişinin listesini isteyin
  • Yana rev-list"ters kronolojik sırayla" varsayılan olarak, biz onun kullanmayı tercih --reversekaydedilmesini listesi önce en eski Öneriliyor almak için anahtarı
• bashKabuğu kullan
  • revizyon sayacı olarak her taahhütte bir sayaç değişkenini artırmak,
  • her taahhüt için bir "geçici" git notu oluşturun ve ekleyin
• Ardından, günlüğüne git logbirlikte kullanarak gözatın --notes, bu da bir taahhüt notu çıkarır ve bu durumda "revizyon numarası" olur.
• İşiniz bittiğinde geçici notları silin ( Not: Bu notların işlenip işlenmediğinden emin değilim; gerçekten gösterilmiyorlargit status )

İlk olarak, gitnotların varsayılan konumunun bulunduğunu - ancak notlar için ref(erence) de belirtebileceğinizi ve bunları altında farklı bir dizinde depolayacağınızı unutmayın .git; örneğin, bir gitrepo klasöründeyken git notes get-refhangi dizinin olacağını görmek için arayabilirsiniz :

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

Dikkat edilmesi gereken şey notes add, a ile birlikte --refolursanız, daha sonra bu referansı tekrar kullanmanız gerekir - aksi takdirde " XXX nesnesi için not bulunamadı ... " gibi hatalar alabilirsiniz .

Bu örnekte, ref"linrev" notlarını (doğrusal revizyon için) çağırmayı seçtim - bu aynı zamanda prosedürün zaten var olan notlara müdahale etmesinin muhtemel olmadığı anlamına gelir. Ben de --git-diranahtarı kullanıyorum, bir gitacemi olduğundan, bunu anlamakta bazı problemlerim vardı - bu yüzden "daha sonra hatırlamak" istiyorum :); ve ben de kullanmak --no-pageryumurtlamasını bastırmak için lesskullanırken git log.

Yani, bir dizin içinde olduğunuzu varsayarsak myrepo_git, bir githavuz olan bir alt klasör ile ; biri yapabilirdi:

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

Yani, en azından şubesiz tam doğrusal geçmişimde, revizyon numaraları bu yaklaşımla eşleşiyor gibi görünüyor - ve ek olarak, bu yaklaşım git logrevizyon aralıklarıyla kullanılmaya izin verirken, hala doğru revizyon numaralarını almaya izin veriyor gibi görünüyor - YMMV farklı bir bağlamda ...

Umarım bu birine yardımcı olur,
Şerefe!

EDIT: Tamam, burada ve gitdenilen yukarıdaki döngüler için takma adlarla , biraz daha kolaydır ; git depo klasörünüzdeyken yapın ( _{Kötü kaçışa dikkat edin , ayrıca bkz. # 16136745 - Noktalı virgül içeren Git takma adı ekleyin} ):setlinrevunsetlinrevbash

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

... böylece git setlinrevdoğrusal revizyon notlarını içeren bir günlük yapmaya çalışmadan önce çağırabilirsiniz ; ve git unsetlinrevişiniz bittiğinde bu notları silmek için; git repo dizini içinden bir örnek:

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

Kabuğun bu takma adları tamamlaması için gereken süre, depo geçmişinin büyüklüğüne bağlı olacaktır.

Bir Ant derleme süreci olan kişiler için, git hedefindeki bir proje için şu hedefle bir sürüm numarası oluşturabilirsiniz:

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

Sonuç şuna benzer:

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

Sürüm numarasını oluştururken işlenmemiş dosyalarınız olduğunda kirli bayrak buradadır. Çünkü genellikle, uygulamanızı oluşturduğunuzda / paketlediğinizde her kod değişikliğinin depoda olması gerekir.

SHA-1 kimliği ile birlikte, kesinti, tarih ve saat sunucu saat yardımcı olurdu?

Bunun gibi bir şey:

taahhüt 19: 30'da 11: 30'da gerçekleşti 2013 6886bbb7be18e63fc4be68ba41917b48f02e09d7_19aug2013_113025

Git kılavuzundan etiketler bu sorunun parlak bir cevabıdır:

Git'te açıklamalı bir etiket oluşturmak basittir. En kolay yol tag komutunu çalıştırdığınızda -a belirtmektir:

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

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

Check out 2.6 Git Temelleri - Etiketleme

Git'ten sürüm ve düzeltme almak için bu komutu kullanıyoruz :

git describe --always --tags --dirty

Geri döner

• etiketleme kullanılmadığında karma değerini düzeltme olarak uygula (ör. gcc7b71f)
• bir etiketin üzerindeyken etiket adı (ör v2.1.0. sürümler için kullanılır)
• etiket adı, son etiketten bu yana yapılan düzeltme numarası ve bir etiketin ardından ne zaman karma (örn. v5.3.0-88-gcc7b71f)
• Aynı (örneğin yukarıda artı çalışma ağaç yerel değişiklikler varsa "kirli" etiketi olarak v5.3.0-88-gcc7b71f-dirty)

Ayrıca bkz: https://www.git-scm.com/docs/git-describe#Documentation/git-describe.txt

Visual Studio için derleme sonrası etkinliği

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

Kullanmayı düşünün

git-rev-label

Git veri havuzu revizyonu gibi bilgileri verir master-c73-gabc6bec. Şablon dizesini veya dosyasını Git değişkenlerinden ortam değişkenleri ve bilgilerle doldurabilir. Programın sürümü hakkında bilgi vermek için kullanışlıdır: şube, etiket, işleme karması, işlem sayısı, kirli durum, tarih ve saat. En yararlı şeylerden biri, birleştirilen şubeleri dikkate almayan taahhütlerin sayısıdır - sadece ilk ebeveyn.