public void ShouldNotChangeBranchWhenNormalizingTheDirectory()
{
using (var fixture = new EmptyRepositoryFixture(new Config()))
{
fixture.Repository.MakeATaggedCommit("v1.0.0");
fixture.Repository.Checkout(fixture.Repository.CreateBranch("develop"));
var lastCommitOnDevelop = fixture.Repository.MakeACommit();
fixture.Repository.Checkout(fixture.Repository.CreateBranch("feature/foo"));
fixture.Repository.MakeACommit();
using (var localFixture = fixture.CloneRepository())
{
localFixture.Repository.Checkout("origin/develop");
// Another commit on feature/foo will force an update
fixture.Checkout("feature/foo");
fixture.Repository.MakeACommit();
GitHelper.NormalizeGitDirectory(localFixture.RepositoryPath, new Authentication(), noFetch: false, currentBranch: null);
localFixture.Repository.DumpGraph();
localFixture.Repository.Head.Tip.Sha.ShouldBe(lastCommitOnDevelop.Sha);
}
}
}
public void DotNetCoreBusterRuntimeImage_Contains_VersionAndCommit_Information(string version)
{
// we cant always rely on gitcommitid as env variable in case build context is not correctly passed
// so we should check agent_os environment variable to know if the build is happening in azure devops agent
// or locally, locally we need to skip this test
var agentOS = Environment.GetEnvironmentVariable("AGENT_OS");
Skip.If(string.IsNullOrEmpty(agentOS));
// Arrange
var buildNumber = Environment.GetEnvironmentVariable("BUILD_BUILDNUMBER");
var expectedOryxVersion = string.Concat(Settings.OryxVersion, buildNumber);
var gitCommitID = GitHelper.GetCommitID();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = _imageHelper.GetRuntimeImage("dotnetcore", version),
CommandToExecuteOnRun = "oryx",
CommandArguments = new[] { "version" }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
Assert.NotNull(result.StdErr);
Assert.DoesNotContain(".unspecified, Commit: unspecified", result.StdOut);
Assert.Contains(gitCommitID, result.StdOut);
Assert.Contains(expectedOryxVersion, result.StdOut);
},
result.GetDebugInfo());
}
public override async Task ExecuteAsync()
{
Uri imageInfoPathIdentifier = GitHelper.GetBlobUrl(Options.GitOptions);
GitObject imageInfoGitObject = await GetUpdatedImageInfoGitObjectAsync();
if (imageInfoGitObject is null)
{
loggerService.WriteMessage($"No changes to the '{imageInfoPathIdentifier}' file were needed.");
return;
}
loggerService.WriteMessage(
$"The '{imageInfoPathIdentifier}' file has been updated with the following content:" +
Environment.NewLine + imageInfoGitObject.Content + Environment.NewLine);
if (!Options.IsDryRun)
{
using IGitHubClient gitHubClient = this.gitHubClientFactory.GetClient(Options.GitOptions.ToGitHubAuth(), Options.IsDryRun);
await GitHelper.ExecuteGitOperationsWithRetryAsync(async() =>
{
GitReference gitRef = await GitHelper.PushChangesAsync(
gitHubClient, Options, "Merging image info updates from build.",
branch => Task.FromResult <IEnumerable <GitObject> >(new GitObject[] { imageInfoGitObject }));
Uri commitUrl = GitHelper.GetCommitUrl(Options.GitOptions, gitRef.Object.Sha);
loggerService.WriteMessage($"The '{imageInfoPathIdentifier}' file was updated ({commitUrl}).");
});
}
}
private IEnumerable <GitCommitInfo> CollectRepoDependencyCommits()
{
foreach (var dep in RepositoryDependencies)
{
var path = dep;
if (path.Contains("@repos@"))
{
path = EnvironmentInfo.ResolvePath(path, false, Overrides);
}
else if (Path.IsPathRooted(path))
{
path = Path.GetFullPath(path);
}
else
{
var basis = Path.GetDirectoryName(FullName);
path = Path.GetFullPath(Path.Combine(basis, path));
}
var commit = GitHelper.GetCommit(path);
if (null != commit)
{
yield return(commit);
}
}
}
public static int PerformCommit(string commitMessage, bool addUntracked, bool stageTracked, bool fullCommit, bool amend)
{
var gitHelper = new GitHelper();
if (!gitHelper.HasRepo)
{
SpectreHelper.WriteError("There is no repository");
return(1);
}
var response = CommitCommandUtils.Commit(gitHelper, addUntracked, stageTracked,
fullCommit, commitMessage, amend);
if (!response.Success)
{
SpectreHelper.WriteError(response.Message);
return(1);
}
if (amend)
{
SpectreHelper.WriteSuccess($"{response.Message}\nCommit amend made successfully.");
return(0);
}
SpectreHelper.WriteSuccess($"{response.Message}\nCommit made successfully.");
return(0);
}
private static bool AreGitToolsInstalled()
{
var gitInstallationPath = GitHelper.GetGitInstallationPath();
string pathToGit = Path.Combine(Path.Combine(gitInstallationPath, "bin\\git.exe"));
return(File.Exists(pathToGit));
}
public void CanRestoreFile()
{
var githelper = new GitHelper {
DirectoryName = dirname, AuthorName = Applications.Application.Current.Principal.CurrentUser.Identity.Name
};
githelper.Connect();
var initial = githelper.GetCommitId();
var currentFile = githelper.GetContent("x");
Assert.Null(currentFile);
githelper.WriteAndCommit("x", "a", "is a");
var first = githelper.GetCommitId();
Assert.AreNotEqual(initial, first);
githelper.WriteAndCommit("x", "b", "is b");
var second = githelper.GetCommitId();
Assert.AreNotEqual(initial, second);
var content = githelper.ReadFile("x");
Assert.AreEqual("b", content);
githelper.RestoreSingleFile("x", first);
content = githelper.ReadFile("x");
Assert.AreEqual("a", content);
}
private bool ConfigureNextReleaseOnMaster(GitHttpClient gitClient, Guid repoId, VersionInfo versionInfo)
{
var nextVersion = new VersionInfo(versionInfo.ToString());
nextVersion.NextMinor();
nextVersion.LastScript = GetLastScriptName();
var topicBranchName = "dev/config-release-" + nextVersion.ToString();
gitClient.CreateBranch(repoId, "master", topicBranchName);
if (!GitHelper.Checkout(topicBranchName, true, true))
{
return(false);
}
SaveFileVersion(nextVersion);
if (!GitHelper.AddAllFiles() ||
!GitHelper.Commit($"Inicialização da release {nextVersion}") ||
!GitHelper.Sync())
{
return(false);
}
CreatePullRequest(gitClient, repoId, topicBranchName, "master", nextVersion);
return(true);
}
protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
{
var releaseVersion = Interaction.InputBox("Release Version:", "Start New Release");
if (string.IsNullOrEmpty(releaseVersion))
{
return;
}
var flowOptions = await GitHelper.GetGitConfig();
var options = await General.GetLiveInstanceAsync();
/* 1. Switch to the develop branch
* 2. Pull latest changes on develop
* 3. Create and switch to a new release branch
*/
await ProcessHelper.StartProcessGui(
"cmd.exe",
$"/c cd \"{await FileHelper.GetSolutionDir()}\" && " +
await GitHelper.GetSshSetup() +
GitHelper.FormatCliCommand($"checkout {flowOptions.DevelopBranch}") +
(options.PullChanges ? GitHelper.FormatCliCommand("pull") : string.Empty) +
GitHelper.FormatCliCommand($"checkout -b {flowOptions.ReleasePrefix}{releaseVersion} {flowOptions.DevelopBranch}", false),
$"Starting release {releaseVersion}"
);
}
public void CanGetChangedList()
{
var githelper = new GitHelper {
DirectoryName = dirname
};
githelper.Connect();
githelper.WriteFile("x", "1");
githelper.WriteFile("y", "1");
var changed = githelper.GetChangedFilesList();
Assert.AreEqual(2, changed.Length);
Assert.True(changed.Any(_ => _.FileName == "x"));
Assert.True(changed.Any(_ => _.FileName == "y"));
var ver1 = githelper.CommitAllChanges("1");
changed = githelper.GetChangedFilesList();
Assert.AreEqual(0, changed.Length);
changed = githelper.GetChangedFilesList(toref: "HEAD");
Assert.AreEqual(2, changed.Length);
var ver2 = githelper.WriteAndCommit("x", "2", "2");
changed = githelper.GetChangedFilesList(toref: "HEAD");
Assert.AreEqual(1, changed.Length);
var ver3 = githelper.WriteAndCommit("y", "2", "3");
changed = githelper.GetChangedFilesList(toref: "HEAD");
Assert.AreEqual(1, changed.Length);
changed = githelper.GetChangedFilesList(fromref: ver1, toref: "HEAD");
Assert.AreEqual(2, changed.Length);
}
private void StartHotfixCommand(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(_envHelper.GetSolutionDir()))
{
return;
}
var hotfixVersion = Interaction.InputBox("Hotfix Version:", "Start New Hotfix");
if (string.IsNullOrEmpty(hotfixVersion))
{
return;
}
var flowOptions = GitHelper.GetGitConfig(_envHelper);
/* 1. Switch to the master branch
* 2. Pull latest changes on master
* 3. Create and switch to a new hotfix branch
*/
ProcessHelper.StartProcessGui(_dte, _envHelper,
"cmd.exe",
$"/c cd \"{_envHelper.GetSolutionDir()}\" && " +
GitHelper.GetSshSetup(_envHelper) +
FormatCliCommand($"checkout {flowOptions.MasterBranch}") +
(_options.PullChanges ? FormatCliCommand("pull") : string.Empty) +
FormatCliCommand($"checkout -b {flowOptions.HotfixPrefix}{hotfixVersion} {flowOptions.MasterBranch}", false),
$"Starting hotfix {hotfixVersion}"
);
}
private void StartReleaseCommand(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(_envHelper.GetSolutionDir()))
{
return;
}
var releaseVersion = Interaction.InputBox("Release Version:", "Start New Release");
if (string.IsNullOrEmpty(releaseVersion))
{
return;
}
var flowOptions = GitHelper.GetGitConfig(_envHelper);
/* 1. Switch to the develop branch
* 2. Pull latest changes on develop
* 3. Create and switch to a new release branch
*/
ProcessHelper.StartProcessGui(_dte, _envHelper,
"cmd.exe",
$"/c cd \"{_envHelper.GetSolutionDir()}\" && " +
GitHelper.GetSshSetup(_envHelper) +
FormatCliCommand($"checkout {flowOptions.DevelopBranch}") +
(_options.PullChanges ? FormatCliCommand("pull") : string.Empty) +
FormatCliCommand($"checkout -b {flowOptions.ReleasePrefix}{releaseVersion} {flowOptions.DevelopBranch}", false),
$"Starting release {releaseVersion}"
);
}
private void FinishFeatureGitHubCommand(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(_envHelper.GetSolutionDir()))
{
return;
}
var featureBranch = GitHelper.GetCurrentBranchName(false, _envHelper);
var featureName = GitHelper.GetCurrentBranchName(true, _envHelper);
/* 1. Switch to the master branch
* 2. Pull latest changes on master
* 3. Merge the feature branch to master
* 4. Push all changes to master
* 5. Delete the local feature branch
* 6. Delete the remote feature branch
*/
ProcessHelper.StartProcessGui(_dte, _envHelper,
"cmd.exe",
$"/c cd \"{_envHelper.GetSolutionDir()}\" && " +
GitHelper.GetSshSetup(_envHelper) +
FormatCliCommand("checkout master") +
(_options.PullChanges ? FormatCliCommand("pull") : string.Empty) +
FormatCliCommand($"merge --no-ff {featureBranch}", false),
$"Finishing feature {featureName}",
featureBranch, null, _options, FormatCliCommand("push origin master"));
}
private void StartFeatureGitHubCommand(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(_envHelper.GetSolutionDir()))
{
return;
}
var featureName = Interaction.InputBox("Feature Name:", "Start New Feature");
if (string.IsNullOrEmpty(featureName))
{
return;
}
/* 1. Switch to the master branch
* 2. Pull latest changes on master
* 3. Create and switch to a new branch
*/
ProcessHelper.StartProcessGui(_dte, _envHelper,
"cmd.exe",
$"/c cd \"{_envHelper.GetSolutionDir()}\" && " +
GitHelper.GetSshSetup(_envHelper) +
FormatCliCommand("checkout master") +
(_options.PullChanges ? FormatCliCommand("pull") : string.Empty) +
FormatCliCommand($"checkout -b {featureName} master", false),
$"Starting feature {featureName}"
);
}
public void CanGetFileList()
{
Assert.NotNull(Applications.Application.Current);
if (null == Applications.Application.Current.Principal)
{
var services = new StringBuilder();
foreach (var componentDefinition in Applications.Application.Current.Container.GetComponents())
{
services.AppendLine(string.Format("{0} {1}", componentDefinition.ServiceType.Name, componentDefinition.ImplementationType.Name));
}
throw new Exception(services.ToString());
}
Assert.NotNull(Applications.Application.Current.Principal);
Assert.NotNull(Applications.Application.Current.Principal.CurrentUser);
Assert.NotNull(Applications.Application.Current.Principal.CurrentUser.Identity);
var githelper = new GitHelper {
DirectoryName = dirname, AuthorName = Applications.Application.Current.Principal.CurrentUser.Identity.Name
};
githelper.Connect();
var initial = githelper.GetCommitId();
var initialList = githelper.GetFileList();
Assert.False(initialList.Any(_ => _ == "x"));
githelper.WriteAndCommit("x", "a", "is a");
var first = githelper.GetCommitId();
Assert.True(githelper.GetFileList().Any(_ => _ == "x"));
githelper.WriteAndCommit("x z", "b", "is b");
Assert.True(githelper.GetFileList().Any(_ => _ == "x z"));
Assert.False(githelper.GetFileList(first).Any(_ => _ == "x z"));
Assert.True(githelper.GetFileList(first).Any(_ => _ == "x"));
Assert.False(githelper.GetFileList(initial).Any(_ => _ == "x"));
}
public override async Task ExecuteAsync()
{
loggerService.WriteHeading("PUBLISHING MCR DOCS");
// Hookup a TraceListener in order to capture details from Microsoft.DotNet.VersionTools
Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
IEnumerable <GitObject> gitObjects =
GetUpdatedReadmes()
.Concat(GetUpdatedTagsMetadata());
foreach (GitObject gitObject in gitObjects)
{
this.loggerService.WriteMessage(
$"Updated file '{gitObject.Path}' with contents:{Environment.NewLine}{gitObject.Content}{Environment.NewLine}");
}
if (!Options.IsDryRun)
{
using IGitHubClient gitHubClient = this.gitHubClientFactory.GetClient(Options.GitOptions.ToGitHubAuth(), Options.IsDryRun);
await GitHelper.ExecuteGitOperationsWithRetryAsync(async() =>
{
GitReference gitRef = await GitHelper.PushChangesAsync(gitHubClient, Options, $"Mirroring readmes", branch =>
{
return(FilterUpdatedGitObjectsAsync(gitObjects, gitHubClient, branch));
});
if (gitRef != null)
{
this.loggerService.WriteMessage(PipelineHelper.FormatOutputVariable("readmeCommitDigest", gitRef.Object.Sha));
}
});
}
}
public void CanGetDistance()
{
var githelper = new GitHelper {
DirectoryName = dirname, AuthorName = "test"
};
githelper.Connect();
var c1 = githelper.WriteAndCommit("x", "a", "message");
var c2 = githelper.WriteAndCommit("x", "b", "message");
var dist1 = githelper.GetDistance(c1, c2);
Assert.AreEqual(0, dist1.Behind);
Assert.AreEqual(1, dist1.Forward);
Assert.True(dist1.IsForwardable);
var dist2 = githelper.GetDistance(c2, c1);
Assert.AreEqual(1, dist2.Behind);
Assert.AreEqual(0, dist2.Forward);
Assert.True(dist2.IsUpdateable);
githelper.Checkout(c1);
var c3 = githelper.WriteAndCommit("x", "c", "message");
var dist3 = githelper.GetDistance(c2, c3);
Assert.AreEqual(1, dist3.Behind);
Assert.AreEqual(1, dist3.Forward);
Assert.False(dist3.IsUpdateable);
Assert.False(dist3.IsForwardable);
}
public void CanUseGit()
{
GitHelper.Init(dir);
File.WriteAllText(file, "select 1 print '1 selected'");
GitHelper.CommitAll(dir);
// Console.WriteLine(GitHelper.GetLastCommit(file).Hash);
var t = new ScriptFileDbUpdateTask(file)
{
Database = DbName
};
t.Execute();
Assert.AreEqual(TaskState.Success, t.State);
// Console.WriteLine(t.GetLastLog());
File.WriteAllText(file, "select 2 print '2 selected'");
t = new ScriptFileDbUpdateTask(file)
{
Database = DbName
};
t.Execute();
Assert.AreEqual(TaskState.SuccessNotRun, t.State);
GitHelper.CommitAll(dir);
// Console.WriteLine(GitHelper.GetLastCommit(file).Hash);
t = new ScriptFileDbUpdateTask(file)
{
Database = DbName
};
t.Execute();
Assert.AreEqual(TaskState.Success, t.State);
}
public void StaticInit()
{
var dir = FileSystemHelper.ResetTemporaryDirectory();
GitHelper.Init(dir);
Assert.True(Directory.Exists(Path.Combine(dir, ".git")));
}
private static bool TryParseHead(Enlistment enlistment, List <string> messages)
{
string refPath = Path.Combine(enlistment.WorkingDirectoryRoot, GVFSConstants.DotGit.Head);
if (!File.Exists(refPath))
{
messages.Add("Could not find ref file for '" + GVFSConstants.DotGit.Head + "'");
return(false);
}
string refContents;
try
{
refContents = File.ReadAllText(refPath).Trim();
}
catch (IOException ex)
{
messages.Add("IOException while reading .git\\HEAD: " + ex.Message);
return(false);
}
const string MinimallyValidRef = "ref: refs/";
if (refContents.StartsWith(MinimallyValidRef, StringComparison.OrdinalIgnoreCase) ||
GitHelper.IsValidFullSHA(refContents))
{
return(true);
}
messages.Add("Invalid contents found in '" + GVFSConstants.DotGit.Head + "': " + refContents);
return(false);
}
public void StaticGetLastFileCommit()
{
var dir = FileSystemHelper.ResetTemporaryDirectory();
var gh = new GitHelper {
DirectoryName = dir
};
Directory.CreateDirectory(Path.Combine(dir, "a"));
var file = Path.Combine(dir, "a", "x");
File.WriteAllText(file, "zzz");
var file2 = Path.Combine(dir, "a", "y");
File.WriteAllText(file2, "zzz2");
gh.Init();
gh.CommitAllChanges();
var fstCommit = gh.GetCommitId();
File.WriteAllText(file2, "zzz3");
gh.CommitAllChanges();
var secCommit = gh.GetCommitId();
Assert.AreEqual(fstCommit, GitHelper.GetLastCommit(file).Hash);
Assert.AreEqual(secCommit, GitHelper.GetLastCommit(file2).Hash);
}
public void HeaderMultiRepositoryDependency()
{
File.WriteAllText(file, @"/*!
opts
repodependency ../FileDescriptorExTest2
repodependency @repos@/qorpent.sys
*/
data");
File.WriteAllText(file2_1, "test");
GitHelper.Init(dir);
GitHelper.CommitAll(dir);
GitHelper.Init(dir2);
GitHelper.CommitAll(dir2);
var h1 = GitHelper.GetCommit(dir).Hash;
var h2 = GitHelper.GetCommit(dir2).Hash;
var h3 = GitHelper.GetCommit(EnvironmentInfo.ResolvePath("@repos@/qorpent.sys")).Hash;
Assert.NotNull(h1);
Assert.NotNull(h2);
Assert.NotNull(h3);
var h = (h1 + h2 + h3).GetMd5();
var desc = new FileDescriptorEx {
FullName = file
};
Assert.AreEqual(h, desc.Hash);
}
public override int Execute(CommandContext context)
{
var gitHelper = new GitHelper();
if (!gitHelper.HasRepo)
{
SpectreHelper.WriteError("There is no repository");
return(1);
}
var flowHelper = new Modules.Flow(gitHelper);
var response = flowHelper.Init();
if (!response.Success)
{
SpectreHelper.WriteError(response.Message);
return(1);
}
if (response.GitReponse is not EnumGitResponse.NONE)
{
SpectreHelper.WriteWarning(response.Message);
return(0);
}
SpectreHelper.WriteSuccess(response.Message);
return(0);
}
public void CreateRepository()
{
var path = @"c:\temp\GithubRepos\testRepo2";
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
var gh = new GitHelper();
bool result = gh.CreateRepository(path, "*.saved.md\r\n*.bak\r\n*.tmp");
Assert.IsTrue(result);
Assert.IsTrue(Directory.Exists(path));
var fileToAdd = Path.Combine(path, "test.txt");
var list = new ObservableCollection <RepositoryStatusItem>()
{
new RepositoryStatusItem {
Filename = fileToAdd
}
};
gh.OpenRepository(path);
Assert.IsTrue(gh.Commit(list, "first commit", "ras", "*****@*****.**"), gh.ErrorMessage);
ShellUtils.OpenFileInExplorer(path);
}
private void test_Click(object sender, RoutedEventArgs e)
{
if (MessageBox.Show("开始20次show根节点", "测试", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
{
DateTime t1 = DateTime.Now;
for (int i = 0; i < 20; i++)
{
GUTag tag = GUTag.Parse(StaticCfg.Ins.DefaultTagID.ToString(), tagDB);
ShowTagGraph(tag, tag);
}
DateTime t2 = DateTime.Now;
MessageBox.Show("总共耗时:" + (t2 - t1).TotalSeconds + TreeLayoutEnv.StatInf);
}
else
{
string dir = @"E:\testall\testgitee";
string git = @"https://gitee.com/kummerwu/testlibgit2sharp.git";
GitHelper h = new GitHelper();
h.Connect(git, dir);
//h.Clone();
//File.WriteAllText(Path.Combine(dir, "test.txt"),DateTime.Now.ToLongDateString()+DateTime.Now.ToLongTimeString());
h.Pull();
}
}
public void UpdatesCurrentBranch()
{
using (var fixture = new EmptyRepositoryFixture(new Config()))
{
fixture.Repository.MakeACommit();
fixture.Repository.Checkout(fixture.Repository.CreateBranch("develop"));
fixture.Repository.MakeACommit();
fixture.Repository.Checkout("master");
using (var localFixture = fixture.CloneRepository())
{
// Advance remote
fixture.Repository.Checkout("develop");
var advancedCommit = fixture.Repository.MakeACommit();
localFixture.Repository.Network.Fetch(localFixture.Repository.Network.Remotes["origin"]);
localFixture.Repository.Checkout(advancedCommit.Sha);
localFixture.Repository.DumpGraph();
GitHelper.NormalizeGitDirectory(localFixture.RepositoryPath, new Authentication(), noFetch: false, currentBranch: "ref/heads/develop");
var normalisedBranch = localFixture.Repository.FindBranch("develop");
normalisedBranch.ShouldNotBe(null);
fixture.Repository.DumpGraph();
localFixture.Repository.DumpGraph();
normalisedBranch.Tip.Sha.ShouldBe(advancedCommit.Sha);
localFixture.Repository.Head.Tip.Sha.ShouldBe(advancedCommit.Sha);
}
}
}
public void MenuUndoGit_Click(object sende, RoutedEventArgs e)
{
var selectedFiles = FolderBrowser.GetSelectedItems();
if (selectedFiles.Count < 1)
{
return;
}
var gh = new GitHelper();
foreach (var selected in selectedFiles)
{
if (selected == null)
{
continue;
}
if (selected.FileStatus != LibGit2Sharp.FileStatus.ModifiedInIndex &&
selected.FileStatus != LibGit2Sharp.FileStatus.ModifiedInWorkdir)
{
continue;
}
gh.UndoChanges(selected.FullPath);
}
}
public void NormalisationOfTag()
{
using (var fixture = new EmptyRepositoryFixture(new Config()))
{
fixture.Repository.MakeACommit();
fixture.Repository.Checkout(fixture.Repository.CreateBranch("feature/foo"));
fixture.Repository.MakeACommit();
fixture.BranchTo("release/2.0.0");
fixture.MakeACommit();
fixture.MakeATaggedCommit("2.0.0-rc.1");
fixture.Checkout("master");
fixture.MergeNoFF("release/2.0.0");
fixture.Repository.Branches.Remove(fixture.Repository.FindBranch("release/2.0.0"));
var remoteTagSha = fixture.Repository.Tags["2.0.0-rc.1"].Target.Sha;
using (var localFixture = fixture.CloneRepository())
{
localFixture.Checkout(remoteTagSha);
GitHelper.NormalizeGitDirectory(localFixture.RepositoryPath, new Authentication(), noFetch: false, currentBranch: string.Empty);
localFixture.AssertFullSemver("2.0.0-rc.1");
}
}
}
public MarkdownBaseController(IConfig config,
IMarkdownToHtml markdownToHtml,
IContentRepository contentRepo,
GitHelper gitHelper,
IPathHelper pathHelper
)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (markdownToHtml == null)
{
throw new ArgumentNullException("markdownToHtml");
}
if (contentRepo == null)
{
throw new ArgumentNullException("contentRepo");
}
this.Config = config;
this.MarkdownToHtml = markdownToHtml;
this.ContentRepo = contentRepo;
this.PathHelper = pathHelper;
this.GitHelper = gitHelper;
}
private void StartFeatureCommand(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(_envHelper.GetSolutionDir()))
{
return;
}
var featureName = Interaction.InputBox("Feature Name:", "Start New Feature");
if (string.IsNullOrEmpty(featureName))
{
return;
}
var flowOptions = GitHelper.GetGitConfig(_envHelper);
/* 1. Switch to the develop branch
* 2. Pull latest changes on develop
* 3. Create and switch to a new branch
*/
ProcessHelper.StartProcessGui(_dte, _envHelper,
"cmd.exe",
$"/c cd \"{_envHelper.GetSolutionDir()}\" && " +
GitHelper.GetSshSetup(_envHelper) +
FormatCliCommand($"checkout {flowOptions.DevelopBranch}") +
FormatCliCommand("pull") +
FormatCliCommand($"checkout -b {flowOptions.FeaturePrefix}{featureName} {flowOptions.DevelopBranch}", false),
$"Starting feature {featureName}"
);
}
public async Task<ActionResult> Login(GitHelper.Server.Backend.Web.Models.LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
try
{
_loginService.Login(new LoginInfoDto { Password = model.Password, UserName = model.Login });
return RedirectToLocal(returnUrl);
}
catch (Exception)
{
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
