public SolutionExpression(ISolutionGraphScenarioBuilder builder, string name)
{
_fileSystem = new FileSystem();
var solutionDir = Path.Combine(builder.Directory, name);
_fileSystem.CreateDirectory(solutionDir);
var rippleConfig = Path.Combine(solutionDir, SolutionFiles.ConfigFile);
_fileSystem.WriteStringToFile(rippleConfig, "");
var solutionFile = Path.Combine(solutionDir, name + ".sln");
_fileSystem.WriteStringToFile(solutionFile, "");
_solution = new Solution
{
Name = name,
Path = rippleConfig,
Directory = solutionDir,
SourceFolder = Path.Combine(solutionDir, "src"),
NugetSpecFolder = Path.Combine(solutionDir, "packaging", "nuget")
};
_fileSystem.CreateDirectory(_solution.SourceFolder);
builder.AddSolution(_solution);
_builder = builder;
_projects = new Cache <string, Project>(createAndAddProject);
addDefaultProject();
}
private Project createAndAddProject(string name)
{
var projectDir = Path.Combine(_solution.SourceFolder, name);
_fileSystem.CreateDirectory(projectDir);
var stream = typeof(SolutionGraphScenario)
.Assembly
.GetManifestResourceStream("{0}.ProjectTemplate.txt".ToFormat(typeof(SolutionGraphScenario).Namespace));
var projectFile = Path.Combine(projectDir, RippleDependencyStrategy.RippleDependenciesConfig);
_fileSystem.WriteStringToFile(projectFile, "");
var csProjectFile = Path.Combine(projectDir, "{0}.csproj".ToFormat(name));
_fileSystem.WriteStreamToFile(csProjectFile, stream);
var debugDir = Path.Combine(projectDir, "bin", "Debug");
_fileSystem.CreateDirectory(debugDir);
_fileSystem.WriteStringToFile(Path.Combine(debugDir, "{0}.dll".ToFormat(name)), "");
var project = new Project(csProjectFile);
_solution.AddProject(project);
return(project);
}
public void find_the_one_and_only_solution()
{
fileSystem.CreateDirectory("only-one");
fileSystem.WriteStringToFile("only-one".AppendPath("anything.sln"), "whatever");
Environment.CurrentDirectory = Environment.CurrentDirectory.AppendPath("only-one").ToFullPath();
SolutionFinder.FindSolutionFile().ShouldEqual("anything.sln");
}
private Project createAndAddProject(string name)
{
var projectDir = Path.Combine(_solution.SourceFolder, name);
var project = ProjectGenerator.Create(projectDir, name);
var debugDir = Path.Combine(projectDir, "bin", "Debug");
_fileSystem.CreateDirectory(debugDir);
_fileSystem.WriteStringToFile(Path.Combine(debugDir, "{0}.dll".ToFormat(name)), "");
_solution.AddProject(project);
return(project);
}
public void Save(Sln solution)
{
var solutionContents = _fileSystem.ReadStringFromFile(solution.FileName);
var solutionBuilder = new StringBuilder();
var modifiers = new List <ISolutionFileModifier>
{
new AddProjectsModifier(solution),
new AddConfigurationsModifier(solution),
new AppendLineModifier()
};
var lines = SplitSolution(solutionContents);
lines.Each(line =>
{
var filteredModifiers = modifiers.Where(m => m.Matches(line));
foreach (var m in filteredModifiers)
{
if (!m.Modify(line, solutionBuilder))
{
break;
}
}
});
_fileSystem.WriteStringToFile(solution.FileName, solutionBuilder.ToString());
}
public static void WriteLogFile(this IFileSystem fileSystem, string filename, string contents)
{
var logsDirectory = RippleLogsDirectory();
fileSystem.CreateDirectory(logsDirectory);
fileSystem.WriteStringToFile(logsDirectory.AppendPath(filename), contents);
}
public void Write(Solution solution)
{
var writer = ObjectBlockWriter.Basic(new RippleBlockRegistry());
var content = writer.Write(solution);
_fileSystem.WriteStringToFile(solution.Path, content);
}
public bool Initialize(InitializeInput input, IFileSystem fileSystem, ISimpleLogger logger)
{
var deploymentDirectory = input.Settings.DeploymentDirectory;
logger.Log("Trying to initialize Bottles deployment folders at {0}", deploymentDirectory);
if (fileSystem.DirectoryExists(deploymentDirectory))
{
if (input.ForceFlag)
{
logger.Log(DELETING_EXISTING_DIRECTORY, deploymentDirectory);
fileSystem.CleanDirectory(deploymentDirectory);
fileSystem.DeleteDirectory(deploymentDirectory);
Thread.Sleep(10); //file system is async
}
else
{
logger.Log(DIRECTORY_ALREADY_EXISTS, deploymentDirectory);
return(false);
}
}
createDirectory(fileSystem, logger, deploymentDirectory);
Console.WriteLine("Writing blank file to " + input.Settings.BottleManifestFile);
fileSystem.WriteStringToFile(input.Settings.BottleManifestFile, "");
createDirectory(fileSystem, logger, input.Settings.BottlesDirectory);
createDirectory(fileSystem, logger, input.Settings.RecipesDirectory);
createDirectory(fileSystem, logger, input.Settings.EnvironmentsDirectory);
createDirectory(fileSystem, logger, input.Settings.ProfilesDirectory);
return(true);
}
public void AddProject(string slnFile, CsProj project)
{
var solutionContents = _fileSystem.ReadStringFromFile(slnFile);
var replacedContents = new StringBuilder();
var appended = false;
var lines = SplitSolution(solutionContents);
lines.Each(line =>
{
if (line.Equals("Global") && !appended)
{
var projectGuid = "{" + project.ProjectGuid + "}";
var projectType = "Project(\"{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}\")";
replacedContents.AppendLine("{0} = \"{1}\", \"{2}\", \"{3}\"".ToFormat(projectType,
project.Name, project.RelativePath, projectGuid));
replacedContents.AppendLine("EndProject");
appended = true;
}
replacedContents.AppendLine(line);
});
_fileSystem.WriteStringToFile(slnFile, replacedContents.ToString());
}
public void Write(Project project)
{
var dependencies = new StringBuilder();
project.Dependencies.Each(dependency => dependencies.AppendLine(dependency.Name));
_fileSystem.WriteStringToFile(FileFor(project), dependencies.ToString());
}
public static Project Create(string projectDir, string name)
{
FileSystem.CreateDirectory(projectDir);
var stream = typeof(SolutionScenario)
.Assembly
.GetManifestResourceStream("{0}.ProjectTemplate.txt".ToFormat(typeof(SolutionScenario).Namespace));
var projectFile = Path.Combine(projectDir, RippleDependencyStrategy.RippleDependenciesConfig);
FileSystem.WriteStringToFile(projectFile, "");
var csProjectFile = Path.Combine(projectDir, "{0}.csproj".ToFormat(name));
FileSystem.WriteStreamToFile(csProjectFile, stream);
return(new Project(csProjectFile));
}
public Guid WriteVersion(IZipFile zipFile)
{
var versionFile = Path.Combine(Path.GetTempPath(), FubuMvcPackages.VersionFile);
var guid = Guid.NewGuid();
_fileSystem.WriteStringToFile(versionFile, guid.ToString());
zipFile.AddFile(versionFile);
return(guid);
}
public void WriteTo(string recipeName, HostDefinition host, DeploymentSettings settings)
{
var fileName = settings.GetHost(recipeName, host.Name);
host.References.Each(WriteReference);
host.Values.Each(WritePropertyValue);
host.Directives.Each(WriteDirective);
_fileSystem.WriteStringToFile(fileName, ToText());
}
public void SetUp()
{
theSolution = new Solution
{
Directory = "SolutionFiles"
};
theFileSystem = new FileSystem();
theFileSystem.CreateDirectory("SolutionFiles");
theSolutionFiles = new SolutionFiles(theFileSystem, new SolutionLoader());
theSolutionFiles.RootDir = Path.GetTempPath().AppendRandomPath();
theFileSystem.CreateDirectory("SolutionFiles", "src");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project1");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project2");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project1", "Project1.csproj"), "test");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project2", "Project2.csproj"), "test");
}
public void SetUp()
{
theSolution = new Solution
{
Directory = "SolutionFiles"
};
theFileSystem = new FileSystem();
theFileSystem.CreateDirectory("SolutionFiles");
theSolutionFiles = new SolutionFiles(theFileSystem, new SolutionLoader());
theSolutionFiles.RootDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SolutionFiles");
theFileSystem.CreateDirectory("SolutionFiles", "src");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project1");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project2");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project1", "Project1.csproj"), "test");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project2", "Project2.csproj"), "test");
}
public void Export(string owner, string repository)
{
Console.WriteLine("Starting to export {0}/{1}", owner, repository);
var history = _client.GetHistory(owner, repository);
var json = _serializer.ToJson(history);
var file = repository.ToLower() + ".json";
var path = _exportPath.AppendPath(file);
Console.WriteLine("Writing json data to " + path);
_fileSystem.WriteStringToFile(path, json);
}
public AssetFile AddFile(string name)
{
var file = new AssetFile(name)
{
FullPath = name + ".txt"
};
_system.WriteStringToFile(file.FullPath, Guid.NewGuid().ToString());
_files[name] = file;
return(file);
}
public void Extract()
{
_fileSystem.DeleteFile(PathToDriver);
_fileSystem.DeleteFile(PathToVersionDeclarationFile);
var type = GetType();
using (var driverStream = type.Assembly.GetManifestResourceStream(type, _embeddedDriver.ResourceName))
{
_fileSystem.WriteStreamToFile(PathToDriver, driverStream);
_fileSystem.WriteStringToFile(PathToVersionDeclarationFile, _embeddedDriver.Version.ToString());
}
}
public void SetUp()
{
theSolution = new Solution
{
Directory = "SolutionFiles"
};
theFileSystem = new FileSystem();
theFileSystem.CreateDirectory("SolutionFiles");
theSolutionFiles = new SolutionFiles(theFileSystem, new SolutionLoader());
theSolutionFiles.RootDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SolutionFiles");
theFileSystem.CreateDirectory("SolutionFiles", "src");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project1");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project2");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project1", "Project1.csproj"), "test");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project2", "Project2.csproj"), "test");
}
public void SetUp()
{
theSolution = new Solution
{
Directory = "SolutionFiles"
};
theFileSystem = new FileSystem();
theFileSystem.CreateDirectory("SolutionFiles");
theSolutionFiles = new SolutionFiles(theFileSystem);
theSolutionFiles.RootDir = Path.GetTempPath().AppendRandomPath();
theFileSystem.CreateDirectory("SolutionFiles", "src");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project1");
theFileSystem.CreateDirectory("SolutionFiles", "src", "Project2");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project1", "Project1.csproj"), "test");
theFileSystem.WriteStringToFile(Path.Combine("SolutionFiles", "src", "Project2", "Project2.csproj"), "test");
}
public void read_a_directory()
{
var imports = new StringBuilder();
imports.AppendLine("import from Pak2.Design, Pak2.Bindings");
imports.AppendLine("import from Pak1");
var exports = new StringBuilder();
exports.AppendLine("export to all");
_fileSystem.WriteStringToFile("imports.spark.config", imports.ToString());
_fileSystem.WriteStringToFile("exports.spark.config", exports.ToString());
_activator.ReadSparkConfig("Pak2.Core", ".", _packageLog);
_graph.CompileDependencies("Pak1", "Pak2.Core", "Pak2.Design", "Pak2.Bindings");
_graph.SharingsFor("Pak1").ShouldHaveTheSameElementsAs("Pak2.Core");
_graph.SharingsFor("Pak2.Core").ShouldHaveTheSameElementsAs("Pak2.Design", "Pak2.Bindings", "Pak1");
_graph.SharingsFor("Pak2.Design").ShouldHaveTheSameElementsAs("Pak2.Core");
_graph.SharingsFor("Pak2.Bindings").ShouldHaveTheSameElementsAs("Pak2.Core");
}
public void CreateRunner(string file, string alias)
{
var text = "{0} %*".ToFormat(_current.AppendPath(file));
var runnerName = alias + ".cmd";
if (Platform.IsUnix())
{
runnerName = alias + ".sh";
text = "ln -s #!/bin/sh {0} $*".ToFormat(file);
}
var runnerFile = _solution.Directory.AppendPath(runnerName);
_fileSystem.WriteStringToFile(runnerFile, text);
_solution.IgnoreFile(runnerName);
Console.WriteLine("Writing file to " + runnerFile);
}
public void ParseFile(string file)
{
var fileContent = _fileSystem.ReadStringFromFile(file);
var replacedFileContent = _keywordReplacer.Replace(fileContent);
if (fileContent != replacedFileContent)
{
_fileSystem.WriteStringToFile(file, replacedFileContent);
}
var newFileName = _keywordReplacer.Replace(file);
if (file != newFileName)
{
Console.WriteLine("{0} -> {1}", file, Path.GetFileName(newFileName));
_fileSystem.MoveFile(file, newFileName);
}
}
public void Execute(FubuWebsite directive, HostManifest host, IPackageLog log)
{
if (_settings.UserForced)
{
log.Trace("UserForced: deleting directories");
_fileSystem.DeleteDirectory(directive.WebsitePhysicalPath);
_fileSystem.DeleteDirectory(directive.VDirPhysicalPath);
}
_fileSystem.CreateDirectory(directive.WebsitePhysicalPath);
_fileSystem.CreateDirectory(directive.VDirPhysicalPath);
var appOfflineFile = FileSystem.Combine(directive.VDirPhysicalPath, "app_offline.htm");
log.Trace("Applying the application offline file");
_fileSystem.WriteStringToFile(appOfflineFile, "<html><body>Application is being rebuilt</body></html>");
}
void CompileStaticFiles(IEnumerable <StaticFile> staticFiles, Site site)
{
foreach (StaticFile staticFile in staticFiles)
{
ExecuteFilters(staticFile, site);
ExecuteLayoutFilter(staticFile, site);
if (staticFile.Item.IsBinary)
{
fileSystem.Copy(staticFile.Item.Meta["filename"].ToString(), staticFile.Path);
}
else
{
fileSystem.WriteStringToFile(staticFile.Path, staticFile.GetLastSnapShot());
}
log.InfoMessage("\tcreate {0}", staticFile.Path);
}
}
private void createFile(params string[] parts)
{
var path = theDirectory.AppendPath(parts);
theFileSystem.WriteStringToFile(path, "");
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
fileSystem.CreateDirectory(_directory);
fileSystem.WriteStringToFile(_directory.AppendPath("activate.txt"), DateTime.UtcNow.ToString());
}
public SolutionExpression(ISolutionGraphScenarioBuilder builder, string name)
{
_fileSystem = new FileSystem();
var solutionDir = Path.Combine(builder.Directory, name);
_fileSystem.CreateDirectory(solutionDir);
var solutionFile = Path.Combine(solutionDir, SolutionFiles.ConfigFile);
_fileSystem.WriteStringToFile(solutionFile, "");
_solution = new Solution
{
Name = name,
Path = solutionFile
};
_solution.Directory = solutionDir;
_solution.SourceFolder = Path.Combine(solutionDir, "src");
_solution.NugetSpecFolder = Path.Combine(solutionDir, "packaging", "nuget");
_fileSystem.CreateDirectory(_solution.SourceFolder);
builder.AddSolution(_solution);
_builder = builder;
_projects = new Cache<string, Project>(createAndAddProject);
addDefaultProject();
}
private void writeFile(string name)
{
var file = currentDirectory.AppendPath(name.Replace('/', Path.DirectorySeparatorChar));
fileSystem.WriteStringToFile(file, "something");
}
public void CreateFile(params string[] parts)
{
var file = _directory.AppendPath(parts);
_fileSystem.WriteStringToFile(file, "");
}
private void withFixtureFile(string fixtureKey, string contents)
{
var file = fixtureFolder.AppendPath(fixtureKey + ".md");
_fileSystem.WriteStringToFile(file, contents);
}
public void AddCachedNuget(string id, string version)
{
var fileName = "{0}.{1}.nupkg".ToFormat(id, version);
_fileSystem.WriteStringToFile(Path.Combine(cacheDirectory, fileName), fileName);
}
