git-log | A Atom package for git commit graphs

I believe what you want is the first token from the output of git describe --tags.

The two commands serve different purposes.

git ls-remote lists the references on a remote repository, but does not make any promises about the ordering in which they are listed. Sure, the most recent one is typically last, but it's not necessarily the most relevant one, especially if that tag was on a branch that didn't get merged yet.

git describe, on the other hand, is trying to give you a concise description of HEAD (by default, or the commit you specify) with respect to the most recent tag reachable from there. If you use your tags only for stable commits, then that's probably going to be the tag you want. Then, once it found that tag, it tells you how many more commits are in HEAD, 606 of them in your example, then "g" (not sure why), then the sha1 of HEAD. This is meant to be a human-readable description of any commit, as in, "oh, you're 606 commits ahead of v2.31.1", but also an unambiguous description, since you get the sha1.

As for adding the --tags option to git describe, you need it if you have tags without annotations, e.g., if some where created using git tag   instead of git tag -a . The latter is preferable, since it allows the tagger to describe the contents of the tag, but you can't always count on everyone using it. So it's probably a good idea to add --tags to git describe.

If your repo only contains tags for stable releases, and those releases are not on a different release branch, and you never have hyphens in your tag names, then this would be the most recent stable release that's a parent of HEAD:

Two reasons:

First: your first graph assumes that the branch topic is still around, and still points to C, which allows that segment of the graph to actually be labeled topic. If the branch was deleted, the graph would still be the same (and the merge commit would still probably say merge branch 'topic'), but the branch itself wouldn't have a label at its head.

Second: a commit can have multiple parents, but those parents aren't all equal; they're ordered. When you do git merge, the merge commit that's created will have the branch-merged-into as its first parent, and the branch-merged-in as its second parent. git log assumes this convention when it makes graphs: the first parent of a commit will be on the side that "continues straight", while the second parent will be on the side that "branches off". You can hand-craft a commit that violates this convention, and makes the graph do weird things, but there's not much reason to.

What to do?

Just define a function that does the compiletion with leading _git_ prefix.

In your situation with a subtree : @ChrisMaes comment linking to how to ignore a directory is a good suggestion.

Yes, you tell git log to ignore a commit and its parent.

Quoting git help log :

Thus, the following command:

Git will read the core.abbrev setting, if you've set it. If not, or if you set it to the literal string auto, the default is to compute an approximation, dynamically, based on the number of objects—well, an approximation of that number—in the Git repository, of a length that will be suitable as Lasse V. Karlsen noted in comments.

The git config documentation describes it this way:

core.abbrev
      Set the length object names are abbreviated to. If unspecified or set to "auto", an appropriate value is computed based on the approximate number of packed objects in your repository, which hopefully is enough for abbreviated object names to stay unique for some time. The minimum length is 4.

You mention that you have:

... two different repositories, one is showing 9 characters hash abbreviation [vs the more usual 7]

7 is the default minimum from the internal calculation (which uses a rough approximation of log2 of the approximated object count); the one with 9 must have many more objects in it than the others. As the documentation says, the goal is to produce an abbreviation that will still work even once the repository grows, so if it's estimating 9 now, there's a good chance that 7 still works now, but maybe won't by next year.

The internal git log algorithm is to insert "new" (unvisited) commits into a priority queue. The overall loop is:

A stupid thing to try : add an extra commit at the tip of your current branch, where you rename the problematic paths to paths that will not conflict :

As ElpieKay mentioned in a comment, you need the three-dot notation. However, just adding the three-dot notation is not sufficient: you will also want to add --left-only or --right-only (depending on which side of the symmetric difference you put the A and B parts, of A...B, on).

Note:

In order to find commits on branch working not merged/picked to master yet [I used] master..working

So here, you'd want --right-only master...working. You can keep --no-merges as well. If the merges only show up on master you don't actually need --no-merges, but it's probably harmless. Note, however, that --no-merges completely eliminates all merges, regardless of their patch-IDs.

Add --decorate=full or --decorate=short to your git log arguments. You can also use --decorate=true or --decorate=1, but full and short are the documented value these days. Full includes the full name (e.g., refs/heads/somebranch) while short shortens to branch or tag names.

The default log.decorate setting is auto (since Git 2.9 anyway; before that it was no/0/false, and at various points various bugs were introduced and then fixed in later versions; it's been stable since Git 2.13). The auto setting mean short if a human is reading the output, no if a program is reading the output.¹

The decorations themselves are required (i.e., must be turned on) for --simplify-by-decoration --decorate-refs=... to work. Probably either of these options should imply --decorate=short if it's currently still auto from being unset in the Git configuration.²

This all points to a more general problem with using git log programmatically, e.g., from Python with subprocess: git log is what Git calls a porcelain command, which means it obeys user configurations. If the user has a log.decorate setting, that overrides any defaults. Now that you know about log.decorate and the --decorate= argument, you can force correct behavior in your program using the --decorate= argument (which overrides any user configuration). But what other user-configurable items exist in git log that could break your program? What about future versions of Git, where git log might acquire new configuration items? There is nothing you can do about this more-general problem today, unfortunately, but since some things that git log does cannot be done by any of the so-called plumbing commands—these are commands that don't change behavior based on user configuration, and hence are useful from other programs as they have a known, fixed output format—git log needs an option to make it behave well. (The git status command has the --porcelain option for this; git log just needs its own version of that.)

¹Git doesn't actually know if a human is reading the output. Instead, it approximates this by examining the standard output stream: if the standard output (file descriptor 1) responds with a true value for the isatty C library call, or git log output is being fed to a pager, it assumes a human is reading the output. Use of pipes in subprocess means that stdout is not a tty, which by default disables the pager too. However, there's a user configuration setting that forces the pager to be used: see the "more general problem" paragraph.

²In general, the way Git configurations work is this:

• First, the program sets any automatic defaults, such as log.decorate=auto (this is typically just open-coded, rather than using the configuration mechanism).

• Next, Git reads the system configuration file. If this has a setting such as log.decorate=short in it, that setting applies, overriding the automatic default. (This usually works through callbacks, from the configuration mechanism to the program.)

• Next, Git reads your personal global configuration file. If this has a setting such as log.decorate=auto in it, that setting applies. If the previous configuration had a setting, this overwrites that previous setting.

• Next, Git reads the configuration file for this particular Git repository. If this has a setting such as log.decorate=full, that setting applies, overwriting any previous setting as before.

• Last, Git applies command-line argument settings. These therefore override any settings picked up in any of the previous steps.

This is how, for instance, you can arrange your user.name and/or user.email to be different for one particular Git repository. You set these in your global config, which Git reads before it reads the per-repository config; then you set them to the different value in the per-repository config, and that overrides the global config.

In relatively recent versions of Git, you can also set up a per-worktree configuration: git config --worktree. This is read after the per-repository config file, but used before command line arguments, so it has the second-highest priority. For the per-worktree setting to take effect, you must enable extensions.worktreeConfig. Be careful here as there were some bugs with this extension for a little while.