protected override void beforeEach()
{
theBaseFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "folder1");
theBinFolder = Path.Combine(theBaseFolder, "bin");
theManifest = new PackageManifest
{
ContentFileSet = new FileSet(),
Assemblies = new[] { "A", "B", "C" },
NativeAssemblies = new[] { "D", "E" }
};
theInput = new CreateBottleInput {
PackageFolder = theBaseFolder
};
theAssemblyFiles = new AssemblyFiles
{
Files = new[] { "a.dll", "b.dll", "d.dll" },
MissingAssemblies = new[] { "c", "e" },
PdbFiles = new[] { "a.pdb", "b.pdb", "c.pdb" }
};
MockFor <IAssemblyFileFinder>()
.Stub(x => x.FindAssemblies(theBinFolder, theManifest.AllAssemblies))
.Return(theAssemblyFiles);
ClassUnderTest.CreatePackage(theInput, theManifest);
}
protected override void beforeEach()
{
theBaseFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "folder1");
theBinFolder = Path.Combine(theBaseFolder, "bin");
theManifest = new PackageManifest {
DataFileSet = new FileSet(),
ContentFileSet = new FileSet()
};
theManifest.AddAssembly("A");
theManifest.AddAssembly("B");
theManifest.AddAssembly("C");
theInput = new CreatePackageInput()
{
PackageFolder = theBaseFolder
};
theAssemblyFiles = new AssemblyFiles()
{
Files = new string[] { "a.dll", "b.dll" },
MissingAssemblies = new string[] { "c" },
PdbFiles = new string[] { "a.dll", "b.dll", "c.dll" },
Success = false
};
MockFor <IAssemblyFileFinder>()
.Stub(x => x.FindAssemblies(theBinFolder, theManifest.Assemblies))
.Return(theAssemblyFiles);
ClassUnderTest.CreatePackage(theInput, theManifest);
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreateBottleInput input, string binFolder)
{
var log = _log.LogFor(manifest);
var sb = new StringBuilder();
sb.AppendFormat("Did not locate all designated assemblies at '{0}'", binFolder.ToFullPath());
sb.AppendLine();
sb.AppendLine("Looking for these assemblies in the package manifest file:");
manifest.Assemblies.Each(name => sb.AppendLine(" " + name));
sb.AppendLine("But only found:");
if (!theAssemblyFiles.Files.Any())
{
sb.AppendLine(" Found no files");
}
theAssemblyFiles.Files.Each(file => sb.AppendLine(" " + file));
sb.AppendLine("Missing");
theAssemblyFiles.MissingAssemblies.Each(file => sb.AppendLine(" " + file));
log.MarkFailure(sb.ToString());
}
private void writeZipFile(CreateBottleInput input, PackageManifest manifest, AssemblyFiles assemblies)
{
var zipFileName = input.GetZipFileName(manifest);
if (_fileSystem.FileExists(zipFileName))
{
LogWriter.Current.Highlight(" Deleting existing file at " + zipFileName);
_fileSystem.DeleteFile(zipFileName);
}
_zipFileService.CreateZipFile(zipFileName, zipFile =>
{
assemblies.Files.Each(file =>
{
zipFile.AddFile(file, "bin");
});
if (input.PdbFlag)
{
assemblies.PdbFiles.Each(file =>
{
zipFile.AddFile(file, "bin");
});
}
WriteVersion(zipFile);
zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), "");
// TODO -- there's an opportunity to generalize this
AddDataFiles(input, zipFile, manifest);
AddContentFiles(input, zipFile, manifest);
AddConfigFiles(input, zipFile, manifest);
});
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreatePackageInput input)
{
Console.WriteLine("Did not locate all designated assemblies at {0}", input.PackageFolder);
Console.WriteLine("Looking for these assemblies in the package manifest file:");
manifest.AssemblyNames.Each(name => Console.WriteLine(" " + name));
Console.WriteLine("But only found");
theAssemblyFiles.Files.Each(file => Console.WriteLine(" " + file));
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreatePackageInput input)
{
Console.WriteLine("Did not locate all designated assemblies at {0}", input.PackageFolder);
Console.WriteLine("Looking for these assemblies in the package manifest file:");
manifest.AssemblyNames.Each(name => Console.WriteLine(" " + name));
Console.WriteLine("But only found");
theAssemblyFiles.Files.Each(file => Console.WriteLine(" " + file));
}
protected override void beforeEach()
{
theBaseFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "folder1");
theBinFolder = Path.Combine(theBaseFolder, "bin");
theManifest = new PackageManifest
{
DataFileSet = new FileSet(),
ContentFileSet = new FileSet()
};
theManifest.AddAssembly("A");
theManifest.AddAssembly("B");
theManifest.AddAssembly("C");
theInput = new CreatePackageInput()
{
PackageFolder = theBaseFolder,
ZipFile = Path.Combine(theBaseFolder, "package1.zip"),
PdbFlag = true
};
theAssemblyFiles = new AssemblyFiles()
{
Files = new string[] {
FileSystem.Combine(theBinFolder, "a.dll"),
FileSystem.Combine(theBinFolder, "b.dll"),
FileSystem.Combine(theBinFolder, "c.dll")
},
MissingAssemblies = new string[0],
PdbFiles = new string[] {
FileSystem.Combine(theBinFolder, "a.pdb"),
FileSystem.Combine(theBinFolder, "b.pdb"),
FileSystem.Combine(theBinFolder, "c.pdb")
},
Success = true
};
MockFor <IAssemblyFileFinder>()
.Stub(x => x.FindAssemblies(theBinFolder, theManifest.Assemblies))
.Return(theAssemblyFiles);
_theZipFileService = new StubZipFileService();
Services.Inject <IZipFileService>(_theZipFileService);
thePackageManifestFileName = FileSystem.Combine(theBaseFolder, PackageManifest.FILE);
ClassUnderTest.CreatePackage(theInput, theManifest);
}
public void Initialize(string[] args)
{
parser.Parse(args);
if (showUsage)
{
throw new OperationCanceledException();
}
if (!AssemblyFiles.Any())
{
throw new OptionException("No assembly file is specified", null);
}
if (!OutputFormats.Any())
{
throw new OptionException("No document format is specified", null);
}
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreateBottleInput input, string binFolder)
{
ConsoleWriter.Write("Did not locate all designated assemblies at '{0}'", binFolder);
ConsoleWriter.Write("Looking for these assemblies in the package manifest file:");
manifest.Assemblies.Each(name => ConsoleWriter.Write(" " + name));
ConsoleWriter.Write("But only found:");
if (!theAssemblyFiles.Files.Any())
{
ConsoleWriter.Write(" Found no files");
}
theAssemblyFiles.Files.Each(file => ConsoleWriter.Write(" " + file));
ConsoleWriter.Write("Missing");
theAssemblyFiles.MissingAssemblies.Each(file => ConsoleWriter.Write(" " + file));
throw new ApplicationException("Invalid package manifest or missing files");
}
public CommandLineOptions()
{
parser = new OptionSet
{
"Usage: dg [OPTIONS] <path-to-assembly>+",
"",
"Options:",
{ "m|markdown", "Generates documents in markdown (default)", md => Markdown.Enabled = (md != null) },
{ "x|html", "Generates documents in HTML", html => Html.Enabled = (html != null) },
{ "s|style=", "Custom stylesheet URL of HTML documents", style => Html.Stylesheet = style },
{ "i|index=", "Index document name (default _toc.<assembly>)", index => IndexName = index },
{ "d|outdir=", "Base output directory (default cwd)", folder => OutputFolder = Path.GetFullPath(folder) },
{ "f|flat", "All formats in one folder (default off)", flat => FlattenFolder = (flat != null) },
{ "h|help", "Shows this message and exits", help => showUsage = (help != null) },
{ "<>", "Path to assembly file", assembly => AssemblyFiles.Add(Path.GetFullPath(assembly)) },
};
}
private void writeZipFile(CreatePackageInput input, PackageManifest manifest, AssemblyFiles assemblies)
{
_zipFileService.CreateZipFile(input.ZipFile, zipFile =>
{
assemblies.Files.Each(file =>
{
zipFile.AddFile(file, "bin");
});
if (input.PdbFlag)
{
assemblies.PdbFiles.Each(file =>
{
zipFile.AddFile(file, "bin");
});
}
WriteVersion(zipFile);
zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), "");
AddDataFiles(input, zipFile, manifest);
AddContentFiles(input, zipFile, manifest);
});
}
/// <summary>
/// Ensures the configuration of CarnaRunner with the specified <see cref="IAssemblyLoader"/>.
/// </summary>
/// <param name="loader">The loader of an assembly.</param>
/// <returns>The instance of the <see cref="CarnaRunnerConfiguration"/>.</returns>
public CarnaRunnerConfiguration Ensure(IAssemblyLoader loader)
{
Assemblies = AssemblyFiles?.Select(loader.Load).ToList();
Filter?.Ensure();
return(this);
}
public Packer Create(AssemblyFiles assemblyFiles)
{
return(new Packer(assemblyFiles, _filesystemAbstraction));
}
private void writeZipFile(CreatePackageInput input, PackageManifest manifest, AssemblyFiles assemblies)
{
_zipFileService.CreateZipFile(input.GetZipFileName(manifest), zipFile =>
{
assemblies.Files.Each(file =>
{
zipFile.AddFile(file, "bin");
});
if (input.PdbFlag)
{
assemblies.PdbFiles.Each(file =>
{
zipFile.AddFile(file, "bin");
});
}
WriteVersion(zipFile);
zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), "");
// TODO -- there's an opportunity to generalize this
AddDataFiles(input, zipFile, manifest);
AddContentFiles(input, zipFile, manifest);
AddConfigFiles(input, zipFile, manifest);
});
}
