public void SetUp()
{
thePlan = TemplatePlan.CreateClean("copy-references");
thePlan.FileSystem.WriteStringToFile("ripple.dependencies.config", @"FubuCore
FubuMVC.Core
");
thePlan.Add(new CreateSolution("References"));
var originalPlan = new ProjectPlan("References");
thePlan.Add(originalPlan);
originalPlan.Add(new SystemReference("System.Data"));
originalPlan.Add(new SystemReference("System.Configuration"));
originalPlan.Add(new CopyFileToProject("ripple.dependencies.config", "ripple.dependencies.config"));
originalPlan.NugetDeclarations.Add("Bottles");
originalPlan.NugetDeclarations.Add("FubuMVC.Core");
originalPlan.NugetDeclarations.Add("FubuLocalization");
testingPlan = new ProjectPlan("References.Testing");
thePlan.Add(testingPlan);
thePlan.Add(new CopyProjectReferences("References"));
thePlan.Execute();
theOriginalProject = thePlan.Solution.FindProject("References").Project;
theTestingProject = thePlan.Solution.FindProject("References.Testing").Project;
}
public void Alter(TemplatePlan plan)
{
plan.AlterFile(".gitignore", delegate(List <string> list)
{
GenericEnumerableExtensions.Each <string>(this._entries, new Action <string>(list.Fill <string>));
});
}
public void Alter(TemplatePlan plan)
{
if (!RemoteOperations.Enabled)
{
plan.Logger.WriteSuccess("Remote operations are disabled.");
return;
}
var bundler = new ProcessStartInfo
{
UseShellExecute = true,
FileName = "bundle",
Arguments = "install",
CreateNoWindow = true,
WorkingDirectory = plan.Root
};
var process = Process.Start(bundler);
process.WaitForExit();
if (process.ExitCode != 0)
{
plan.Logger.WriteWarning("bundler install failed!");
}
else
{
plan.Logger.WriteSuccess("bundler install was successful");
}
}
public void SetUp()
{
var context = TemplatePlan.CreateClean("assembly-info");
context.Add(new CreateSolution("AssemblyInfoSolution"));
var project = new ProjectPlan("MyProject");
context.Add(project);
var system = new FileSystem();
system.CreateDirectory("assembly-info");
system.CreateDirectory("assembly-info", "src");
system.CreateDirectory("assembly-info", "src", "MyProject");
system.CreateDirectory("assembly-info", "src", "MyProject", "Properties");
var expectedPath = "assembly-info".AppendPath("src", "MyProject", "Properties", "AssemblyInfo.cs");
system.WriteStringToFile(expectedPath, @"using System.Reflection;
[assembly: AssemblyTitle('MyProject')]
".Replace("'", "\""));
var alteration = new AssemblyInfoAlteration("using System.Reflection;", "[assembly: AssemblyTitle(\"%ASSEMBLYNAME%\")]", "using FubuMVC.Core;", "[assembly: FubuModule]");
project.Add(alteration);
context.Execute();
theProject = CsProjFile.LoadFrom("assembly-info".AppendPath("src", "MyProject", "MyProject.csproj"));
theContents =
new FileSystem().ReadStringFromFile(expectedPath);
}
public static void ConfigurePlan(TextFile textFile, TemplatePlan plan)
{
textFile.ReadLines().Each(line => {
var parts = line.ToDelimitedArray();
plan.Add(new GemReference(parts.First(), parts.Last()));
});
}
public void Alter(TemplatePlan plan)
{
if (!RemoteOperations.Enabled)
{
plan.Logger.WriteSuccess("Remote operations are disabled.");
return;
}
var rake = new ProcessStartInfo
{
UseShellExecute = true,
FileName = "rake",
CreateNoWindow = true,
WorkingDirectory = plan.Root
};
var process = Process.Start(rake);
process.WaitForExit();
if (process.ExitCode != 0)
{
plan.Logger.WriteWarning("rake script failed!");
}
else
{
plan.Logger.WriteSuccess("rake succeeded");
}
}
public static void ConfigurePlan(TextFile textFile, TemplatePlan plan)
{
var ignores = textFile.ReadLines().Where(x => x.IsNotEmpty()).ToArray();
var step = new GitIgnoreStep(ignores);
plan.Add(step);
}
public void Alter(TemplatePlan plan)
{
if (!RemoteOperations.Enabled)
{
plan.Logger.WriteSuccess("Remote operations are disabled.");
return;
}
var bundler = new ProcessStartInfo
{
UseShellExecute = true,
FileName = "bundle",
Arguments = "install",
CreateNoWindow = true,
WorkingDirectory = plan.Root
};
var process = Process.Start(bundler);
process.WaitForExit();
if (process.ExitCode != 0)
{
plan.Logger.WriteWarning("bundler install failed!");
}
else
{
plan.Logger.WriteSuccess("bundler install was successful");
}
}
public void Alter(TemplatePlan plan)
{
if (!RemoteOperations.Enabled)
{
plan.Logger.WriteSuccess("Remote operations are disabled.");
return;
}
var rake = new ProcessStartInfo
{
UseShellExecute = true,
FileName = "rake",
CreateNoWindow = true,
WorkingDirectory = plan.Root
};
var process = Process.Start(rake);
process.WaitForExit();
if (process.ExitCode != 0)
{
plan.Logger.WriteWarning("rake script failed!");
}
else
{
plan.Logger.WriteSuccess("rake succeeded");
}
}
public void Alter(TemplatePlan plan)
{
Solution solution = Solution.CreateNew(plan.SourceDirectory, this._solutionName);
solution.Version = this.Version;
plan.Solution = solution;
}
public static object UpdateTemplate(int code, bool use, bool data)
{
var user = UserSession.Current.User;
if (user != null)
{
var repo = new TemplateRepository((int)Constants.TemplateAction.Plan, code, false);
var template = repo.List.FirstOrDefault();
if (template != null)
{
template.IsUpdate = data;
return(use ? repo.UpdateTemplate(template) : repo.DeleteTemplate());
}
else
{
var plan = PlanManager.GetPlan(code);
if (plan == null)
{
throw new Exception();
}
template = new TemplatePlan()
{
UserCode = user.Code,
AllPlan = code.ToString(),
IsUpdate = data,
PlanCode = code
};
return(repo.InsertData(template) > Constants.DEFAULT_CODE);
}
}
throw new NotImplementedException();
}
public void Alter(TemplatePlan plan)
{
FileSystemExtensions.CreateDirectory(new FileSystem(), new string[]
{
plan.Root,
this._relativePath
});
}
public static void ConfigurePlan(TextFile textFile, TemplatePlan plan)
{
GenericEnumerableExtensions.Each <string>(textFile.ReadLines(), delegate(string line)
{
string[] parts = FubuCore.StringExtensions.ToDelimitedArray(line);
plan.Add(new GemReference(parts.First <string>(), parts.Last <string>()));
});
}
public void Alter(TemplatePlan plan)
{
var expectedFile = plan.Root.AppendPath(_relativePath);
var contents = plan.FileSystem.ReadStringFromFile(_source);
var transformedContents = plan.ApplySubstitutions(contents);
plan.FileSystem.WriteStringToFile(expectedFile, transformedContents);
}
public void Alter(TemplatePlan plan)
{
var solution = Solution.CreateNew(plan.SourceDirectory, _solutionName);
solution.Version = Version;
plan.Solution = solution;
}
public static void ExecutePlan(TemplatePlan plan)
{
plan.Execute();
new RakeStep().Alter(plan);
plan.WriteInstructions();
}
public void SetUp()
{
thePlan = TemplatePlan.CreateClean("gitignore");
_contents = new Lazy <string[]>(() =>
{
return(fileSystem.ReadStringFromFile("gitignore", ".gitignore").SplitOnNewLine().ToArray());
});
}
public void substitutes_the_solution_path()
{
var plan = new TemplatePlan("root");
plan.Solution = Solution.CreateNew("root".AppendPath("src"), "MySolution");
plan.ApplySubstitutions("*%SOLUTION_PATH%*")
.ShouldEqual("*src/MySolution.sln*");
}
public void substitutes_the_solution_name()
{
var plan = new TemplatePlan("root");
plan.Solution = Solution.CreateNew("root", "MySolution");
plan.ApplySubstitutions("*%SOLUTION_NAME%*")
.ShouldEqual("*MySolution*");
}
public static void ConfigurePlan(TextFile textFile, TemplatePlan plan)
{
string[] ignores = (from x in textFile.ReadLines()
where FubuCore.StringExtensions.IsNotEmpty(x)
select x).ToArray <string>();
GitIgnoreStep step = new GitIgnoreStep(ignores);
plan.Add(step);
}
private void findNugetsInOriginalRippleDeclarations(TemplatePlan plan, ProjectPlan testPlan)
{
var configFile = _originalProject.ParentDirectory().AppendPath("ripple.dependencies.config");
plan.FileSystem.ReadTextFile(configFile, line => { if (line.IsNotEmpty())
{
testPlan.NugetDeclarations.Fill(line);
}
});
}
private static void initializeTheBottle(BottleInput input, TemplatePlan plan)
{
new InitCommand().Execute(
new InitInput
{
Name = input.Name,
Path = plan.Solution.FindProject(input.Name).Project.ProjectDirectory
}
);
}
public DataMother(string directory, bool withProject = true)
{
_directory = directory;
_plan = TemplatePlan.CreateClean(_directory);
if (withProject)
{
_plan.Add(new ProjectPlan("SomeProject"));
}
}
public void creates_a_new_directory_if_it_does_not_already_exist()
{
var solutionDirectory = new SolutionDirectory("foo");
var plan = TemplatePlan.CreateClean("solution");
solutionDirectory.Alter(plan);
Directory.Exists("solution".AppendPath("foo")).ShouldBeTrue();
}
public void Alter(TemplatePlan plan)
{
string expectedFile = FubuCore.StringExtensions.AppendPath(plan.Root, new string[]
{
this._relativePath
});
string contents = plan.FileSystem.ReadStringFromFile(this._source);
string transformedContents = plan.ApplySubstitutions(contents);
plan.FileSystem.WriteStringToFile(expectedFile, transformedContents);
}
public void create_a_deep_directory()
{
var solutionDirectory = new SolutionDirectory("foo/bar");
var plan = TemplatePlan.CreateClean("solution");
solutionDirectory.Alter(plan);
Directory.Exists("solution".AppendPath("foo")).ShouldBeTrue();
Directory.Exists("solution".AppendPath("foo", "bar")).ShouldBeTrue();
}
private void executePlan(Action <TemplateRequest> configure = null)
{
if (configure != null)
{
configure(theRequest);
}
thePlan = new TemplatePlanBuilder(library).BuildPlan(theRequest);
thePlan.Execute();
}
public void Alter(TemplatePlan plan)
{
CsProjFile original = plan.Solution.FindProject(this._originalProject).Project;
ProjectPlan originalPlan = plan.FindProjectPlan(this._originalProject);
ProjectPlan testPlan = plan.CurrentProject;
CsProjFile testProject = plan.Solution.FindProject(testPlan.ProjectName).Project;
CopyProjectReferences.copyNugetDeclarations(originalPlan, testPlan, original, testProject);
this.findNugetsInOriginalRippleDeclarations(plan, testPlan);
CopyProjectReferences.buildProjectReference(original, testProject);
}
public void add_instructions_simple()
{
var plan = new TemplatePlan("root");
plan.AddInstructions("some foo");
plan.WriteInstructions();
new FileSystem().ReadStringFromFile("root".AppendPath(TemplatePlan.InstructionsFile))
.ShouldContain("some foo");
}
public void project_folder_is_substituted()
{
thePlan = TemplatePlan.CreateClean("create-solutionProject");
thePlan.Add(new CreateSolution("MySolution"));
thePlan.Add(new ProjectPlan("MyProject"));
thePlan.Execute();
thePlan.CurrentProject.ApplySubstitutions("*%PROJECT_FOLDER%*")
.ShouldEqual("*src/MyProject*");
}
public void execute_blows_up_if_there_are_any_missing_inputs()
{
var plan = TemplatePlan.CreateClean("missing-inputs");
plan.MissingInputs.Add("Foo");
plan.MissingInputs.Add("Bar");
Exception <MissingInputException> .ShouldBeThrownBy(() => {
plan.Execute();
}).InputNames.ShouldHaveTheSameElementsAs("Foo", "Bar");
}
protected override void beforeEach()
{
_plan = new TemplatePlan();
_input = new NewCommandInput {
ProjectName = "Test"
};
MockFor <IFileSystem>()
.Expect(f => f.DirectoryExists(Arg <string> .Is.NotNull))
.Return(false);
}
