public BranchPicker(GitRepository repository)
{
InitializeComponent();
this.repository = repository;
_branches = new ObservableCollection<GitBranchInfo>();
comboBranches.ItemsSource = _branches;
//this.list = list;
}
public string FindNoCommitedFiles()
{
var result = "";
var breakLine = "";
foreach (var directory in DirectoriesPaths())
{
GitRepository repository = new GitRepository(directory.Value);
result += breakLine + directory.Key + " : " + repository.ModifiedFiles().ToString();
breakLine = ";";
}
return result;
}
public static void ShowStashManager(GitRepository repo)
{
using (var dlg = new StashManagerDialog(repo))
MessageService.ShowCustomDialog(dlg);
}
public void MinimalGitData()
{
var repoDir = Temp.CreateDirectory();
var gitDir = repoDir.CreateDirectory(".git");
gitDir.CreateFile("HEAD").WriteAllText("1111111111111111111111111111111111111111");
gitDir.CreateFile("config").WriteAllText(@"[remote ""origin""]url=""http://github.com/test-org/test-repo""");
gitDir.CreateDirectory("objects");
gitDir.CreateDirectory("refs");
repoDir.CreateFile(".gitignore").WriteAllText("ignore_this_*");
// submodule:
var gitModules = repoDir.CreateFile(".gitmodules").WriteAllText(@"
[submodule ""my submodule""]
path = sub
url = https://github.com/test-org/test-sub
");
var subDir = repoDir.CreateDirectory("sub");
subDir.CreateFile(".git").WriteAllText("gitdir: ../.git/modules/sub");
subDir.CreateFile(".gitignore").WriteAllText("ignore_in_submodule_*");
var gitDirSub = gitDir.CreateDirectory("modules").CreateDirectory("sub");
gitDirSub.CreateFile("HEAD").WriteAllText("2222222222222222222222222222222222222222");
gitDirSub.CreateDirectory("objects");
gitDirSub.CreateDirectory("refs");
var repository = GitRepository.OpenRepository(repoDir.Path, GitEnvironment.Empty) !;
Assert.Equal("http://github.com/test-org/test-repo", GitOperations.GetRepositoryUrl(repository, remoteName: null));
Assert.Equal("1111111111111111111111111111111111111111", repository.GetHeadCommitSha());
var warnings = new List <(string, object?[])>();
var sourceRoots = GitOperations.GetSourceRoots(repository, remoteName: null, (message, args) => warnings.Add((message, args)));
AssertEx.Equal(new[]
{
$@"'{repoDir.Path}{s}' SourceControl='git' RevisionId='1111111111111111111111111111111111111111' ScmRepositoryUrl='http://github.com/test-org/test-repo'",
$@"'{repoDir.Path}{s}sub{s}' SourceControl='git' RevisionId='2222222222222222222222222222222222222222' NestedRoot='sub/' ContainingRoot='{repoDir.Path}{s}' ScmRepositoryUrl='https://github.com/test-org/test-sub'",
}, sourceRoots.Select(TestUtilities.InspectSourceRoot));
AssertEx.Equal(new string[0], warnings.Select(TestUtilities.InspectDiagnostic));
var files = new[]
{
new MockItem(@"ignore_this_a"),
new MockItem(@"b"),
new MockItem(@"ignore_this_c"),
new MockItem(@"sub\ignore_in_submodule_d"),
};
var untrackedFiles = GitOperations.GetUntrackedFiles(repository, files, repoDir.Path);
AssertEx.Equal(new[]
{
"ignore_this_a",
"ignore_this_c",
MockItem.AdjustSeparators(@"sub\ignore_in_submodule_d"),
}, untrackedFiles.Select(item => item.ItemSpec));
}
private static GitPullRequest CreatePullRequestInternal(ClientSampleContext context, GitRepository repo, GitHttpClient gitClient)
{
// we need a new branch with changes in order to create a PR
// first, find the default branch
string defaultBranchName = WithoutRefsPrefix(repo.DefaultBranch);
GitRef defaultBranch = gitClient.GetRefsAsync(repo.Id, filter: defaultBranchName).Result.First();
// next, craft the branch and commit that we'll push
GitRefUpdate newBranch = new GitRefUpdate()
{
Name = $"refs/heads/vsts-api-sample/{ChooseRefsafeName()}",
OldObjectId = defaultBranch.ObjectId,
};
string newFileName = $"{ChooseItemsafeName()}.md";
GitCommitRef newCommit = new GitCommitRef()
{
Comment = "Add a sample file",
Changes = new GitChange[]
{
new GitChange()
{
ChangeType = VersionControlChangeType.Add,
Item = new GitItem()
{
Path = $"/vsts-api-sample/{newFileName}"
},
NewContent = new ItemContent()
{
Content = "# Thank you for using VSTS!",
ContentType = ItemContentType.RawText,
},
}
},
};
// create the push with the new branch and commit
GitPush push = gitClient.CreatePushAsync(new GitPush()
{
RefUpdates = new GitRefUpdate[] { newBranch },
Commits = new GitCommitRef[] { newCommit },
}, repo.Id).Result;
// finally, create a PR
var pr = gitClient.CreatePullRequestAsync(new GitPullRequest()
{
SourceRefName = newBranch.Name,
TargetRefName = repo.DefaultBranch,
Title = $"Add {newFileName} (from VSTS REST samples)",
Description = "Adding this file from the pull request samples",
},
repo.Id).Result;
return(pr);
}
internal override void InternalExecute()
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
//////////////////////////////////////////////////
var sourceGitRepoService = me.Source.Collection.GetService <GitRepositoryService>();
var sourceGitRepos = sourceGitRepoService.QueryRepositories(me.Source.Name);
//////////////////////////////////////////////////
var targetGitRepoService = me.Target.Collection.GetService <GitRepositoryService>();
var targetGitRepos = targetGitRepoService.QueryRepositories(me.Target.Name);
WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);
TfsQueryContext tfsqc = new TfsQueryContext(targetStore);
tfsqc.AddParameter("TeamProject", me.Target.Name);
tfsqc.Query = string.Format(@"SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = @TeamProject");
WorkItemCollection workitems = tfsqc.Execute();
Trace.WriteLine(string.Format("Update {0} work items?", workitems.Count));
//////////////////////////////////////////////////
int current = workitems.Count;
int count = 0;
long elapsedms = 0;
int noteFound = 0;
foreach (WorkItem workitem in workitems)
{
Stopwatch witstopwatch = new Stopwatch();
witstopwatch.Start();
workitem.Open();
List <ExternalLink> newEL = new List <ExternalLink>();
List <ExternalLink> removeEL = new List <ExternalLink>();
Trace.WriteLine(string.Format("WI: {0}?", workitem.Id));
List <string> gitWits = new List <string>
{
"Branch",
"Fixed in Commit",
"Pull Request"
};
foreach (Link l in workitem.Links)
{
if (l is ExternalLink && gitWits.Contains(l.ArtifactLinkType.Name))
{
ExternalLink el = (ExternalLink)l;
//vstfs:///Git/Commit/25f94570-e3e7-4b79-ad19-4b434787fd5a%2f50477259-3058-4dff-ba4c-e8c179ec5327%2f41dd2754058348d72a6417c0615c2543b9b55535
string guidbits = el.LinkedArtifactUri.Substring(el.LinkedArtifactUri.LastIndexOf('/') + 1);
string[] bits = Regex.Split(guidbits, "%2f", RegexOptions.IgnoreCase);
string oldCommitId = null;
string oldGitRepoId = bits[1];
if (bits.Count() >= 3)
{
oldCommitId = $"{bits[2]}";
for (int i = 2; i < bits.Count(); i++)
{
oldCommitId += $"%2f{bits[i]}";
}
}
else
{
oldCommitId = bits[2];
}
var oldGitRepo =
(from g in sourceGitRepos where g.Id.ToString() == oldGitRepoId select g)
.SingleOrDefault();
if (oldGitRepo != null)
{
// Find the target git repo
GitRepository newGitRepo = null;
var repoNameToLookFor = !string.IsNullOrEmpty(_config.TargetRepository)
? _config.TargetRepository
: oldGitRepo.Name;
// Source and Target project names match
if (oldGitRepo.ProjectReference.Name == me.Target.Name)
{
newGitRepo = (from g in targetGitRepos
where
g.Name == repoNameToLookFor &&
g.ProjectReference.Name == oldGitRepo.ProjectReference.Name
select g).SingleOrDefault();
}
// Source and Target project names do not match
else
{
newGitRepo = (from g in targetGitRepos
where
g.Name == repoNameToLookFor &&
g.ProjectReference.Name != oldGitRepo.ProjectReference.Name
select g).SingleOrDefault();
}
// Fix commit links if target repo has been found
if (newGitRepo != null)
{
Trace.WriteLine($"Fixing {oldGitRepo.RemoteUrl} to {newGitRepo.RemoteUrl}?");
// Create External Link object
ExternalLink newLink = null;
switch (l.ArtifactLinkType.Name)
{
case "Branch":
newLink = new ExternalLink(targetStore.Store.RegisteredLinkTypes[ArtifactLinkIds.Branch],
$"vstfs:///git/ref/{newGitRepo.ProjectReference.Id}%2f{newGitRepo.Id}%2f{oldCommitId}");
break;
case "Fixed in Commit":
newLink = new ExternalLink(targetStore.Store.RegisteredLinkTypes[ArtifactLinkIds.Commit],
$"vstfs:///git/commit/{newGitRepo.ProjectReference.Id}%2f{newGitRepo.Id}%2f{oldCommitId}");
break;
case "Pull Request":
newLink = new ExternalLink(targetStore.Store.RegisteredLinkTypes[ArtifactLinkIds.PullRequest],
$"vstfs:///Git/PullRequestId/{newGitRepo.ProjectReference.Id}%2f{newGitRepo.Id}%2f{oldCommitId}");
break;
default:
Trace.WriteLine(String.Format("Skipping unsupported link type {0}", l.ArtifactLinkType.Name));
break;
}
if (newLink != null)
{
var elinks = from Link lq in workitem.Links
where gitWits.Contains(lq.ArtifactLinkType.Name)
select(ExternalLink) lq;
var found =
(from Link lq in elinks
where (((ExternalLink)lq).LinkedArtifactUri.ToLower() == newLink.LinkedArtifactUri.ToLower())
select lq).SingleOrDefault();
if (found == null)
{
newEL.Add(newLink);
}
removeEL.Add(el);
}
}
else
{
Trace.WriteLine($"FAIL: cannot map {oldGitRepo.RemoteUrl} to ???");
}
}
else
{
Trace.WriteLine($"FAIL could not find source git repo");
noteFound++;
}
}
}
// add and remove
foreach (ExternalLink eln in newEL)
{
try
{
Trace.WriteLine("Adding " + eln.LinkedArtifactUri, Name);
workitem.Links.Add(eln);
}
catch (Exception)
{
// eat exception as sometimes TFS thinks this is an attachment
}
}
foreach (ExternalLink elr in removeEL)
{
if (workitem.Links.Contains(elr))
{
try
{
Trace.WriteLine("Removing " + elr.LinkedArtifactUri, Name);
workitem.Links.Remove(elr);
}
catch (Exception)
{
// eat exception as sometimes TFS thinks this is an attachment
}
}
}
if (workitem.IsDirty)
{
Trace.WriteLine($"Saving {workitem.Id}");
workitem.Save();
}
witstopwatch.Stop();
elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
current--;
count++;
TimeSpan average = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion",
string.Format(@"{0:s\:fff} seconds", average),
string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)));
}
Trace.WriteLine(string.Format("Did not find old repo for {0} links?", noteFound));
//////////////////////////////////////////////////
stopwatch.Stop();
Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
}
internal void Refresh(GitRepository tracker, MyToolWindow toolWindow)
{
this.toolWindow = toolWindow;
this.tracker = tracker;
RefreshPrompt();
}
public static string GetGitHubCompareTagsUrl(this GitRepository repository, string startTag, string endTag)
{
Assert.True(repository.IsGitHubRepository());
return($"https://github.com/{repository.Identifier}/compare/{endTag}...{startTag}");
}
public static string GetGitHubCommitUrl(this GitRepository repository, string commitSha)
{
Assert.True(repository.IsGitHubRepository());
return($"https://github.com/{repository.Identifier}/commit/{commitSha}");
}
public static string GetGitHubCompareCommitsUrl(this GitRepository repository, string startCommitSha, string endCommitSha)
{
Assert.True(repository.IsGitHubRepository());
return($"https://github.com/{repository.Identifier}/compare/{endCommitSha}^...{startCommitSha}");
}
public static string GetGitHubCompareTagToHeadUrl(this GitRepository repository, string tag)
{
Assert.True(repository.IsGitHubRepository());
return($"https://github.com/{repository.Identifier}/compare/{tag}...HEAD");
}
public static string GetGitHubName(this GitRepository repository)
{
Assert.True(repository.IsGitHubRepository());
return(repository.Identifier.Split('/')[1]);
}
private async Task <OperationResult <AgentInformation> > RunAgentAsync(StartAgentInformation startAgentInformation, GitRepository agentRepository)
{
var args = new ShellRunnerArgs(agentRepository.Directory,
"docker", false, $"run -p {startAgentInformation.Port}:80 -d agent:latest");
var runAgentResult = await shellRunner.RunAsync(args);
if (!runAgentResult.IsSuccessful)
{
return(OperationResult <AgentInformation> .Failed($"Cannot run container with agent. Error: {runAgentResult.Error}"));
}
logger.LogInformation(await runAgentResult.Value.Output.ReadToEndAsync());
return(OperationResult <AgentInformation> .Success(new AgentInformation(new Uri($"http://localhost:{startAgentInformation.Port}"))));
}
public override bool OnBeginCommit(ChangeSet changeSet)
{
// In this callback we check if the user information configured in Git
// matches the user information configured in MonoDevelop. If the configurations
// don't match, it shows a dialog asking the user what to do.
GitRepository repo = (GitRepository)changeSet.Repository;
if (!widget.CommitterIsAuthor)
{
if (widget.AuthorName.Length > 0)
{
changeSet.ExtendedProperties ["Git.AuthorName"] = widget.AuthorName;
}
if (widget.AuthorMail.Length > 0)
{
changeSet.ExtendedProperties ["Git.AuthorEmail"] = widget.AuthorMail;
}
}
Solution sol = null;
// Locate the solution to which the changes belong
foreach (Solution s in IdeApp.Workspace.GetAllSolutions())
{
if (s.BaseDirectory == changeSet.BaseLocalPath || changeSet.BaseLocalPath.IsChildPathOf(s.BaseDirectory))
{
sol = s;
break;
}
}
if (sol == null)
{
return(true);
}
string user;
string email;
repo.GetUserInfo(out user, out email);
string val = sol.UserProperties.GetValue <string> ("GitUserInfo");
if (val == "UsingMD")
{
// If the solution is configured to use the MD configuration, make sure the Git config is up to date.
if (user != sol.AuthorInformation.Name || email != sol.AuthorInformation.Email)
{
repo.SetUserInfo(sol.AuthorInformation.Name, sol.AuthorInformation.Email);
}
}
else if (val != "UsingGIT")
{
if (repo.IsUserInfoDefault())
{
var dlg = new UserGitConfigDialog();
try {
if (MessageService.RunCustomDialog(dlg) == (int)Gtk.ResponseType.Ok)
{
user = dlg.UserText;
email = dlg.EmailText;
repo.SetUserInfo(dlg.UserText, dlg.EmailText);
}
else
{
return(false);
}
} finally {
dlg.Destroy();
}
}
if (user != sol.AuthorInformation.Name || email != sol.AuthorInformation.Email)
{
// There is a conflict. Ask the user what to do
string gitInfo = GetDesc(user, email);
string mdInfo = GetDesc(sol.AuthorInformation.Name, sol.AuthorInformation.Email);
UserInfoConflictDialog dlg = new UserInfoConflictDialog(mdInfo, gitInfo);
try {
if (MessageService.RunCustomDialog(dlg) == (int)Gtk.ResponseType.Ok)
{
if (dlg.UseMonoDevelopConfig)
{
repo.SetUserInfo(sol.AuthorInformation.Name, sol.AuthorInformation.Email);
sol.UserProperties.SetValue("GitUserInfo", "UsingMD");
}
else
{
sol.UserProperties.SetValue("GitUserInfo", "UsingGIT");
}
sol.SaveUserProperties();
}
else
{
return(false);
}
} finally {
dlg.Destroy();
}
}
}
return(true);
}
public void ClonePublic()
{
string repos = GetTempPath();
using (GitClient git = new GitClient())
{
GitCloneArgs ca = new GitCloneArgs();
ca.Synchronous = true;
git.Clone(new Uri("https://github.com/libgit2/TestGitRepository.git"), repos, ca);
List<string> found = new List<string>();
GitStatusArgs sa = new GitStatusArgs();
sa.IncludeUnmodified = true;
sa.UseGlobPath = true;
git.Status(repos, sa,
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(8));
Assert.That(found, Is.All.Not.Null);
Assert.That(found, Is.Unique);
found.Clear();
git.Status(repos + "/a/*", sa,
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(3));
Assert.That(found, Is.All.Not.Null);
Assert.That(found, Is.Unique);
GitFetchArgs fa = new GitFetchArgs();
fa.All = true;
git.Fetch(repos, fa);
using (GitRepository repo = new GitRepository(repos))
{
Assert.That(repo.HeadBranch, Is.Not.Null);
Assert.That(repo.HeadBranch.Name, Is.EqualTo("refs/heads/master"));
Assert.That(repo.HeadBranch.UpstreamReference, Is.Not.Null);
Assert.That(repo.HeadBranch.UpstreamReference.Name, Is.EqualTo("refs/remotes/origin/master"));
Assert.That(repo.HeadBranch.IsHead, "Head knows that it is head");
//Assert.That(repo.HeadBranch.TrackedBranch, Is.Null);
Assert.That(repo.HeadBranch.Name, Is.EqualTo("refs/heads/master"));
Assert.That(repo.HeadBranch.IsRemote, Is.False, "Local branch");
Assert.That(repo.HeadBranch.RemoteName, Is.EqualTo("origin"));
foreach (GitBranch b in repo.Branches.Remote)
{
Assert.That(b.IsRemote, "Remote branch");
Assert.That(b.IsLocal, Is.False, "Not local");
Assert.That(b.Name, Is.StringStarting("refs/remotes/origin/"));
Assert.That(b.IsHead, Is.False);
Assert.That(b.UpstreamReference, Is.Null);
Assert.That(b.LocalUpstreamName, Is.Null);
Assert.That(b.RemoteName, Is.EqualTo("origin"));
}
foreach (GitBranch b in repo.Branches.Local)
{
Assert.That(b.IsLocal, "Local branch");
Assert.That(b.IsRemote, Is.False, "Not remote");
Assert.That(b.Name, Is.StringStarting("refs/").Or.EqualTo("master"));
Assert.That(b.IsHead, Is.EqualTo(b.ShortName == "master"));
Assert.That(b.RemoteName, Is.EqualTo("origin"));
if (!b.IsHead)
{
Assert.That(b.LocalUpstreamName, Is.Not.Null);
GitBranch tracked = b.TrackedBranch;
Assert.That(tracked, Is.Not.Null, "Have tracked");
Assert.That(b.RemoteName, Is.Not.Null);
}
}
foreach (GitRemote r in repo.Remotes)
{
Assert.That(r.Name, Is.Not.Null);
Assert.That(r.TagSynchronize, Is.EqualTo(GitTagSynchronize.Auto));
//Assert.That(r.Save(new GitFetchArgs()));
foreach (GitRefSpec rs in r.FetchRefSpecs)
{
}
foreach (GitRefSpec rs in r.PushRefSpecs)
{
}
}
}
git.Pull(repos);
// libgit2's local push code only supports bare repositories at
// this time, so we use a few more clones to test the real push
string cloneDir = GetTempPath();
GitCloneArgs cca = new GitCloneArgs();
cca.InitArgs.CreateBareRepository = true;
git.Clone(repos, cloneDir, cca);
string clone2Dir = GetTempPath();
git.Clone(cloneDir, clone2Dir);
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(clone2Dir, pa);
}
}
public static bool IsGitHubRepository(this GitRepository repository)
{
return(repository != null && repository.Endpoint.EqualsOrdinalIgnoreCase("github.com"));
}
public void UseGitClient()
{
GitCommitArgs ga = new GitCommitArgs();
ga.Author.Name = "Tester";
ga.Author.EmailAddress = "*****@*****.**";
ga.Signature.Name = "Other";
ga.Signature.EmailAddress = "*****@*****.**";
// Use stable time and offset to always produce the same hash
DateTime ct = new DateTime(2002, 01, 01, 0, 0, 0, DateTimeKind.Utc);
ga.Author.When = ct;
ga.Author.TimeOffsetInMinutes = 120;
ga.Signature.When = ct;
ga.Signature.TimeOffsetInMinutes = 120;
string repoDir = GetTempPath();
string repo2Dir = GetTempPath();
GitId firstResult;
GitId lastCommit;
using (GitRepository repo = GitRepository.Create(repoDir))
using (GitClient git = new GitClient())
{
string ignoreFile = Path.Combine(repoDir, ".gitignore");
string file = Path.Combine(repoDir, "newfile");
string subDir = Path.Combine(repoDir, "dir");
string fileInSubDir = Path.Combine(subDir, "file2");
string file3 = Path.Combine(repoDir, "other");
string file4 = Path.Combine(repoDir, "q.ignore");
File.WriteAllText(file, "Some body");
Directory.CreateDirectory(subDir);
File.WriteAllText(fileInSubDir, "Some other body");
File.WriteAllText(file3, "file3");
File.WriteAllText(ignoreFile, "*.ignore\n");
File.WriteAllText(file4, "file4");
git.Add(ignoreFile);
git.Add(file);
git.Commit(repoDir, ga, out firstResult);
git.Add(fileInSubDir);
int ticked = 0;
File.AppendAllText(file, "\nExtra Line");
GitStatusArgs gsa = new GitStatusArgs();
gsa.IncludeIgnored = true;
gsa.IncludeUnmodified = true;
Assert.That(git.Status(repoDir, gsa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
case "newfile":
//Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Added));
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "newfile index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "newfile wc modified");
Assert.That(e.WorkingDirectoryModified);
Assert.That(e.Ignored, Is.False);
break;
case "dir/file2":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.New), "file2 index added");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "file2 wc normal");
Assert.That(e.Ignored, Is.False);
break;
case "other":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New));
Assert.That(e.Ignored, Is.False);
break;
case ".gitignore":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Ignored, Is.False);
break;
case "q.ignore":
// TODO: Make this ignored
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Ignored, Is.True);
break;
default:
Assert.Fail("Invalid node found: {0}", e.RelativePath);
break;
}
Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
ticked++;
}), Is.True);
Assert.That(ticked, Is.EqualTo(5), "Ticked");
ga.LogMessage = "Intermediate";
git.Commit(repoDir, ga);
Assert.That(git.Delete(fileInSubDir));
Assert.That(git.Add(file));
GitId commit;
ga.LogMessage = "A log message to remember";
// The passed path is currently just used to find the local repository
lastCommit = new GitId("996cf198b49ed6fce3bcba232e2d88eb473560f9");
Assert.That(git.Commit(repoDir, ga, out commit));
Assert.That(commit, Is.EqualTo(lastCommit));
File.Move(file, file + ".a");
ticked = 0;
gsa.IncludeIgnored = false;
gsa.IncludeUnversioned = true;
gsa.IncludeUnmodified = false;
Assert.That(git.Status(repoDir, gsa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
/*case "dir":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "dir index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "dir wc normal");
break;*/
case "newfile":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Deleted), "newfile wc deleted");
break;
case "newfile.a":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile.a index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "newfile.a wc new");
break;
case "other":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "other index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "other wc normal");
break;
default:
Assert.Fail("Invalid node found: {0}", e.RelativePath);
break;
}
Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
ticked++;
}), Is.True);
Assert.That(ticked, Is.EqualTo(3));
GitCloneArgs gc = new GitCloneArgs();
gc.Synchronous = true;
git.Clone(repoDir, repo2Dir, gc);
GitCommit theCommit;
Assert.That(repo.Lookup(commit, out theCommit));
Assert.That(repo.Branches.Create(theCommit, "vNext"));
Assert.That(repo.Branches, Is.Not.Empty);
}
using (GitRepository repo1 = new GitRepository(repoDir))
using (GitRepository repo2 = new GitRepository(repo2Dir))
{
GitReference head = repo1.HeadReference;
Assert.That(head, Is.Not.Null, "Has head");
Assert.That(head.Name, Is.EqualTo("refs/heads/master"));
//Assert.That(repo2.Head, Is.Not.Null);
GitId headId;
Assert.That(repo1.ResolveReference(repo1.HeadReference, out headId));
Assert.That(headId, Is.EqualTo(lastCommit));
GitCommit commit;
Assert.That(repo1.Lookup(headId, out commit));
Assert.That(commit, Is.Not.Null, "Have a commit");
Assert.That(commit.Id, Is.EqualTo(lastCommit));
Assert.That(commit.Ancestors, Is.Not.Empty);
Assert.That(commit.Ancestor, Is.Not.Null);
Assert.That(commit.Ancestor.Ancestor, Is.Not.Null);
Assert.That(commit.Ancestor.Ancestor.Ancestor, Is.Null);
Assert.That(commit.Ancestor.Ancestor.Id, Is.EqualTo(firstResult));
Assert.That(commit.Author, Is.Not.Null);
Assert.That(commit.Author.Name, Is.EqualTo("Tester"));
Assert.That(commit.Author.EmailAddress, Is.EqualTo("*****@*****.**"));
Assert.That(commit.Committer, Is.Not.Null);
Assert.That(commit.Committer.Name, Is.EqualTo("Other"));
Assert.That(commit.Committer.EmailAddress, Is.EqualTo("*****@*****.**"));
Assert.That(commit.Committer.TimeOffsetInMinutes, Is.EqualTo(120), "Time offset"); // CEST dependent
Assert.That(commit.Committer.When, Is.EqualTo(ct), "Exact time");
Assert.That(commit.LogMessage, Is.EqualTo("A log message to remember\n"));
Assert.That(commit.Parents, Is.Not.Empty);
Assert.That(commit.ParentIds, Is.Not.Empty);
Assert.That(commit.Tree, Is.Not.Empty);
Assert.That(commit.Tree.Count, Is.EqualTo(2));
Assert.That(commit.Ancestor.Tree.Count, Is.EqualTo(3));
Assert.That(commit.Ancestor.Ancestor.Tree.Count, Is.EqualTo(2));
Assert.That(commit.Tree.Id, Is.Not.EqualTo(commit.Ancestor.Tree.Id));
GitId id;
Assert.That(repo1.LookupViaPrefix(commit.Id.ToString(), out id));
Assert.That(id, Is.EqualTo(commit.Id));
Assert.That(repo1.LookupViaPrefix(commit.Id.ToString().Substring(0, 10), out id));
Assert.That(id, Is.EqualTo(commit.Id));
Assert.That(commit.Peel<GitObject>().Id, Is.EqualTo(commit.Tree.Id));
Assert.That(commit.Peel<GitTree>(), Is.EqualTo(commit.Tree)); // Compares members
Assert.That(commit.Tree.Peel<GitObject>(), Is.Null);
GitTagArgs ta = new GitTagArgs();
ta.Signature.When = ct;
ta.Signature.Name = "Me";
ta.Signature.EmailAddress = "[email protected]";
ta.LogMessage = "Some message";
ga.Author.TimeOffsetInMinutes = 120;
Assert.That(commit.Tag("MyTag", ta, out id));
Assert.That(id, Is.EqualTo(new GitId("db31f8333fc64d7e7921ea91f6e007b755dcfcbb")));
GitTag tag;
Assert.That(repo1.Lookup(id, out tag));
Assert.That(tag, Is.Not.Null);
Assert.That(tag.Name, Is.EqualTo("MyTag"));
Assert.That(tag.LogMessage, Is.EqualTo("Some message\n"));
Assert.That(tag.Tagger.Name, Is.EqualTo("Me"));
Assert.That(tag.Target.Id, Is.EqualTo(commit.Id));
Assert.That(tag.Peel<GitTree>(), Is.EqualTo(commit.Peel<GitTree>()));
repo1.CheckOut(commit.Tree);
//Console.WriteLine("1:");
//foreach (GitTreeEntry e in commit.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("2:");
//foreach (GitTreeEntry e in commit.Ancestor.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("3:");
//foreach (GitTreeEntry e in commit.Ancestor.Ancestor.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("-");
}
}
public static string GetGitHubName(this GitRepository repository)
{
ControlFlow.Assert(repository.IsGitHubRepository(), text: "repository.IsGitHubRepository()");
return(repository.Identifier.Split('/')[1]);
}
internal void Refresh(GitRepository tracker)
{
this.tracker = tracker;
RefreshPrompt();
}
private static string GetMethod([CanBeNull] string relativePath, GitHubItemType itemType, GitRepository repository)
{
var absolutePath = repository.LocalDirectory != null && relativePath != null
? NormalizePath(Path.Combine(repository.LocalDirectory, relativePath))
: null;
if (itemType == GitHubItemType.Directory || Directory.Exists(absolutePath) || relativePath == null)
{
return("tree");
}
if (itemType == GitHubItemType.File || File.Exists(absolutePath))
{
return("blob");
}
return(null);
}
private static bool IsRelevantCommit(GitRepository repository, GitTree tree, GitTree parent, string relativePath, IReadOnlyList <FilterPath> filters)
{
// Walk over all child nodes in the current tree. If a child node was found in the parent,
// remove it, so that after the iteration the parent contains all nodes which have been
// deleted.
foreach (var child in tree.Children)
{
var entry = child.Value;
GitTreeEntry?parentEntry = null;
// If the entry is not present in the parent commit, it was added;
// if the Sha does not match, it was modified.
if (!parent.Children.TryGetValue(child.Key, out parentEntry) ||
parentEntry.Sha != child.Value.Sha)
{
// Determine whether the change was relevant.
var fullPath = $"{relativePath}{entry.Name}";
bool isRelevant =
// Either there are no include filters at all (i.e. everything is included), or there's an explicit include filter
(!filters.Any(f => f.IsInclude) || filters.Any(f => f.Includes(fullPath, repository.IgnoreCase)))
// The path is not excluded by any filters
&& !filters.Any(f => f.Excludes(fullPath, repository.IgnoreCase));
// If the change was relevant, and the item is a directory, we need to recurse.
if (isRelevant && !entry.IsFile)
{
isRelevant = IsRelevantCommit(
repository,
repository.GetTree(entry.Sha),
parentEntry == null ? GitTree.Empty : repository.GetTree(parentEntry.Sha),
$"{fullPath}/",
filters);
}
// Quit as soon as any relevant change has been detected.
if (isRelevant)
{
return(true);
}
}
if (parentEntry != null)
{
parent.Children.Remove(child.Key);
}
}
// Inspect removed entries (i.e. present in parent but not in the current tree)
foreach (var child in parent.Children)
{
// Determine whether the change was relevant.
var fullPath = Path.Combine(relativePath, child.Key);
bool isRelevant =
filters.Any(f => f.Includes(fullPath, repository.IgnoreCase)) &&
!filters.Any(f => f.Excludes(fullPath, repository.IgnoreCase));
if (isRelevant)
{
return(true);
}
}
// No relevant changes have been detected
return(false);
}
protected virtual void DoFetch(IGitTfsRemote remote, bool stopOnFailMergeCommit)
{
if (remote.Repository.IsBare)
{
if (string.IsNullOrEmpty(BareBranch))
{
throw new GitTfsException("error : specify a git branch to fetch on...");
}
if (!remote.Repository.HasRef(GitRepository.ShortToLocalName(BareBranch)))
{
throw new GitTfsException("error : the specified git branch doesn't exist...");
}
if (!ForceFetch && remote.MaxCommitHash != remote.Repository.GetCommit(BareBranch).Sha)
{
throw new GitTfsException("error : fetch is not allowed when there is ahead commits!",
new List <string>()
{
"Remove ahead commits and retry", "use the --force option (ahead commits will be lost!)"
});
}
}
// It is possible that we have outdated refs/remotes/tfs/<id>.
// E.g. someone already fetched changesets from TFS into another git repository and we've pulled it since
// in that case tfs fetch will retrieve same changes again unnecessarily. To prevent it we will scan tree from HEAD and see if newer changesets from
// TFS exists (by checking git-tfs-id mark in commit's comments).
// The process is similar to bootstrapping.
if (!ForceFetch)
{
globals.Repository.MoveTfsRefForwardIfNeeded(remote);
}
var exportMetadatasFilePath = Path.Combine(globals.GitDir, "git-tfs_workitem_mapping.txt");
if (ExportMetadatas)
{
remote.ExportMetadatas = true;
remote.Repository.SetConfig(GitTfsConstants.ExportMetadatasConfigKey, "true");
if (!string.IsNullOrEmpty(ExportMetadatasFile))
{
if (File.Exists(ExportMetadatasFile))
{
File.Copy(ExportMetadatasFile, exportMetadatasFilePath);
}
else
{
throw new GitTfsException("error: the work items mapping file doesn't exist!");
}
}
}
else
{
if (remote.Repository.GetConfig(GitTfsConstants.ExportMetadatasConfigKey) == "true")
{
remote.ExportMetadatas = true;
}
}
remote.ExportWorkitemsMapping = new Dictionary <string, string>();
if (remote.ExportMetadatas && File.Exists(exportMetadatasFilePath))
{
try
{
foreach (var lineRead in File.ReadAllLines(exportMetadatasFilePath))
{
if (string.IsNullOrWhiteSpace(lineRead))
{
continue;
}
var values = lineRead.Split('|');
var oldWorkitem = values[0].Trim();
if (!remote.ExportWorkitemsMapping.ContainsKey(oldWorkitem))
{
remote.ExportWorkitemsMapping.Add(oldWorkitem, values[1].Trim());
}
}
}
catch (Exception)
{
throw new GitTfsException("error: bad format of workitems mapping file! One line format should be: OldWorkItemId|NewWorkItemId");
}
}
try
{
remote.Fetch(stopOnFailMergeCommit);
}
finally
{
Trace.WriteLine("Cleaning...");
remote.CleanupWorkspaceDirectory();
if (remote.Repository.IsBare)
{
remote.Repository.UpdateRef(GitRepository.ShortToLocalName(BareBranch), remote.MaxCommitHash);
}
}
}
public void FromUrlProtocolTest(string url, GitProtocol protocol)
{
var repository = GitRepository.FromUrl(url);
repository.Protocol.Should().Be(protocol);
}
internal GitSet(GitRepository repository)
{
Repository = repository ?? throw new ArgumentNullException(nameof(repository));
}
private static bool FindAnyRepository(ClientSampleContext context, Guid projectId, out GitRepository repo)
{
// Check if we already have a repo loaded
if (!context.TryGetValue <GitRepository>("$someRepo", out repo))
{
VssConnection connection = context.Connection;
GitHttpClient gitClient = connection.GetClient <GitHttpClient>();
using (new ClientSampleHttpLoggerOutputSuppression())
{
// Check if an ID was already set (this could have been provided by the caller)
Guid repoId;
if (!context.TryGetValue <Guid>("repositoryId", out repoId))
{
// Get the first repo
repo = gitClient.GetRepositoriesAsync(projectId).Result.FirstOrDefault();
}
else
{
// Get the details for this repo
repo = gitClient.GetRepositoryAsync(repoId.ToString()).Result;
}
}
if (repo != null)
{
context.SetValue <GitRepository>("$someRepo", repo);
}
else
{
// create a project here?
throw new Exception("No repos available for running the sample.");
}
}
return(repo != null);
}
public static (string gitHubOwner, string repositoryName) GetGitHubRepositoryInfo(GitRepository gitRepository)
{
ControlFlow.Assert(gitRepository.IsGitHubRepository(), $"The {nameof(gitRepository)} parameter must reference a GitHub repository.");
var split = gitRepository.Identifier.Split('/');
return(split[0], split[1]);
}
internal void Refresh(GitRepository tracker)
{
this.tracker = tracker;
RefreshPrompt();
}
internal void Refresh(GitRepository tracker, MyToolWindow toolWindow)
{
this.toolWindow = toolWindow;
this.tracker = tracker;
RefreshPrompt();
}
public static void ShowConfigurationDialog(GitRepository repo)
{
using (var dlg = new GitConfigurationDialog(repo))
MessageService.ShowCustomDialog(dlg);
}
public GitConfigurationDialog(VersionControlSystem vcs, string repoPath, string repoUrl)
{
this.Build();
this.repo = new GitRepository(vcs, repoPath, repoUrl, false);
this.HasSeparator = false;
this.UseNativeContextMenus();
// Branches list
storeBranches = new ListStore(typeof(Branch), typeof(string), typeof(string), typeof(string));
listBranches.Model = storeBranches;
listBranches.SearchColumn = -1; // disable the interactive search
listBranches.HeadersVisible = true;
SemanticModelAttribute modelAttr = new SemanticModelAttribute("storeBranches__Branch", "storeBranches__DisplayName", "storeBranches__Tracking", "storeBranches__Name");
TypeDescriptor.AddAttributes(storeBranches, modelAttr);
listBranches.AppendColumn(GettextCatalog.GetString("Branch"), new CellRendererText(), "markup", 1);
listBranches.AppendColumn(GettextCatalog.GetString("Tracking"), new CellRendererText(), "text", 2);
listBranches.Selection.Changed += delegate {
TreeIter it;
bool anythingSelected =
buttonRemoveBranch.Sensitive = buttonEditBranch.Sensitive = buttonSetDefaultBranch.Sensitive = listBranches.Selection.GetSelected(out it);
if (!anythingSelected)
{
return;
}
if (repo == null || repo.IsDisposed)
{
return;
}
string currentBranch = repo.GetCurrentBranch();
var b = (Branch)storeBranches.GetValue(it, 0);
buttonRemoveBranch.Sensitive = b.FriendlyName != currentBranch;
buttonSetDefaultBranch.Sensitive = !b.IsCurrentRepositoryHead;
};
buttonRemoveBranch.Sensitive = buttonEditBranch.Sensitive = buttonSetDefaultBranch.Sensitive = false;
// Sources tree
storeRemotes = new TreeStore(typeof(Remote), typeof(string), typeof(string), typeof(string), typeof(string));
treeRemotes.Model = storeRemotes;
treeRemotes.SearchColumn = -1; // disable the interactive search
treeRemotes.HeadersVisible = true;
SemanticModelAttribute remotesModelAttr = new SemanticModelAttribute("storeRemotes__Remote", "storeRemotes__Name", "storeRemotes__Url", "storeRemotes__BranchName", "storeRemotes__FullName");
TypeDescriptor.AddAttributes(storeRemotes, remotesModelAttr);
treeRemotes.AppendColumn(GettextCatalog.GetString("Remote Source / Branch"), new CellRendererText(), "markup", 1);
treeRemotes.AppendColumn(GettextCatalog.GetString("Url"), new CellRendererText(), "text", 2);
treeRemotes.Selection.Changed += delegate {
TreeIter it;
bool anythingSelected = treeRemotes.Selection.GetSelected(out it);
buttonTrackRemote.Sensitive = false;
buttonFetch.Sensitive = buttonEditRemote.Sensitive = buttonRemoveRemote.Sensitive = anythingSelected;
if (!anythingSelected)
{
return;
}
string branchName = (string)storeRemotes.GetValue(it, 3);
if (branchName != null)
{
buttonTrackRemote.Sensitive = true;
}
};
buttonTrackRemote.Sensitive = buttonFetch.Sensitive = buttonEditRemote.Sensitive = buttonRemoveRemote.Sensitive = false;
// Tags list
storeTags = new ListStore(typeof(string));
listTags.Model = storeTags;
listTags.SearchColumn = -1; // disable the interactive search
listTags.HeadersVisible = true;
SemanticModelAttribute tagsModelAttr = new SemanticModelAttribute("storeTags__Name");
TypeDescriptor.AddAttributes(storeTags, tagsModelAttr);
listTags.AppendColumn(GettextCatalog.GetString("Tag"), new CellRendererText(), "text", 0);
listTags.Selection.Changed += delegate {
TreeIter it;
buttonRemoveTag.Sensitive = buttonPushTag.Sensitive = listTags.Selection.GetSelected(out it);
};
buttonRemoveTag.Sensitive = buttonPushTag.Sensitive = false;
// Fill data
FillBranches();
FillRemotes();
FillTags();
}
public void DualStart()
{
string master = GetTempPath();
using (GitClient git = new GitClient())
{
GitInitArgs ia = new GitInitArgs();
ia.CreateBareRepository = true;
ia.Description = "Harry & Sally root";
git.Init(master, ia);
}
Uri masterUri = new Uri(master);
string harry = GetTempPath();
string sally = GetTempPath();
using (GitClient git = new GitClient()) // Harry
{
git.Clone(masterUri, harry);
using (GitRepository harryRepo = new GitRepository(harry))
{
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Harry");
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(harry, "src");
Directory.CreateDirectory(src);
string index = Path.Combine(src, "index.txt");
File.WriteAllText(index, "This is index.txt\n");
git.Add(index);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result);
using (GitRepository harryRepo = new GitRepository(harry))
{
GitCommit commit;
Assert.That(harryRepo.Lookup(result, out commit));
Assert.That(commit.Author.Name, Is.EqualTo("Harry"));
}
}
using (GitClient git = new GitClient()) // Sally
{
git.Clone(masterUri, sally);
using (GitRepository sallyRepo = new GitRepository(sally))
{
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Sally");
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string iota = Path.Combine(sally, "iota.txt");
File.WriteAllText(iota, "This is iota\n");
git.Stage(iota);
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(sally, cma);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.False);
}
using (GitClient git = new GitClient()) // Harry
{
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(harry, pa);
}
using (GitClient git = new GitClient()) // Sally
{
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(sally, pa);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.True);
}
}
/// <summary>
/// Gets the available branches list.
/// </summary>
/// <returns>List of branches</returns>
public IEnumerable <BranchInfo> GetBranches() =>
GitRepository.ListBranches(new ListBranches(
GetSetting(GitSettingKeys.Url),
GetSetting(GitSettingKeys.Username),
GetSetting(GitSettingKeys.Password)));
public void PushChanges()
{
string master = GetTempPath();
using (GitClient git = new GitClient())
{
GitInitArgs ia = new GitInitArgs();
ia.CreateBareRepository = true;
ia.Description = "Harry & Sally root";
git.Init(master, ia);
}
Uri masterUri = new Uri(master);
string harry = GetTempPath();
string sally = GetTempPath();
using (GitClient git = new GitClient()) // Harry
{
git.Clone(masterUri, harry);
using (GitRepository harryRepo = new GitRepository(harry))
{
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Harry");
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(harry, "src");
Directory.CreateDirectory(src);
string index = Path.Combine(src, "index.txt");
File.WriteAllText(index, "This is index.txt\n");
string appCode = Path.Combine(harry, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
printf(""hello world\n"");
return 0;
}
");
git.Add(index);
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result);
using (GitRepository harryRepo = new GitRepository(harry))
{
GitCommit commit;
Assert.That(harryRepo.Lookup(result, out commit));
Assert.That(commit.Author.Name, Is.EqualTo("Harry"));
}
}
using (GitClient git = new GitClient()) // Sally
{
git.Clone(masterUri, sally);
using (GitRepository sallyRepo = new GitRepository(sally))
{
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Sally");
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.False);
}
using (GitClient git = new GitClient()) // Harry
{
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(harry, pa);
}
using (GitClient git = new GitClient()) // Sally
{
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(sally, pa);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.True);
string appCode = Path.Combine(sally, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
int i;
if (argc != 1)
{
fprintf(stderr, ""Usage %s <int>\n"", argv[0]);
return 1;
}
for (i = 0; i < atoi(argv[1]); i++
printf(""hello world %d\n"", i);
return 0;
}
");
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 2, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 2, 0, 0, 0, DateTimeKind.Utc);
git.Commit(sally, cma, out result);
GitPushArgs ph = new GitPushArgs();
ph.Mode = GitPushMode.All;
git.Push(sally, ph);
}
using (GitClient git = new GitClient()) // Harry
{
string appCode = Path.Combine(harry, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
if (argc > 0 && strcmp(argv[1], ""-V"")
{
printf(""%s version 1.0 (c) QQn\n"");
return 0;
}
printf(""hello world\n"");
return 0;
}
");
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result); // Local commit will succeed
GitPushArgs ph = new GitPushArgs();
ph.Mode = GitPushMode.All;
try
{
git.Push(harry, ph); // But push fails, as it conflicts
Assert.Fail("Should have failed"); // ###
}
catch(GitException ge)
{
Assert.That(ge.Message, Is.StringContaining("Cannot push"));
}
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(harry, pa);
bool gotConflict = false;
git.Status(harry,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
case "app.c":
gotConflict = true;
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Conflicted, Is.True, "Conflicted");
break;
default:
Assert.Fail("Unexpected path: {0}", e.RelativePath);
break;
}
});
Assert.That(gotConflict, "Found conflict status");
try
{
git.Push(harry, ph); // But push fails, as it conflicts
Assert.Fail("Should still fail");
}
catch (GitException ge)
{
Assert.That(ge.Message, Is.StringContaining("Cannot push"));
}
GitResetArgs ra = new GitResetArgs();
ra.Mode = GitResetMode.Hard;
git.Reset(harry, ra);
}
}
public VersionResolver(GitRepository gitRepository, string versionPath, ILogger <VersionResolver> logger)
{
this.gitRepository = gitRepository ?? throw new ArgumentNullException(nameof(gitRepository));
this.versionPath = versionPath ?? throw new ArgumentNullException(nameof(versionPath));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
private GitRepository CreateProxiedTestGitManager(string branch = null)
{
DeleteDirectory(GitRepositoryFixture.LocalTestProxyRepository);
DeleteDirectory(GitRepositoryFixture.LocalRepository);
RegisterForCleanup(GitRepositoryFixture.LocalTestProxyRepository);
RegisterForCleanup(GitRepositoryFixture.LocalRepository);
var testRepo = new GitRepository()
{
Branch = branch,
LocalRepositoryPath = GitRepositoryFixture.LocalTestProxyRepository,
RemoteRepositoryPath = GitRepositoryFixture.RemoteRepository,
}.Update();
return new GitRepository()
{
Branch = branch,
LocalRepositoryPath = GitRepositoryFixture.LocalRepository,
RemoteRepositoryPath = GitRepositoryFixture.LocalTestProxyRepository,
};
}
/// <summary>
/// Finalizes the changelog by moving all entries from `[vNext]` to the version specified by release.
/// <p>If <paramref name="repository"/> is specified a summary with all versions and links to list the changes directly on GitHub is appended to the end of the changelog.</p>
/// </summary>
/// <param name="changelogFile">The path to the changelog file.</param>
/// <param name="tag">The <see cref="NuGetVersion"/> to finalize the changelog.</param>
/// <param name="repository">The repository to create the version overview for.</param>
/// <seealso cref="FinalizeChangelog(ChangeLog,NuGetVersion,GitRepository)"/>
public static void FinalizeChangelog(ChangeLog changelogFile, NuGetVersion tag, [CanBeNull] GitRepository repository = null)
{
Logger.Info($"Finalizing {PathConstruction.GetRelativePath(NukeBuild.RootDirectory, changelogFile.Path)} for '{tag}'...");
var unreleasedNotes = changelogFile.Unreleased;
var releaseNotes = changelogFile.ReleaseNotes;
var lastReleased = changelogFile.LatestVersion;
ControlFlow.Assert(unreleasedNotes != null, "Changelog should have draft section.");
ControlFlow.Assert(releaseNotes.Any(x => x.Version != null && x.Version.Equals(tag)), $"Tag '{tag}' already exists.");
ControlFlow.Assert(lastReleased != null && tag.CompareTo(lastReleased.Version) > 0, $"Tag '{tag}' is not greater compared to last tag '{lastReleased.NotNull().Version}'.");
var path = changelogFile.Path;
var content = TextTasks.ReadAllLines(path).ToList();
content.Insert(unreleasedNotes.StartIndex + 1, string.Empty);
content.Insert(unreleasedNotes.EndIndex + 2, $"## [{tag}] / {DateTime.Now:yyyy-MM-dd}");
UpdateVersionSummary(tag.ToString(), content, repository);
content.Add(string.Empty);
TextTasks.WriteAllLines(path, content);
}
public void Run_Spider_Inflate_And_Save_Results_To_GitHub()
{
DateTime Start = new DateTime(2013, 2, 15);
DateTime End = new DateTime(2013, 2, 18);
WebSiteDownloaderOptions options =
new WebSiteDownloaderOptions();
options.DestinationFolderPath =
new DirectoryInfo(dataDir);
options.DestinationFileName = String.Format("Session-Activity[{0}][{1}].state",
Start.Date.ToShortDateString().Replace("/", "-"),
End.Date.ToShortDateString().Replace("/", "-"));
options.MaximumLinkDepth = 4;
options.TargetSession = 28;
options.DownloadUri =
new Uri(String.Format(@"http://www.legis.state.ak.us/basis/range_multi.asp?session={0}&Date1={1}&Date2={2}",
options.TargetSession,
Start.Date.ToShortDateString(),
End.Date.ToShortDateString()));
WebSiteDownloader rslt = Spider.DownloadingProcessor(options);
/*
1. Select Bill Names
* We need to know the bill name (HB16), so we can save data in a folder of the same name.
*/
//Static List of Bills
var masterlist = (from r in rslt.Resources
where r.Index == 1 && (r.AbsoluteUri.AbsoluteUri.Contains(@"get_bill.asp"))
select r).ToList();
//Match bill titles in the URI (HB16,SB12..)
Regex billTitles = new Regex(@"(?<=[=])[H|R|S][B|C|R|J]{0,3}[0-9]{1,4}", RegexOptions.IgnoreCase);
//Return a list of the first matches
var bills = (from b in masterlist
let matches = billTitles.Matches(b.AbsoluteUri.AbsoluteUri)
where matches.Count > 0
select new
{
resource = b,
url = b.AbsoluteUri,
name = matches.Cast<Match>().FirstOrDefault()
}).ToList();
/*
2. Build out directory structure for bill data.
* We have a list of bills, now where are we going to save the data?
*/
DirectoryInfo session = new DirectoryInfo(String.Format(@"{0}/{1}", dataDir, 28));
if (!session.Exists)
session.Create();
foreach (var item in bills)
{
//bill directory
DirectoryInfo bill = new DirectoryInfo(String.Format(@"{0}/{1}/{2}", dataDir, 28, item.name));
if (!bill.Exists)
bill.Create();
}
/*
3. Associated bill data
* Grab associated bill data. Name, Title, LongTitle,
* Minutes Content, Bill Revisions, Bill Activity
*/
foreach (var bill in bills)
{
//Results placeholders
List<iCollector> meta = new List<iCollector>();
List<iCollector> revisions = new List<iCollector>();
List<iCollector> minutes = new List<iCollector>();
List<iCollector> committee = new List<iCollector>();
//Document history, activity and kvp..
meta.AddRange((from h in rslt.Parsings
where h.source.AbsoluteUri.AbsoluteUri == bill.url.AbsoluteUri
|| h.source.Parent.AbsoluteUri == bill.url.AbsoluteUri
select h).ToList());
//Bill Content
revisions.AddRange((from d in rslt.Parsings
where d.source.Parent.AbsoluteUri
.Contains(String.Format(@"get_fulltext.asp?session={0}&bill={1}", 28, bill.name))
select d).ToList());
//Committee
committee.AddRange((from d in rslt.Resources
join p in rslt.Parsings
on d.AbsoluteUri.AbsoluteUri equals
p.source.Parent.AbsoluteUri
where p.source.AbsoluteUri.AbsoluteUri.Contains("get_minutes.asp")
&& d.AbsoluteUri.AbsoluteUri.Contains(String.Format("{0}", bill.name))
select p).ToList());
//Minutes Transcript
minutes.AddRange((from d in rslt.Resources
join p in rslt.Parsings
on d.AbsoluteUri.AbsoluteUri equals
p.source.Parent.AbsoluteUri
where p.source.AbsoluteUri.AbsoluteUri
.Contains(@"get_single_minute.asp")
&& d.AbsoluteUri.AbsoluteUri
.Contains(String.Format("{0}", bill.name))
select p).ToList());
/*
4. Start saving off the data
* We have a list of bills, now where are we going to save the data?
*/
String fileLoc = String.Format(@"{0}\{1}\", 28, bill.name);
GitRepository gr = new GitRepository();
gr.ProcessBill(fileLoc, new ParsedBill() {
meta = meta,
minutes = minutes,
revisions = revisions,
committee = committee });
}
Assert.IsTrue(true);
}
public CommitGraphChain(GitRepository repository, string chain) : base(repository, "CommitChain:" + chain)
{
_chainDir = chain;
}
public GitObject(GitRepository entry)
{
this.name = entry.name;
this.size = entry.size;
this.type = "repository";
}
private MonitoredPath GetMonitoredPath(MonitoredPath monitoredPath, string repository, string branchName, int days)
{
List <GitCommit> commits = new List <GitCommit>();
//if (days == 0)
//{
// days = monitoredPath.Days == 0 ? Convert.ToInt32(Startup.Configuration["Defaults:DefaultDays"]) : monitoredPath.Days;
//}
DirectoryInfo[] directoriesToScan;
if (!string.IsNullOrWhiteSpace(repository))
{
directoriesToScan = new DirectoryInfo(monitoredPath.Path).GetDirectories(repository, SearchOption.TopDirectoryOnly);
}
else
{
if (monitoredPath.AllFolders)
{
directoriesToScan = new DirectoryInfo(monitoredPath.Path).GetDirectories("*", SearchOption.TopDirectoryOnly);
}
else
{
directoriesToScan = new DirectoryInfo[monitoredPath.Repositories.Count];
int i = 0;
foreach (var dir in monitoredPath.Repositories)
{
directoriesToScan[i++] = new DirectoryInfo(Path.Combine(monitoredPath.Path, dir.Name));
}
}
}
//if (days == 0)
//{
// days = Convert.ToInt32(Startup.Configuration["Defaults:DefaultDays"]);
//}
if (days > 0)
{
days = days * -1;
}
MonitoredPath newmonitoredPath = new MonitoredPath();
foreach (var dir in directoriesToScan)
{
try
{
GitRepository gitrepo = this.TryGetRepo(monitoredPath, dir.Name);
using (var repo = new Repository(dir.FullName))
{
DateTime startDate = DateTime.Now.AddDays(days);
int commitCount = 0;
if (string.IsNullOrEmpty(branchName))
{
branchName = "master";
}
string branch = repo.Info.IsBare ? branchName : $"origin/{branchName}";
gitrepo.Branch = branch;
foreach (
LibGit2Sharp.Commit com in
repo.Branches[branch].Commits.Where(s => s.Committer.When >= startDate)
.OrderByDescending(s => s.Author.When))
{
if (!monitoredPath.IncludeMergeCommits)
{
// filter out merge commits
if (com.Parents.Count() > 1)
{
continue;
}
}
//string[] nameexclusions = Startup.Configuration["Defaults:DefaultUserNameExcludeFilter"].Split(',');
//if (nameexclusions.Any(name => com.Author.Name.Contains(name)))
//{
// continue;
//}
string url = string.IsNullOrWhiteSpace(gitrepo.CommitUrl)
? string.Empty
: string.Format($"{gitrepo.CommitUrl}{com.Sha}");
string repositoryUrl = string.Empty;
if (repo.Network.Remotes?["origin"] != null)
{
repositoryUrl = repo.Network.Remotes["origin"].Url;
}
commits.Add(new GitCommit
{
Author = com.Author.Name,
AuthorEmail = string.IsNullOrWhiteSpace(com.Author.Email) ? string.Empty : com.Author.Email,
AuthorWhen = com.Author.When.UtcDateTime,
Committer = com.Committer.Name,
CommitterEmail = string.IsNullOrWhiteSpace(com.Committer.Email) ? string.Empty : com.Committer.Email,
CommitterWhen = com.Committer.When.UtcDateTime,
Sha = com.Sha,
Message = com.Message,
RepositoryFriendlyName = gitrepo.FriendlyName,
RepositoryName = dir.Name,
RepositoryUrl = repositoryUrl,
CommitUrl = url,
IsMerge = com.Parents.Count() > 1
});
commitCount++;
}
gitrepo.CommitCount = commitCount;
newmonitoredPath.Repositories.Add(gitrepo);
newmonitoredPath.AllowFetch = monitoredPath.AllowFetch;
}
newmonitoredPath.Name = monitoredPath.Name;
newmonitoredPath.AllowFetch = monitoredPath.AllowFetch;
newmonitoredPath.AllFolders = monitoredPath.AllFolders;
newmonitoredPath.Days = days;
newmonitoredPath.Path = monitoredPath.Path;
newmonitoredPath.CommitCount = commits.Count;
newmonitoredPath.Commits = commits;
newmonitoredPath.Commits.Sort((x, y) => - DateTime.Compare(x.CommitterWhen, y.CommitterWhen));
}
catch (Exception ex)
{
this.locallogger.LogError("GetMonitoredItem Bad - ", ex);
}
}
return(newmonitoredPath);
}
public RepositoryGraph(string repository)
{
this.workingDirectory = repository;
_repository = RepositoryManager.Instance.GetTrackerForPath(workingDirectory);
}
private static int GetCommitHeight(GitRepository repository, GitCommit startingCommit, GitWalkTracker tracker, Func <GitCommit, bool>?continueStepping)
{
if (continueStepping is object && !continueStepping(startingCommit))
{
return(0);
}
var commitsToEvaluate = new Stack <GitCommit>();
bool TryCalculateHeight(GitCommit commit)
{
// Get max height among all parents, or schedule all missing parents for their own evaluation and return false.
int maxHeightAmongParents = 0;
bool parentMissing = false;
foreach (GitObjectId parentId in commit.Parents)
{
var parent = repository.GetCommit(parentId);
if (!tracker.TryGetVersionHeight(parent, out int parentHeight))
{
if (continueStepping is object && !continueStepping(parent))
{
// This parent isn't supposed to contribute to height.
continue;
}
commitsToEvaluate.Push(parent);
parentMissing = true;
}
else
{
maxHeightAmongParents = Math.Max(maxHeightAmongParents, parentHeight);
}
}
if (parentMissing)
{
return(false);
}
var versionOptions = tracker.GetVersion(commit);
var pathFilters = versionOptions?.PathFilters;
var includePaths =
pathFilters
?.Where(filter => !filter.IsExclude)
.Select(filter => filter.RepoRelativePath)
.ToList();
var excludePaths = pathFilters?.Where(filter => filter.IsExclude).ToList();
var ignoreCase = repository.IgnoreCase;
/*
* bool ContainsRelevantChanges(IEnumerable<TreeEntryChanges> changes) =>
* excludePaths.Count == 0
* ? changes.Any()
* // If there is a single change that isn't excluded,
* // then this commit is relevant.
* : changes.Any(change => !excludePaths.Any(exclude => exclude.Excludes(change.Path, ignoreCase)));
*/
int height = 1;
if (pathFilters != null)
{
var relevantCommit = true;
foreach (var parentId in commit.Parents)
{
var parent = repository.GetCommit(parentId);
relevantCommit = IsRelevantCommit(repository, commit, parent, pathFilters);
// If the diff between this commit and any of its parents
// does not touch a path that we care about, don't bump the
// height.
if (!relevantCommit)
{
break;
}
}
/*
* // If there are no include paths, or any of the include
* // paths refer to the root of the repository, then do not
* // filter the diff at all.
* var diffInclude =
* includePaths.Count == 0 || pathFilters.Any(filter => filter.IsRoot)
* ? null
* : includePaths;
*
* // If the diff between this commit and any of its parents
* // does not touch a path that we care about, don't bump the
* // height.
* var relevantCommit =
* commit.Parents.Any()
* ? commit.Parents.Any(parent => ContainsRelevantChanges(commit.GetRepository().Diff
* .Compare<TreeChanges>(parent.Tree, commit.Tree, diffInclude, DiffOptions)))
* : ContainsRelevantChanges(commit.GetRepository().Diff
* .Compare<TreeChanges>(null, commit.Tree, diffInclude, DiffOptions));
*/
if (!relevantCommit)
{
height = 0;
}
}
tracker.RecordHeight(commit, height + maxHeightAmongParents);
return(true);
}
commitsToEvaluate.Push(startingCommit);
while (commitsToEvaluate.Count > 0)
{
GitCommit commit = commitsToEvaluate.Peek();
if (tracker.TryGetVersionHeight(commit, out _) || TryCalculateHeight(commit))
{
commitsToEvaluate.Pop();
}
}
Assumes.True(tracker.TryGetVersionHeight(startingCommit, out int result));
return(result);
}