I'd like to get the number of commits of my Git repository, a bit like SVN revision numbers.
The goal is to use it as a unique, incrementing build number.
I currently do like that, on Unix/Cygwin/msysGit:
git log --pretty=format:'' | wc -l
But I feel it's a bit of a hack.
Is there a better way to do that? It would be cool if I actually didn't need wc
or even Git, so it could work on a bare Windows. Just read a file or a directory structure...
This question is related to
git
build-process
revision
Generate a number during the build and write it to a file. Whenever you make a release, commit that file with the comment "Build 147" (or whatever the build number currently is). Don't commit the file during normal development. This way, you can easily map between build numbers and versions in Git.
git rev-parse --short HEAD
If you’re looking for a unique and still quite readable identifier for commits, git describe might be just the thing for you.
Git shortlog is one way to get the commit details:
git shortlog -s -n
This will give the number of commits followed by the author name. The -s option removes all the commit messages for each commit that the author made. Remove the same option if you would like to see the commit messages also. The -n option is used for sorting the entire list. Hope this helps.
The following command prints the total number of commits on the current branch.
git shortlog -s -n | awk '{ sum += $1; } END { print sum; }' "$@"
It is made up of two parts:
Print the total logs number grouped by author (git shortlog -s -n
)
Example output
1445 John C
1398 Tom D
1376 Chrsitopher P
166 Justin T
166 You
Sum up the total commit number of each author, i.e. the first argument of each line, and print the result out (awk '{ sum += $1; } END { print sum; }' "$@"
)
Using the same example as above it will sum up 1445 + 1398 + 1376 + 166 + 166
. Therefore the output will be:
4,551
There's a nice helper script that the Git folks use to help generate a useful version number based on Git describe. I show the script and explain it in my answer to How would you include the current commit id in a Git project's files?.
How about making an alias
?
alias gc="git rev-list --all --count" #Or whatever name you wish
git config --global alias.count 'rev-list --all --count'
If you add this to your config, you can just reference the command;
git count
You are not the first one to think about a "revision number" in Git, but 'wc
' is quite dangerous, since commit can be erased or squashed, and the history revisited.
The "revision number" was especially important for Subversion since it was needed in case of merge (SVN1.5 and 1.6 have improved on that front).
You could end up with a pre-commit hook which would include a revision number in the comment, with an algorithm not involving looking up the all history of a branch to determine the correct number.
Bazaar actually came up with such an algorithm , and it may be a good starting point for what you want to do.
(As Bombe's answer points out, Git has actually an algorithm of its own, based on the latest tag, plus the number of commits, plus a bit of an SHA-1 key). You should see (and upvote) his answer if it works for you.
To illustrate Aaron's idea, you can also append the Git commit hash into an application’s "info" file you are distributing with your application.
That way, the about box would look like:
The applicative number is part of the commit, but the 'application’s "info" file' is generated during the packaging process, effectively linking an applicative build number to a technical revision id.
A simple way is:
git log --oneline | wc -l
oneline
ensures that.
To get it into a variable, the easiest way is:
export GIT_REV_COUNT=`git rev-list --all --count`
Using Bash syntax,
$(git rev-list --count HEAD)
looks fine for purely linear history. If you also want to sometimes have “numbers” from branches (based off master
), consider:
$(git rev-list --count $(git merge-base master HEAD)).$(git rev-list --count ^master HEAD)
When run from a checkout of master
, you get simply 1234.0
or the like. When run from a checkout of a branch you will get something like 1234.13
, if there have been 13 commits made on that branch. Obviously this is useful only insofar as you are basing at most one branch off a given master
revision.
--first-parent
could be added to the micro number to suppress some commits arising only from merging other branches, though it is probably unnecessary.
git shortlog
by itself does not address the original question of total number of commits (not grouped by author)
That is true, and git rev-list HEAD --count remains the simplest answer.
However, with Git 2.29 (Q4 2020), "git shortlog
"(man) has become more precise.
It has been taught to group commits by the contents of the trailer lines, like "Reviewed-by:
", "Coauthored-by:
", etc.
See commit 63d24fa, commit 56d5dde, commit 87abb96, commit f17b0b9, commit 47beb37, commit f0939a0, commit 92338c4 (27 Sep 2020), and commit 45d93eb (25 Sep 2020) by Jeff King (peff
).
(Merged by Junio C Hamano -- gitster
-- in commit 2fa8aac, 04 Oct 2020)
shortlog
: allow multiple groups to be specifiedSigned-off-by: Jeff King
Now that
shortlog
supports reading from trailers, it can be useful to combine counts from multiple trailers, or between trailers and authors.
This can be done manually by post-processing the output from multiple runs, but it's non-trivial to make sure that each name/commit pair is counted only once.This patch teaches shortlog to accept multiple
--group
options on the command line, and pull data from all of them.That makes it possible to run:
git shortlog -ns --group=author --group=trailer:co-authored-by
to get a shortlog that counts authors and co-authors equally.
The implementation is mostly straightforward. The "
group
" enum becomes a bitfield, and the trailer key becomes a list.
I didn't bother implementing the multi-group semantics for reading from stdin. It would be possible to do, but the existing matching code makes it awkward, and I doubt anybody cares.The duplicate suppression we used for trailers now covers authors and committers as well (though in non-trailer single-group mode we can skip the hash insertion and lookup, since we only see one value per commit).
There is one subtlety: we now care about the case when no group bit is set (in which case we default to showing the author).
The caller inbuiltin/log.c
needs to be adapted to ask explicitly for authors, rather than relying onshortlog_init()
. It would be possible with some gymnastics to make this keep working as-is, but it's not worth it for a single caller.
git shortlog
now includes in its man page:
--group=<type>
Group commits based on
<type>
. If no--group
option is specified, the default isauthor
.<type>
is one of:
author
, commits are grouped by authorcommitter
, commits are grouped by committer (the same as-c
)This is an alias for
--group=committer
.
git shortlog
now also includes in its man page:
If
--group
is specified multiple times, commits are counted under each value (but again, only once per unique value in that commit). For example,git shortlog --group=author --group=trailer:co-authored-by
counts both authors and co-authors.
This command returns count of commits grouped by committers:
git shortlog -s
Output:
14 John lennon
9 Janis Joplin
You may want to know that the -s
argument is the contraction form of --summary
.
You can try
git log --oneline | wc -l
or to list all the commits done by the people contributing in the repository
git shortlog -s
git shortlog
is one way.
Use git shortlog just like this
git shortlog -sn
Or create an alias (for ZSH based terminal)
# show contributors by commits
alias gcall="git shortlog -sn"
git rev-list HEAD --count
git rev-list <commit>
:
List commits that are reachable by following the parent links from the given commit (in this case, HEAD).
--count
: Print a number stating how many commits would have been listed, and suppress all other output.
The one I used to use was:
git log | grep "^commit" | wc -l
Simple but it worked.
U can just use :
git shortlog -s -n
Result :
827 user one
15 user two
2 Gest
In our company, we moved from SVN to Git. Lack of revision numbers was a big problem!
Do git svn clone
, and then tag the last SVN commit by its SVN revision number:
export hr=`git svn find-rev HEAD`
git tag "$hr" -f HEAD
Then you can get the revision number with help of
git describe --tags --long
This command gives something like:
7603-3-g7f4610d
Means: The last tag is 7603 - it's the SVN revision. 3 - is count of commits from it. We need to add them.
So, the revision number can be counted by this script:
expr $(git describe --tags --long | cut -d '-' -f 1) + $(git describe --tags --long | cut -d '-' -f 2)
If you're just using one branch, such as master, I think this would work great:
git rev-list --full-history --all | wc -l
This will only output a number. You can alias it to something like
git revno
to make things really convenient. To do so, edit your .git/config
file and add this in:
[alias]
revno = "!git rev-list --full-history --all | wc -l"
This will not work on Windows. I do not know the equivalent of "wc" for that OS, but writing a Python script to do the counting for you would be a multi-platform solution.
EDIT: Get count between two commits:
I was looking for an answer that would show how to get the number of commits between two arbitrary revisions and didn't see any.
git rev-list --count [older-commit]..[newer-commit]
Source: Stackoverflow.com