public CommitWrapper(LibGit2Sharp.Commit commit)
        {
            this.commit = commit;

            Sha = commit.Sha;
            MessageShort = commit.MessageShort;
            Message = commit.Message;
            Author = commit.Author;
            Committer = commit.Committer;
            Tree = (async (i) => commit.Tree);
            Parents = (async (i) => commit.Parents.Select((p) => new CommitWrapper(p)));
        }

 public int NumberOfCommitsOnBranchSinceCommit(Branch branch, Commit commit)
 {
     var olderThan = branch.Tip.Committer.When;
     return branch.Commits
         .TakeWhile(x => x != commit)
         .Count();
 }

        static Branch[] CalculateWhenMultipleParents(IRepository repository, Commit currentCommit, ref Branch currentBranch, Branch[] excludedBranches)
        {
            var parents = currentCommit.Parents.ToArray();
            var branches = repository.Branches.Where(b => !b.IsRemote && b.Tip == parents[1]).ToList();
            if (branches.Count == 1)
            {
                var branch = branches[0];
                excludedBranches = new[]
                {
                    currentBranch,
                    branch
                };
                currentBranch = branch;
            }
            else if (branches.Count > 1)
            {
                currentBranch = branches.FirstOrDefault(b => b.Name == "master") ?? branches.First();
            }
            else
            {
                var possibleTargetBranches = repository.Branches.Where(b => !b.IsRemote && b.Tip == parents[0]).ToList();
                if (possibleTargetBranches.Count > 1)
                {
                    currentBranch = possibleTargetBranches.FirstOrDefault(b => b.Name == "master") ?? possibleTargetBranches.First();
                }
                else
                {
                    currentBranch = possibleTargetBranches.FirstOrDefault() ?? currentBranch;
                }
            }

            Logger.WriteInfo("HEAD is merge commit, this is likely a pull request using " + currentBranch.Name + " as base");

            return excludedBranches;
        }

        public SemanticVersion FindVersion(IRepository repository, Commit tip)
        {
            int major;
            int minor;
            int patch;
            foreach (var tag in repository.TagsByDate(tip))
            {
                if (ShortVersionParser.TryParse(tag.Name, out major, out minor, out patch))
                {
                    return BuildVersion(repository, tip, major, minor, patch);
                }
            }

            var semanticVersion = new SemanticVersion();

            string versionString;
            if (MergeMessageParser.TryParse(tip, out versionString))
            {
                if (ShortVersionParser.TryParse(versionString, out major, out minor, out patch))
                {
                    semanticVersion = BuildVersion(repository, tip, major, minor, patch);
                }
            }

            semanticVersion.OverrideVersionManuallyIfNeeded(repository);

            if (semanticVersion == null || semanticVersion.IsEmpty())
            {
                throw new WarningException("The head of a support branch should always be a merge commit if you follow gitflow. Please create one or work around this by tagging the commit with SemVer compatible Id.");
            }

            return semanticVersion;
        }

 public CommitModel(Commit commit)
 {
     Hash = commit.Id.Sha;
     Who = commit.Author.Name;
     When = commit.Author.When;
     What = commit.MessageShort;
 }

        public void Visit(Commit commit)
        {
            Dictionary<DateTime, List<CommitDetails>> commitsOnDay = null;
            if (!commitsByAuthor.TryGetValue(commit.Author.Email, out commitsOnDay))
            {
                commitsOnDay = new Dictionary<DateTime, List<CommitDetails>>();
                commitsByAuthor.Add(commit.Author.Email, commitsOnDay);
            }

            DateTime commitDate = commit.Committer.When.DateTime.Round(TimeSpan.FromDays(1));
            List<CommitDetails> commitDetails = null;
            if (!commitsOnDay.TryGetValue(commitDate, out commitDetails))
            {
                commitDetails = new List<CommitDetails>();
                commitsOnDay[commitDate] = commitDetails;
            }

            commitDetails.Add(new CommitDetails()
            {
                Id = commit.Id.Sha.Substring(0, 7),
                Author = commit.Author.Email,
                Message = commit.Message,
                CommitTime = commit.Committer.When.DateTime
            });
        }

        public static KeyValuePair<string, BranchConfig> GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)
        {
            var matchingBranches = LookupBranchConfiguration(config, currentBranch);

            if (matchingBranches.Length == 0)
            {
                var branchConfig = new BranchConfig();
                ConfigurationProvider.ApplyBranchDefaults(config, branchConfig);
                return new KeyValuePair<string, BranchConfig>(string.Empty, branchConfig);
            }
            if (matchingBranches.Length == 1)
            {
                var keyValuePair = matchingBranches[0];
                var branchConfiguration = keyValuePair.Value;

                if (branchConfiguration.Increment == IncrementStrategy.Inherit)
                {
                    return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, keyValuePair, branchConfiguration, config, excludedInheritBranches);
                }

                return keyValuePair;
            }

            const string format = "Multiple branch configurations match the current branch branchName of '{0}'. Matching configurations: '{1}'";
            throw new Exception(string.Format(format, currentBranch.Name, string.Join(", ", matchingBranches.Select(b => b.Key))));
        }

        private static IEnumerable<Commit> GetIntermediateCommits(IRepository repo, Commit baseCommit, Commit headCommit)
        {
            if (baseCommit == null) yield break;

            if (intermediateCommitCache == null || intermediateCommitCache.LastOrDefault() != headCommit)
            {
                var filter = new CommitFilter
                {
                    Since = headCommit,
                    SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Reverse
                };

                intermediateCommitCache = repo.Commits.QueryBy(filter).ToList();
            }

            var found = false;
            foreach (var commit in intermediateCommitCache)
            {
                if (commit.Sha == baseCommit.Sha)
                    found = true;

                if (found)
                    yield return commit;
            }
        }

 public TagCommit( Commit c, ReleaseTagVersion first )
 {
     Debug.Assert( c != null && first != null && first.IsValid );
     _commitSha = c.Sha;
     _contentSha = c.Tree.Sha;
     _thisTag = first;
 }

 /// <summary>
 /// Create a TAR archive of the given commit.
 /// </summary>
 /// <param name="odb">The object database.</param>
 /// <param name="commit">commit.</param>
 /// <param name="archivePath">The archive path.</param>
 public static void Archive(this ObjectDatabase odb, Commit commit, string archivePath)
 {
     using (var output = new FileStream(archivePath, FileMode.Create))
     using (var archiver = new TarArchiver(output))
     {
         odb.Archive(commit, archiver);
     }
 }

 public BaseVersion(string source, bool shouldIncrement, SemanticVersion semanticVersion, Commit baseVersionSource, string branchNameOverride)
 {
     Source = source;
     ShouldIncrement = shouldIncrement;
     SemanticVersion = semanticVersion;
     BaseVersionSource = baseVersionSource;
     BranchNameOverride = branchNameOverride;
 }

        public static GraphEntry FromCommit(GraphEntry previous, Commit commit)
        {
            if (previous == null) {
                return CreateFirstEntry(commit);
            }

            return CreateEntryFromCommit(previous, commit);
        }

 internal GitCommit(Commit commit)
 {
     Sha = commit.Sha;
     Author = new GitSignature(commit.Author.Email, commit.Author.Name, commit.Author.When);
     Committer = new GitSignature(commit.Committer.Email, commit.Committer.Name, commit.Committer.When);
     Message = commit.Message;
     MessageShort = commit.MessageShort;
 }

 private bool ContainsUser(Commit commit)
 {
     if (!string.IsNullOrEmpty(user))
        {
        return commit.Committer.Name.Equals(user);
        }
        return true;
 }

 public BisectStep(Commit c, int result)
 {
     commit = c;
     if (-1 <= result && result <= 1)
         i = result;
     else
         i = Result.NOTSET;
 }

 private bool ContainsComment(Commit commit)
 {
     if (!string.IsNullOrEmpty(comment))
        {
        return commit.Message.ToLower().Contains(comment.ToLower()) || commit.MessageShort.ToLower().Contains(comment.ToLower()); ;
        }
        return true;
 }

 private bool BeforeDate(Commit commit)
 {
     if (to != null)
        {
        return commit.Committer.When.Date <= to;
        }
        return true;
 }

 private bool AfterDate(Commit commit)
 {
     if (from != null)
        {
        return commit.Committer.When.Date >= from;
        }
        return true;
 }

 public GitDiffDirectory(Commit commit)
 {
   var files = new List<IDiffFile>();
   GitMergeOperation.WalkTree(commit.Tree, (path, blob) =>
   {
     files.Add(new GitDiffFile(blob) { Path = path });
   });
   _files = files;
 }

        private bool HighlightCommit(Commit commit)
        {
            CommitVertex commitVertex = GetCommitVertex(commit);
            if (commitVertex.OnCurrentBranch)
                return false;

            commitVertex.OnCurrentBranch = true;
            return true;
        }