static void Main(string[] args)
{
#if DEBUG
OldLogger.AnnounceStartStopActions = true;
OldLogger.Level = OldLogger.LevelValue.Verbose;
#endif
string currentBranch = GitOperations.GetCurrentBranchName();
List <string> branches = new List <string>(GitOperations.GetLocalBranches());
branches.Remove(currentBranch);
OldLogger.LogLine(@"Currently on " + currentBranch);
OldLogger.LogLine(@"Select from the following:");
for (int ii = 0; ii < Math.Min(9, branches.Count); ii++)
{
OldLogger.LogLine("\t" + (ii + 1) + " : " + branches[ii]);
}
OldLogger.LogLine("\tn : Make a new branch");
OldLogger.LogLine("\tf : Follow an existing remote branch");
string input = Console.ReadKey().KeyChar.ToString().Trim().ToLower();
OldLogger.LogLine(string.Empty);
if (string.IsNullOrEmpty(input) || (input.ToLower() == "q"))
{
return;
}
if (input.ToLower() == "n")
{
MakeNewBranch();
return;
}
if (input.ToLower() == "f")
{
FollowExistingRemoteBranch();
return;
}
if ((input == "-") || (input == "--"))
{
SwitchBranch("-");
OldLogger.LogLine("Branch is now : " + GitOperations.GetCurrentBranchName());
return;
}
int index = -1;
if (!int.TryParse(input, out index))
{
OldLogger.LogLine(@"Not a valid number: " + input, OldLogger.LevelValue.Error);
return;
}
if ((index <= 0) || (index > branches.Count))
{
OldLogger.LogLine(@"Invalid index: " + index, OldLogger.LevelValue.Error);
return;
}
SwitchBranch(branches[index - 1]);
}
public void GetRepositoryUrl_Unix(string originUrl, string expectedUrl)
{
var repo = new TestRepository(workingDir: "/usr/src/a/b", commitSha: "1111111111111111111111111111111111111111",
remotes: new[] { new TestRemote("origin", originUrl) });
Assert.Equal(expectedUrl, GitOperations.GetRepositoryUrl(repo));
}
public void GetRepositoryUrl_Agnostic2(string originUrl, string expectedUrl)
{
var repo = new TestRepository(workingDir: s_root, commitSha: "1111111111111111111111111111111111111111",
remotes: new[] { new TestRemote("origin", originUrl) });
Assert.Equal(expectedUrl, GitOperations.GetRepositoryUrl(repo));
}
/// <summary>
/// Get last 30 or less commits for current repository
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ProjectRecentCommitsButton_Click(object sender, EventArgs e)
{
RepositoryCommitItem[] recentCommits = {};
try
{
recentCommits = GitOperations.RecentCommits(RepositoryTextBox.Text, RepositoryListBox.Text);
}
catch (Exception ex)
{
MessageBox.Show($"Failed to get commits\n{ex.Message}");
Exceptions.Write(ex);
return;
}
if (recentCommits.Length > 0)
{
var commitForm = new RepositoryRecentCommitsForm(recentCommits);
try
{
commitForm.ShowDialog();
}
finally
{
commitForm.Dispose();
}
}
else
{
MessageBox.Show("No commits found");
}
}
public void BuildDirectoryTree()
{
var repo = new TestRepository(
workingDir: s_root,
commitSha: null,
submodules: new[]
{
new TestSubmodule(null, "c/x", null, null),
new TestSubmodule(null, "e", null, null),
new TestSubmodule(null, "a", null, null),
new TestSubmodule(null, "a/a/a/a/", null, null),
new TestSubmodule(null, "c", null, null),
new TestSubmodule(null, "a/z", null, null),
});
var root = GitOperations.BuildDirectoryTree(repo);
string inspect(GitOperations.SourceControlDirectory node)
=> node.Name + (node.RepositoryFullPath != null ? $"!" : "") + "{" + string.Join(",", node.OrderedChildren.Select(inspect)) + "}";
var expected = IsUnix ?
"{/{usr{src!{a!{a{a{a!{}}},z!{}},c!{x!{}},e!{}}}}}" :
"{C:{src!{a!{a{a{a!{}}},z!{}},c!{x!{}},e!{}}}}";
Assert.Equal(expected, inspect(root));
}
public void GetSourceRoots_InvalidSubmoduleUrlOrPath()
{
var repo = new TestRepository(
workingDir: s_root,
commitSha: "0000000000000000000000000000000000000000",
submodules: new[]
{
new TestSubmodule("1", "sub/1", "http:///", "1111111111111111111111111111111111111111"),
new TestSubmodule("2", "sub/\0*<>|:", "http://2.com", "2222222222222222222222222222222222222222"),
new TestSubmodule("3", "sub/3", "http://3.com", "3333333333333333333333333333333333333333"),
});
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: null);
AssertEx.Equal(new[]
{
$@"'{s_root}{s}' SourceControl='git' RevisionId='0000000000000000000000000000000000000000'",
$@"'{s_root}{s}sub{s}3{s}' SourceControl='git' RevisionId='3333333333333333333333333333333333333333' NestedRoot='sub/3/' ContainingRoot='{s_root}{s}' RepositoryUrl='http://3.com/'",
}, items.Select(InspectSourceRoot));
AssertEx.Equal(new[]
{
string.Format(Resources.InvalidSubmoduleUrl_SourceLink, "1", "http:///"),
string.Format(Resources.InvalidSubmodulePath_SourceLink, "2", "sub/\0*<>|:")
}, warnings.Select(InspectDiagnostic));
}
private static void CreateBranch(string branchName, string basedOn)
{
if (!GitOperations.CreateBranch(branchName, basedOn, out ProcessHelper proc))
{
OldLogger.LogLine("Unable to create your branch", OldLogger.LevelValue.Error);
OldLogger.LogLine(proc.AllOutput, OldLogger.LevelValue.Warning);
}
}
private static void SwitchBranch(string newBranch)
{
if (!GitOperations.SwitchBranch(newBranch, out ProcessHelper proc))
{
OldLogger.LogLine("Unable to switch branches", OldLogger.LevelValue.Error);
OldLogger.LogLine(proc.AllOutput, OldLogger.LevelValue.Warning);
}
}
public void GetRepositoryUrl_NoRemotes()
{
var repo = new TestRepository(workingDir: s_root, commitSha: "1111111111111111111111111111111111111111");
var warnings = new List <KeyValuePair <string, object[]> >();
Assert.Null(GitOperations.GetRepositoryUrl(repo, (message, args) => warnings.Add(KVP(message, args))));
AssertEx.Equal(new[] { Resources.RepositoryHasNoRemote }, warnings.Select(InspectDiagnostic));
}
private static void ApplyChanges(string masterBranch, string fromVersion, string toVersion)
{
string gitRootDir = GitOperations.GetRoot();
Debug.Assert(Directory.Exists(gitRootDir));
string currentDir = Directory.GetCurrentDirectory();
Debug.Assert(IOHelper.IsSubdirectory(gitRootDir, currentDir));
string[] directoriesWithDifferences = GitOperations.GetDifferentFiles(masterBranch)
.Where(path => path.ToLower().Contains("/" + fromVersion.ToLower() + "/"))
.Select(path => path.Substring(0, path.ToLower().IndexOf(fromVersion.ToLower())))
.Distinct()
.ToArray();
Dictionary <string, string> patchPaths = new Dictionary <string, string>();
OldLogger.Start("Generating Patches", OldLogger.LevelValue.Normal);
foreach (string directoryWithDifference in directoriesWithDifferences)
{
string patchPath = Path.Combine(gitRootDir, fromVersion + "." + directoryWithDifference.Replace('\\', '-').Replace('/', '-').Trim(new char[] { '-' }) + ".patch");
// git format-patch --relative origin/master . --stdout
ProcessHelper proc = new ProcessHelper(@"C:\Program Files\Git\cmd\git.exe", $"format-patch --relative {masterBranch} . --stdout");
proc.WorkingDirectory = Path.Combine(gitRootDir, directoryWithDifference, fromVersion);
proc.Go();
File.WriteAllText(patchPath, string.Join("\n", proc.RawOutput));
patchPaths.Add(directoryWithDifference, patchPath);
}
OldLogger.Stop("Generating Patches", OldLogger.LevelValue.Normal);
for (int ii = 0; ii < directoriesWithDifferences.Length; ii++)
{
string directoryWithDifference = directoriesWithDifferences[ii];
string destinationDirectory = Path.Combine(gitRootDir, directoryWithDifference, toVersion).Replace('\\', '/');
string patchPath = patchPaths[directoryWithDifference];
OldLogger.Start("Applying changes to " + destinationDirectory, OldLogger.LevelValue.Normal);
// git apply --reject --directory=<destination-dir> --unsafe-paths <patch-path>
ProcessHelper proc = new ProcessHelper("git.exe", $"apply --reject --directory={destinationDirectory} --unsafe-paths {patchPath}");
proc.WorkingDirectory = gitRootDir;
proc.Go();
foreach (string line in proc.RawOutput)
{
Console.WriteLine(line);
}
OldLogger.Stop("Applying changes to " + destinationDirectory, OldLogger.LevelValue.Normal);
if (proc.RawOutput.Length > 0 && ii < directoriesWithDifferences.Length - 1)
{
Console.WriteLine("Press any key to continue");
Console.ReadKey();
}
}
}
public void GetSourceRoots_RepoWithoutCommits()
{
var repo = new TestRepository(workingDir: s_root, commitSha: null);
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: null);
Assert.Empty(items);
AssertEx.Equal(new[] { Resources.RepositoryWithoutCommit_SourceLink }, warnings.Select(InspectDiagnostic));
}
/// <summary>
/// Fetch repository in repository TextBox
/// </summary>
/// <returns></returns>
private async Task FetchSelectedRepository()
{
if (string.IsNullOrWhiteSpace(RepositoryTextBox.Text))
{
MessageBox.Show(@"Requires a repository");
return;
}
WorkingPictureBox.Image = spinner;
if (RepositoryListBox.DataSource != null)
{
_lastSelectedRepositoryName = RepositoryListBox.Text;
}
RepositoryListBox.DataSource = null;
try
{
_repositoriesBindingList = new BindingList <Repository>(await GitOperations.DownLoadPublicRepositoriesAsync(RepositoryTextBox.Text));
}
catch (Exception ex)
{
WorkingPictureBox.Image = null;
// a consideration is rate limit
MessageBox.Show($@"Failed to get repositories {ex.Message}");
return;
}
_repositoriesBindingSource.DataSource = _repositoriesBindingList;
RepositoryListBox.DataSource = _repositoriesBindingSource;
if (_repositoriesBindingSource.Count > 0)
{
RepositoryListBox.SelectedIndex = 0;
}
BindControls();
ControlHelpers.SetWaterMarkers(this);
if (!string.IsNullOrWhiteSpace(_lastSelectedRepositoryName))
{
var index = RepositoryListBox.FindString(_lastSelectedRepositoryName);
if (index >= 0)
{
RepositoryListBox.SelectedIndex = index;
}
}
ActiveControl = RepositoryListBox;
WorkingPictureBox.Image = null;
}
public void GetSourceRoots_GvfsWithModules()
{
var repo = new TestRepository(
workingDir: s_root,
commitSha: "0000000000000000000000000000000000000000",
config: new Dictionary <string, object> {
{ "core.gvfs", true }
},
submodulesSupported: false);
Assert.Throws <LibGit2SharpException>(() => GitOperations.GetSourceRoots(repo, null, fileExists: _ => true));
}
public async Task <IActionResult> CreateWebAPI([FromBody] WebAPI webApi)
{
if (webApi != null)
{
//var outputFolderPath = _hostingEnvironment.ContentRootPath + "\\" + webApi.projectName + localDateTime +"\\";
var outputFolderPath = @"D:\work\poc\CodeGenOutput" + "\\" + webApi.projectName + localDateTime + "\\";
while (!Directory.Exists(outputFolderPath))
{
Directory.CreateDirectory(outputFolderPath);
}
if (webApi.saveToGit)
{
gitOperations = new GitOperations(webApi.gitUsername, webApi.gitPassword, webApi.gitURL, outputFolderPath);
gitOperations.CloneRepo();
gitbranchName = gitbranchName + webApi.projectName;
}
var config = new CodeGenConfig()
{
Messaging = webApi.messaging,
UseCircuitbreaker = webApi.useCircuitBreaker,
PackageName = webApi.projectName,
namespaceName = webApi.namespaceName,
SwaggerFile = webApi.swaggerPath,
outputFolderPath = outputFolderPath
};
WebApiProjectCodeGen webApiProjectCodeGen = new WebApiProjectCodeGen();
await webApiProjectCodeGen.GenerateProjectCode(config);
if (webApi.saveToGit)
{
if (!string.IsNullOrEmpty(webApi.gitUsername) && !string.IsNullOrEmpty(webApi.gitPassword) &&
!string.IsNullOrEmpty(webApi.gitURL))
{
var branches = gitOperations.ListGitBranches(gitbranchName);
if (!branches)
{
gitOperations.CreateBranch(gitbranchName, gitbranchName);
gitOperations.PushCommits(gitbranchName, gitbranchName);
return(Ok(new CreateResponse()
{
Result = "Project Created. Pushed to Git."
}));
}
}
}
}
return(Ok(new CreateResponse()
{
Result = "Project Created. TODO: Download zip file."
}));
}
private static void MakeNewBranch()
{
string suggestedPrefix = "u/" + Environment.GetEnvironmentVariable("USERNAME") + "/";
OldLogger.Log("\r\nPrefix? [" + suggestedPrefix + "] : ");
string prefix = Console.ReadLine().Trim().ToLower().Replace('_', '-').Replace(' ', '-');
if (string.IsNullOrEmpty(prefix))
{
prefix = suggestedPrefix;
}
OldLogger.Log("Short name : ");
string shortName = Console.ReadLine().Trim().ToLower().Replace('_', '-').Replace(' ', '-');
if (string.IsNullOrEmpty(shortName))
{
OldLogger.LogLine("Short name must be provided!", OldLogger.LevelValue.Error);
return;
}
string branchName = string.Join("/", string.Join("/", new string[] { prefix, shortName }).Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries));
string suggestedBasedOn = GitOperations.GetBranchBase(GitOperations.GetCurrentBranchName());
if (string.IsNullOrEmpty(suggestedBasedOn))
{
suggestedBasedOn = GetDefaultBranch();
}
OldLogger.Log("Based on what branch? [" + suggestedBasedOn + "] : ");
string basedOn = Console.ReadLine().Trim();
if (string.IsNullOrEmpty(basedOn))
{
basedOn = suggestedBasedOn;
}
string remoteBranchName = "origin/" + branchName;
OldLogger.LogLine("Confirming new branch called " + branchName + " based on " + basedOn);
OldLogger.LogLine("This will also be tracking " + remoteBranchName);
OldLogger.Log("That look ok? [y] ");
string prompt = Console.ReadKey().KeyChar.ToString().Trim().ToLower();
OldLogger.LogLine(string.Empty);
if (string.IsNullOrEmpty(prompt))
{
prompt = "y";
}
if (prompt == "y")
{
CreateBranch(branchName, basedOn);
}
}
private void ValidateGetRepositoryUrl(string workingDir, string actualUrl, string expectedUrl)
{
var testRemote = new TestRemote("origin", actualUrl);
var repo = new TestRepository(workingDir, commitSha: "1111111111111111111111111111111111111111",
remotes: new[] { testRemote });
var expectedWarnings = (expectedUrl != null) ?
Array.Empty <string>() :
new[] { string.Format(Resources.InvalidRepositoryRemoteUrl, testRemote.Name, testRemote.Url) };
var warnings = new List <KeyValuePair <string, object[]> >();
Assert.Equal(expectedUrl, GitOperations.GetRepositoryUrl(repo, (message, args) => warnings.Add(KVP(message, args))));
AssertEx.Equal(expectedWarnings, warnings.Select(InspectDiagnostic));
}
private static void MergeBranch(string localBranch, string mergeSource)
{
if (!GitOperations.IsBranchBehind(localBranch, mergeSource))
{
OldLogger.LogLine(localBranch + " is up to date with " + mergeSource);
return;
}
if (!GitOperations.SwitchBranch(localBranch, out ProcessHelper failureProc))
{
OldLogger.LogLine("Unable to switch branches", OldLogger.LevelValue.Warning);
OldLogger.LogLine(failureProc.AllOutput, OldLogger.LevelValue.Normal);
return;
}
GitOperations.MergeFromBranch(mergeSource);
}
public void GetSourceRoots_GvfsWithoutModules()
{
var repo = new TestRepository(
workingDir: s_root,
commitSha: "0000000000000000000000000000000000000000",
config: new Dictionary <string, object> {
{ "core.gvfs", true }
},
submodulesSupported: false);
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: _ => false);
AssertEx.Equal(new[]
{
$@"'{s_root}{s}' SourceControl='git' RevisionId='0000000000000000000000000000000000000000'",
}, items.Select(InspectSourceRoot));
}
public void GetUntrackedFiles_ProjectInMainRepoIncludesFilesInSubmodules()
{
string gitRoot = s_root.Replace('\\', '/');
var repo = new TestRepository(
workingDir: s_root,
commitSha: "0000000000000000000000000000000000000000",
submodules: new[]
{
new TestSubmodule("1", "sub/1", "http://1.com", "1111111111111111111111111111111111111111"),
new TestSubmodule("2", "sub/2", "http://2.com", "2222222222222222222222222222222222222222")
},
ignoredPaths: new[] { gitRoot + @"/c.cs", gitRoot + @"/p/d.cs", gitRoot + @"/sub/1/x.cs" });
var subRoot1 = Path.Combine(s_root, "sub", "1");
var subRoot2 = Path.Combine(s_root, "sub", "2");
var subRepos = new Dictionary <string, TestRepository>()
{
{ subRoot1, new TestRepository(subRoot1, commitSha: null, ignoredPaths: new[] { gitRoot + @"/sub/1/obj/a.cs" }) },
{ subRoot2, new TestRepository(subRoot2, commitSha: null, ignoredPaths: new[] { gitRoot + @"/sub/2/obj/b.cs" }) },
};
var actual = GitOperations.GetUntrackedFiles(repo,
new[]
{
new MockItem(@"c.cs"), // not ignored
new MockItem(@"..\sub\1\x.cs"), // ignored in the main repository, but not in the submodule (which has a priority)
new MockItem(@"../sub/2/obj/b.cs"), // ignored in submodule #2
new MockItem(@"d.cs"), // not ignored
new MockItem(@"..\..\w.cs"), // outside of repo
new MockItem(IsUnix ? "/d/w.cs" : @"D:\w.cs"), // outside of repo
},
projectDirectory: Path.Combine(s_root, "p"),
root => subRepos[root]);
AssertEx.Equal(new[]
{
MockItem.AdjustSeparators("../sub/2/obj/b.cs"),
MockItem.AdjustSeparators("d.cs"),
MockItem.AdjustSeparators(@"..\..\w.cs"),
MockItem.AdjustSeparators(IsUnix ? "/d/w.cs" : @"D:\w.cs")
}, actual.Select(item => item.ItemSpec));
}
/// <summary>
/// Temp code for testing
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FoldersForSelectedButton_Click(object sender, EventArgs e)
{
if (RepositoryListBox.DataSource == null || string.IsNullOrWhiteSpace(RepositoryListBox.Text))
{
return;
}
var directories = GitOperations.Directories(RepositoryTextBox.Text, RepositoryListBox.Text);
var directoryNameList = directories.Where(item => item.type == "dir").Select(item => item.name).ToList();
var repoDirectoryForm = new RepositoryDirectoryForm(directoryNameList);
try
{
repoDirectoryForm.ShowDialog();
}
finally
{
repoDirectoryForm.Dispose();
}
}
/// <summary>
/// Provides logic to move menu items up/down
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CreateDownLoadBatchFileButton_Click(object sender, EventArgs e)
{
if (RepositoryListBox.DataSource == null || string.IsNullOrWhiteSpace(RepositoryListBox.Text))
{
return;
}
var directories = GitOperations.Directories(RepositoryTextBox.Text, RepositoryListBox.Text);
var directoryList = directories.Where(item => item.type == "dir").Select(item => item.name).ToList();
var f = new CreateDownloadBatchForm(directoryList, HtmlUrlTextBox.Text);
try
{
f.ShowDialog();
}
finally
{
f.Dispose();
}
}
private static bool UpdateBranch(string localBranch, string remoteBranch = null)
{
remoteBranch = remoteBranch ?? ("origin/" + localBranch);
if (!GitOperations.IsBranchBehind(localBranch, remoteBranch))
{
OldLogger.LogLine($"{localBranch} is up to date with {remoteBranch}");
return(false);
}
if (!GitOperations.SwitchBranch(localBranch, out ProcessHelper failureProc))
{
OldLogger.LogLine("Unable to switch branches", OldLogger.LevelValue.Warning);
OldLogger.LogLine(failureProc.AllOutput, OldLogger.LevelValue.Normal);
return(false);
}
GitOperations.PullCurrentBranch();
return(true);
}
public void GetContainingRepository_Unix(string path, string expectedDirectory)
{
var actual = GitOperations.GetContainingRepository(path,
new GitOperations.SourceControlDirectory("", null,
new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("/", null, new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("src", "/src", new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("a", "/src/a"),
new GitOperations.SourceControlDirectory("c", "/src/c", new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("x", "/src/c/x"),
}),
new GitOperations.SourceControlDirectory("e", "/src/e"),
}),
})
}));
Assert.Equal(expectedDirectory, actual?.RepositoryFullPath);
}
public void GetContainingRepository_Windows(string path, string expectedDirectory)
{
var actual = GitOperations.GetContainingRepository(path,
new GitOperations.SourceControlDirectory("", null,
new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("C:", null, new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("src", @"C:\src", new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("a", @"C:\src\a"),
new GitOperations.SourceControlDirectory("c", @"C:\src\c", new List <GitOperations.SourceControlDirectory>
{
new GitOperations.SourceControlDirectory("x", @"C:\src\c\x")
}),
new GitOperations.SourceControlDirectory("e", @"C:\src\e")
}),
})
}));
Assert.Equal(expectedDirectory, actual?.RepositoryFullPath);
}
public void GetSourceRoots_GvfsBadOptionType()
{
var repo = new TestRepository(
workingDir: s_root,
commitSha: "0000000000000000000000000000000000000000",
config: new Dictionary <string, object> {
{ "core.gvfs", 1 }
},
submodules: new[]
{
new TestSubmodule("1", "sub/1", "http://1.com/", "1111111111111111111111111111111111111111"),
});
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: null);
AssertEx.Equal(new[]
{
$@"'{s_root}{s}' SourceControl='git' RevisionId='0000000000000000000000000000000000000000'",
$@"'{s_root}{s}sub{s}1{s}' SourceControl='git' RevisionId='1111111111111111111111111111111111111111' NestedRoot='sub/1/' ContainingRoot='{s_root}{s}' RepositoryUrl='http://1.com/'",
}, items.Select(InspectSourceRoot));
}
public void GetSourceRoots_RepoWithCommitsWithSubmodules()
{
var repo = new TestRepository(
workingDir: s_root,
commitSha: "0000000000000000000000000000000000000000",
submodules: new[]
{
new TestSubmodule("1", "sub/1", "http://1.com", workDirCommitSha: null),
new TestSubmodule("1", "sub/2", "http://2.com", "2222222222222222222222222222222222222222")
});
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: null);
AssertEx.Equal(new[]
{
$@"'{s_root}{s}' SourceControl='git' RevisionId='0000000000000000000000000000000000000000'",
$@"'{s_root}{s}sub{s}2{s}' SourceControl='git' RevisionId='2222222222222222222222222222222222222222' NestedRoot='sub/2/' ContainingRoot='{s_root}{s}' RepositoryUrl='http://2.com/'",
}, items.Select(InspectSourceRoot));
AssertEx.Equal(new[] { string.Format(Resources.SubmoduleWithoutCommit_SourceLink, "1") }, warnings.Select(InspectDiagnostic));
}
public void GetSourceRoots_RelativeSubmodulePaths_Windows_UnicodeAndEscapes()
{
var repo = new TestRepository(
workingDir: @"C:\%25@噸",
commitSha: "0000000000000000000000000000000000000000",
submodules: new[]
{
new TestSubmodule("%25ሴ", "sub/%25ሴ", "./a/b", "1111111111111111111111111111111111111111"),
new TestSubmodule("%25ለ", "sub/%25ለ", "../a", "2222222222222222222222222222222222222222"),
});
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: null);
AssertEx.Equal(new[]
{
$@"'C:\%25@噸\' SourceControl='git' RevisionId='0000000000000000000000000000000000000000'",
$@"'C:\%25@噸\sub\%25ሴ\' SourceControl='git' RevisionId='1111111111111111111111111111111111111111' NestedRoot='sub/%25ሴ/' ContainingRoot='C:\%25@噸\' ScmRepositoryUrl='file:///C:/%25@噸/a/b'",
$@"'C:\%25@噸\sub\%25ለ\' SourceControl='git' RevisionId='2222222222222222222222222222222222222222' NestedRoot='sub/%25ለ/' ContainingRoot='C:\%25@噸\' ScmRepositoryUrl='file:///C:/a'",
}, items.Select(InspectSourceRoot));
Assert.Empty(warnings);
}
public void GetSourceRoots_RelativeSubmodulePaths_Unix()
{
var repo = new TestRepository(
workingDir: @"/src",
commitSha: "0000000000000000000000000000000000000000",
submodules: new[]
{
new TestSubmodule("1", "sub/1", "./a/b", "1111111111111111111111111111111111111111"),
new TestSubmodule("2", "sub/2", "../a", "2222222222222222222222222222222222222222"),
});
var warnings = new List <KeyValuePair <string, object[]> >();
var items = GitOperations.GetSourceRoots(repo, (message, args) => warnings.Add(KVP(message, args)), fileExists: null);
AssertEx.Equal(new[]
{
$@"'/src/' SourceControl='git' RevisionId='0000000000000000000000000000000000000000'",
$@"'/src/sub/1/' SourceControl='git' RevisionId='1111111111111111111111111111111111111111' NestedRoot='sub/1/' ContainingRoot='/src/' RepositoryUrl='file:///src/a/b'",
$@"'/src/sub/2/' SourceControl='git' RevisionId='2222222222222222222222222222222222222222' NestedRoot='sub/2/' ContainingRoot='/src/' RepositoryUrl='file:///a'",
}, items.Select(InspectSourceRoot));
Assert.Empty(warnings);
}
public void GetRepositoryUrl_NoRemotes()
{
var repo = new TestRepository(workingDir: s_root, commitSha: "1111111111111111111111111111111111111111");
Assert.Null(GitOperations.GetRepositoryUrl(repo));
}
public void GetRevisionId_RepoWithCommit()
{
var repo = new TestRepository(workingDir: "", commitSha: "8398cdcd9043724b9bef1efda8a703dfaa336c0f");
Assert.Equal("8398cdcd9043724b9bef1efda8a703dfaa336c0f", GitOperations.GetRevisionId(repo));
}
