public void Cleanup()
{
_fileSystem.ForceClean(_directory);
_fileSystem.DeleteDirectory(_directory);
RippleFileSystem.Live();
}
public SolutionFiles(IFileSystem fileSystem, ISolutionLoader loader)
{
resetDirectories(RippleFileSystem.FindSolutionDirectory());
_fileSystem = fileSystem;
_loader = loader;
}
public void TearDown()
{
theFileSystem.ForceClean(theSolutionDir);
theFileSystem.DeleteDirectory(theSolutionDir);
RippleFileSystem.Live();
}
public override bool Execute(GitIgnoreInput input)
{
var fileSystem = new FileSystem();
var gitIgnoreFile = RippleFileSystem.FindSolutionDirectory().AppendPath(".gitignore");
if (input.Line.IsNotEmpty())
{
ConsoleWriter.Write("Writing \"{0}\" to {1}", input.Line, gitIgnoreFile);
fileSystem.AlterFlatFile(gitIgnoreFile, list => list.Fill(input.Line));
ConsoleWriter.Line();
ConsoleWriter.Line();
}
ConsoleWriter.PrintHorizontalLine();
ConsoleWriter.Write(gitIgnoreFile);
ConsoleWriter.PrintHorizontalLine();
var text = fileSystem.ReadStringFromFile(gitIgnoreFile);
ConsoleWriter.Write(text);
ConsoleWriter.PrintHorizontalLine();
return(true);
}
public static SolutionGraph BuildForCurrentDirectory()
{
var builder = new SolutionGraphBuilder(new FileSystem());
var codeDirectory = RippleFileSystem.FindCodeDirectory();
return(builder.ReadFrom(codeDirectory));
}
public void TearDown()
{
theScenario.Cleanup();
RippleFileSystem.Live();
FeedRegistry.Reset();
RippleOperation.Reset();
}
public static ISolutionBuilder NewSolutionBuilder(Solution solution)
{
var loader = new InMemorySolutionLoader(solution);
var files = SolutionFiles.FromDirectory(RippleFileSystem.CurrentDirectory(), loader);
return(new SolutionBuilder(files, ProjectReader.Basic()));
}
public IEnumerable <Solution> FindSolutions()
{
if (RippleFileSystem.IsSolutionDirectory())
{
yield return(SolutionBuilder.ReadFromCurrentDirectory());
}
}
public override bool Execute(WhereAmIInput input)
{
Console.WriteLine("The root code directory for ripple is " + RippleFileSystem.FindCodeDirectory());
Console.WriteLine("ripple.exe is at " + RippleFileSystem.RippleExeLocation());
return(true);
}
public void Describe(Description description)
{
description.Title = "Solution Graph at {0}".ToFormat(RippleFileSystem.FindCodeDirectory());
var solutions = description.AddList("Solutions", _orderedSolutions.Value.Select(x => new SolutionListItem(x)));
solutions.Label = "Solutions";
}
public DirectorySandbox(string directory)
{
_directory = directory;
_fileSystem = new FileSystem();
RippleFileSystem.StubCurrentDirectory(directory);
RippleFileSystem.StopTraversingAt(directory);
}
public void TearDown()
{
var fileSystem = new FileSystem();
fileSystem.DeleteDirectory(theCodeDir);
RippleFileSystem.Live();
}
public SolutionScenario(string directory, string cacheDirectory)
{
_directory = directory;
_cacheDirectory = cacheDirectory;
_fileSystem = new FileSystem();
RippleFileSystem.StubCurrentDirectory(_directory);
RippleFileSystem.StopTraversingAt(_directory);
}
public void finding_the_solution_dir_with_do_not_throw_argument_should_not_throw()
{
var nonSolutionDir = theCodeDir.AppendPath("not-a-solution-dir");
fileSystem.CreateDirectory(nonSolutionDir);
RippleFileSystem.StubCurrentDirectory(nonSolutionDir);
RippleFileSystem.FindSolutionDirectory(false).ShouldBeNull();
}
public void SetUp()
{
theScenario = SolutionScenario.Create(scenario =>
{
scenario.Solution("Test");
});
RippleFileSystem.StubCurrentDirectory(theScenario.DirectoryForSolution("Test"));
}
private string writeBatchInstructionsFile(Action <TextWriter> configure)
{
var file = RippleFileSystem.CurrentDirectory().AppendPath(Guid.NewGuid().ToString() + ".txt");
using (var writer = new StreamWriter(file))
{
configure(writer);
}
return(file);
}
private string writeBatchInstructionsFile(Action <TextWriter> configure)
{
var file = RippleFileSystem.CurrentDirectory().AppendPath(RestoreCommand.BatchFile);
using (var writer = new StreamWriter(file))
{
configure(writer);
}
return(file);
}
public SolutionFiles(IFileSystem fileSystem)
{
if (RippleFileSystem.IsSolutionDirectory())
{
resetDirectories(RippleFileSystem.FindSolutionDirectory());
}
_fileSystem = fileSystem;
_findLoader = findLoader;
_loader = new Lazy <ISolutionLoader>(() => _findLoader());
}
public void SetUp()
{
theScenario = SolutionGraphScenario.Create(scenario =>
{
scenario.Solution("Test", test =>
{
test.SolutionDependency("StructureMap", "2.6.3", UpdateMode.Fixed);
test.ProjectDependency("Test", "structuremap");
test.ProjectDependency("Test", "FubuCore");
test.ProjectDependency("Test2", "FubuCore");
});
});
theSolution = theScenario.Find("Test");
FeedScenario.Create(scenario =>
{
scenario.For(Feed.Fubu)
.Add("structuremap", "2.6.4.54")
.Add("FubuCore", "1.0.0.0")
.Add("Bottles", "1.0.0.0")
.Add("FubuMVC.Katana", "1.0.0.1")
.Add("FubuMVC.Core", "1.0.1.1")
.Add("FubuMVC.OwinHost", "1.2.0.0")
.ConfigureRepository(teamcity =>
{
teamcity.ConfigurePackage("FubuMVC.Katana", "1.0.0.1", katana =>
{
katana.DependsOn("FubuMVC.Core");
katana.DependsOn("FubuMVC.OwinHost");
});
teamcity.ConfigurePackage("FubuMVC.OwinHost", "1.2.0.0", owin => owin.DependsOn("FubuMVC.Core"));
});
scenario.For(Feed.NuGetV2)
.Add("structuremap", "2.6.3");
});
RippleFileSystem.StubCurrentDirectory(theScenario.DirectoryForSolution("Test"));
theFile = writeBatchInstructionsFile(writer =>
{
writer.WriteLine("Bottles/1.0.0.0:Test,Test2");
writer.WriteLine("Test: FubuMVC.Katana");
writer.WriteLine("Test2: FubuMVC.Core");
});
RippleOperation
.With(theSolution, resetSolution: true)
.Execute <RestoreInput, RestoreCommand>();
}
public SolutionGraphScenario(string directory, string cacheDirectory)
{
_directory = directory;
_cacheDirectory = cacheDirectory;
_fileSystem = new FileSystem();
var builder = new SolutionGraphBuilder(_fileSystem);
_graph = new Lazy <SolutionGraph>(() => builder.ReadFrom(_directory));
RippleFileSystem.StubCurrentDirectory(_directory);
}
public void SetUp()
{
FeedScenario.Create(scenario =>
{
scenario.For(Feed.Fubu)
.Add("FubuCore", "1.0.0.0")
.Add("Bottles", "1.0.0.0")
.Add("FubuMVC.Katana", "1.0.0.1")
.Add("FubuMVC.Core", "1.0.1.1")
.Add("FubuMVC.OwinHost", "1.2.0.0")
.ConfigureRepository(teamcity =>
{
teamcity.ConfigurePackage("FubuMVC.Katana", "1.0.0.1", katana =>
{
katana.DependsOn("FubuMVC.Core");
katana.DependsOn("FubuMVC.OwinHost");
});
teamcity.ConfigurePackage("FubuMVC.OwinHost", "1.2.0.0", owin => owin.DependsOn("FubuMVC.Core"));
});
});
theScenario = SolutionScenario.Create(scenario =>
{
scenario.Solution("Test", test =>
{
test.ProjectDependency("Test", "FubuCore");
test.ProjectDependency("Test2", "FubuCore");
});
});
theSolution = theScenario.Find("Test");
RippleFileSystem.StubCurrentDirectory(theScenario.DirectoryForSolution("Test"));
theFile = writeBatchInstructionsFile(writer =>
{
writer.WriteLine("Bottles/1.0.0.0:Test,Test2");
writer.WriteLine("Test: FubuMVC.Katana");
writer.WriteLine("Test2: FubuMVC.Core");
});
RippleOperation
.With(theSolution)
.Execute <BatchInstallInput, BatchInstallCommand>(input =>
{
input.FileFlag = theFile;
});
}
public void Should_use_solution_dir_as_base_dir()
{
Assert.True(BranchDetector.CanDetectBranch());
Assert.IsNotEmpty(BranchDetector.Current());
BranchDetector.Live();
//simulate a no git dir
RippleFileSystem.StubCurrentDirectory(Path.GetTempPath());
Assert.False(BranchDetector.CanDetectBranch());
Assert.Throws <RippleFatalError>(() => BranchDetector.Current());
}
public void SetUp()
{
theCodeDir = ".".AppendPath("code");
theSolutionDir = theCodeDir.AppendPath("ripple");
var fileSystem = new FileSystem();
fileSystem.CreateDirectory(theCodeDir);
fileSystem.CreateDirectory(theSolutionDir);
fileSystem.WriteStringToFile(Path.Combine(theSolutionDir, SolutionFiles.ConfigFile), "");
RippleFileSystem.StubCurrentDirectory(theCodeDir);
RippleFileSystem.StopTraversingAt(theCodeDir);
}
public void SetUp()
{
rootDir = Path.GetTempPath().AppendRandomPath();
theCodeDir = rootDir.AppendPath("code");
theSolutionDir = theCodeDir.AppendPath("ripple");
theCurrentDir = theSolutionDir.AppendPath("src", "project1");
fileSystem = new FileSystem();
fileSystem.CreateDirectory(theCodeDir);
fileSystem.CreateDirectory(theSolutionDir);
fileSystem.CreateDirectory(theCurrentDir);
fileSystem.WriteStringToFile(Path.Combine(theSolutionDir, SolutionFiles.ConfigFile), "");
RippleFileSystem.StubCurrentDirectory(theCurrentDir);
}
public override bool Execute(InitInput input)
{
var rippleConfigDirectory = RippleFileSystem.FindSolutionDirectory(false);
if (rippleConfigDirectory.IsNotEmpty())
{
RippleAssert.Fail(ExistingSolution.ToFormat(rippleConfigDirectory));
return(false);
}
var builder = NewSolutionBuilder(input.ToSolution());
var solution = builder.Build();
solution.Save(true);
return(true);
}
public void SetUp()
{
theFileSystem = new FileSystem();
theSolutionDir = Guid.NewGuid().ToString().ToFullPath();
theFileSystem.CreateDirectory(theSolutionDir);
theFileSystem.CreateDirectory(theSolutionDir, "src");
createProject("ProjectA");
createProject("ProjectB");
createProject("ProjectC");
RippleFileSystem.StopTraversingAt(theSolutionDir.ParentDirectory());
RippleFileSystem.StubCurrentDirectory(theSolutionDir);
new InitCommand().Execute(new InitInput {
Name = "Test"
});
}
public bool Matches(IFileSystem fileSystem, string directory)
{
if (!RippleFileSystem.IsSolutionDirectory(directory))
{
return(false);
}
var slnDir = RippleFileSystem.FindSolutionDirectory(directory);
var configFile = Path.Combine(slnDir, SolutionFiles.ConfigFile);
if (!File.Exists(configFile))
{
return(false);
}
using (var stream = File.OpenRead(configFile))
{
return(stream.ReadAllText().Contains("<?xml"));
}
}
public IEnumerable <Solution> FindSolutions()
{
if (SolutionFlag.IsNotEmpty())
{
yield return(_graph.Value[SolutionFlag]);
}
else if (AllFlag || RippleFileSystem.IsCodeDirectory())
{
foreach (var solution in _graph.Value.AllSolutions)
{
yield return(solution);
}
}
else
{
if (RippleFileSystem.IsSolutionDirectory())
{
yield return(SolutionBuilder.ReadFromCurrentDirectory());
}
}
}
public override bool Execute(RestoreInput input)
{
Thread.Sleep(5000);
var operation = RippleOperation
.For(input)
.Step <DownloadMissingNugets>()
.Step <ExplodeDownloadedNugets>()
.Step <ProcessDirectives>();
if (input.FixReferencesFlag)
{
operation.Step <FixReferences>();
}
var success = operation.Execute();
if (!success)
{
return(false);
}
var file = RippleFileSystem.CurrentDirectory().AppendPath(BatchFile);
if (File.Exists(file))
{
success = new BatchInstallCommand().Execute(new BatchInstallInput
{
FileFlag = file
});
}
if (input.FixSolutionFlag && success)
{
return(new FixCommand().Execute(new FixInput()));
}
return(success);
}
public IEnumerable <NugetPlanRequest> Requests(Solution solution)
{
BatchOperation operation;
if (FileFlag.IsNotEmpty())
{
var file = Path.Combine(RippleFileSystem.CurrentDirectory(), FileFlag);
RippleLog.Info("Detected {0}. Reading batch instructions.".ToFormat(FileFlag));
var contents = File.ReadAllText(file);
operation = BatchOperation.Parse(solution, contents);
After = () => File.Delete(file);
}
else
{
operation = readFromCommandLine(solution);
}
return(operation.Requests);
}
