private void ProcessAuthor(CheckinOptions checkinOptions, TextWriter writer, GitCommit commit)
{
if (checkinOptions.AuthorsFilePath == null)
{
writer.WriteLine("Author file was not set.");
return;
}
// get authors file FIXME
AuthorsFile af = new AuthorsFile();
TextReader tr = new StreamReader(checkinOptions.AuthorsFilePath);
af.Parse(tr);
Author a = af.FindAuthor(commit.AuthorAndEmail);
if (a == null)
{
checkinOptions.AuthorTfsUserId = null;
return;
}
checkinOptions.AuthorTfsUserId = a.TfsUserId;
writer.WriteLine("Commit was authored by git user {0} {1} ({2})", a.Name, a.Email, a.TfsUserId);
}
public async Task TestCommitingAsync()
{
// Init default working folder repo
await git.InitRepoAsync();
// Write file and check status that a file has been added
io.WriteFile("file1.txt", "Some text 1");
status = await git.GetStatusAsync();
Assert.AreEqual(1, status.Added);
// Commit and check status that staus has no changes
GitCommit commit1 = await git.CommitAllChangesAsync("Message 1");
status = await git.GetStatusAsync();
Assert.AreEqual(0, status.AllChanges);
// Make a change to to file and check that status is 1 file modified
io.WriteFile("file1.txt", "Some text 2");
status = await git.GetStatusAsync();
Assert.AreEqual(1, status.Modified);
// Commit and verify status
GitCommit commit2 = await git.CommitAllChangesAsync("Message 2");
status = await git.GetStatusAsync();
Assert.AreEqual(0, status.AllChanges);
}
private string GetUpdateBlockedReason(
GitHubPullRequest pr,
GitCommit headCommit,
string upgradeBranchPrefix,
GitHubProject origin)
{
if (pr.Head.User.Login != origin.Owner)
{
return($"Owner of head repo '{pr.Head.User.Login}' is not '{origin.Owner}'");
}
if (!pr.Head.Ref.StartsWith(upgradeBranchPrefix))
{
return($"Ref name '{pr.Head.Ref}' does not start with '{upgradeBranchPrefix}'");
}
if (headCommit.Author.Name != GitAuthorName)
{
return($"Head commit author '{headCommit.Author.Name}' is not '{GitAuthorName}'");
}
if (headCommit.Committer.Name != GitAuthorName)
{
return($"Head commit committer '{headCommit.Committer.Name}' is not '{GitAuthorName}'");
}
if (pr.Labels?.Any(IsMaestroStopUpdatesLabel) ?? false)
{
return($"Label `{MaestroStopUpdatesLabel}` is attached");
}
return(null);
}
public async Task TestGetCommitMessageLog()
{
await git.InitRepoAsync();
io.WriteFile("file1.txt", "some text 1");
string message1 = "Message 1\n\nSome body text l1\nome body text l2";
GitCommit commit1 = await git.CommitAllChangesAsync(message1);
io.WriteFile("file2.txt", "some text 2");
string message2 = "Message 2";
GitCommit commit2 = await git.CommitAllChangesAsync(message2);
io.WriteFile("file2.txt", "some text 3");
string message3 = "Message 2\nsome short body";
GitCommit commit3 = await git.CommitAllChangesAsync(message3);
R <string> message21 = await cmd.GetCommitMessageAsync(commit1.Sha.Sha, ct);
Assert.AreEqual(message1, message21.Value);
R <string> message22 = await cmd.GetCommitMessageAsync(commit2.Sha.Sha, ct);
Assert.AreEqual(message2, message22.Value);
R <string> message23 = await cmd.GetCommitMessageAsync(commit3.Sha.Sha, ct);
Assert.AreEqual(message3, message23.Value);
}
public List <GitCommit> GetCommits()
{
List <Commit> commits = GetCommitsInternal();
List <GitCommit> gitCommits = new List <GitCommit>();
for (int i = 0; i < commits.Count - 1; i++)
{
Tree currentTree = commits[i].Tree;
Tree previousTree = commits[i + 1].Tree;
Patch patch = _repository.Diff.Compare <Patch>(currentTree, previousTree);
Console.WriteLine($"{commits[i].MessageShort}");
GitCommit gitCommit = new GitCommit(commits[i].Sha, commits[i].MessageShort, commits[i].Author.Name, commits[i].Author.When);
foreach (PatchEntryChanges pec in patch)
{
Console.WriteLine("{0} = {1} ({2}+ and {3}-)",
pec.Path,
pec.LinesAdded + pec.LinesDeleted,
pec.LinesAdded,
pec.LinesDeleted);
string fileContent = GetFileContent(commits[i], pec.Path);
gitCommit.PatchEntryChanges.Add(new GitPatchEntryChange(pec.Path, pec.LinesAdded, pec.LinesDeleted, fileContent));
}
Console.WriteLine();
gitCommits.Add(gitCommit);
}
return(gitCommits);
}
public async Task TestUncommitMergedIntoMasterCommitAsync()
{
await git.InitRepoAsync();
// Make 2 commits on a file
io.WriteFile("file1.txt", "Some text 1");
GitCommit commit1 = await git.CommitAllChangesAsync("Message 1");
io.WriteFile("file1.txt", "Some text 2");
GitCommit commit2 = await git.CommitAllChangesAsync("Message 2");
await git.BranchAsync("branch1");
io.WriteFile("file1.txt", "Some text on branch 1");
GitCommit commit3 = await git.CommitAllChangesAsync("Message on branch 1");
await git.CheckoutAsync("master");
await git.MergeAsync("branch1");
status = await git.GetStatusAsync();
await git.CommitAllChangesAsync($"{status.MergeMessage} into master");
R result = await cmd.UnCommitAsync(ct);
Assert.AreEqual(true, result.IsOk);
}
public GitCommit Info(IHostingEnvironment environment, string repoName)
{
var repoPath = $"{environment.WebRootPath}/Repos/{repoName}";
var gitResult = StartGit(" log -1 --numstat --date=raw", repoPath);
var regex = new Regex(@"commit (.+)\nAuthor: (.+) <(.+)>[\n ]*Date:[\n ]*(.\d+)[ +\d]*[\n ]*(.+)[\n ]",RegexOptions.IgnoreCase);
var match = regex.Matches(gitResult);
if (match.Count == 0)
return null;
var result = new GitCommit
{
Hash = match[0].Groups[1].Value,
Author = match[0].Groups[2].Value,
AuthorEmail = match[0].Groups[3].Value,
//Todo: fix timezones
CommitTime = DateTimeOffset.FromUnixTimeSeconds(long.Parse(match[0].Groups[4].Value)).DateTime,
Description = match[0].Groups[5].Value,
Changes = new Dictionary<string, Tuple<int, int>>()
};
regex = new Regex(@"(\d[ \n]*\d[ \n]*.+\n)",RegexOptions.IgnoreCase);
match = regex.Matches(gitResult);
for (int i = 2; i < match.Count; i++)
{
try
{
var elements = match[i].Value.Split(' ', '\t');
result.Changes[elements[2]] = new Tuple<int, int>(int.Parse(elements[0]), int.Parse(elements[1]));
}
catch (Exception ex)
{
i++;
}
}
return result;
}
private static string GetFileContentForFilePath(string filePath, GitCommit gitCommit)
{
return(gitCommit
.PatchEntryChanges
.Single(x => x.Path == filePath)
.FileContent);
}
public async Task TestDiffDeletedFiletAsync()
{
GitDiffParser diffParser = new GitDiffParser();
await git.InitRepoAsync();
io.WriteFile("file1.txt", "text1");
GitCommit commit1 = await git.CommitAllChangesAsync("Message1");
io.DeleteFile("file1.txt");
GitCommit commit2 = await git.CommitAllChangesAsync("Message2");
R <string> result1 = await cmd.GetFileDiffAsync(commit1.Sha.Sha, "file1.txt", ct);
Assert.AreEqual(true, result1.IsOk);
CommitDiff diff1 = await diffParser.ParseAsync(commit1.Sha, result1.Value, false, false);
Assert.IsNullOrEmpty(File.ReadAllText(diff1.LeftPath));
Assert.AreEqual("text1\r\n", File.ReadAllText(diff1.RightPath));
R <string> result2 = await cmd.GetFileDiffAsync(commit2.Sha.Sha, "file1.txt", ct);
Assert.AreEqual(true, result2.IsOk);
CommitDiff diff2 = await diffParser.ParseAsync(commit2.Sha, result2.Value, false, false);
Assert.AreEqual("text1\r", File.ReadAllText(diff2.LeftPath));
Assert.IsNullOrEmpty(File.ReadAllText(diff2.RightPath));
}
public async Task TestBranchAtCommitAsync()
{
await git.InitRepoAsync();
io.WriteFile("file1.txt", "Text 1");
var commit1 = await git.CommitAllChangesAsync("Message 1");
io.WriteFile("file1.txt", "Text 2");
var commit2 = await git.CommitAllChangesAsync("Message 2");
io.WriteFile("file1.txt", "Text 3");
var commit3 = await git.CommitAllChangesAsync("Message 3");
await cmd.BranchFromCommitAsync("branch1", commit2.Sha.Sha, true, ct);
io.WriteFile("file1.txt", "Text 1 on bbranch1");
var commit4 = await git.CommitAllChangesAsync("Message 1 on branch1");
branches = await git.GetBranchesAsync();
branches.TryGet("branch1", out GitBranch branch);
Assert.AreEqual(commit4.Sha, branch.TipSha);
GitCommit parentCommit = await git.GetCommit(commit4.ParentIds.First().Id);
Assert.AreEqual(commit2.Sha, parentCommit.Sha);
}
public void EqualsObjectTest()
{
var commit = new GitCommit()
{
Sha = GitObjectId.Parse(this.shaAsByteArray),
};
var commit2 = new GitCommit()
{
Sha = GitObjectId.Parse(this.shaAsByteArray),
};
var emptyCommit = new GitCommit()
{
Sha = GitObjectId.Empty,
};
// Must be equal to itself
Assert.True(commit.Equals((object)commit));
Assert.True(commit.Equals((object)commit2));
// Not equal to null
Assert.False(commit.Equals(null));
// Not equal to other representations of the commit
Assert.False(commit.Equals(this.shaAsByteArray));
Assert.False(commit.Equals(commit.Sha));
// Not equal to other object ids
Assert.False(commit.Equals((object)emptyCommit));
}
public async Task TestDiffCommitAsync()
{
await git.InitRepoAsync();
io.WriteFile("file1.txt", "text1");
io.WriteFile("file2.txt", "text2");
GitCommit commit1 = await git.CommitAllChangesAsync("Message1");
io.WriteFile("file1.txt", "text12");
io.WriteFile("file2.txt", "text22");
GitCommit commit2 = await git.CommitAllChangesAsync("Message2");
R <string> result = await cmd.GetCommitDiffAsync(commit1.Sha.Sha, ct);
Assert.AreEqual(true, result.IsOk);
CommitDiff diff = await git.ParsePatchAsync(commit1.Sha, result.Value);
Assert.IsNotNullOrEmpty(diff.LeftText);
Assert.IsNotNullOrEmpty(diff.RightText);
result = await cmd.GetCommitDiffAsync(commit2.Sha.Sha, ct);
Assert.AreEqual(true, result.IsOk);
CommitDiff diff2 = await git.ParsePatchAsync(commit1.Sha, result.Value);
Assert.IsNotNullOrEmpty(diff2.LeftText);
Assert.IsNotNullOrEmpty(diff2.RightText);
}
public void WhenGettingCommitIdentifierShouldReturnCommitHash()
{
var c = new GitCommit();
c.CommitHash = "a";
Assert.Equal("a", c.ChangesetIdentifier);
}
private string GetUpdateBlockedReason(
GitHubClient client,
GitHubPullRequest pullRequest,
string upgradeBranchPrefix)
{
if (pullRequest.Head.User.Login != Origin.Owner)
{
return($"Owner of head repo '{pullRequest.Head.User.Login}' is not '{Origin.Owner}'");
}
if (!pullRequest.Head.Ref.StartsWith(upgradeBranchPrefix))
{
return($"Ref name '{pullRequest.Head.Ref}' does not start with '{upgradeBranchPrefix}'");
}
GitCommit commit = client.GetCommitAsync(Origin, pullRequest.Head.Sha).Result;
if (commit.Author.Name != GitAuthorName)
{
return($"Head commit author '{commit.Author.Name}' is not '{GitAuthorName}'");
}
if (commit.Committer.Name != GitAuthorName)
{
return($"Head commit committer '{commit.Committer.Name}' is not '{GitAuthorName}'");
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommitHistoryItemViewModel" /> class.
/// </summary>
/// <param name="commit">The commit the view model is related to.</param>
public CommitHistoryItemViewModel(GitCommit commit)
{
GitCommit = commit;
Gravatar = new GravatarViewModel {
EmailAddress = GitCommit.CommitterEmail
};
}
/// <inheritdoc />
public string GetCommitMessageLong(GitCommit commit, IScheduler scheduler = null)
{
IList <string> result =
this.gitProcessManager.RunGit(new[] { "log", "--format=%B", "-n 1", commit.Sha }, scheduler: scheduler).Select(
x => x.Trim().Trim('\r', '\n')).ToList().Wait();
return(string.Join("\r\n", result).Trim().Trim('\r', '\n', ' '));
}
public void ToStringTest()
{
var commit = new GitCommit()
{
Sha = GitObjectId.Parse(this.shaAsByteArray),
};
Assert.Equal("Git Commit: 4e912736c27e40b389904d046dc63dc9f578117f", commit.ToString());
}
public void Remove(GitCommit commit)
{
if (commit is null)
{
throw new ArgumentNullException(nameof(commit));
}
m_AllCommits.Remove(commit.Id);
}
/// <inheritdoc />
public IObservable <string> GetCommitMessagesAfterParent(GitCommit parent, IScheduler scheduler = null)
{
return(CurrentBranch.Select(branch => ExtractLogParameter(branch, 0, 0, GitLogOptions.None, $"{parent.Sha}..HEAD"))
.Switch()
.Select(x => _gitProcessManager.RunGit(x, scheduler: scheduler))
.Switch()
.Select(x => ConvertStringToGitCommit(x).MessageLong.Select(y => y.Trim('\r', '\n')))
.Switch());
}
private static bool IsRelevantCommit(GitRepository repository, GitCommit commit, GitCommit parent, IReadOnlyList <FilterPath> filters)
{
return(IsRelevantCommit(
repository,
repository.GetTree(commit.Tree),
parent != default ? repository.GetTree(parent.Tree) : null,
relativePath: string.Empty,
filters));
}
private CommitViewModel ConvertCommit(GitCommit gitCommit)
{
return(new CommitViewModel
{
Committer = gitCommit.Committer,
Identifier = gitCommit.ShaId,
Message = gitCommit.Message
});
}
protected override bool TryGetOverrideMessage(GitCommit commit, [NotNullWhen(true)] out string?message)
{
if (m_OverrideMessages.Value.TryGetValue(commit.Id, out message))
{
m_Logger.LogInformation($"Commit message for commit '{commit.Id}' was overridden through filesystem. Using message from filesystem instead of commit message.");
return(true);
}
return(false);
}
public bool IsCommitOnSameDay(GitCommit current, GitCommit previous)
{
if (previous == null || current == null)
{
return(true);
}
var currentDate = current.CommitTimeStamp;
var previousDate = previous.CommitTimeStamp;
return(currentDate.DayOfWeek == previousDate.DayOfWeek);
}
public void WhenParsingCommitWithBinaryFilesShouldGetResultsCorrectly()
{
var list = GetListWithContent(Resources.GitExample2);
GitCommit commit = this.parser.Parse(list)[0];
Assert.Single(commit.ChangesetFileChanges);
Assert.Equal("src/dir-with-dashes/File1.cs", commit.ChangesetFileChanges[0].FileName);
Assert.Equal(0, commit.ChangesetFileChanges[0].Added);
Assert.Equal(0, commit.ChangesetFileChanges[0].Deleted);
}
private static async Task <bool> SearchCommitAtPathAsync(string filePath, string sha)
{
GitCommit gitCommit = await GitCommit.FindCommitAsync(filePath, sha);
if (gitCommit != null)
{
s_localCache[sha] = gitCommit;
return(true);
}
return(false);
}
public TimeSpan TimeSinceLastCommit(GitCommit current, GitCommit previous)
{
if (previous == null || current == null)
{
return(TimeSpan.MaxValue);
}
var currentDate = current.CommitTimeStamp;
var previousDate = previous.CommitTimeStamp;
return((currentDate - previousDate).Duration());
}
/// <inheritdoc />
public async Task <string> GetCommitMessages(GitCommit startCommit, CancellationToken token)
{
if (startCommit == null)
{
return(null);
}
var result = await this.branchManager.GetCommitMessagesAfterParent(startCommit, token);
return(result.TrimEmptyLines());
}
/// <inheritdoc />
public IObservable <string> GetCommitMessageLong(GitCommit commit, IScheduler scheduler = null)
{
if (commit == null)
{
throw new ArgumentNullException(nameof(commit));
}
return(_gitProcessManager.RunGit(new[] { "log", "--format=%B", "-n 1", commit.Sha }, scheduler: scheduler)
.Select(x => x.Trim().Trim('\r', '\n'))
.ToList()
.Select(result => string.Join("\r\n", result).Trim().Trim('\r', '\n', ' ')));
}
public void WhenParsingSubsequentCommitsShouldParseStatsCorrectly()
{
var list = GetListWithContent(Resources.GitExample1);
GitCommit commit = this.parser.Parse(list)[1];
Assert.Equal(2, commit.ChangesetFileChanges.Count);
Assert.Equal(4, commit.ChangesetFileChanges[1].Added);
Assert.Equal(3, commit.ChangesetFileChanges[1].Deleted);
Assert.Equal("src/dir2/SomeOtherFile.cs", commit.ChangesetFileChanges[1].FileName);
}
public GitFileSystem(GitFileSystemParams param) : base(param)
{
try
{
this.Commit = this.Repository.FindCommitAsync(param.CommitId)._GetResult();
}
catch (Exception ex)
{
this._DisposeSafe(ex);
throw;
}
}
public void TaskCommitTest()
{
// create a file to commit
string contentFile4 = dummyRepo + "\\testFile4.txt";
using (var writer = new StreamWriter(contentFile4))
{
writer.WriteLine("File content for file 4");
writer.Close();
}
List<string> output = Add.ExecCommand(true, null);
GitCommit t = new GitCommit
{
Message = "Init commit"
};
t.BuildEngine = new DummyBuildEngine();
bool result = t.Execute();
Assert.IsTrue(result, "Execution failed");
}
