public bool BuildPackage(IEnumerable <ProjectContext> contexts, List <DiagnosticMessage> packDiagnostics)
{
Reporter.Output.WriteLine($"Producing nuget package \"{GetPackageName()}\" for {Project.Name}");
PackageBuilder = CreatePackageBuilder(Project);
// TODO: Report errors for required fields
// id
// author
// description
foreach (var context in contexts)
{
Reporter.Verbose.WriteLine($"Processing {context.TargetFramework.ToString().Yellow()}");
ProcessContext(context);
Reporter.Verbose.WriteLine("");
}
var packageOutputPath = Path.Combine(
ArtifactPathsCalculator.PackageOutputPath,
GetPackageName() + NuGet.Constants.PackageExtension);
if (GeneratePackage(packageOutputPath, packDiagnostics))
{
return(true);
}
return(false);
}
/// <summary>
/// Compiles a single .nuspec file
/// </summary>
/// <param name="specItem">
/// The .nuspec file to compile
/// </param>
private void BuildPackage(ITaskItem specItem)
{
// load the package manifest (nuspec) from the task item
// using the nuget package builder
var specPath = specItem.GetMetadata("FullPath");
var builder = new NuGet.PackageBuilder(
specPath,
this as NuGet.IPropertyProvider,
true
);
// initialize dynamic manifest properties
var version = specItem.GetMetadata("NuPackageVersion");
if (!String.IsNullOrEmpty(version))
{
builder.Version = new NuGet.SemanticVersion(version);
}
// add a new file to the folder for each project
// referenced by the current project
AddLibraries(builder);
// write the configured package out to disk
var pkgPath = specItem.GetMetadata("NuPackagePath");
using (var pkgFile = File.Create(pkgPath))
builder.Save(pkgFile);
}
public static Response Pack(NuGetPackRequest request)
{
var console = new Console();
PackageBuilder builder = new PackageBuilder();
var command = new PackCommand
{
BasePath = PathTools.OptimizePath(request.BaseDirectory),
OutputDirectory = PathTools.OptimizePath(request.OutputDirectory),
Version = request.Version,
Console = console,
Verbosity = Verbosity.Detailed,
Rules = new IPackageRule[0],
};
command.Arguments.Add(request.SpecPath);
try
{
command.Execute();
}
catch (Exception e)
{
console.WriteError(e);
}
return new Response(console.Messages);
}
public static void SavePackage(IPackageMetadata packageMetadata, IEnumerable<IPackageFile> files, string targetFilePath, bool useTempFile)
{
var builder = new PackageBuilder();
// set metadata
CopyMetadata(packageMetadata, builder);
// add files
builder.Files.AddRange(files);
// create package in the temprary file first in case the operation fails which would
// override existing file with a 0-byte file.
string fileNameToUse = useTempFile ? Path.GetTempFileName() : targetFilePath;
try {
using (Stream stream = File.Create(fileNameToUse)) {
builder.Save(stream);
}
if (useTempFile) {
File.Copy(fileNameToUse, targetFilePath, true);
}
}
finally {
try {
if (useTempFile && File.Exists(fileNameToUse)) {
File.Delete(fileNameToUse);
}
}
catch {
// don't care if this fails
}
}
}
/// <summary>
/// Go through each referenced project, and add any nuget dependencies from
/// their packages.config file. Ignores any that have developerDependency=true
/// </summary>
/// <param name="builder"></param>
private void AddDependencies(NuGet.PackageBuilder builder)
{
Dictionary <string, string> NugetPackages = new Dictionary <string, string>();
string projectRoot = Path.GetDirectoryName(this.ProjectPath);
XElement root = XElement.Load(this.ProjectPath);
var ns = root.Name.Namespace;
var elems = (from el in root.Descendants(ns + "ProjectReference")
select el).ToList();
if (elems.Any())
{
foreach (var item in elems)
{
string itemPath = item.Attribute("Include").Value;
string packagesPath = Path.GetFullPath(Path.Combine(projectRoot, Path.GetDirectoryName(itemPath))) + Path.DirectorySeparatorChar + PACKAGES_CONFIG;
GetNuGetDependencies(packagesPath, NugetPackages);
}
}
if (NugetPackages.Any())
{
AddNugetDependencies(builder, NugetPackages);
}
}
/// <summary>
/// Creates a test package. - Take from NuGet.Core.Tests
/// </summary>
/// <param name="packageId">The id of the created package.</param>
/// <param name="version">The version of the created package.</param>
/// <param name="path">The directory where the package is created.</param>
/// <returns>The full path of the created package file.</returns>
public static string CreateTestPackage(string packageId, string version, string path, Uri licenseUrl = null)
{
var packageBuilder = new PackageBuilder
{
Id = packageId,
Version = new SemanticVersion(version)
};
packageBuilder.Description = string.Format(
CultureInfo.InvariantCulture,
"desc of {0} {1}",
packageId, version);
if (licenseUrl != null)
{
packageBuilder.LicenseUrl = licenseUrl;
}
packageBuilder.Files.Add(CreatePackageFile(@"content\test1.txt"));
packageBuilder.Authors.Add("test author");
var packageFileName = string.Format("{0}.{1}.nupkg", packageId, version);
var packageFileFullPath = Path.Combine(path, packageFileName);
using (var fileStream = File.Create(packageFileFullPath))
{
packageBuilder.Save(fileStream);
}
return packageFileFullPath;
}
/// <summary>
/// Adds framework assembly and package dependencies to the package
/// </summary>
/// <param name="builder">
/// The current package builder
/// </param>
private void AddDependencies(NuGet.PackageBuilder builder)
{
var dependencyManager = new DependencyManager(TargetFrameworkMoniker, AddBinariesToSubfolder, LimitMajorVersionOfDependencies, Log);
dependencyManager.CalculateMinimalSet(this.ReferenceProjects, this.ReferenceLibraries, builder);
foreach (var fr in dependencyManager.FrameworkReferences)
{
if (builder.FrameworkReferences.Any(_fr => string.Compare(_fr.AssemblyName, fr.AssemblyName, true) == 0))
{
Log.LogWarning("Same frameworkAssembly reference ({0}) found in .nuspec and in referenced projects, frameworkAssembly reference from the referenced project is skipped!", fr.AssemblyName);
}
else
{
builder.FrameworkReferences.Add(fr);
}
}
foreach (var pds in dependencyManager.DependencySets)
{
if (pds.TargetFramework != null && builder.DependencySets.Any(_pds => _pds.TargetFramework == null && _pds.Dependencies.Any(_ds => pds.Dependencies.Any(ds => string.Compare(_ds.Id, ds.Id, true) == 0))))
{
Log.LogWarning("Same dependency reference found in .nuspec (without targetFramework) and in referenced projects (with targetFrameWork), dependency reference from the referenced project is skipped!");
}
else if (pds.TargetFramework == null && builder.DependencySets.Any(_pds => _pds.TargetFramework != null && _pds.Dependencies.Any(_ds => pds.Dependencies.Any(ds => string.Compare(_ds.Id, ds.Id, true) == 0))))
{
Log.LogWarning("Same dependency reference found in .nuspec (with targetFramework) and in referenced projects (without targetFrameWork), dependency reference from the referenced project is skipped!");
}
else
{
builder.DependencySets.Add(pds);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Create NuGet Package via Code");
ManifestMetadata metadata = new ManifestMetadata()
{
Authors = "Authors Name",
Version = "1.0.0.0",
Id = "NuGetId",
Description = "NuGet Package Description goes here!",
};
PackageBuilder builder = new PackageBuilder();
var path = AppDomain.CurrentDomain.BaseDirectory + "..\\..\\DemoContent\\";
builder.PopulateFiles(path, new[] { new ManifestFile { Source = "**", Target = "content" } });
builder.Populate(metadata);
using (FileStream stream = File.Open("test.nupkg", FileMode.OpenOrCreate))
{
builder.Save(stream);
}
Console.WriteLine("... and extract NuGet Package via Code");
NuGet.ZipPackage package = new ZipPackage("test.nupkg");
var content = package.GetContentFiles();
Console.WriteLine("Package Id: " + package.Id);
Console.WriteLine("Content-Files-Count: " + content.Count());
Console.ReadLine();
}
public void AddLibs(PackageBuilder packageBuilder, string pattern, bool recursiveSearch)
{
// Look for .dll,.xml files in top directory
var searchOption = SearchOption.TopDirectoryOnly;
if (recursiveSearch)
{
//for .resources.dll, search all directories
searchOption = SearchOption.AllDirectories;
}
// Add everything in the output folder to the lib path
foreach (var path in Directory.EnumerateFiles(_outputPath, pattern, searchOption))
{
var targetPath = Path.Combine("lib", _targetFrameworkFolder, Path.GetFileName(path));
if (!Path.GetDirectoryName(path).Equals(_outputPath))
{
string folderName = PathUtility.GetDirectoryName(Path.GetDirectoryName(path));
targetPath = Path.Combine("lib", _targetFrameworkFolder, folderName, Path.GetFileName(path));
}
packageBuilder.Files.Add(new PhysicalPackageFile
{
SourcePath = path,
TargetPath = targetPath
});
}
}
public void BuildNuGetPackage(NuGetPackSpecification packConfiguration)
{
var packageBuilder = new PackageBuilder(packConfiguration.NuSpec, NullPropertyProvider.Instance, true);
var packagePath = Path.Combine(packConfiguration.OutputDirectory, GetDefaultPackagePath(packageBuilder));
var packageStream = File.Create(packagePath);
packageBuilder.Save(packageStream);
}
public static Manifest Create(PackageBuilder copy)
{
var metadata = new ManifestMetadata();
metadata.Id = copy.Id?.Trim();
metadata.Version = copy.Version;
metadata.Title = copy.Title?.Trim();
metadata.Authors = copy.Authors.Distinct();
metadata.Owners = copy.Owners.Distinct();
metadata.Tags = string.Join(",", copy.Tags).Trim();
metadata.LicenseUrl = copy.LicenseUrl;
metadata.ProjectUrl = copy.ProjectUrl;
metadata.IconUrl = copy.IconUrl;
metadata.RequireLicenseAcceptance = copy.RequireLicenseAcceptance;
metadata.Description = copy.Description?.Trim();
metadata.Copyright = copy.Copyright?.Trim();
metadata.Summary = copy.Summary?.Trim();
metadata.ReleaseNotes = copy.ReleaseNotes?.Trim();
metadata.Language = copy.Language?.Trim();
metadata.DependencySets = copy.DependencySets;
metadata.FrameworkAssemblies = copy.FrameworkAssemblies;
metadata.PackageAssemblyReferences = copy.PackageAssemblyReferences;
metadata.MinClientVersionString = copy.MinClientVersion?.ToString();
return new Manifest(metadata);
}
protected virtual void CreateNugetPackage([Diagnostics.NotNull] string tempDirectory, [Diagnostics.NotNull] string fileName, [Diagnostics.NotNull] string sourceFileName)
{
var packageId = Path.GetFileNameWithoutExtension(fileName);
var sb = new StringBuilder();
sb.AppendLine("<?xml version=\"1.0\"?>");
sb.AppendLine("<package xmlns=\"http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd\">");
sb.AppendLine(" <metadata>");
sb.AppendLine(" <id>" + packageId + "</id>");
sb.AppendLine(" <title>" + packageId + "</title>");
sb.AppendLine(" <version>1.0.0</version>");
sb.AppendLine(" <authors>Sitecore Pathfinder</authors>");
sb.AppendLine(" <requireLicenseAcceptance>false</requireLicenseAcceptance>");
sb.AppendLine(" <description>Generated by Sitecore Pathfinder</description>");
sb.AppendLine(" </metadata>");
sb.AppendLine(" <files>");
sb.AppendLine(" <file src=\"" + sourceFileName + "\" target=\"content\\sitecore.project\\exports.xml\" />");
sb.AppendLine(" </files>");
sb.AppendLine("</package>");
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString())))
{
var packageBuilder = new PackageBuilder(stream, tempDirectory);
using (var nupkg = new FileStream(fileName, FileMode.Create))
{
packageBuilder.Save(nupkg);
}
}
}
private void AddFileOptionally(NuGet.PackageBuilder builder, String tgtFolder, String filePath)
{
if (File.Exists(filePath))
{
AddFile(builder, tgtFolder, filePath);
}
}
public bool BuildPackage(IEnumerable<ProjectContext> contexts, List<DiagnosticMessage> packDiagnostics)
{
Reporter.Output.WriteLine($"Producing nuget package \"{GetPackageName()}\" for {Project.Name}");
PackageBuilder = CreatePackageBuilder(Project);
// TODO: Report errors for required fields
// id
// author
// description
foreach (var context in contexts)
{
Reporter.Verbose.WriteLine($"Processing {context.TargetFramework.ToString().Yellow()}");
ProcessContext(context);
Reporter.Verbose.WriteLine("");
}
var packageOutputPath = Path.Combine(
ArtifactPathsCalculator.PackageOutputPath,
Configuration,
GetPackageName() + NuGet.Constants.PackageExtension);
if (GeneratePackage(packageOutputPath, packDiagnostics))
{
return true;
}
return false;
}
public static IPackage BuildPackage(IPackageMetadata metadata, IEnumerable<IPackageFile> files)
{
var builder = new PackageBuilder();
CopyMetadata(metadata, builder);
builder.Files.AddRange(files);
return builder.Build();
}
/// <summary>
/// Compiles a single .nuspec file
/// </summary>
/// <param name="specItem">
/// The .nuspec file to compile
/// </param>
private void BuildPackage(ITaskItem specItem)
{
// load the package manifest (nuspec) from the task item
// using the nuget package builder
var specPath = specItem.GetMetadata("FullPath");
var builder = new NuGet.PackageBuilder(
specPath,
this as NuGet.IPropertyProvider,
true
);
// initialize dynamic manifest properties
version = specItem.GetMetadata("NuPackageVersion");
if (!String.IsNullOrEmpty(version))
{
builder.Version = new NuGet.SemanticVersion(version);
}
// add required frameworkAssemblies and dependencies based on each project
// referenced by the current project
if (AutoGenerateDependencies)
{
AddDependencies(builder);
}
// add a new file to the lib/tools/content folder for each project
// referenced by the current project
AddLibraries(builder);
// add a new file to the tools/content folder for each project
// specified as embedded resource by the current project
AddEmbedded(builder);
// write the configured package out to disk
var pkgPath = specItem.GetMetadata("NuPackagePath");
using (var pkgFile = File.Create(pkgPath))
builder.Save(pkgFile);
}
public IPackage CreatePackage(
string packageId,
string packageVersion,
string contentFilePath,
License requiresLicenseAccept,
params IPackage[] dependencies)
{
PackageBuilder builder = new PackageBuilder();
ManifestMetadata metadata = new ManifestMetadata()
{
Authors = "dummy author",
Version = new SemanticVersion(packageVersion).ToString(),
Id = packageId,
Description = "dummy description",
LicenseUrl = "http://choosealicense.com/",
RequireLicenseAcceptance = (requiresLicenseAccept == License.Required)
};
List<ManifestDependency> dependencyList = new List<ManifestDependency>();
foreach (IPackage dependencyNode in dependencies)
{
dependencyList.Add(new ManifestDependency()
{
Id = dependencyNode.Id,
Version = dependencyNode.Version.ToString(),
});
}
List<ManifestDependencySet> dependencySetList = new List<ManifestDependencySet>()
{
new ManifestDependencySet()
{
Dependencies = dependencyList
}
};
metadata.DependencySets = dependencySetList;
builder.Populate(metadata);
PhysicalPackageFile file = new PhysicalPackageFile();
file.SourcePath = contentFilePath;
file.TargetPath = Path.GetFileName(contentFilePath);
builder.Files.Add(file);
string fileName = packageId + "." + metadata.Version + ".nupkg";
string destinationName = Path.Combine(this.manager.LocalRepository.Source, fileName);
using (Stream fileStream = File.Open(destinationName, FileMode.OpenOrCreate))
{
builder.Save(fileStream);
}
// Retrieve and return the newly-created package
IPackage package = this.fakeRemoteRepo.FindPackage(packageId, new SemanticVersion(packageVersion));
Assert.IsNotNull(package, "Test setup error: failed to create and retrieve a test package");
return package;
}
public void ParametersOverrideModuleSpecFile()
{
// Arrange
Mock<ExportModuleCommand> mockCmd = new Mock<ExportModuleCommand>() { CallBase = true };
mockCmd.Object.Description = "Override";
mockCmd.Object.PackageId = "Override";
mockCmd.Object.Version = new SemanticVersion(2, 0, 0, 0);
mockCmd.Object.Authors = new string[] { "Over", "Ride" };
mockCmd.Object.Copyright = "Override";
mockCmd.Object.IconUrl = "http://over.ride";
mockCmd.Object.Language = "ovr-RIDE";
mockCmd.Object.LicenseUrl = "http://over.ride";
mockCmd.Object.Owners = new string[] { "Over", "Ride" };
mockCmd.Object.ProjectUrl = "http://over.ride";
mockCmd.Object.ReleaseNotes = "Override";
mockCmd.Object.RequireLicenseAcceptance = SwitchParameter.Present;
mockCmd.Object.Summary = "Override";
mockCmd.Object.Tags = new string[] { "Over", "Ride" };
mockCmd.Object.Title = "Override";
PackageBuilder expected = new PackageBuilder()
{
Id = "Original",
Description = "Original",
Version = new SemanticVersion(1, 0, 0, 0)
};
Mock<IFileSystem> mockFs = new Mock<IFileSystem>();
mockFs.Setup(fs => fs.FileExists("Original.nuspec")).Returns(true);
mockFs.Setup(fs => fs.GetAllFiles()).Returns(new string[0]);
mockFs.Setup(fs => fs.OpenFile(It.IsAny<string>())).Returns(Stream.Null);
mockCmd.Setup(c => c.OpenManifest(@"D:\Foo", Stream.Null)).Returns(expected);
IModuleMetadata module = new SimpleModuleMetadata("Original", new Version(1, 0, 0, 0))
{
ModuleBase = @"D:\Foo"
};
// Act
PackageBuilder actual = mockCmd.Object.BuildManifest(module, mockFs.Object);
// Assert
Assert.Equal("Override", actual.Description);
Assert.Equal("Override", actual.Id);
Assert.Equal(new SemanticVersion(2, 0, 0, 0), actual.Version);
Assert.Equal(new string[] { "Over", "Ride" }, actual.Authors.ToArray());
Assert.Equal("Override", actual.Copyright);
Assert.Equal("http://over.ride/", actual.IconUrl.ToString());
Assert.Equal("ovr-RIDE", actual.Language);
Assert.Equal("http://over.ride/", actual.LicenseUrl.ToString());
Assert.Equal(new string[] { "Over", "Ride" }, actual.Owners.ToArray());
Assert.Equal("http://over.ride/", actual.ProjectUrl.ToString());
Assert.Equal("Override", actual.ReleaseNotes);
Assert.True(actual.RequireLicenseAcceptance);
Assert.Equal("Override", actual.Summary);
Assert.Equal(new string[] { "Over", "Ride" }, actual.Tags.ToArray());
Assert.Equal("Override", actual.Title);
}
/// <summary>
/// Creates a NuGet package from this mock package spec and copies it into the
/// specified repository path.
/// </summary>
/// <param name="buildPath"></param>
/// <param name="repositoryPath"></param>
public void CreatePackage(string buildPath, string repositoryPath)
{
NuGet.PackageBuilder builder = new NuGet.PackageBuilder();
NuGet.ManifestMetadata metadata = new NuGet.ManifestMetadata
{
Authors = "AdamsLair",
Version = this.name.Version.ToString(),
Id = this.name.Id,
Description = string.Format("Mock Package: {0} {1}", this.name.Id, this.name.Version),
Tags = string.Join(" ", this.tags),
DependencySets = this.dependencySets.Select(pair => new NuGet.ManifestDependencySet()
{
TargetFramework = pair.Key,
Dependencies =
pair.Value
.Select(item => new NuGet.ManifestDependency {
Id = item.Id, Version = item.Version.ToString()
})
.ToList()
}).ToList()
};
// Set up file contents metadata for the package
List <NuGet.ManifestFile> fileMetadata = new List <NuGet.ManifestFile>();
foreach (var pair in this.files)
{
fileMetadata.Add(new NuGet.ManifestFile {
Source = pair.Key, Target = pair.Value
});
this.CreateFile(buildPath, pair.Key);
}
// If we don't have files or dependencies, at least at one mock file so we
// can create a package at all. This is useful for test cases where we're
// not actually interested in package contents at all.
if (this.files.Count == 0 && !this.dependencySets.SelectMany(pair => pair.Value).Any())
{
fileMetadata.Add(new NuGet.ManifestFile {
Source = "Empty.dll", Target = "lib"
});
this.CreateFile(buildPath, "Empty.dll");
}
builder.PopulateFiles(buildPath, fileMetadata);
builder.Populate(metadata);
string packageFileName = Path.Combine(
repositoryPath,
string.Format("{0}.{1}.nupkg", this.name.Id, this.name.Version));
using (FileStream stream = File.Open(packageFileName, FileMode.Create))
{
builder.Save(stream);
}
}
public void BuildPackage(string baseUrl, ManifestMetadata metadata, ManifestFile[] files)
{
NuGet.PackageBuilder packageBuilder = new NuGet.PackageBuilder();
packageBuilder.Populate(metadata);
packageBuilder.PopulateFiles(baseUrl, files);
var saveDir = Path.Combine(DEFAULT_PACKAGES_SAVE_PATH, packageBuilder.Id, packageBuilder.Version.ToString().Replace('.', '_'));
Directory.CreateDirectory(saveDir);
var saveStream = File.Create(Path.Combine(saveDir, packageBuilder.Id + ".nupkg"));
packageBuilder.Save(saveStream);
}
private void AddFile(NuGet.PackageBuilder builder, String tgtFolder, String filePath)
{
builder.Files.Add(
new NuGet.PhysicalPackageFile()
{
SourcePath = filePath,
TargetPath = Path.Combine(tgtFolder, Path.GetFileName(filePath))
}
);
}
public static void PopulateDependencies(ProjectContext context, PackageBuilder packageBuilder)
{
var dependencies = new List<PackageDependency>();
var project = context.RootProject;
foreach (var dependency in project.Dependencies)
{
if (!dependency.HasFlag(LibraryDependencyTypeFlag.BecomesNupkgDependency))
{
continue;
}
// TODO: Efficiency
var dependencyDescription = context.LibraryManager.GetLibraries().First(l => l.RequestedRanges.Contains(dependency));
// REVIEW: Can we get this far with unresolved dependencies
if (dependencyDescription == null || !dependencyDescription.Resolved)
{
continue;
}
if (dependencyDescription.Identity.Type == LibraryType.Project &&
((ProjectDescription)dependencyDescription).Project.EmbedInteropTypes)
{
continue;
}
if (dependency.Target == LibraryType.ReferenceAssembly)
{
packageBuilder.FrameworkAssemblies.Add(new FrameworkAssemblyReference(dependency.Name, new[] { context.TargetFramework }));
Reporter.Verbose.WriteLine($"Adding framework assembly {dependency.Name.Yellow()}");
}
else
{
VersionRange dependencyVersion = null;
if (dependency.VersionRange == null ||
dependency.VersionRange.IsFloating)
{
dependencyVersion = new VersionRange(dependencyDescription.Identity.Version);
}
else
{
dependencyVersion = dependency.VersionRange;
}
Reporter.Verbose.WriteLine($"Adding dependency {dependency.Name.Yellow()} {VersionUtility.RenderVersion(dependencyVersion).Yellow()}");
dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion));
}
}
packageBuilder.DependencySets.Add(new PackageDependencySet(context.TargetFramework, dependencies));
}
private static void BuildPackages()
{
var directory = new DirectoryInfo(BuildDirectory);
XmlSerializer serializer = new XmlSerializer(typeof(game));
var fs = File.Open(directory.GetFiles().First().FullName, FileMode.Open);
var game = (game)serializer.Deserialize(fs);
fs.Close();
var builder = new NuGet.PackageBuilder()
{
Id = game.id,
Description = game.description,
ProjectUrl = new Uri(game.gameurl),
Version = new SemanticVersion(game.version),
Title = game.name,
IconUrl = new Uri(game.iconurl),
};
foreach (var author in game.authors.Split(','))
{
builder.Authors.Add(author);
}
foreach (var tag in game.tags.Split(' '))
{
builder.Tags.Add(tag);
}
// files and maybe release notes
var allFiles = directory
.GetFiles("*.*", SearchOption.AllDirectories)
.Where(x => x.Extension.ToLower() != ".nupkg" && x.Extension.ToLower() != ".o8g");
foreach (var file in allFiles)
{
var path = file.FullName;
var relPath = path.Replace(directory.FullName, "\\def");
var pf = new PhysicalPackageFile()
{
SourcePath = path, TargetPath = relPath
};
builder.Files.Add(pf);
}
var feedPath = Path.Combine(directory.FullName, game.name + '-' + game.version + ".nupkg");
var olPath = Path.Combine(directory.FullName, game.name + '-' + game.version + ".o8g");
var filestream = File.Open(feedPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
builder.Save(filestream);
filestream.Flush(true);
filestream.Close();
filestream = File.Open(olPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
builder.Save(filestream);
filestream.Flush(true);
filestream.Close();
}
/// <summary>
/// Adds project references to the package lib/tools/content section
/// </summary>
/// <param name="builder">
/// The current package builder
/// </param>
private void AddLibraries(NuGet.PackageBuilder builder)
{
// add package files from project references
// . DLL references go in the lib package folder
// . EXE references go in the tools package folder
// . everything else goes in the content package folder
// . folders may be overridden using NuBuildTargetFolder metadata (lib\net40, etc.)
// . folders may be overridden using TargetFramework attribute (lib\net40, etc.)
foreach (var libItem in this.ReferenceLibraries
.ValidReferenceLibraryForBinaryNuSource())
{
//AddFile(builder, libItem.GetMetadata("FullPath"), libItem.GetMetadata("NuBuildTargetFolder"));
var srcPath = libItem.GetMetadata("FullPath");;
var srcExt = Path.GetExtension(srcPath).ToLower();
var tgtFolder = "content";
var hasPdb = false;
if (srcExt == ".dll")
{
tgtFolder = "lib";
hasPdb = true;
}
else if (srcExt == ".exe")
{
tgtFolder = AddExecutablesToLibFolder ? "lib" : "tools";
hasPdb = true;
}
// apply the custom folder override on the reference, or based on TargetFramework
var customFolder = libItem.GetMetadata("NuBuildTargetFolder");
if (!String.IsNullOrWhiteSpace(customFolder))
{
tgtFolder = customFolder;
}
else if (AddBinariesToSubfolder)
{
try
{
var targetFrameworkName = AssemblyReader.Read(srcPath).TargetFrameworkName;
if (!String.IsNullOrWhiteSpace(targetFrameworkName))
{
tgtFolder = Path.Combine(tgtFolder, VersionUtility.GetShortFrameworkName(new FrameworkName(targetFrameworkName)));
}
}
catch { }
}
// add the source library file to the package
AddFile(builder, tgtFolder, srcPath);
// add PDB and/or XML if specified and exist
if (hasPdb && this.IncludePdbs)
{
AddFileOptionally(builder, tgtFolder, Path.ChangeExtension(srcPath, ".pdb"));
AddFileOptionally(builder, tgtFolder, Path.ChangeExtension(srcPath, ".xml"));
}
}
}
public void AddLibs(PackageBuilder packageBuilder, string pattern)
{
// Add everything in the output folder to the lib path
foreach (var path in Directory.EnumerateFiles(_outputPath, pattern))
{
packageBuilder.Files.Add(new PhysicalPackageFile
{
SourcePath = path,
TargetPath = Path.Combine("lib", _targetFrameworkFolder, Path.GetFileName(path))
});
}
}
protected override void ProcessCompleted(string url, string targetFileName, Action <string> completed)
{
Debug.ArgumentNotNull(completed, nameof(completed));
Debug.ArgumentNotNull(targetFileName, nameof(targetFileName));
Debug.ArgumentNotNull(url, nameof(url));
targetFileName = Path.ChangeExtension(targetFileName, "nuspec");
var client = new WebClient();
try
{
client.DownloadFile(url, targetFileName);
}
catch (WebException ex)
{
if (AppHost.MessageBox(string.Format("Failed to download the package file: {0}\n\nDo you want to report this error?\n\n{1}\n{2}", url, ex.Message, ex.StackTrace), "Information", MessageBoxButton.OKCancel, MessageBoxImage.Information) == MessageBoxResult.OK)
{
AppHost.Shell.HandleException(ex);
}
completed(string.Empty);
return;
}
var nuspecFileName = targetFileName;
var nupkgFileName = Path.ChangeExtension(nuspecFileName, string.Empty) + Version + ".nupkg";
try
{
using (var nuspec = new FileStream(nuspecFileName, FileMode.Open, FileAccess.Read))
{
var packageBuilder = new NuGet.PackageBuilder(nuspec, Path.GetDirectoryName(targetFileName));
using (var nupkg = new FileStream(nupkgFileName, FileMode.Create))
{
packageBuilder.Save(nupkg);
}
}
}
catch (Exception ex)
{
if (AppHost.MessageBox(string.Format("Failed to create the NuGet package file: {0}\n\nDo you want to report this error?\n\n{1}", url, ex.Message), "Information", MessageBoxButton.OKCancel, MessageBoxImage.Information) == MessageBoxResult.OK)
{
AppHost.Shell.HandleException(ex);
}
completed(string.Empty);
return;
}
completed(nupkgFileName);
}
private void ExecuteBuildNuGetPackages(BuildConfiguration configuration)
{
foreach (var buildNuGetPackage in configuration.BuildNuGetPackages)
{
try
{
var properties = new PropertyProvider();
string version = buildNuGetPackage.Version;
if (version == null)
version = VersionRetriever.GetVersion(TargetPath);
properties.Properties["version"] = version;
string manifest = TranslatePath(buildNuGetPackage.Manifest);
var builder = new PackageBuilder(
manifest,
buildNuGetPackage.BasePath ?? TargetDir,
properties,
false
);
string target =
buildNuGetPackage.Target != null
? TranslatePath(buildNuGetPackage.Target)
: Path.Combine(TargetDir, Path.GetFileNameWithoutExtension(manifest) + "." + version + ".nupkg");
bool isExistingPackage = File.Exists(target);
try
{
using (Stream stream = File.Create(target))
{
builder.Save(stream);
}
}
catch
{
if (!isExistingPackage && File.Exists(target))
File.Delete(target);
throw;
}
}
catch (Exception ex)
{
Log.LogErrorFromException(ex);
}
}
}
private PackageBuilder CreatePackage()
{
PackageBuilder pb = new PackageBuilder();
pb.Id = Id;
pb.Version = new SemanticVersion(Version);
pb.Title = Title;
pb.Description = Description;
pb.Authors.AddRange(Authors.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
pb.Owners.AddRange(Owners.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
if (FrameworkAssemblies != null)
foreach (var fa in FrameworkAssemblies)
pb.FrameworkReferences.Add(new FrameworkAssemblyReference(fa.FrameworkName));
if (Dependencies != null)
{
var groups = new Dictionary<string, List<NuGetDependency>>();
foreach (var dpg in Dependencies)
{
string framework = dpg.TargetFramework;
if (String.IsNullOrWhiteSpace(framework))
framework = "";
List<NuGetDependency> list;
if (!groups.TryGetValue(framework, out list))
groups[framework] = list = new List<NuGetDependency>();
list.AddRange(dpg.Dependencies);
}
foreach (var g in groups)
{
FrameworkName fn = g.Key == "" ? null : VersionUtility.ParseFrameworkName(g.Key);
PackageDependencySet ds = new PackageDependencySet(fn, g.Value.Select(v => (PackageDependency)v));
pb.DependencySets.Add(ds);
}
}
if (Icon != null)
pb.IconUrl = Icon;
if (Url != null)
pb.ProjectUrl = Url;
if (License != null)
pb.LicenseUrl = License;
if (Summary != null)
pb.Summary = Summary;
if (Copyright != null)
pb.Copyright = Copyright;
if (ReleaseNotes != null)
pb.ReleaseNotes = ReleaseNotes;
return pb;
}
private static PackageBuilder CreatePackageBuilder(Project project)
{
var builder = new PackageBuilder();
builder.Authors.AddRange(project.Authors);
builder.Owners.AddRange(project.PackOptions.Owners);
if (builder.Authors.Count == 0)
{
var defaultAuthor = Environment.GetEnvironmentVariable("NUGET_AUTHOR");
if (string.IsNullOrEmpty(defaultAuthor))
{
builder.Authors.Add(project.Name);
}
else
{
builder.Authors.Add(defaultAuthor);
}
}
builder.Description = project.Description ?? project.Name;
builder.Id = project.Name;
builder.Version = project.Version;
builder.Title = project.Title;
builder.Summary = project.PackOptions.Summary;
builder.Copyright = project.Copyright;
builder.RequireLicenseAcceptance = project.PackOptions.RequireLicenseAcceptance;
builder.ReleaseNotes = project.PackOptions.ReleaseNotes;
builder.Language = project.Language;
builder.Tags.AddRange(project.PackOptions.Tags);
builder.Serviceable = project.Serviceable;
if (!string.IsNullOrEmpty(project.PackOptions.IconUrl))
{
builder.IconUrl = new Uri(project.PackOptions.IconUrl);
}
if (!string.IsNullOrEmpty(project.PackOptions.ProjectUrl))
{
builder.ProjectUrl = new Uri(project.PackOptions.ProjectUrl);
}
if (!string.IsNullOrEmpty(project.PackOptions.LicenseUrl))
{
builder.LicenseUrl = new Uri(project.PackOptions.LicenseUrl);
}
return(builder);
}
/// <summary>
/// Inserts a dependency set into the packagebuilder object, based on a dictionary
/// containing Id/version pairs (Newtonsoft.json, 5.0.6 for example).
/// </summary>
/// <param name="builder"></param>
/// <param name="packages"></param>
private void AddNugetDependencies(NuGet.PackageBuilder builder, Dictionary <string, string> packages)
{
//add dependencies
List <PackageDependency> dependencies = new List <PackageDependency>();
foreach (var package in packages)
{
dependencies.Add(new PackageDependency(package.Key, new VersionSpec {
MinVersion = new SemanticVersion(package.Value), IsMinInclusive = true
}));
}
var set = new PackageDependencySet(null, dependencies);
builder.DependencySets.Add(set);
}
static void Main()
{
Console.Title = "Nuget Packer";
Console.WriteLine("Prepare...");
string packages = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Packages");
if (Directory.Exists(packages))
Directory.Delete(packages, true);
Directory.CreateDirectory(packages);
Console.WriteLine();
foreach (var directory in Directory.EnumerateDirectories(AppDomain.CurrentDomain.BaseDirectory))
{
try
{
Console.Write("Packing... ");
if(directory.EndsWith("Packages")) continue;
string name = Path.GetFileName(directory) + ".nuspec";
var pack = new PackageBuilder(Directory.EnumerateFiles(directory).First(s => s.EndsWith(name)),
directory, null, true);
Console.Write(pack.Id + "... ");
using (var stream = new FileStream(Path.Combine(packages, pack.Id + ".nupkg"), FileMode.Create))
{
pack.Save(stream);
}
Directory.Delete(directory, true);
Console.WriteLine("Done");
}
catch (Exception e)
{
Console.WriteLine();
Console.Write("Error: ");
Console.WriteLine(e);
Console.WriteLine("Press enter.");
Console.ReadKey();
}
}
Console.WriteLine();
Console.WriteLine("Finished");
Console.WriteLine("Press Enter...");
Console.ReadKey();
}
private void Pack([NotNull] IBuildContext context, [NotNull] string zipFileName)
{
var packageName = Path.GetFileNameWithoutExtension(zipFileName);
var packageId = packageName.GetSafeCodeIdentifier();
var srcFileName = PathHelper.UnmapPath(context.ProjectDirectory, zipFileName);
var targetFileName = "content\\packages\\" + Path.GetFileName(zipFileName);
context.Trace.TraceInformation(Msg.M1016, Texts.Packing, packageName);
var nuspec = new StringWriter();
nuspec.WriteLine("<package xmlns=\"http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd\">");
nuspec.WriteLine(" <metadata>");
nuspec.WriteLine(" <id>" + packageId + "</id>");
nuspec.WriteLine(" <title>" + packageName + "</title>");
nuspec.WriteLine(" <version>1.0.0</version>");
nuspec.WriteLine(" <authors>Sitecore Pathfinder</authors>");
nuspec.WriteLine(" <requireLicenseAcceptance>false</requireLicenseAcceptance>");
nuspec.WriteLine(" <description>Generated by Sitecore Pathfinder</description>");
nuspec.WriteLine(" </metadata>");
nuspec.WriteLine(" <files>");
nuspec.WriteLine(" <file src=\"" + srcFileName + "\" target=\"" + targetFileName + "\"/>");
nuspec.WriteLine(" </files>");
nuspec.WriteLine("</package>");
var nupkgFileName = Path.Combine(Path.GetDirectoryName(zipFileName) ?? string.Empty, packageId + ".nupkg");
try
{
var byteArray = Encoding.UTF8.GetBytes(nuspec.ToString());
using (var nuspecStream = new MemoryStream(byteArray))
{
var packageBuilder = new PackageBuilder(nuspecStream, context.ProjectDirectory);
using (var nupkg = new FileStream(nupkgFileName, FileMode.Create))
{
packageBuilder.Save(nupkg);
}
}
}
catch (Exception ex)
{
context.Trace.TraceError(Msg.M1003, Texts.Failed_to_create_the_Nupkg_file, ex.Message);
}
}
private static void CopyMetadata(IPackageMetadata source, PackageBuilder builder)
{
builder.Id = source.Id;
builder.Version = source.Version;
builder.Title = source.Title;
builder.Authors.AddRange(source.Authors);
builder.Owners.AddRange(source.Owners);
builder.IconUrl = source.IconUrl;
builder.LicenseUrl = source.LicenseUrl;
builder.ProjectUrl = source.ProjectUrl;
builder.RequireLicenseAcceptance = source.RequireLicenseAcceptance;
builder.Description = source.Description;
builder.Summary = source.Summary;
builder.Language = source.Language;
builder.Tags.AddRange(ParseTags(source.Tags));
builder.Dependencies.AddRange(source.Dependencies);
builder.FrameworkReferences.AddRange(source.FrameworkAssemblies);
}
private static Stream CreateTestPackageStream()
{
var packageStream = new MemoryStream();
var builder = new PackageBuilder
{
Id = "TestPackage",
Version = SemanticVersion.Parse("0.0.0.1"),
Description = "Trivial Description",
Authors = { "AuthorsIsRequiredSayWhaat?" },
};
var file = new Mock<IPackageFile>();
file.Setup(s => s.Path).Returns(@"content\HelloWorld.cs");
file.Setup(s => s.GetStream()).Returns(Stream.Null);
builder.Files.Add(file.Object);
builder.Save(packageStream);
return packageStream;
}
/// <summary>
/// Creates a local nupkg file, and stores it in a local folder (<see cref="LocalNuGetPackageFolder"/>).
/// </summary>
/// <returns>The path to the nupkg file</returns>
public static string CreateLocalNupkgFile(string nuspecFilePath, string directory)
{
var packageName = nuspecFilePath.Substring(nuspecFilePath.LastIndexOf(Path.DirectorySeparatorChar) + 1)
.Replace(".nuspec", ".nupkg");
var nupkg = Path.Combine(LocalNuGetPackageFolder, packageName);
// read the nuspec metadata file
using (var stream = new FileStream(nuspecFilePath, FileMode.Open, FileAccess.Read))
{
TraceSource.TraceEvent(TraceEventType.Verbose, "Creating {0}", packageName);
// create the package and save it to disk
var builder = new PackageBuilder(stream, directory);
using (FileStream nupkgStream = File.Open(nupkg, FileMode.Create))
{
builder.Save(nupkgStream);
}
TraceSource.TraceEvent(TraceEventType.Verbose, "{0} was created", nupkg);
}
return nupkg;
}
public void BuildPackage(string basePath, IList<string> includes, ManifestMetadata metadata, string outFolder, bool overwrite)
{
var package = new PackageBuilder();
package.PopulateFiles(basePath, includes.Select(i => new ManifestFile { Source = i }));
package.Populate(metadata);
var filename = metadata.Id + "." + metadata.Version + ".nupkg";
var output = Path.Combine(outFolder, filename);
if (fileSystem.FileExists(output) && !overwrite)
throw new CommandException("The package file already exists and --overwrite was not specified");
log.InfoFormat("Saving {0} to {1}...", filename, outFolder);
fileSystem.EnsureDirectoryExists(outFolder);
using (var outStream = fileSystem.OpenFile(output, FileMode.Create))
package.Save(outStream);
}
public PackageBuilder BuildPackage(IEnumerable<IPackageFile> packageFiles, PackageMetadata metaData)
{
var package = new PackageBuilder
{
Id = metaData.Id,
Version = metaData.Version,
Description = metaData.Description
};
foreach (var item in metaData.Authors)
{
package.Authors.Add(item);
}
foreach (var file in packageFiles)
{
package.Files.Add(file);
}
return package;
}
private IPackage createPackage(PackageBuilder builder, string outputPath)
{
bool isExistingPackage = File.Exists(outputPath);
try
{
using (Stream stream = File.Create(outputPath))
{
builder.Save(stream);
}
}
catch
{
if (!isExistingPackage && File.Exists(outputPath))
{
File.Delete(outputPath);
}
throw;
}
RippleLog.Info("Created nuget at: " + outputPath);
return new ZipPackage(outputPath);
}
protected virtual void BuildNupkgFile([NotNull] IBuildContext context, [NotNull] string nuspecFileName, [NotNull] string nupkgFileName)
{
var configFileName = Path.Combine(context.ToolsDirectory, context.Configuration.GetString(Constants.Configuration.ProjectConfigFileName));
var nuspec = context.FileSystem.ReadAllText(nuspecFileName);
nuspec = nuspec.Replace("$global.scconfig.json$", configFileName);
var stream = new MemoryStream(Encoding.UTF8.GetBytes(nuspec));
try
{
var packageBuilder = new PackageBuilder(stream, context.ProjectDirectory);
using (var nupkg = new FileStream(nupkgFileName, FileMode.Create))
{
packageBuilder.Save(nupkg);
}
}
catch (Exception ex)
{
context.Trace.TraceError(Msg.D1020, Texts.Failed_to_create_the_Nupkg_file, ex.Message);
}
}
IPackage IPackageFactory.CreateFromProject(string nupecFile, string csprojFile, string buildConfiguration, bool includeBinOutput)
{
var projectReader = _projectReaderFactory.Create(csprojFile);
var binDir = projectReader.GetBinPath(buildConfiguration);
var assemblyName = projectReader.GetAssemblyName();
var assemblyPath = _fileSystem.CombinePaths(binDir, assemblyName);
var assemblyReader = _assemblyReaderFactory.Create(assemblyPath);
var manifest = new ManifestMetadata()
{
Id = assemblyReader.GetPackageId(),
Title = assemblyReader.GetPackageTitle(),
Owners = assemblyReader.GetCompany(),
Authors = assemblyReader.GetCompany(),
Description = assemblyReader.GetDescription(),
Copyright = assemblyReader.GetCopyright(),
Version = assemblyReader.GetFileVersion()
};
var files = new List<ManifestFile>();
foreach (var dll in _fileSystem.FindFiles(binDir, "*.dll", false))
files.Add(new ManifestFile() { Source = dll, Target = @"lib\net40" });
var packageBuilder = new PackageBuilder();
packageBuilder.Populate(manifest);
packageBuilder.PopulateFiles(string.Empty, files);
var projDir = _fileSystem.GetDirectory(csprojFile);
var packagefile = _fileSystem.CombinePaths(projDir, "packages.config");
var packagePath = _fileSystem.ChangeFileExtension(csprojFile, "nupkg");
using (var stream = _fileSystem.OpenWrite(packagePath))
{
packageBuilder.Save(stream);
}
return new ZipPackage(packagePath);
}
public static Response Restore(NuGetRestoreRequest request)
{
var console = new Console();
PackageBuilder builder = new PackageBuilder();
var command = new RestoreCommand
{
FileSystem = new PhysicalFileSystem(PathTools.OptimizePath(request.BaseDirectory)),
Console = console,
Verbosity = Verbosity.Detailed,
};
command.Arguments.Add(request.SolutionPath);
try
{
command.Execute();
}
catch (Exception e)
{
console.WriteError(e);
}
return new Response(console.Messages);
}
public static IPackage BuildPackage(PackageBuilder builder, IFileSystem fileSystem, string outputPath = null)
{
ExcludeFiles(builder.Files);
// Track if the package file was already present on disk
bool isExistingPackage = fileSystem.file_exists(outputPath);
try
{
using (Stream stream = fileSystem.create_file(outputPath))
{
builder.Save(stream);
}
}
catch
{
if (!isExistingPackage && fileSystem.file_exists(outputPath))
{
fileSystem.delete_file(outputPath);
}
throw;
}
return new OptimizedZipPackage(outputPath);
}
private static void CopyMetadata(IPackageMetadata source, PackageBuilder builder)
{
builder.Id = source.Id;
builder.Version = source.Version;
builder.Title = source.Title;
builder.Authors.AddRange(source.Authors);
builder.Owners.AddRange(source.Owners);
builder.IconUrl = source.IconUrl;
builder.LicenseUrl = source.LicenseUrl;
builder.ProjectUrl = source.ProjectUrl;
builder.RequireLicenseAcceptance = source.RequireLicenseAcceptance;
builder.DevelopmentDependency = source.DevelopmentDependency;
builder.Description = source.Description;
builder.Summary = source.Summary;
builder.ReleaseNotes = source.ReleaseNotes;
builder.Copyright = source.Copyright;
builder.Language = source.Language;
builder.Tags.AddRange(ParseTags(source.Tags));
builder.DependencySets.AddRange(source.DependencySets);
builder.FrameworkReferences.AddRange(source.FrameworkAssemblies);
builder.PackageAssemblyReferences.AddRange(source.PackageAssemblyReferences);
builder.MinClientVersion = source.MinClientVersion;
}
/// <summary>
/// Adds embedded resources to the package tools/content section
/// </summary>
/// <param name="builder">
/// The current package builder
/// </param>
private void AddEmbedded(NuGet.PackageBuilder builder)
{
// add package files from project embedded resources
foreach (var fileItem in this.Embedded)
{
// only link items has Link metadata, that is the path, where the link itself is located (not the referred item)
var tgtPath = fileItem.GetMetadata("Link");
// if it is not a link, handle as normal file
if (String.IsNullOrEmpty(tgtPath))
{
tgtPath = fileItem.GetMetadata("Identity");
}
if (tgtPath.IndexOf('\\') == -1)
{
// warning if file is not in a subfolder
Log.LogWarning(
"The source item '{0}' is not a valid content! Files has to be in a subfolder, like content or tools! File skipped.",
tgtPath);
}
else
{
// determine pre package processing necessity
var prePackProc = tgtPath.EndsWith(".ppp");
if (prePackProc)
{
tgtPath = tgtPath.Substring(0, tgtPath.Length - 4);
}
// create the source file
var file = prePackProc ? new TokenProcessingPhysicalPackageFile(this) : new PhysicalPackageFile();
file.SourcePath = fileItem.GetMetadata("FullPath");
file.TargetPath = tgtPath;
// add the source file to the package
builder.Files.Add(file);
}
}
}
private static void BuildPackages()
{
var directory = new DirectoryInfo(BuildDirectory);
XmlSerializer serializer = new XmlSerializer(typeof(game));
var fs = File.Open(directory.GetFiles().First(x => x.Name == "definition.xml").FullName, FileMode.Open);
var game = (game)serializer.Deserialize(fs);
fs.Close();
var builder = new NuGet.PackageBuilder()
{
Id = game.id,
Description = game.description,
ProjectUrl = new Uri(game.gameurl),
Version = new SemanticVersion(game.version),
Title = game.name,
IconUrl = new Uri(game.iconurl),
};
foreach (var author in game.authors.Split(','))
{
builder.Authors.Add(author);
}
foreach (var tag in game.tags.Split(' '))
{
builder.Tags.Add(tag);
}
// files and maybe release notes
var baseRefPath = "\\def";
foreach (var dir in directory.GetDirectories())
{
if (dir.Name == "Sets")
{
var refpath = baseRefPath + "\\" + "Sets" + "\\";
foreach (var setdir in dir.GetDirectories())
{
var doc = XDocument.Load(Path.Combine(setdir.FullName, "set.xml"));
var gameId = doc.Root.Attribute("id").Value;
var setRefPath = refpath + gameId;
foreach (var f in setdir.GetFiles("*", SearchOption.AllDirectories))
{
var relPath = f.FullName.Replace(setdir.FullName, setRefPath);
var pf = new PhysicalPackageFile()
{
SourcePath = f.FullName, TargetPath = relPath
};
builder.Files.Add(pf);
}
}
}
else
{
var refpath = baseRefPath + "\\" + dir.Name;
var files = dir.GetFiles("*", SearchOption.AllDirectories);
foreach (var f in files)
{
var relPath = f.FullName.Replace(dir.FullName, refpath);
var pf = new PhysicalPackageFile()
{
SourcePath = f.FullName, TargetPath = relPath
};
builder.Files.Add(pf);
}
}
}
var defFile = new FileInfo(Path.Combine(directory.FullName, "definition.xml"));
var defFilePack = new PhysicalPackageFile()
{
SourcePath = defFile.FullName,
TargetPath =
defFile.FullName.Replace(defFile.Directory.FullName, baseRefPath)
};
builder.Files.Add(defFilePack);
//var allFiles = directory
// .GetFiles("*.*", SearchOption.AllDirectories)
// .Where(x=>x.Extension.ToLower() != ".nupkg" && x.Extension.ToLower() != ".o8g");
//foreach (var file in allFiles)
//{
// //Sets\0abccf03-2825-4b6e-ba59-698408a2005c
// var path = file.FullName;
// var relPath = path.Replace(directory.FullName, "\\def");
// var pf = new PhysicalPackageFile() { SourcePath = path, TargetPath = relPath };
// builder.Files.Add(pf);
//}
var feedPath = Path.Combine(directory.FullName, game.name + '-' + game.version + ".nupkg");
// var olPath = Path.Combine(directory.FullName, game.name + '-' + game.version + ".o8g");
// O8gPath = olPath;
NupkgPath = feedPath;
Console.WriteLine("Feed Path: " + feedPath);
// Console.WriteLine("Manual Path: " + olPath);
var filestream = File.Open(feedPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
builder.Save(filestream);
filestream.Flush(true);
filestream.Close();
// filestream = File.Open(olPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
// builder.Save(filestream);
// filestream.Flush(true);
// filestream.Close();
}
/// <summary>
/// Adds project references to the package lib section
/// </summary>
/// <param name="builder">
/// The current package builder
/// </param>
private void AddLibraries(NuGet.PackageBuilder builder)
{
// add package files from project references
// . DLL references go in the lib package folder
// . EXE references go in the tools package folder
// . everything else goes in the content package folder
// . folders may be overridden using NuBuildTargetFolder metadata (lib\net40, etc.)
// . folders may be overridden using TargetFramework attribute (lib\net40, etc.)
foreach (var libItem in this.ReferenceLibraries)
{
var srcPath = libItem.GetMetadata("FullPath");
var srcExt = Path.GetExtension(srcPath).ToLower();
var tgtFolder = "content";
var hasPdb = false;
if (srcExt == ".dll")
{
tgtFolder = "lib";
hasPdb = true;
}
else if (srcExt == ".exe")
{
tgtFolder = "tools";
hasPdb = true;
}
// apply the custom folder override on the reference, or based on TargetFramework
var customFolder = libItem.GetMetadata("NuBuildTargetFolder");
if (!String.IsNullOrWhiteSpace(customFolder))
{
tgtFolder = customFolder;
}
else if (AddBinariesToSubfolder)
{
try
{
var targetFrameworkName = libItem.GetMetadata("TargetFrameworkName");
if (!String.IsNullOrWhiteSpace(targetFrameworkName))
{
tgtFolder = Path.Combine(tgtFolder, VersionUtility.GetShortFrameworkName(new FrameworkName(targetFrameworkName)));
}
}
catch { }
}
// add the source library file to the package
builder.Files.Add(
new NuGet.PhysicalPackageFile()
{
SourcePath = srcPath,
TargetPath = String.Format(
@"{0}\{1}",
tgtFolder,
Path.GetFileName(srcPath)
)
}
);
// add PDBs if specified and exist
if (hasPdb && this.IncludePdbs)
{
var pdbPath = Path.ChangeExtension(srcPath, ".pdb");
if (File.Exists(pdbPath))
{
builder.Files.Add(
new NuGet.PhysicalPackageFile()
{
SourcePath = pdbPath,
TargetPath = String.Format(
@"{0}\{1}",
tgtFolder,
Path.GetFileName(pdbPath)
)
}
);
}
}
}
}