AheadBehind compare two local branches

[Aimeast]

To calculate AheadBehind with two local branches.

My application level code is

using (var repo = new Repository(@"\libgit2sharp"))
{
    var head = repo.Head;
    var branch = repo.Branches["vNext"];

    var commitLog = repo.Commits;
    var commonAncestor = commitLog.FindCommonAncestor(head.Tip, branch.Tip);
    var ahead = commitLog.QueryBy(new CommitFilter { Since = branch.Tip, Until = commonAncestor });
    var behind = commitLog.QueryBy(new CommitFilter { Since = head.Tip, Until = commonAncestor });

    var Ahead = ahead.Count();
    var Behind = behind.Count();
}

But it very slowly and the result not very equals to github. It is available in libgit2?

[nulltoken]

Yes. git_graph_ahead_behind() is what you're after. FWIW, It's already leveraged by LibGit2Sharp to retrieve the Branch.TrackingDetails.

However, no method allowing to arbitrarily determine AheadBy/BehindBy counts for two branches or commits) is exposed yet.

We may add a method to the BranchCollection, but I'm having a hard time figuring out a correct name for it.

Beside this, in the case, we'd like to compare Tags or even bare Commits, I'm not even sure making it exposed by BranchCollection would be very discoverable.

Any idea, anyone?

[carlosmn]

We had no idea where to put it either, which is why it's the only function under the git_graph namespace. It would be at home either in the repo or odb, as it works purely on the commit graph. I don't think BranchCollection would be a good place for it.

[nulltoken]

But it very slowly and the result not very equals to github

@Aimeast That would be very unexpected. Can you share with us the steps to follow in order to replicate this inconsistency?

[nulltoken]

@carlosmn I kind of like the ObjectDatabase namespace idea..

[dahlbyk]

I'll throw in a vote for repo.Commits.AheadBehind(commitish1, commitish2).

[nulltoken]

@dahlbyk I'd still like to return the merge base as well, beside the counts. I still have a pending libgit2 PR that I intend to wrap up to cope with this (libgit2/libgit2#1259). Until it's finished, we can still call, behind the scene, FindCommonAncestor() to retrieve it.

Considering this, I'm not sure if AheadBehind() would be explicit enough.

If we try to work this from another angle, how would we name the returned type (the one exposing the counts and the ancestor)? DivergenceDetails? I've got the feeling that there's a proper term to define this, but I can't find it...

[dahlbyk]

So you're thinking we would change FindCommonAncestor() to return more than just the Commit?

[nulltoken]

So you're thinking we would change FindCommonAncestor() to return more than just the Commit?

Actually, I was thinking more about making ObjectDatabase.NiceNameToFind() more or less mimic the behavior of BranchTrackingDetails, by making it invoke both Proxy.git_graph_ahead_behind() and FindCommonAncestor().

[Aimeast]

Yes. git_graph_ahead_behind() is what you're after. FWIW, It's already leveraged by LibGit2Sharp to retrieve the Branch.TrackingDetails.

Yeah, `git_graph_ahead_behind()', that's it! I want a method can compare any two commits.

But it very slowly and the result not very equals to github

@Aimeast That would be very unexpected. Can you share with us the steps to follow in order to replicate this inconsistency?

See hereafter codes, which access the last libgit2sharp clone

using (var repo = new Repository(@"F:\Dev\Projects\LocalForks\libgit2sharp"))
{
    var head = repo.Head; // this is vNext
    Console.WriteLine("Head branch: {0}, {1}", head.Name, head.Tip.Sha.Substring(0, 7));

    foreach (var branch in repo.Branches.OrderByDescending(s => s.Tip.Author.When))
    {
        if (head == branch)
            continue;

        var commitLog = repo.Commits;
        var commonAncestor = commitLog.FindCommonAncestor(head.Tip, branch.Tip);
        var ahead = commitLog.QueryBy(new CommitFilter { Since = branch.Tip, Until = commonAncestor });
        var behind = commitLog.QueryBy(new CommitFilter { Since = head.Tip, Until = commonAncestor });

        var Ahead = ahead.Count();
        var Behind = behind.Count();

        Console.WriteLine("Branch: {0,30} {1}, Ahead: {2,2}, Behind: {3,3}", branch.Name, branch.Tip.Sha.Substring(0, 7), Ahead, Behind);
    }
}

Results

Head branch: vNext, 91d52df
Branch:                    origin/HEAD 91d52df, Ahead:  0, Behind:   0
Branch:                   origin/vNext 91d52df, Ahead:  0, Behind:   0
Branch:                  origin/master 2f4368b, Ahead:  0, Behind:  47
Branch:             origin/ntk/fix/507 a5aa0de, Ahead:  2, Behind:  63
Branch:          origin/topic/nuget_25 75c8b74, Ahead:  1, Behind: 169
Branch:                    origin/GHfW 50f82f9, Ahead: 11, Behind: 219
Branch:                   origin/refdb ff1c734, Ahead:  1, Behind: 173
Branch:             origin/GHfW-1.0.30 905b0a7, Ahead:  7, Behind: 463
Branch:             origin/ignore-ghfw 01cb991, Ahead: 12, Behind: 549
Branch:   origin/blueline-true-history 54356e5, Ahead:  2, Behind: 549
Branch:  origin/blueline-revwalk-globs 9153f74, Ahead: 77, Behind: 608
Press any key to continue . . .

Compare with https://github.com/libgit2/libgit2sharp/branches, Looks like Ahead always right, but Behind always wrong.

[carlosmn]

Those counts are accurate, which you can check with e.g. git rev-list ^upstream/blueline-revwalk-globs upstream/vNext and counting the lines ( | wc -l in something unixy).

That branches page is simply out of date.

[carlosmn]

The page now shows the correct results. FWIW while you're waiting for the ahead-behind method, you can leave out the call to FindCommonAncestor() and simply put head.Tip and branch.Tip in the CommitFilter.

[nulltoken]

how would we name the returned type (the one exposing the counts and the ancestor)? DivergenceDetails? I've got the feeling that there's a proper term to define this, but I can't find it...

@carlosmn (the NameWhisperer™) suggested HistoryDivergence which sounds just right to me.

@dahlbyk How about this?

[dahlbyk]

@carlosmn (the NameWhisperer™) suggested HistoryDivergence which sounds just right to me.

@dahlbyk How about this?

👍

With ObjectDatabase.GetHistoryDivergence(Commit, Commit)?