public bool Equals(LockFileTargetLibrary other)
{
if (other == null)
{
return(false);
}
if (Object.ReferenceEquals(this, other))
{
return(true);
}
return(string.Equals(Name, other.Name) &&
VersionComparer.Default.Equals(Version, other.Version) &&
string.Equals(Type, other.Type, StringComparison.Ordinal) &&
string.Equals(Framework, other.Framework, StringComparison.Ordinal) &&
Dependencies.OrderedEquals(other.Dependencies, dependency => dependency.Id, StringComparer.OrdinalIgnoreCase) &&
FrameworkAssemblies.OrderedEquals(other.FrameworkAssemblies, s => s, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase) &&
FrameworkReferences.OrderedEquals(other.FrameworkReferences, s => s, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase) &&
RuntimeAssemblies.OrderedEquals(other.RuntimeAssemblies, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
ResourceAssemblies.OrderedEquals(other.ResourceAssemblies, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
CompileTimeAssemblies.OrderedEquals(other.CompileTimeAssemblies, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
NativeLibraries.OrderedEquals(other.NativeLibraries, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
ContentFiles.OrderedEquals(other.ContentFiles, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
RuntimeTargets.OrderedEquals(other.RuntimeTargets, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
Build.OrderedEquals(other.Build, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
BuildMultiTargeting.OrderedEquals(other.BuildMultiTargeting, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
ToolsAssemblies.OrderedEquals(other.ToolsAssemblies, item => item.Path, StringComparer.OrdinalIgnoreCase) &&
EmbedAssemblies.OrderedEquals(other.EmbedAssemblies, item => item.Path, StringComparer.OrdinalIgnoreCase));
}
public AssemblyDefinition[] GetAssemblies(string src, EventHandler <Confuser.Core.LogEventArgs> err)
{
Dictionary <string, AssemblyDefinition> ret = new Dictionary <string, AssemblyDefinition>();
AssemblyDefinition main = AssemblyDefinition.ReadAssembly(src);
ret.Add(main.FullName, main);
foreach (ModuleDefinition mod in main.Modules)
{
mod.FullLoad();
foreach (AssemblyNameReference refer in mod.AssemblyReferences)
{
if (!FrameworkAssemblies.Contains(string.Format("{0}/{1}", refer.Name, BitConverter.ToString(refer.PublicKeyToken ?? new byte[0]))) && !ret.ContainsKey(refer.FullName))
{
AssemblyDefinition asm = GlobalAssemblyResolver.Instance.Resolve(refer);
if (asm == null)
{
err(this, new Core.LogEventArgs(string.Format("WARNING : Cannot load dependency '" + refer.FullName + ".")));
}
else
{
ret.Add(refer.FullName, asm);
GetAssemblies(asm, ret, err);
}
}
}
}
return(ret.Values.ToArray());
}
public IList <FrameworkName> ComputeSupportedFrameworks()
{
return(FrameworkAssemblies.SelectMany(f => f.SupportedFrameworks)
.Union(Files.SelectMany(f => f.SupportedFrameworks))
.Where(f => f != null && f != VersionUtility.UnsupportedFrameworkName)
.ToArray());
}
public override int GetHashCode()
{
var combiner = new HashCodeCombiner();
combiner.AddObject(Name);
combiner.AddObject(Version);
combiner.AddObject(Type);
combiner.AddObject(Framework);
foreach (var dependency in Dependencies.OrderBy(dependency => dependency.Id, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(dependency);
}
foreach (var reference in FrameworkAssemblies.OrderBy(s => s, StringComparer.OrdinalIgnoreCase))
{
combiner.AddStringIgnoreCase(reference);
}
foreach (var item in RuntimeAssemblies.OrderBy(item => item.Path, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(item);
}
foreach (var item in ResourceAssemblies.OrderBy(item => item.Path, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(item);
}
foreach (var item in CompileTimeAssemblies.OrderBy(item => item.Path, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(item);
}
foreach (var item in NativeLibraries.OrderBy(item => item.Path, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(item);
}
foreach (var item in ContentFiles.OrderBy(item => item.Path, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(item);
}
foreach (var item in RuntimeTargets.OrderBy(item => item.Path, StringComparer.OrdinalIgnoreCase))
{
combiner.AddObject(item);
}
return(combiner.CombinedHash);
}
void GetAssemblies(AssemblyDefinition asm, Dictionary <string, AssemblyDefinition> ret, EventHandler <Confuser.Core.LogEventArgs> err)
{
foreach (ModuleDefinition mod in asm.Modules)
{
mod.FullLoad();
foreach (AssemblyNameReference refer in mod.AssemblyReferences)
{
if (!FrameworkAssemblies.Contains(string.Format("{0}/{1}", refer.Name, BitConverter.ToString(refer.PublicKeyToken ?? new byte[0]))) && !ret.ContainsKey(refer.FullName))
{
AssemblyDefinition asmRef = GlobalAssemblyResolver.Instance.Resolve(refer);
if (asmRef == null)
{
err(this, new Core.LogEventArgs(string.Format("WARNING : Cannot load dependency '" + refer.FullName + ".")));
}
else
{
ret.Add(refer.FullName, asmRef);
GetAssemblies(asmRef, ret, err);
}
}
}
}
}
public virtual IEnumerable <FrameworkName> GetSupportedFrameworks()
{
return(FrameworkAssemblies.SelectMany(f => f.SupportedFrameworks).Distinct());
}
public void Save(Stream stream)
{
// Make sure we're saving a valid package id
PackageIdValidator.ValidatePackageId(Id);
// Throw if the package doesn't contain any dependencies nor content
if (!Files.Any() && !DependencySets.SelectMany(d => d.Dependencies).Any() && !FrameworkAssemblies.Any())
{
// TODO: Resources
throw new InvalidOperationException("NuGetResources.CannotCreateEmptyPackage");
}
if (!ValidateSpecialVersionLength(Version))
{
// TODO: Resources
throw new InvalidOperationException("NuGetResources.SemVerSpecialVersionTooLong");
}
ValidateDependencySets(Version, DependencySets);
ValidateReferenceAssemblies(Files, PackageAssemblyReferences);
using (var package = new ZipArchive(stream, ZipArchiveMode.Create))
{
// Validate and write the manifest
WriteManifest(package, ManifestVersionUtility.DefaultVersion);
// Write the files to the package
var extensions = WriteFiles(package);
extensions.Add("nuspec");
WriteOpcContentTypes(package, extensions);
}
}
public XDocument Create()
{
var doc = new XDocument(new XDeclaration("1.0", "utf-8", "no"));
var package = new XElement(XName.Get("package"));
var metadata = new XElement(XName.Get("metadata"));
package.Add(metadata);
doc.Add(package);
metadata.Add(new XElement(XName.Get("id"), Id));
metadata.Add(new XElement(XName.Get("version"), Version));
if (!string.IsNullOrEmpty(MinClientVersion))
{
metadata.Add(new XAttribute(XName.Get("minClientVersion"), MinClientVersion));
}
AddIfExists(metadata, "title", Title);
AddIfExists(metadata, "authors", Authors);
AddIfExists(metadata, "owners", Owners);
AddIfExists(metadata, "description", Description);
AddIfExists(metadata, "releaseNotes", ReleaseNotes);
AddIfExists(metadata, "summary", Summary);
AddIfExists(metadata, "language", Language);
AddIfExists(metadata, "projectUrl", ProjectUrl);
AddIfExists(metadata, "iconUrl", IconUrl);
AddIfExists(metadata, "licenseUrl", LicenseUrl);
AddIfExists(metadata, "copyright", Copyright);
AddIfExists(metadata, "requireLicenseAcceptance", RequireLicenseAcceptance);
AddIfExists(metadata, "tags", Tags);
AddIfExists(metadata, "developmentDependency", DevelopmentDependency);
if (Dependencies.Any())
{
var dependencies = new XElement(XName.Get("dependencies"));
metadata.Add(dependencies);
if (Dependencies.All(d => d.TargetFramework.IsAny))
{
foreach (var d in Dependencies.Single().Packages)
{
var dependency = new XElement(XName.Get("dependency"));
dependency.Add(new XAttribute(XName.Get("id"), d.Id));
dependency.Add(new XAttribute(XName.Get("version"), d.VersionRange.ToLegacyShortString()));
dependencies.Add(dependency);
}
}
else
{
foreach (var group in Dependencies)
{
var groupNode = new XElement(XName.Get("group"));
dependencies.Add(groupNode);
if (!group.TargetFramework.IsAny)
{
groupNode.Add(new XAttribute(XName.Get("targetFramework"), group.TargetFramework.GetShortFolderName()));
}
foreach (var d in group.Packages)
{
var dependency = new XElement(XName.Get("dependency"));
dependency.Add(new XAttribute(XName.Get("id"), d.Id));
dependency.Add(new XAttribute(XName.Get("version"), d.VersionRange.ToLegacyShortString()));
groupNode.Add(dependency);
}
}
}
}
if (FrameworkAssemblies.Any())
{
var frameworkAssemblies = new XElement(XName.Get("frameworkAssemblies"));
metadata.Add(frameworkAssemblies);
foreach (var fwa in FrameworkAssemblies)
{
var fwaNode = new XElement(XName.Get("frameworkAssembly"));
frameworkAssemblies.Add(fwaNode);
fwaNode.Add(new XAttribute("assemblyName", fwa.Key));
fwaNode.Add(new XAttribute("targetFramework", string.Join(",", fwa.Value.Select(f => f.GetShortFolderName()))));
}
}
return(doc);
}
