protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
if (string.IsNullOrWhiteSpace(result))
{
return(StepResult.InvalidResponseSelected());
}
var configureBranchStep = StepFactory.CreateStep <ConfigureBranch>();
switch (result)
{
case "0":
steps.Enqueue(configureBranchStep.WithData(name, branchConfig));
return(StepResult.Ok());
case "1":
branchConfig.Tag = string.Empty;
steps.Enqueue(configureBranchStep.WithData(name, branchConfig));
return(StepResult.Ok());
default:
branchConfig.Tag = result;
steps.Enqueue(configureBranchStep.WithData(name, branchConfig));
return(StepResult.Ok());
}
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
if (int.TryParse(result, out var parsed))
{
if (parsed == 0)
{
steps.Enqueue(StepFactory.CreateStep <EditConfigStep>());
return(StepResult.Ok());
}
try
{
var foundBranch = OrderedBranches(config).ElementAt(parsed - 1);
var branchConfig = foundBranch.Value;
if (branchConfig == null)
{
branchConfig = new BranchConfig {
Name = foundBranch.Key
};
config.Branches.Add(foundBranch.Key, branchConfig);
}
steps.Enqueue(StepFactory.CreateStep <ConfigureBranch>().WithData(foundBranch.Key, branchConfig));
return(StepResult.Ok());
}
catch (ArgumentOutOfRangeException)
{ }
}
return(StepResult.InvalidResponseSelected());
}
// for Test
SequenceFile GenerateTestSequenceFile()
{
SequenceFile seqFile = new SequenceFile();
seqFile.Name = "TestSequenceFile";
seqFile.Description = "This is a test sequenceFile.";
seqFile.Comment = "Nothing";
seqFile.Version.MarjorVersion = "1";
ISequence mainSequence = SequenceFactory.CreateSequence(SequenceTypes.Normal);
mainSequence.Name = "MainSequence1";
mainSequence.Description = "Main sequence for test.";
mainSequence.EnableLogging = false;
mainSequence.TestTimeout = 3000;
mainSequence.BreakPoint = true;
IStep actionStep = StepFactory.CreateStep(StepTypes.Action);
actionStep.Name = "Action step test";
actionStep.Description = "this is a test action step";
IAdaptor adaptor = AdaptorFactory.CreateAdaptor(AdaptorTypes.DotnetAdaptor);
adaptor.MethodName = "Test";
adaptor.TestModuleName = "DotNetTest.dll";
adaptor.Parameters.Add(new DotNetParameter());
adaptor.Parameters.Add(new DotNetParameter("parameter1"));
adaptor.Parameters.Add(new DotNetParameter("parameter2"));
actionStep.Adaptor = adaptor;
IStep subActionStep = StepFactory.CreateStep(StepTypes.Action);
subActionStep.Name = "SubAction step test";
subActionStep.Description = "this is a sub test action step";
actionStep.Children.Add(subActionStep);
mainSequence.Children.Add(actionStep);
mainSequence.Children.Add(subActionStep);
mainSequence.Children.Add(subActionStep);
ISequence mainSequence2 = SequenceFactory.CreateSequence(SequenceTypes.Normal);
mainSequence2.Name = "MainSequence2";
mainSequence2.Description = "Main sequence 2 for test.";
mainSequence2.EnableLogging = false;
mainSequence2.TestTimeout = 3000;
mainSequence2.BreakPoint = true;
seqFile.Sequences.Add(mainSequence);
seqFile.Sequences.Add(mainSequence2);
return(seqFile);
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "0":
steps.Enqueue(StepFactory.CreateStep <EditConfigStep>());
return(StepResult.Ok());
case "1":
steps.Enqueue(StepFactory.CreateStep <AppveyorPublicPrivate>());
return(StepResult.Ok());
}
return(StepResult.Ok());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "0":
steps.Enqueue(StepFactory.CreateStep <EditConfigStep>());
return(StepResult.Ok());
case "1":
steps.Enqueue(StepFactory.CreateStep <AppVeyorSetup>().WithData(ProjectVisibility.Public));
return(StepResult.Ok());
case "2":
steps.Enqueue(StepFactory.CreateStep <AppVeyorSetup>().WithData(ProjectVisibility.Private));
return(StepResult.Ok());
}
return(StepResult.Ok());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result.ToLower())
{
case "y":
Console.Write(@"Because you need to maintain multiple versions of your product in production at the same time, GitFlow is likely a good fit.
GitFlow allows you to have new development happening on the 'develop' branch, patch issues in old minor versions with 'hotfix/' branches and support old major versions with 'support/' branches");
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategyStep>());
return(StepResult.Ok());
case "n":
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategy2Step>());
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "0":
steps.Enqueue(StepFactory.CreateStep <ConfigureBranches>());
return(StepResult.Ok());
case "1":
steps.Enqueue(StepFactory.CreateStep <SetBranchTag>().WithData(name, branchConfig));
return(StepResult.Ok());
case "2":
steps.Enqueue(StepFactory.CreateStep <SetBranchIncrementMode>().WithData(name, branchConfig));
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
var editConfigStep = StepFactory.CreateStep <EditConfigStep>();
if (string.IsNullOrEmpty(result))
{
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
}
if (!SemanticVersion.TryParse(result, string.Empty, out var semVer))
{
return(StepResult.InvalidResponseSelected());
}
config.NextVersion = semVer.ToString("t");
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result.ToLower())
{
case "y":
Console.WriteLine("GitFlow is likely a good fit, the 'develop' branch can be used " +
"for active development while stabilising the next release.");
Console.WriteLine();
Console.WriteLine("GitHubFlow is designed for a lightweight workflow where master is always " +
"good to deploy to production and feature branches are used to stabilise " +
"features, once stable they are merged to master and made available in the next release");
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategyStep>());
return(StepResult.Ok());
case "n":
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategy3Step>());
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
var editConfigStep = StepFactory.CreateStep <EditConfigStep>();
switch (result)
{
case "0":
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "1":
GenerateBasicConfig(workingDirectory);
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "2":
GenerateNuGetConfig(workingDirectory);
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
var editConfigStep = StepFactory.CreateStep <EditConfigStep>();
switch (result)
{
case "0":
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "1":
config.AssemblyVersioningScheme = AssemblyVersioningScheme.Major;
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "2":
config.AssemblyVersioningScheme = AssemblyVersioningScheme.MajorMinor;
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "3":
config.AssemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch;
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "4":
config.AssemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatchTag;
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "5":
config.AssemblyVersioningScheme = AssemblyVersioningScheme.None;
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result.ToLower())
{
case "y":
Console.WriteLine("GitFlow could be a better fit than GitHubFlow for you.");
Console.WriteLine();
Console.WriteLine("GitVersion increments the SemVer for each commit on the develop branch by default, " +
"this means all packages built from develop can be published to a single NuGet feed.");
break;
case "n":
Console.WriteLine("We recommend the GitHubFlow branching strategy, it sounds like you will " +
"not benefit from the additional complexity that GitFlow introduces");
break;
default:
return(StepResult.InvalidResponseSelected());
}
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategyStep>());
return(StepResult.Ok());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
var configureBranchStep = StepFactory.CreateStep <ConfigureBranch>();
switch (result)
{
case "0":
steps.Enqueue(configureBranchStep.WithData(name, branchConfig));
return(StepResult.Ok());
case "1":
branchConfig.VersioningMode = VersioningMode.ContinuousDelivery;
steps.Enqueue(configureBranchStep.WithData(name, branchConfig));
return(StepResult.Ok());
case "2":
branchConfig.VersioningMode = VersioningMode.ContinuousDeployment;
steps.Enqueue(configureBranchStep.WithData(name, branchConfig));
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "0":
return(StepResult.SaveAndExit());
case "1":
return(StepResult.ExitWithoutSaving());
case "2":
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategyStep>());
return(StepResult.Ok());
case "3":
steps.Enqueue(StepFactory.CreateStep <SetNextVersion>());
return(StepResult.Ok());
case "4":
steps.Enqueue(StepFactory.CreateStep <ConfigureBranches>());
return(StepResult.Ok());
case "5":
var editConfigStep = StepFactory.CreateStep <EditConfigStep>();
steps.Enqueue(StepFactory.CreateStep <GlobalModeSetting>().WithData(editConfigStep, false));
return(StepResult.Ok());
case "6":
steps.Enqueue(StepFactory.CreateStep <AssemblyVersioningSchemeSetting>());
return(StepResult.Ok());
case "7":
steps.Enqueue(StepFactory.CreateStep <SetupBuildScripts>());
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
var returnToStep = StepFactory.CreateStep <FinishedSetupStep>();
switch (result)
{
case "1":
steps.Enqueue(StepFactory.CreateStep <GitFlowSetupStep>().WithData(returnToStep, true));
break;
case "2":
steps.Enqueue(StepFactory.CreateStep <GitHubFlowStep>().WithData(returnToStep, true));
break;
case "3":
steps.Enqueue(StepFactory.CreateStep <PickBranchingStrategy1Step>());
break;
default:
return(StepResult.InvalidResponseSelected());
}
return(StepResult.Ok());
}
private void OnAddActionStep()
{
IStep step = StepFactory.CreateStep(StepTypes.Action);
AddStepVM(step);
}
private void OnAddPassFailTestStep()
{
IStep step = StepFactory.CreateStep(StepTypes.PassOrFailTest);
AddStepVM(step);
}
