/// <summary> /// Calculate most frequent contributor for list of commits. /// </summary> /// <param name="commits"></param> /// <returns></returns> private static LibGit2Sharp.Signature GetMostFrequentContributor(ICommitLog commits) { return(commits.GroupBy(x => x.Author) .Select(x => new { Author = x.Key, CommitsCount = x.Count() }) .OrderBy(x => x.CommitsCount) .FirstOrDefault()?.Author); }
public IEnumerable <CommitAggregate> Get() { ICommitLog commitLog = _repo.Commits.QueryBy(new CommitFilter()); IEnumerator <LibGit2Sharp.Commit> commitEnumerator = commitLog.GetEnumerator(); commitEnumerator.MoveNext(); LibGit2Sharp.Commit previousCommit = commitEnumerator.Current; while (commitEnumerator.MoveNext()) { // As the enumerator reads the history top down, the current enumerator value // is the older commit. Therefore, the previousCommit is the newer commit. Tree olderCommitTree = commitEnumerator.Current.Tree; Tree newerCommmitTree = previousCommit.Tree; Patch patch = _repo.Diff.Compare <Patch>(olderCommitTree, newerCommmitTree); previousCommit = commitEnumerator.Current; yield return(new CommitAggregate { Commit = commitEnumerator.Current, Changes = patch }); } }
private Commit FindMostRecentCommitBefore(ICommitLog commits, DateTime beforeDateTime) { var mostRecentCommit = commits .Where(c => c.Author.When < beforeDateTime) .Aggregate((Commit)null, (curMax, c) => (curMax == null || c.Author.When > curMax.Author.When ? c : curMax)); return(mostRecentCommit); }
private static void AssertEnumerationOfCommitsInRepo(IRepository repo, Func <IRepository, CommitFilter> filterBuilder, IEnumerable <string> abbrevIds) { ICommitLog commits = repo.Commits.QueryBy(filterBuilder(repo)); IEnumerable <string> commitShas = commits.Select(c => c.Id.ToString(7)).ToArray(); Assert.Equal(abbrevIds, commitShas); }
private void ProcessCommits(ICommitLog commits) { foreach (var commit in commits) { var message = RemovePullRequestSubstring(commit.Message); AddTicketNumbersFrom(message); IncrementNumberOfCommits(); } }
public Statistics(ICommitLog commits) { TicketNumbers = new List <int>(); NumberOfCommits = 0; Points = 0; LastCommitSha = commits.First().Sha; ProcessCommits(commits); }
private Commit FindVersionSynchronizationEnabledCommit(ICommitLog commits) { var syncEnabledCommitMessage = "TeamCity change in '<Root project>' project: Synchronization with own VCS root is enabled"; var syncEnabledCommit = commits.First(c => c.Message == syncEnabledCommitMessage); if (syncEnabledCommit == null) { throw new Exception("Cannot find commit with \"{syncEnabledCommitMessage}\" message."); } return(syncEnabledCommit); }
IEnumerable <Migrator> GetLogMigrators(IRepository repository, ICommitLog log, List <IMigration> deferred, Commit previousCommit, MigrationMode mode) { foreach (var commit in log) { if (previousCommit != null) { var migrations = GetCommitMigrations(repository, previousCommit, commit).ToList(); deferred.AddRange(migrations.Where(m => m.IsIdempotent)); migrations.RemoveAll(m => m.IsIdempotent); if (migrations.Any()) { yield return(new Migrator(migrations.Where(m => !m.IsIdempotent).ToImmutableList(), mode, commit.Id)); } } previousCommit = commit; } }
private IEnumerable <Migrator> GetLogMigrators(IRepository repository, ICommitLog log, List <IMigration> deferred, Commit previousCommit, MigrationMode mode) { var context = new ModelObjectSerializationContext(_container); var serializer = _repositorySerializerFactory(context); foreach (var commit in log) { if (previousCommit != null) { var migrations = GetCommitMigrations(repository, previousCommit, commit, serializer).ToList(); deferred.AddRange(migrations.Where(m => m.IsIdempotent)); migrations.RemoveAll(m => m.IsIdempotent); if (migrations.Any()) { yield return(new Migrator(migrations.Where(m => !m.IsIdempotent).ToImmutableList(), mode, commit.Id)); } } previousCommit = commit; } }
private void updateDropdownList() { // init repo if (tb_ondisk.Text.Length > 0) { git = new Repository(tb_ondisk.Text); List <BisectStep> bss = new List <BisectStep>(); StringBuilder sb = new StringBuilder(); ICommitLog commits = git.Branches["master"].Commits; for (int i = commits.Count() - 1; i >= 0; i--) { bss.Add(new BisectStep(commits.ElementAt(i))); } steps = bss.ToArray(); cb_from.DataSource = bss; cb_from.Enabled = cb_to.Enabled = b_start.Enabled = true; } else { cb_from.Enabled = cb_to.Enabled = b_start.Enabled = false; } }
public UnknownBranch(DateTimeOffset when) { commits_ = new UnknownCommitLog(when); }
private static DateTime GetFirstCommit(ICommitLog commitLog) { return(commitLog.Last().Author.When.Date); }
public List <Commit> Get(String path, String username, String password, String branch) { DirectoryInfo di = new DirectoryInfo("tempRepo/"); if (di.Exists) { BranchController.setAttributesNormal(di); di.Delete(true); } string clone; if (username != null && password != null) { var cloneOptions = new CloneOptions() { CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials { Username = username, Password = password } }; clone = Repository.Clone(path, "tempRepo/", cloneOptions); } else { clone = Repository.Clone(path, "tempRepo/"); } var list = new List <Commit>(); using (var repo = new Repository(@clone)) { // Object lookup var obj = repo.Lookup("sha"); var commit = repo.Lookup <LibGit2Sharp.Commit>("sha"); var tree = repo.Lookup <Tree>("sha"); // var tag = repo.Lookup<Tag>("sha"); ICommitLog commits = null; if (branch == null) { commits = repo.Head.Commits; } else { commits = repo.Branches[branch].Commits; } foreach (var tempCommit in commits.Take(100)) { string message; string type = "None"; if (tempCommit.Message.Contains(":")) { string[] strings = tempCommit.Message.Split(":"); message = strings[1]; type = strings[0]; } else { message = tempCommit.Message; } var commitObj = new Commit { author = tempCommit.Author, commiter = tempCommit.Committer, message = message, type = type }; list.Add(commitObj); } return(list); // Branches // special kind of reference } }
internal CommitCollection(ICommitLog collection) => this.innerCollection = collection.NotNull();
private static IEnumerable <Tuple <ObjectId, ObjectId> > SplitRepository(Repository baseRepo, ICommitLog commits, string name, string path, IEnumerable <SharedRepo> sharedRepos, IEnumerable <MergedRepo> mergedRepos) { var shared = sharedRepos.Where(r => r.Paths.Any(p => p.StartsWith(path + "/"))).Select(r => new { Repo = "../" + r.Name + ".git", Path = r.Paths.First(p => p.StartsWith(path + "/")).Substring(path.Length + 1), Commits = r.Commits }); var merged = mergedRepos.Where(r => r.Name == name); using (var repo = new Repository(Repository.Init(Path.Combine("output", name)))) { File.Copy(Path.Combine(Config.Instance.MainRepo, ".gitignore"), Path.Combine("output", name, ".gitignore")); repo.Index.Add(".gitignore"); File.Copy(Path.Combine(Config.Instance.MainRepo, ".gitattributes"), Path.Combine("output", name, ".gitattributes")); repo.Index.Add(".gitattributes"); foreach (var toMerge in merged) { using (var mergeRepo = new Repository(toMerge.Repo)) { foreach (var c in mergeRepo.Commits.QueryBy(new CommitFilter { SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Reverse })) { bool any = false; foreach (var m in toMerge.Mapping) { if (Merge(repo, c, m.Key, m.Value)) { any = true; } } if (any) { var rewrittenCommit = repo.Commit(c.Message, new Signature(c.Author.Name, Config.Instance.MapEmail(c.Author.Email), c.Author.When), new Signature(c.Committer.Name, Config.Instance.MapEmail(c.Author.Email), c.Author.When), new CommitOptions { AllowEmptyCommit = true }); yield return(new Tuple <ObjectId, ObjectId>(c.Id, rewrittenCommit.Id)); } } } repo.Index.Clear(); repo.Index.Add(".gitignore"); repo.Index.Add(".gitattributes"); } if (shared.Any()) { File.WriteAllText(Path.Combine("output", name, ".gitmodules"), string.Join("", shared.Select(s => $"[submodule \"{s.Path}\"]\n path = {s.Path}\n url = {s.Repo}\n"))); repo.Index.Add(".gitmodules"); } foreach (var c in commits) { if (c.Tree[path] == null) { continue; } TreeDefinition tree = null; foreach (var s in shared) { var mapping = s.Commits.FirstOrDefault(commit => c.Id == commit.Item1); if (mapping != null) { if (tree == null) { var tempCommit = repo.Commit("temp", new Signature("temp", "*****@*****.**", DateTimeOffset.UtcNow), new Signature("temp", "*****@*****.**", DateTimeOffset.UtcNow), new CommitOptions { AllowEmptyCommit = true }); tree = TreeDefinition.From(tempCommit); repo.Reset(ResetMode.Soft, tempCommit.Parents.First()); } tree.AddGitLink(s.Path, mapping.Item2); } } if (tree != null) { repo.Index.Replace(repo.ObjectDatabase.CreateTree(tree)); } var oldTree = c.Parents.FirstOrDefault()?.Tree?[path]?.Target as Tree; if (oldTree != null) { var diff = baseRepo.Diff.Compare <TreeChanges>(oldTree, (Tree)c.Tree[path].Target); if (!diff.Any()) { continue; } foreach (var file in diff) { if (file.Mode == Mode.Directory) { continue; } if (!file.Exists || (file.OldPath != file.Path && file.Status != ChangeKind.Copied)) { if (!shared.Any(s => file.OldPath.Replace('\\', '/').StartsWith(s.Path + '/'))) { File.Delete(Path.Combine("output", name, file.OldPath)); repo.Index.Remove(file.OldPath); } } if (file.Exists) { if (!shared.Any(s => file.Path.Replace('\\', '/').StartsWith(s.Path + '/'))) { Directory.CreateDirectory(Path.GetDirectoryName(Path.Combine("output", name, file.Path))); using (var input = baseRepo.Lookup <Blob>(file.Oid).GetContentStream()) using (var output = File.Create(Path.Combine("output", name, file.Path))) { input.CopyTo(output); } repo.Index.Add(file.Path); } } } } else { foreach (var entry in RecursiveTree((Tree)c.Tree[path].Target, path)) { if (shared.Any(s => entry.Item1.Replace('\\', '/').StartsWith(s.Path + '/'))) { continue; } var fullPath = Path.Combine("output", name, entry.Item1); Directory.CreateDirectory(Path.GetDirectoryName(fullPath)); using (var content = entry.Item2.GetContentStream()) using (var output = File.Create(fullPath)) { content.CopyTo(output); } repo.Index.Add(entry.Item1); } } var email = Config.Instance.MapEmail(c.Author.Email); var rewrittenCommit = repo.Commit(c.Message, new Signature(c.Author.Name, email, c.Author.When), new Signature(c.Committer.Name, email, c.Author.When), new CommitOptions { AllowEmptyCommit = true }); yield return(new Tuple <ObjectId, ObjectId>(c.Id, rewrittenCommit.Id)); } repo.Network.Remotes.Add("origin", Config.Instance.Origin(name)); Console.WriteLine("Copying LFS files..."); var lfsCount = CopyLfsFiles(repo, Path.Combine("output", name, ".git", "lfs", "objects"), new[] { Path.Combine(baseRepo.Info.WorkingDirectory, ".git", "lfs", "objects") }.Concat(merged.Where(r => r.Name == name).Select(r => Path.Combine(r.Repo, ".git", "lfs", "objects")))); Console.WriteLine($"Copied {lfsCount} files."); // LibGit2Sharp doesn't support git gc, so we use the command line: using (var gc = Process.Start(new ProcessStartInfo("git", "gc --aggressive") { WorkingDirectory = repo.Info.WorkingDirectory, UseShellExecute = false })) { gc.WaitForExit(); } } }
internal CommitCollection(ICommitLog collection) => innerCollection = collection;
public MockQueryableCommitLog(ICommitLog commits) { this.commits = commits; }