// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System.Diagnostics;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using LibGit2Sharp;
|
using System.Linq;
|
using System.Collections.Generic;
|
using System;
|
using System.IO;
|
using Tap.Shared;
|
|
namespace OpenTap.Package
|
{
|
/// <summary>
|
/// Calculates the version number of a commit in a git repository
|
/// </summary>
|
internal class GitVersionCalulator : IDisposable
|
{
|
private static readonly TraceSource log = Log.CreateSource("GitVersion");
|
private const string configFileName = ".gitversion";
|
private readonly LibGit2Sharp.Repository repo;
|
private readonly string RepoDir;
|
|
private class Config
|
{
|
public SemanticVersion Version { get => _version; set => _version = value; }
|
private SemanticVersion _version = new SemanticVersion(0, 0, 1, null, null);
|
|
/// <summary> version before it got parsed to a SemanticVersion. Possibly not valid.</summary>
|
public string RawVersion { get; set; }
|
|
/// <summary>
|
/// Regex that runs against the FriendlyName of a branch to determine if it is a beta branch
|
/// (commits from this branch will get a "beta" prerelease identifier)
|
/// </summary>
|
public List<Regex> BetaBranchRegexes { get; private set; } = new List<Regex>
|
{
|
new Regex("^integration$", RegexOptions.Compiled | RegexOptions.IgnoreCase),
|
new Regex("^develop$", RegexOptions.Compiled | RegexOptions.IgnoreCase),
|
new Regex("^dev$", RegexOptions.Compiled | RegexOptions.IgnoreCase),
|
new Regex("^master$", RegexOptions.Compiled | RegexOptions.IgnoreCase),
|
new Regex("^main$", RegexOptions.Compiled | RegexOptions.IgnoreCase)
|
};
|
public List<string> BetaBranchPatterns { get; private set; } = new List<string>
|
{
|
"^integration$",
|
"^master$",
|
"^develop$",
|
"^dev$",
|
"^main$"
|
};
|
|
/// <summary>
|
/// Regex that runs against the FriendlyName of a branch to determine if it is a release branch
|
/// (commits from this branch will not get any prerelease identifier)
|
/// </summary>
|
public Regex ReleaseBranchRegex { get; private set; } = new Regex("^release[0-9x]*$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
public Regex ReleaseTagRegex { get; private set; } = new Regex(@"v\d+\.\d+\.\d+", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
private int _maxBranchChars = 30;
|
/// <summary>
|
/// Cap the length of the branch name to this many chars. This can be useful e.g. if the version number is used in a file name, which could otherwise become too long.
|
/// </summary>
|
public int MaxBranchChars => _maxBranchChars;
|
|
public string ConfigFilePath;
|
|
private Config()
|
{
|
|
}
|
|
private static Regex configLineRegex = new Regex(@"^(?!#)(?<key>.*?)\s*=\s*(?<value>.*)", RegexOptions.Compiled);
|
public static Config ParseConfig(Stream str, string configFilePath = configFileName)
|
{
|
Config cfg = new Config();
|
if (str == null)
|
return cfg;
|
cfg.ConfigFilePath = configFilePath;
|
bool isBetaBranchSet = false;
|
using (var reader = new StreamReader(str, Encoding.UTF8))
|
{
|
String line;
|
while ((line = reader.ReadLine()) != null)
|
{
|
var m = configLineRegex.Match(line);
|
if (m.Success)
|
{
|
string val = m.Groups["value"].Value;
|
switch (m.Groups["key"].Value.ToLower())
|
{
|
case "beta branch":
|
if (!isBetaBranchSet)
|
{
|
cfg.BetaBranchRegexes = new List<Regex>();
|
cfg.BetaBranchPatterns = new List<string>();
|
}
|
isBetaBranchSet = true;
|
cfg.BetaBranchRegexes.Add(new Regex(val, RegexOptions.IgnoreCase));
|
cfg.BetaBranchPatterns.Add(val);
|
break;
|
case "release branch":
|
cfg.ReleaseBranchRegex = new Regex(val, RegexOptions.IgnoreCase);
|
break;
|
case "release tag":
|
cfg.ReleaseTagRegex = new Regex(val, RegexOptions.IgnoreCase);
|
break;
|
case "max branch chars":
|
int.TryParse(val, out cfg._maxBranchChars);
|
break;
|
case "version":
|
cfg.RawVersion = val;
|
SemanticVersion.TryParse(val, out cfg._version);
|
break;
|
}
|
}
|
}
|
}
|
return cfg;
|
}
|
}
|
|
private const string GIT_HASH = "b7bad55";
|
|
void ensureLibgit2Present()
|
{
|
string libgit2name;
|
|
if (OperatingSystem.Current == OperatingSystem.Windows)
|
libgit2name = $"git2-{GIT_HASH}.dll";
|
else if (OperatingSystem.Current == OperatingSystem.Linux)
|
libgit2name = $"libgit2-{GIT_HASH}.so";
|
else if (OperatingSystem.Current == OperatingSystem.MacOS)
|
libgit2name = $"libgit2-{GIT_HASH}.dylib";
|
else
|
{
|
log.Error($"Unsupported platform.");
|
return;
|
}
|
|
var requiredFile = Path.Combine(PathUtils.OpenTapDir, libgit2name);
|
if (File.Exists(requiredFile))
|
return;
|
|
string sourceFile = Path.Combine(PathUtils.OpenTapDir, "Dependencies/LibGit2Sharp.0.27.0.0/", libgit2name);
|
if (OperatingSystem.Current == OperatingSystem.Windows)
|
sourceFile += $".{(Environment.Is64BitProcess ? CpuArchitecture.x64 : CpuArchitecture.x86)}";
|
if (OperatingSystem.Current == OperatingSystem.MacOS)
|
sourceFile += $".{MacOsArchitecture.Current.Architecture}";
|
if (OperatingSystem.Current == OperatingSystem.Linux)
|
sourceFile += $".{LinuxArchitecture.Current.Architecture}";
|
|
try
|
{
|
File.Copy(sourceFile, requiredFile, true);
|
}
|
catch (Exception e)
|
{
|
if (OperatingSystem.Current == OperatingSystem.Windows)
|
{
|
var opentapArch = Installation.Current.GetOpenTapPackage()?.Architecture;
|
var processArch = Environment.Is64BitProcess ? CpuArchitecture.x64 : CpuArchitecture.x86;
|
if (opentapArch != processArch)
|
throw new PlatformNotSupportedException($"Unable to find the correct 'libgit2-{GIT_HASH}' because the process architecture '{processArch}' does not match the installed OpenTAP architecture '{opentapArch}'", e);
|
}
|
|
throw new PlatformNotSupportedException($"Unable to copy 'libgit2-{GIT_HASH}': {e.Message}.", e);
|
}
|
}
|
|
/// <summary>
|
/// Instanciates a new <see cref="GitVersionCalulator"/> to work on a specified git repository.
|
/// </summary>
|
/// <param name="repositoryDir">Path pointing to a directory inside the git repository to use.</param>
|
public GitVersionCalulator(string repositoryDir)
|
{
|
repositoryDir = Path.GetFullPath(repositoryDir);
|
RepoDir = repositoryDir;
|
while (!Directory.Exists(Path.Combine(repositoryDir, ".git")))
|
{
|
repositoryDir = Path.GetDirectoryName(repositoryDir);
|
if (repositoryDir == null)
|
throw new ArgumentException("Directory is not a git repository.", "repositoryDir");
|
}
|
RepoDir = RepoDir.Substring(repositoryDir.Length);
|
|
ensureLibgit2Present();
|
repo = new LibGit2Sharp.Repository(repositoryDir);
|
}
|
|
public void Dispose()
|
{
|
if (repo != null)
|
repo.Dispose();
|
}
|
|
/// <summary> Keeps iterating until a valid version is read.</summary>
|
SemanticVersion getLatestReadableVersion(Commit c)
|
{
|
while (c != null)
|
{
|
var cfg = readConfig(c);
|
if (cfg.Version != null) return cfg.Version;
|
c = getLatestConfigVersionChange(c.Parents.FirstOrDefault());
|
}
|
// no version was found.
|
return null;
|
}
|
|
static IEnumerable<TreeEntry> GetAllConfigFilesInTree(Tree t)
|
{
|
foreach (TreeEntry te in t)
|
{
|
if (te.Target is Tree subtree)
|
{
|
foreach (var match in GetAllConfigFilesInTree(subtree))
|
yield return match;
|
}
|
else if (te.Name == configFileName)
|
{
|
yield return te;
|
}
|
}
|
}
|
|
Config readConfig(Commit c)
|
{
|
var cfgFiles = GetAllConfigFilesInTree(c?.Tree).ToList();
|
|
string repositoryDir = RepoDir.TrimStart('/','\\');
|
TreeEntry cfg = null;
|
while (cfg == null)
|
{
|
var dir = Path.Combine(repositoryDir ?? "", configFileName).Replace('\\','/');
|
cfg = cfgFiles.FirstOrDefault(c => c.Path == dir);
|
if (String.IsNullOrEmpty(repositoryDir))
|
break;
|
repositoryDir = Path.GetDirectoryName(repositoryDir);
|
}
|
Blob configBlob = cfg?.Target as Blob;
|
return Config.ParseConfig(configBlob?.GetContentStream(), cfg?.Path);
|
}
|
|
Config ParseConfig(Commit c)
|
{
|
var cfg = readConfig(c);
|
if (cfg.Version == null)
|
{
|
log.Error("Unable to parse version specification {0}. It is not a valid semantic version.", cfg.RawVersion);
|
var ver = getLatestReadableVersion(c.Parents.FirstOrDefault());
|
if (ver != null)
|
{
|
log.Warning("Using previous {0} as version instead.", ver);
|
cfg.Version = ver;
|
}
|
}
|
|
return cfg;
|
}
|
|
private Commit getLatestConfigVersionChange(Commit c)
|
{
|
if (c.Parents.Any() == false)
|
return c; // 'c' is the first commit in the repo. There was never any change.
|
|
// find all changes in the file (for some reason that sometimes returns an empty list)
|
//var fileLog = repo.Commits.QueryBy(configFileName, new CommitFilter() { IncludeReachableFrom = c, SortBy = CommitSortStrategies.Topological, FirstParentOnly = false });
|
//... go on to iterate through filelog...
|
|
// Instead, just walk all commits comparing the version in the .gitversion file to the one in the previous commit
|
Config currentCfg = readConfig(c);
|
while (true)
|
{
|
Commit parent = c.Parents.FirstOrDefault(); // first parent only, we are only interested in when the file changes on the beta branch
|
if (parent == null)
|
{
|
// we got to the very first commit in this repo without seeing any changes in the gitversion
|
// this might be because there is no .gitversion file, or just because the content of the file is the same as the default values.
|
// in both cases, we should treat this commit (the initial commit) as the LatestConfigVersionChange
|
return c;
|
}
|
Config parentCfg = readConfig(parent);
|
if (currentCfg.Version != null && (parentCfg.Version == null || currentCfg.Version.CompareTo(parentCfg.Version) > 0))
|
{
|
// the version number was bumped
|
return c;
|
}
|
c = parent;
|
currentCfg = parentCfg;
|
}
|
}
|
|
/// <summary>
|
/// Calculates the version number of the current HEAD of the git repository
|
/// </summary>
|
public SemanticVersion GetVersion()
|
{
|
if (!repo.Commits.Any())
|
return new SemanticVersion(0, 0, 0, null, null);
|
return GetVersion(repo.Head.Tip);
|
}
|
|
/// <summary>
|
/// Calculates the version number of a specific commit in the git repository
|
/// </summary>
|
public SemanticVersion GetVersion(string sha)
|
{
|
Commit commit = repo.Lookup<Commit>(sha);
|
if (commit == null)
|
throw new ArgumentException($"The commit with reference {sha} does not exist in the repository.");
|
return GetVersion(commit);
|
}
|
|
/// <summary>
|
/// Calculates the version number of a specific commit in the git repository
|
/// </summary>
|
public SemanticVersion GetVersion(Commit targetCommit)
|
{
|
if (repo.Lookup<Commit>(targetCommit.Sha) == null)
|
throw new ArgumentException($"The commit with hash {targetCommit} does not exist the in repository.");
|
if(!GetAllConfigFilesInTree(targetCommit.Tree).Any())
|
{
|
log.Warning("Did not find any .gitversion file.");
|
}
|
Config cfg = ParseConfig(targetCommit);
|
if (cfg.ConfigFilePath != configFileName)
|
log.Debug("Using configuration from {0}", cfg.ConfigFilePath);
|
|
Branch defaultBranch = getBetaBranch(cfg);
|
|
string branchName = guessBranchName(cfg,targetCommit,defaultBranch);
|
|
string preRelease = "alpha";
|
if (branchName == defaultBranch.GetShortName())
|
preRelease = "beta";
|
if (cfg.ReleaseBranchRegex.IsMatch(branchName))
|
preRelease = "rc";
|
Tag releaseTag = getReleaseTag(cfg, targetCommit);
|
if (releaseTag != null)
|
preRelease = null;
|
|
string metadata = targetCommit.Sha.Substring(0, 8);
|
if (preRelease == "alpha")
|
{
|
if (branchName == "(no branch)")
|
branchName = "NONE"; // '(' and ' ' are not allowed in semver
|
else
|
branchName = Regex.Replace(branchName, "[^a-zA-Z0-9-]", "-"); // replace any chars that is not valid semver with '-'
|
if (branchName.Length > cfg.MaxBranchChars)
|
branchName = branchName.Remove(cfg.MaxBranchChars);
|
metadata += "." + branchName;
|
}
|
if (!String.IsNullOrEmpty(preRelease))
|
{
|
// The version calculation is slightly different for RC versions
|
// For an RC, we want to count merge commits as a single commit
|
// For other branches, we want to count the literal number of commits
|
// Historically, we have counted merge commits as single commits for all branches,
|
// but this causes issues in scenarios where merge commits are fast-forwarded onto e.g. the main branch.
|
// See here: https://github.com/opentap/opentap/pull/1384
|
// And here: https://github.com/opentap/opentap/issues/1321#issuecomment-1895749385
|
bool isRc = preRelease.StartsWith("rc", StringComparison.OrdinalIgnoreCase);
|
Commit cfgCommit = getLatestConfigVersionChange(targetCommit);
|
Commit commonAncestor = findFirstCommonAncestor(defaultBranch, targetCommit);
|
int commitsFromDefaultBranch = countCommitsBetween(commonAncestor, targetCommit, firstParentOnly: isRc);
|
log.Debug("Found {0} commits since branchout from beta branch in commit {1}.", commitsFromDefaultBranch, commonAncestor.Sha.Substring(0, 8));
|
int commitsSinceVersionUpdate = countCommitsBetween(cfgCommit, targetCommit, firstParentOnly: isRc) + 1;
|
log.Debug("Found {0} commits since last version bump in commit {1}.", commitsSinceVersionUpdate, cfgCommit.Sha.Substring(0, 8));
|
int alphaVersion = Math.Min(commitsFromDefaultBranch, commitsSinceVersionUpdate);
|
if (isRc == false)
|
{
|
int betaVersion = countCommitsBetween(cfgCommit, commonAncestor, false) + 1;
|
if (betaVersion > 0)
|
{
|
preRelease += "." + betaVersion;
|
}
|
}
|
if (alphaVersion > 0)
|
{
|
preRelease += "." + alphaVersion;
|
}
|
}
|
|
if (cfg.Version == null) return new SemanticVersion(0, 0, 0, preRelease, metadata);
|
return new SemanticVersion(cfg.Version.Major,cfg.Version.Minor,cfg.Version.Patch,preRelease,metadata);
|
}
|
|
private Tag getReleaseTag(Config cfg, Commit c)
|
{
|
foreach (Tag t in repo.Tags)
|
{
|
if (t.IsAnnotated &&
|
t.Target.Peel<Commit>() == c &&
|
cfg.ReleaseTagRegex.IsMatch(t.FriendlyName))
|
{
|
return t;
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// Find the first (youngest) commit that is reachable from two specified places
|
/// </summary>
|
private Commit findFirstCommonAncestor(Branch b1, Commit target)
|
{
|
// This fixes gitversion calculation in scenarios where the local revision of
|
// a checked out branch is behind the origin branch. If the local revision is fully merged
|
// in the remote tracking branch, we base our calculation on the remote branch instead.
|
// Otherwise, if the local branch contains commits that are *not* merged in the remote, we base the calculation on that.
|
// This should make the gitversion calculation work as expected after `git fetch --all`.
|
if (b1.TrackedBranch != null)
|
{
|
// Check if any local commits are unreachable from the tracking branch
|
var commitsMissingFromUpstream = (IQueryableCommitLog)repo.Commits.QueryBy(new CommitFilter() { IncludeReachableFrom = b1.Tip, ExcludeReachableFrom = b1.TrackedBranch.Tip});
|
if (commitsMissingFromUpstream.Any())
|
{
|
throw new Exception(
|
$"The local branch '{b1.GetShortName()}' contains commits missing from the tracked upstream branch.\n" +
|
$"This can cause unexpected mismatching version numbers. Please align '{b1.GetShortName()}' with its upstream.");
|
}
|
b1 = b1.TrackedBranch;
|
}
|
|
Commit b1Commit = b1.Tip;
|
while (b1Commit != null)
|
{
|
if (b1Commit.Sha == target.Sha)
|
return target; // target is a directly on the b1 branch
|
b1Commit = b1Commit.Parents.FirstOrDefault();
|
}
|
log.Debug($"Common ancestor of {b1.Tip} and {target} is not on the same branch.");
|
HashSet<Commit> targetHistory = repo.Commits.QueryBy(new CommitFilter() { IncludeReachableFrom = target }).ToHashSet();
|
Commit firstCommon = b1.Commits.FirstOrDefault(c => targetHistory.Contains(c)); // same as repo.ObjectDatabase.FindMergeBase(b1.Tip, target); but faster on average
|
// if this branch is being used for several releases (merged to several times, one for each release)
|
// we will need to check against older releases as well as target might already exist on the tip of
|
// this release branch (i.e. it could have been merged there "in the future").
|
b1Commit = b1.Tip;
|
while (firstCommon == target) // this can happen if target is later merged into b1
|
{
|
if (targetHistory.Contains(b1Commit))
|
{
|
// We have reached past the begining of the release branch. There is no point in going further
|
firstCommon = null;
|
break;
|
}
|
b1Commit = b1Commit.Parents.FirstOrDefault();
|
var releaseCommits = (IQueryableCommitLog)repo.Commits.QueryBy(new CommitFilter() { SortBy = CommitSortStrategies.Topological, IncludeReachableFrom = b1Commit });
|
firstCommon = releaseCommits.FirstOrDefault(c => targetHistory.Contains(c));
|
}
|
return firstCommon;
|
}
|
|
private int countCommitsBetween(object tag, object now, bool firstParentOnly = false)
|
{
|
var filter = new CommitFilter()
|
{
|
SortBy = CommitSortStrategies.Reverse | CommitSortStrategies.Time,
|
ExcludeReachableFrom = tag,
|
IncludeReachableFrom = now,
|
FirstParentOnly = firstParentOnly
|
};
|
return repo.Commits.QueryBy(filter).Count();
|
}
|
|
private Branch getBetaBranch(Config cfg)
|
{
|
// Try to find the HEAD of the
|
foreach (var remote in repo.Network.Remotes)
|
{
|
string expectedDefaultRefName = $"refs/remotes/{remote.Name}/HEAD";
|
var defaultRef = repo.Refs.FirstOrDefault(r => r.CanonicalName == expectedDefaultRefName) as SymbolicReference;
|
if (defaultRef != null)
|
{
|
// be careful to return the remote branch instead of any local one. On build runners the local branch might be behind, as they usually just checkout a sha not the actual branch
|
var branch = repo.Branches.FirstOrDefault(b => b.CanonicalName == defaultRef.TargetIdentifier);
|
if (branch != null)
|
{
|
log.Debug("Determined beta branch to be '{0}' by looking at the HEAD of the remote '{1}'.",
|
branch.GetShortName(), remote.Name);
|
return branch;
|
}
|
}
|
}
|
|
// For each regex from the config, try to find a branch that matches.
|
Branch defaultBranch = cfg.BetaBranchRegexes.Select(rx => repo.Branches.FirstOrDefault(b => rx.IsMatch(b.GetShortName()))).FirstOrDefault(b => b != null);
|
|
if (defaultBranch == null)
|
{
|
StringBuilder error = new StringBuilder("Unable to determine the default branch. No branch matching ");
|
error.Append(String.Join(", ", cfg.BetaBranchPatterns.SkipLastN(1).Select(p => $"'{p}'")));
|
if (cfg.BetaBranchPatterns.Count > 1)
|
error.Append($" or ");
|
error.Append($"'{cfg.BetaBranchPatterns.Last()}' could be found. Searched {repo.Branches.Count()} branches.");
|
log.Error(error.ToString());
|
log.Debug("Branches:");
|
int c = 0;
|
StringBuilder line = new StringBuilder();
|
foreach (Branch item in repo.Branches.OrderBy(b => b.FriendlyName))
|
{
|
string bName = item.FriendlyName;
|
if (bName.Length > 25)
|
bName = bName.Substring(0, 25 - 3) + "...";
|
line.AppendFormat("{0,-26}", bName);
|
c++;
|
if (c == 4)
|
{
|
log.Debug(line.ToString());
|
c = 0;
|
line.Clear();
|
}
|
}
|
if (line.Length > 0)
|
log.Debug(line.ToString());
|
throw new NotSupportedException(error.ToString());
|
}
|
log.Debug("Determined beta branch to be '{0}' using regular expression match.", defaultBranch.GetShortName());
|
return defaultBranch;
|
}
|
|
/// <summary>
|
/// Try to find the name of the branch a commit was originally created on. Logs warnings if not sure.
|
/// </summary>
|
private string guessBranchName(Config cfg,Commit commit, Branch defaultBranch)
|
{
|
// is this the tip of the current branch
|
if (repo.Head.Tip.Sha == commit.Sha && repo.Info.IsHeadDetached == false)
|
return repo.Head.GetShortName();
|
|
// is the commit directly on the default branch?
|
var commitsOnDefault = repo.Commits.QueryBy(new CommitFilter { IncludeReachableFrom = defaultBranch, FirstParentOnly = true });
|
var shasOnDefault = commitsOnDefault.Select(c => c.Sha).ToHashSet();
|
if (shasOnDefault.Contains(commit.Sha))
|
{
|
// is this also the tip of a release branch, then pick that instead
|
var releaseBranch = repo.Branches.Where(r => cfg.ReleaseBranchRegex.IsMatch(r.GetShortName()) && r.Tip.Sha == commit.Sha).FirstOrDefault();
|
if (releaseBranch != null)
|
{
|
return releaseBranch.GetShortName();
|
}
|
return defaultBranch.GetShortName();
|
}
|
|
// is the commit the tip of any branches
|
var tipMatches = repo.Branches.Where(r => r.Tip.Sha == commit.Sha).Where(r => !r.FriendlyName.EndsWith("HEAD"));
|
if (tipMatches.Any())
|
{
|
if (tipMatches.Count() == 1)
|
return tipMatches.First().GetShortName();
|
var releaseBranch = tipMatches.FirstOrDefault(b => cfg.ReleaseBranchRegex.IsMatch(b.FriendlyName));
|
if (releaseBranch != null)
|
return releaseBranch.GetShortName();
|
if (tipMatches.Contains(defaultBranch))
|
return defaultBranch.GetShortName();
|
log.Warning("This commit is the tip of several branches, picking one. ({0})",String.Join(", ", tipMatches.Select(b => b.FriendlyName)));
|
return tipMatches.First().GetShortName();
|
}
|
|
// is the commit on the default branch indirectly through a merge commit
|
foreach (Commit onDefault in commitsOnDefault)
|
{
|
if (onDefault.Parents.Count() > 1)
|
{
|
Commit commitOnBranch = onDefault.Parents.Last();
|
|
while (!shasOnDefault.Contains(commitOnBranch.Sha))
|
{
|
if (commitOnBranch.Sha == commit.Sha)
|
{
|
var m = Regex.Match(onDefault.MessageShort, "Merge branch '([^']*)'");
|
if (m.Success)
|
{
|
string branchName = m.Groups[m.Groups.Count - 1].Value;
|
if (branchName.StartsWith("origin/"))
|
branchName = branchName.Substring(7);
|
return branchName;
|
}
|
else
|
{
|
log.Warning("Unable to determine old branch name. The branch has probably been deleted.");
|
return "DELETED";
|
}
|
}
|
commitOnBranch = commitOnBranch.Parents.First();
|
}
|
}
|
}
|
|
// is the commit on a branch that has not yet been merged to the default branch?
|
Stopwatch timer = Stopwatch.StartNew();
|
List<Branch> candidates = new List<Branch>();
|
foreach (var branch in repo.Branches)
|
{
|
Commit commitOnBranch = branch.Tip;
|
while (!shasOnDefault.Contains(commitOnBranch.Sha))
|
{
|
if (commitOnBranch.Sha == commit.Sha)
|
{
|
candidates.Add(branch);
|
break;
|
}
|
if (!commitOnBranch.Parents.Any())
|
break;
|
commitOnBranch = commitOnBranch.Parents.First();
|
}
|
}
|
TimeSpan dur = timer.Elapsed;
|
if (!candidates.Any())
|
{
|
log.Warning("Unable to determine branch name.");
|
return "ERROR";
|
}
|
if (candidates.Count == 1)
|
return candidates.First().GetShortName();
|
|
if(candidates.Select(b => b.GetShortName()).Distinct().Count() == 1) // all candicates have the same name (e.g. on is a local branch and one is the remote of that same branch)
|
return candidates.First().GetShortName();
|
|
log.Warning("Several possible branch names found. Picking one.");
|
|
// pick the first candidate that is has a merge commit as the child of commit
|
try
|
{
|
for (int b = 0; b < candidates.Count; b++)
|
{
|
var commitsOnB = repo.Commits.QueryBy(new CommitFilter { IncludeReachableFrom = candidates[b], ExcludeReachableFrom = commit, FirstParentOnly = true });
|
if (commitsOnB.Last().Parents.Count() == 2 && commitsOnB.Last().Parents.First() == commit)
|
return candidates[b].GetShortName();
|
}
|
}
|
catch
|
{
|
|
}
|
|
// TODO: we need some better logic to pick the right candidate here
|
//var selected = candidates.Select(b => (b, branchCountFromDefault(b, shasOnDefault))).ToList();
|
return candidates.First().GetShortName();
|
}
|
}
|
|
internal static class libGit2Helpers
|
{
|
public static string GetShortName(this Branch b)
|
{
|
if (b.FriendlyName.StartsWith("origin/"))
|
return b.FriendlyName.Substring(7);
|
return b.FriendlyName;
|
}
|
}
|
}
|
