Deriving application build version from `git describe` - how to get a relatively straightforward string?

Question

UPDATE

I see that this question has become somewhat popular. It's now years into my admittedly enjoyable Git use, and I have learned a lot since then. Please, pretty please read the last paragraph before going on about your Git adventures with whatever you will have learned from this Q&A.

---

I want to compose application build version that is automatically derived from GIT branch name I am on (when building) and the number of commits since the branch has diverged. I believe this will be unique for any commit in my GIT repository? Branch names are unique, and commits are linked to each other along a branch? If and when I tag a commit, I can also have the version be prefixed with that tag.

In a way git describe does what I want, but it does not include the branch name I am on, and it includes abbreviated commit SHA-1 hash, which I don't think I need as it does not add anything to the entropy of the string and may be redundant (I may be wrong here, so please correct me).

What are my options? And am I thinking in the right direction here at all? I am just a bit tired of appending numbers to versions when I have more important things to deal with with regards to software development.

I never build with a dirty working tree, by the way. I.e. I always commit changes to the repository before building a public release.

I am now aware that Git branches are just commit references, and so, many branches (and tags!) may point to a single commit. Therefore, the question "which branch does this commit belong to / lie on" is not entirely valid with Git. Git does track a "current" branch you're on -- the one it has checked out for you -- but at the same time any number of other branches may be pointing to the same commit and arguably no single branch can be chosen as "main" unless you want to mean the one currently checked out to disk. Please read the following answer on this page for elaboration.

Answer 1

The thing you have you to understand about git is that branches are essentially merely commit bookmarks. The fact that you were on the foo branch when you made the 0deadbeef commit is immaterial to the commit itself; the branch is not part of its identity.

(Mercurial bakes the branch name into the commit. In a variety of ways, this is inferior, as Dustin Sallings explains.)

Even assuming that git describe would just use the currently checked out branch – if you have a mergy history, there could be multiple paths leading to the same most recent tagged commit that git describe would use. So there isn’t even necessarily any one branch.

Another note: you may object that even if “3rd commit from tag X” is ambiguous in the general case, git describe could just look at the graph and figure out whether it is ambiguous and if not, leave out the hash. However, there is nothing stopping anyone starting a branch on top of that tag at a later time – so then your describe string would become ambiguous retrospectively.

Bottom line is that the only unambiguous identifier of a commit is its hash. So that must be in there. What git describe does is add some redundant (and in case of the commit number, ambiguous) information that makes the description more useful to the kind of spatial/relational comprehension that humans orient themselves with, within the confines of the Git model.

Answer 2

Here is what I use:

echo "`git symbolic-ref HEAD 2> /dev/null | cut -b 12-`-`git log --pretty=format:\"%h\" -1`"

It produces something like:

master-6de772e

As noted by Aristotle, in actuality the SHA-1 by itself is all that is necessary and sufficient to provide an unambiguous build tag, as well as full information regarding the developmental historical context. Everything else is redundant, in the sense that any information they provide can be figured out or derived from the SHA-1. However, humans might like the supplementary contextual information of the actual branch immediately evident as well (or, at least, this human does), and hence the embedding of the branch name into the label. For this reason also (i.e. immediate human parsing of the information), most of my projects also use a longer build identity 'description' that includes the date and time of the commit that the build was based on in addition to the build identity 'label' given above.

Answer 3

git describe --long would always output version number like this: v1.2-10-gdeadbee, which means 10th commit since annotated tag 'v1.2' that points at commit with shortened SHA-1 'deadbee'. So all you have to do is to tag branch start (branching point of a branch) e.g. <branch>-start.

The abbreviated commit SHA-1 hash is required to distinguish between ambiguous situations, because "3rd commit since tag 'x'" (for example) does not uniquely distinguish a commit; there can be more than one commit that fits mentioned description in the presence of nonlinear, branchy development. For example in the situation shown on the ASCII-art diagram below both commits marked with * fits "3rd commit since tag 'x'" description.

          /-.---*---.-\                   
         /             \                  
.---x---.---.---*---.---M---.    <--- branch

_{Note that in "merged in" case as shown above you can't use branch name to distinguish between those two commits with the same description.}

So what you have to do would be to take git describe --long output (the --long option is here to avoid ambiguities with parsing, see git describe manpage), parse it, and add current branch info (from e.g. git symbolic-ref HEAD, not from pasing git branch output) yourself.

Answer 4

Official releases should have a tag with their version number. In this case I suggest the following approach:

1. If the current commit has a tag, use that tag
2. If no tag is available, use the branch name and the SHA1-key

This single command should work:

git describe --exact-match 2> /dev/null || echo "`git symbolic-ref HEAD 2> /dev/null | cut -b 12-`-`git log --pretty=format:\"%h\" -1`"