protected virtual void ProcessManifest(Stream manifestStream)
{
IPackageMetadata packageMetadata = Manifest.ReadFrom(manifestStream, false).Metadata;
Id = packageMetadata.Id;
Version = packageMetadata.Version;
MinClientVersion = packageMetadata.MinClientVersion;
Title = packageMetadata.Title;
Authors = packageMetadata.Authors;
Owners = packageMetadata.Owners;
IconUrl = packageMetadata.IconUrl;
LicenseUrl = packageMetadata.LicenseUrl;
ProjectUrl = packageMetadata.ProjectUrl;
RequireLicenseAcceptance = packageMetadata.RequireLicenseAcceptance;
Description = packageMetadata.Description;
Summary = packageMetadata.Summary;
ReleaseNotes = packageMetadata.ReleaseNotes;
Language = packageMetadata.Language;
Tags = packageMetadata.Tags;
DependencySets = packageMetadata.DependencySets;
FrameworkAssemblies = packageMetadata.FrameworkAssemblies;
Copyright = packageMetadata.Copyright;
PackageAssemblyReferences = packageMetadata.PackageAssemblyReferences;
DevelopmentDependency = packageMetadata.DevelopmentDependency;
if (string.IsNullOrEmpty(Tags))
{
return;
}
Tags = " " + Tags + " ";
}
public async Task PushPackage(string apiKey, string filePath, IPackageMetadata package, bool pushAsUnlisted)
{
string requestUri = EnsureTrailingSlash(_source) + ServiceEndpoint;
HttpWebRequest httpRequest = WebRequest.CreateHttp(requestUri);
httpRequest.Method = "PUT";
httpRequest.AllowAutoRedirect = true;
httpRequest.AllowWriteStreamBuffering = false;
httpRequest.KeepAlive = false;
httpRequest.Headers.Add(ApiKeyHeader, apiKey);
httpRequest.UserAgent = _userAgent;
var multipartRequest = new MultipartWebRequest();
multipartRequest.AddFile(new FileInfo(filePath), package.ToString());
// sending package data asynchronously
await multipartRequest.CreateMultipartRequest(httpRequest);
// waiting for response asynchronously
await EnsureSuccessfulResponse(httpRequest, HttpStatusCode.Created);
if (pushAsUnlisted)
{
await DeletePackageFromServer(apiKey, package.Id, package.Version.ToString());
}
}
public async Task PushPackageWithCredentials(string filePath, IPackageMetadata package, bool pushAsUnlisted, bool appendV2ApiToUrl, string username, string password)
{
string requestUri = CreateRequestUri(appendV2ApiToUrl);
// Nuget Server returns Created. VSTS Returns Accepted
HttpStatusCode expectedStatus = HttpStatusCode.Created | HttpStatusCode.Accepted;
HttpWebRequest httpRequest = CreatePushRequest(requestUri);
ConfigureRequestAuthCredentials(httpRequest, username, password);
var multipartRequest = new MultipartWebRequest();
multipartRequest.AddFile(new FileInfo(filePath), package.ToString());
// sending package data asynchronously
await multipartRequest.CreateMultipartRequest(httpRequest);
// waiting for response asynchronously
await EnsureSuccessfulResponse(httpRequest, expectedStatus);
if (pushAsUnlisted)
{
await DeletePackageFromServerWithCredentials(package.Id, package.Version.ToString(), appendV2ApiToUrl, username, password);
}
}
protected void ReadManifest(Stream manifestStream)
{
Manifest manifest = Manifest.ReadFrom(manifestStream);
IPackageMetadata metadata = manifest.Metadata;
Id = metadata.Id;
Version = metadata.Version;
Title = metadata.Title;
Authors = metadata.Authors;
Owners = metadata.Owners;
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
Description = metadata.Description;
Summary = metadata.Summary;
ReleaseNotes = metadata.ReleaseNotes;
Language = metadata.Language;
Tags = metadata.Tags;
DependencySets = metadata.DependencySets;
FrameworkAssemblies = metadata.FrameworkAssemblies;
Copyright = metadata.Copyright;
ManifestReferences = manifest.Metadata.References;
IEnumerable <string> references = (ManifestReferences ?? Enumerable.Empty <ManifestReference>()).Select(c => c.File);
_references = new HashSet <string>(references, StringComparer.OrdinalIgnoreCase);
// Ensure tags start and end with an empty " " so we can do contains filtering reliably
if (!String.IsNullOrEmpty(Tags))
{
Tags = " " + Tags + " ";
}
}
public static Manifest Create(IPackageMetadata metadata)
{
return(new Manifest
{
Metadata = new ManifestMetadata
{
Id = metadata.Id.SafeTrim(),
Version = metadata.Version.ToStringSafe(),
Title = metadata.Title.SafeTrim(),
Authors = GetCommaSeparatedString(metadata.Authors),
Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors),
Tags = String.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim(),
LicenseUrl = ConvertUrlToStringSafe(metadata.LicenseUrl),
ProjectUrl = ConvertUrlToStringSafe(metadata.ProjectUrl),
IconUrl = ConvertUrlToStringSafe(metadata.IconUrl),
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
DevelopmentDependency = metadata.DevelopmentDependency,
Description = metadata.Description.SafeTrim(),
Copyright = metadata.Copyright.SafeTrim(),
Summary = metadata.Summary.SafeTrim(),
ReleaseNotes = metadata.ReleaseNotes.SafeTrim(),
Language = metadata.Language.SafeTrim(),
DependencySets = CreateDependencySets(metadata),
FrameworkAssemblies = CreateFrameworkAssemblies(metadata),
ReferenceSets = CreateReferenceSets(metadata),
MinClientVersionString = metadata.MinClientVersion.ToStringSafe()
},
});
}
public static PackageLicenseModel FromV2Package(IPackageMetadata package)
{
return new PackageLicenseModel(
package.Id,
package.LicenseUrl,
package.Authors);
}
public static bool IsSatellitePackage(
IPackageMetadata package,
IPackageRepository repository,
FrameworkName targetFramework,
out IPackage runtimePackage)
{
// A satellite package has the following properties:
// 1) A package suffix that matches the package's language, with a dot preceding it
// 2) A dependency on the package with the same Id minus the language suffix
// 3) The dependency can be found by Id in the repository (as its path is needed for installation)
// Example: foo.ja-jp, with a dependency on foo
runtimePackage = null;
if (package.IsSatellitePackage())
{
string runtimePackageId = package.Id.Substring(0, package.Id.Length - (package.Language.Length + 1));
PackageDependency dependency = package.FindDependency(runtimePackageId, targetFramework);
if (dependency != null)
{
runtimePackage = repository.FindPackage(runtimePackageId, versionSpec: dependency.VersionSpec, allowPrereleaseVersions: true, allowUnlisted: true);
}
}
return runtimePackage != null;
}
public void Populate(ManifestMetadata manifestMetadata)
{
IPackageMetadata metadata = manifestMetadata;
Id = metadata.Id;
Version = metadata.Version;
Title = metadata.Title;
Authors.AddRange(metadata.Authors);
Owners.AddRange(metadata.Owners);
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
Description = metadata.Description;
Summary = metadata.Summary;
ReleaseNotes = metadata.ReleaseNotes;
Language = metadata.Language;
Copyright = metadata.Copyright;
if (metadata.Tags != null)
{
Tags.AddRange(ParseTags(metadata.Tags));
}
DependencySets.AddRange(metadata.DependencySets);
FrameworkReferences.AddRange(metadata.FrameworkAssemblies);
if (manifestMetadata.ReferenceSets != null)
{
PackageAssemblyReferences.AddRange(manifestMetadata.ReferenceSets.Select(r => new PackageReferenceSet(r)));
}
}
protected void ReadManifest(Stream manifestStream)
{
Manifest manifest = Manifest.ReadFrom(manifestStream, validateSchema: false);
IPackageMetadata metadata = manifest.Metadata;
Id = metadata.Id;
Version = metadata.Version;
Title = metadata.Title;
Authors = metadata.Authors;
Owners = metadata.Owners;
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
// DevelopmentDependency = metadata.DevelopmentDependency;
Description = metadata.Description;
Summary = metadata.Summary;
ReleaseNotes = metadata.ReleaseNotes;
Language = metadata.Language;
Tags = metadata.Tags;
DependencySets = metadata.DependencySets;
FrameworkAssemblies = metadata.FrameworkAssemblies;
Copyright = metadata.Copyright;
PackageAssemblyReferences = metadata.PackageAssemblyReferences;
MinClientVersion = metadata.MinClientVersion;
// Ensure tags start and end with an empty " " so we can do contains filtering reliably
if (!String.IsNullOrEmpty(Tags))
{
Tags = " " + Tags + " ";
}
}
protected void ReadManifest(Stream manifestStream)
{
IPackageMetadata metadata = Manifest.ReadFrom(manifestStream, false).Metadata;
this.Id = metadata.Id;
this.Version = metadata.Version;
this.Title = metadata.Title;
this.Authors = metadata.Authors;
this.Owners = metadata.Owners;
this.IconUrl = metadata.IconUrl;
this.LicenseUrl = metadata.LicenseUrl;
this.ProjectUrl = metadata.ProjectUrl;
this.RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
this.DevelopmentDependency = metadata.DevelopmentDependency;
this.Description = metadata.Description;
this.Summary = metadata.Summary;
this.ReleaseNotes = metadata.ReleaseNotes;
this.Language = metadata.Language;
this.Tags = metadata.Tags;
this.DependencySets = metadata.DependencySets;
this.FrameworkAssemblies = metadata.FrameworkAssemblies;
this.Copyright = metadata.Copyright;
this.PackageAssemblyReferences = metadata.PackageAssemblyReferences;
this.MinClientVersion = metadata.MinClientVersion;
if (!string.IsNullOrEmpty(this.Tags))
{
this.Tags = " " + this.Tags + " ";
}
}
public void Resolve(string workingDirectory, IPackageMetadata metadata, string folder, string templateName, bool forceUpgrade)
{
var protobuildMetadata = metadata as ProtobuildPackageMetadata;
var nuGet3Metadata = metadata as NuGet3PackageMetadata;
var transformedMetadata = metadata as TransformedPackageMetadata;
if (protobuildMetadata != null)
{
ResolveProtobuild(workingDirectory, protobuildMetadata, folder, templateName, forceUpgrade);
return;
}
if (nuGet3Metadata != null)
{
ResolveNuGet3(workingDirectory, nuGet3Metadata, folder, templateName, forceUpgrade);
return;
}
if (transformedMetadata != null)
{
ResolveTransformed(workingDirectory, transformedMetadata, folder, templateName, forceUpgrade);
return;
}
throw new InvalidOperationException("Unexpected metadata type " + metadata.GetType().Name + " for binary resolve.");
}
public static PackageLicenseModel FromV2Package(IPackageMetadata package)
{
return(new PackageLicenseModel(
package.Id,
package.LicenseUrl,
package.Authors));
}
internal string InitializeProperties(IPackageMetadata metadata)
{
// Set the properties that were resolved from the assembly/project so they can be
// resolved by name if the nuspec contains tokens
_properties.Clear();
_properties.Add("Id", metadata.Id);
_properties.Add("Version", metadata.Version.ToString());
if (!String.IsNullOrEmpty(metadata.Title))
{
_properties.Add("Title", metadata.Title);
}
if (!String.IsNullOrEmpty(metadata.Description))
{
_properties.Add("Description", metadata.Description);
}
if (!String.IsNullOrEmpty(metadata.Copyright))
{
_properties.Add("Copyright", metadata.Copyright);
}
string projectAuthor = metadata.Authors.FirstOrDefault();
if (!String.IsNullOrEmpty(projectAuthor))
{
_properties.Add("Author", projectAuthor);
}
return(projectAuthor);
}
public static Manifest Create(IPackageMetadata metadata)
{
return new Manifest
{
Metadata = new ManifestMetadata
{
Id = metadata.Id.SafeTrim(),
Version = metadata.Version.ToStringSafe(),
Title = metadata.Title.SafeTrim(),
Authors = GetCommaSeparatedString(metadata.Authors),
Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors),
Tags = String.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim(),
LicenseUrl = ConvertUrlToStringSafe(metadata.LicenseUrl),
ProjectUrl = ConvertUrlToStringSafe(metadata.ProjectUrl),
IconUrl = ConvertUrlToStringSafe(metadata.IconUrl),
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
// DevelopmentDependency = metadata.DevelopmentDependency,
Description = metadata.Description.SafeTrim(),
Copyright = metadata.Copyright.SafeTrim(),
Summary = metadata.Summary.SafeTrim(),
ReleaseNotes = metadata.ReleaseNotes.SafeTrim(),
Language = metadata.Language.SafeTrim(),
DependencySets = CreateDependencySets(metadata),
FrameworkAssemblies = CreateFrameworkAssemblies(metadata),
ReferenceSets = CreateReferenceSets(metadata),
MinClientVersionString = metadata.MinClientVersion.ToStringSafe()
},
};
}
public static IPackage BuildPackage(IPackageMetadata metadata, IEnumerable<IPackageFile> files)
{
var builder = new PackageBuilder();
CopyMetadata(metadata, builder);
builder.Files.AddRange(files);
return builder.Build();
}
public async Task PushPackage(string apiKey, string filePath, IPackageMetadata package, bool pushAsUnlisted)
{
string requestUri = EnsureTrailingSlash(_source) + ServiceEndpoint;
HttpWebRequest httpRequest = WebRequest.CreateHttp(requestUri);
httpRequest.Method = "PUT";
httpRequest.AllowAutoRedirect = true;
httpRequest.AllowWriteStreamBuffering = false;
httpRequest.KeepAlive = false;
httpRequest.Headers.Add(ApiKeyHeader, apiKey);
httpRequest.UserAgent = _userAgent;
var multipartRequest = new MultipartWebRequest();
multipartRequest.AddFile(new FileInfo(filePath), package.ToString());
// sending package data asynchronously
await multipartRequest.CreateMultipartRequest(httpRequest);
// waiting for response asynchronously
await EnsureSuccessfulResponse(httpRequest, HttpStatusCode.Created);
if (pushAsUnlisted)
{
await DeletePackageFromServer(apiKey, package.Id, package.Version.ToString());
}
}
public static Manifest Create(IPackageMetadata metadata)
{
ManifestMetadata metadata1 = new ManifestMetadata();
metadata1.Id = metadata.Id.SafeTrim();
metadata1.Version = metadata.Version.ToStringSafe();
metadata1.Title = metadata.Title.SafeTrim();
metadata1.Authors = GetCommaSeparatedString(metadata.Authors);
Manifest manifest1 = new Manifest();
Manifest manifest2 = new Manifest();
metadata1.Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors);
ManifestMetadata local3 = metadata1;
ManifestMetadata local4 = metadata1;
local4.Tags = string.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim();
ManifestMetadata local2 = local4;
local2.LicenseUrl = ConvertUrlToStringSafe(metadata.LicenseUrl);
local2.ProjectUrl = ConvertUrlToStringSafe(metadata.ProjectUrl);
local2.IconUrl = ConvertUrlToStringSafe(metadata.IconUrl);
local2.RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
local2.DevelopmentDependency = metadata.DevelopmentDependency;
local2.Description = metadata.Description.SafeTrim();
local2.Copyright = metadata.Copyright.SafeTrim();
local2.Summary = metadata.Summary.SafeTrim();
local2.ReleaseNotes = metadata.ReleaseNotes.SafeTrim();
local2.Language = metadata.Language.SafeTrim();
local2.DependencySets = CreateDependencySets(metadata);
local2.FrameworkAssemblies = CreateFrameworkAssemblies(metadata);
local2.ReferenceSets = CreateReferenceSets(metadata);
local2.MinClientVersionString = metadata.MinClientVersion.ToStringSafe();
manifest2.Metadata = local2;
return(manifest2);
}
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
}
}
}
private static List <ManifestFrameworkAssembly> CreateFrameworkAssemblies(IPackageMetadata metadata) =>
(!metadata.FrameworkAssemblies.IsEmpty <FrameworkAssemblyReference>() ? Enumerable.Select <FrameworkAssemblyReference, ManifestFrameworkAssembly>(metadata.FrameworkAssemblies, delegate(FrameworkAssemblyReference reference) {
ManifestFrameworkAssembly assembly1 = new ManifestFrameworkAssembly();
assembly1.AssemblyName = reference.AssemblyName;
assembly1.TargetFramework = string.Join(", ", Enumerable.Select <FrameworkName, string>(reference.SupportedFrameworks, new Func <FrameworkName, string>(VersionUtility.GetFrameworkString)));
return(assembly1);
}).ToList <ManifestFrameworkAssembly>() : null);
public static Manifest Create(IPackageMetadata metadata)
{
return new Manifest {
Metadata = new ManifestMetadata {
Id = metadata.Id.SafeTrim(),
Version = metadata.Version.ToStringSafe(),
Title = metadata.Title.SafeTrim(),
Authors = GetCommaSeparatedString(metadata.Authors),
Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors),
Tags = String.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim(),
LicenseUrl = metadata.LicenseUrl != null ? metadata.LicenseUrl.OriginalString.SafeTrim() : null,
ProjectUrl = metadata.ProjectUrl != null ? metadata.ProjectUrl.OriginalString.SafeTrim() : null,
IconUrl = metadata.IconUrl != null ? metadata.IconUrl.OriginalString.SafeTrim() : null,
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
Description = metadata.Description.SafeTrim(),
Summary = metadata.Summary.SafeTrim(),
Language = metadata.Language.SafeTrim(),
Dependencies = metadata.Dependencies == null ||
!metadata.Dependencies.Any() ? null :
(from d in metadata.Dependencies
select new ManifestDependency {
Id = d.Id.SafeTrim(),
Version = d.VersionSpec.ToStringSafe()
}).ToList(),
FrameworkAssemblies = metadata.FrameworkAssemblies == null ||
!metadata.FrameworkAssemblies.Any() ? null :
(from reference in metadata.FrameworkAssemblies
select new ManifestFrameworkAssembly {
AssemblyName = reference.AssemblyName,
TargetFramework = String.Join(", ", reference.SupportedFrameworks.Select(VersionUtility.GetFrameworkString))
}).ToList()
}
};
}
public async Task PushPackage(string apiKey, string filePath, IPackageMetadata package, bool pushAsUnlisted, bool appendV2ApiToUrl)
{
string requestUri = CreateRequestUri(appendV2ApiToUrl);
HttpWebRequest httpRequest = WebRequest.CreateHttp(requestUri);
httpRequest.Method = "PUT";
httpRequest.AllowAutoRedirect = true;
httpRequest.KeepAlive = false;
httpRequest.Headers.Add(ApiKeyHeader, apiKey);
httpRequest.UserAgent = _userAgent;
httpRequest.UseDefaultCredentials = true;
httpRequest.PreAuthenticate = true;
var multipartRequest = new MultipartWebRequest();
multipartRequest.AddFile(new FileInfo(filePath), package.ToString());
// sending package data asynchronously
await multipartRequest.CreateMultipartRequest(httpRequest);
// waiting for response asynchronously
await EnsureSuccessfulResponse(httpRequest, HttpStatusCode.Created);
if (pushAsUnlisted)
{
await DeletePackageFromServer(apiKey, package.Id, package.Version.ToString(), appendV2ApiToUrl);
}
}
private List <PackageRequest> GetNuGetPackageDependencies(IPackageMetadata package)
{
var dependencies = package.GetCompatiblePackageDependencies(SystemUtility.GetTargetFramework())
.Select(dependency => new PackageRequest
{
Id = dependency.Id,
VersionsRange = dependency.VersionSpec != null ? dependency.VersionSpec.ToString() : null,
RequestedBy = "package " + package.Id
}).ToList();
if (!dependencies.Any(p => string.Equals(p.Id, "Rhetos", StringComparison.OrdinalIgnoreCase)))
{
// FrameworkAssembly is an obsolete way of marking package dependency on a specific Rhetos version:
var rhetosFrameworkAssemblyRegex = new Regex(@"^Rhetos\s*,\s*Version\s*=\s*(\S+)$");
var parseFrameworkAssembly = package.FrameworkAssemblies
.Select(fa => rhetosFrameworkAssemblyRegex.Match(fa.AssemblyName.Trim()))
.SingleOrDefault(m => m.Success);
if (parseFrameworkAssembly != null)
{
dependencies.Add(new PackageRequest
{
Id = "Rhetos",
VersionsRange = parseFrameworkAssembly.Groups[1].Value,
RequestedBy = "package " + package.Id
});
}
}
return(dependencies);
}
public RoslynReflector(IPackageMetadata package)
{
_types = new Dictionary<string, TypeModel>();
_namespaces = new Dictionary<string, NamespaceModel>();
_extensions = new Dictionary<string, ExtensionModel>();
_package = package;
}
public static bool IsSatellitePackage(
IPackageMetadata package,
IPackageRepository repository,
FrameworkName targetFramework,
out IPackage runtimePackage)
{
// A satellite package has the following properties:
// 1) A package suffix that matches the package's language, with a dot preceding it
// 2) A dependency on the package with the same Id minus the language suffix
// 3) The dependency can be found by Id in the repository (as its path is needed for installation)
// Example: foo.ja-jp, with a dependency on foo
runtimePackage = null;
if (package.IsSatellitePackage())
{
string runtimePackageId = package.Id.Substring(0, package.Id.Length - (package.Language.Length + 1));
PackageDependency dependency = package.FindDependency(runtimePackageId, targetFramework);
if (dependency != null)
{
runtimePackage = repository.FindPackage(runtimePackageId, versionSpec: dependency.VersionSpec, allowPrereleaseVersions: true, allowUnlisted: true);
}
}
return(runtimePackage != null);
}
/// <summary>
/// Constructs a ManifestMetadata instance from an IPackageMetadata instance
/// </summary>
public ManifestMetadata(IPackageMetadata copy)
{
Id = copy.Id?.Trim();
Version = copy.Version;
Title = copy.Title?.Trim();
Authors = copy.Authors;
Owners = copy.Owners;
Tags = string.IsNullOrEmpty(copy.Tags) ? null : copy.Tags.Trim();
Serviceable = copy.Serviceable;
_licenseUrl = copy.LicenseUrl?.OriginalString;
_projectUrl = copy.ProjectUrl?.OriginalString;
_iconUrl = copy.IconUrl?.OriginalString;
RequireLicenseAcceptance = copy.RequireLicenseAcceptance;
Description = copy.Description?.Trim();
Copyright = copy.Copyright?.Trim();
Summary = copy.Summary?.Trim();
ReleaseNotes = copy.ReleaseNotes?.Trim();
Language = copy.Language?.Trim();
DependencyGroups = copy.DependencyGroups;
FrameworkReferences = copy.FrameworkReferences;
PackageAssemblyReferences = copy.PackageAssemblyReferences;
PackageTypes = copy.PackageTypes;
MinClientVersionString = copy.MinClientVersion?.ToString();
ContentFiles = copy.ContentFiles;
DevelopmentDependency = copy.DevelopmentDependency;
Repository = copy.Repository;
LicenseMetadata = copy.LicenseMetadata;
}
public static Manifest Create(IPackageMetadata metadata)
{
return(new Manifest {
Metadata = new ManifestMetadata {
Id = metadata.Id.SafeTrim(),
Version = metadata.Version.ToStringSafe(),
Title = metadata.Title.SafeTrim(),
Authors = GetCommaSeparatedString(metadata.Authors),
Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors),
Tags = String.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim(),
LicenseUrl = metadata.LicenseUrl != null?metadata.LicenseUrl.OriginalString.SafeTrim() : null,
ProjectUrl = metadata.ProjectUrl != null?metadata.ProjectUrl.OriginalString.SafeTrim() : null,
IconUrl = metadata.IconUrl != null?metadata.IconUrl.OriginalString.SafeTrim() : null,
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
Description = metadata.Description.SafeTrim(),
Summary = metadata.Summary.SafeTrim(),
Language = metadata.Language.SafeTrim(),
Dependencies = metadata.Dependencies == null ||
!metadata.Dependencies.Any() ? null :
(from d in metadata.Dependencies
select new ManifestDependency {
Id = d.Id.SafeTrim(),
Version = d.VersionSpec.ToStringSafe()
}).ToList(),
FrameworkAssemblies = metadata.FrameworkAssemblies == null ||
!metadata.FrameworkAssemblies.Any() ? null :
(from reference in metadata.FrameworkAssemblies
select new ManifestFrameworkAssembly {
AssemblyName = reference.AssemblyName,
TargetFramework = String.Join(", ", reference.SupportedFrameworks.Select(VersionUtility.GetFrameworkString))
}).ToList()
}
});
}
public async Task PushPackage(string apiKey, string filePath, IPackageMetadata package, bool pushAsUnlisted, bool appendV2ApiToUrl)
{
string requestUri = CreateRequestUri(appendV2ApiToUrl);
HttpWebRequest httpRequest = WebRequest.CreateHttp(requestUri);
httpRequest.Method = "PUT";
httpRequest.AllowAutoRedirect = true;
httpRequest.KeepAlive = false;
httpRequest.Headers.Add(ApiKeyHeader, apiKey);
httpRequest.Headers.Add("X-NuGet-Protocol-Version", "4.1.0");
httpRequest.UserAgent = _userAgent;
httpRequest.UseDefaultCredentials = true;
httpRequest.PreAuthenticate = true;
var multipartRequest = new MultipartWebRequest();
multipartRequest.AddFile(new FileInfo(filePath), package.ToString());
// sending package data asynchronously
await multipartRequest.CreateMultipartRequest(httpRequest);
// waiting for response asynchronously
await EnsureSuccessfulResponse(httpRequest, HttpStatusCode.Created);
if (pushAsUnlisted)
{
await DeletePackageFromServer(apiKey, package.Id, package.Version.ToString(), appendV2ApiToUrl);
}
}
public void Resolve(IPackageMetadata metadata, string folder, string templateName, bool forceUpgrade)
{
var gitMetadata = metadata as GitPackageMetadata;
var protobuildMetadata = metadata as ProtobuildPackageMetadata;
var folderMetadata = metadata as FolderPackageMetadata;
if (gitMetadata != null)
{
ResolveGit(gitMetadata, folder, templateName, forceUpgrade);
return;
}
if (protobuildMetadata != null)
{
ResolveProtobuild(protobuildMetadata, folder, templateName, forceUpgrade);
return;
}
if (folderMetadata != null)
{
ResolveFolder(folderMetadata, folder, templateName);
return;
}
throw new InvalidOperationException("Unexpected metadata type " + metadata.GetType().Name + " for source resolve.");
}
public void CopyFrom(IPackageMetadata source)
{
Id = source.Id;
Version = source.Version;
Title = source.Title;
Authors = ConvertToString(source.Authors);
Owners = ConvertToString(source.Owners);
IconUrl = FixIconUrl(source.IconUrl);
LicenseUrl = source.LicenseUrl;
ProjectUrl = source.ProjectUrl;
RequireLicenseAcceptance = source.RequireLicenseAcceptance;
DevelopmentDependency = source.DevelopmentDependency;
Description = source.Description;
Summary = source.Summary;
ReleaseNotes = source.ReleaseNotes;
Copyright = source.Copyright;
Language = source.Language;
Tags = source.Tags;
DependencySets = new ObservableCollection <PackageDependencySet>(source.DependencySets);
FrameworkAssemblies = new ObservableCollection <FrameworkAssemblyReference>(source.FrameworkAssemblies);
PackageAssemblyReferences = new ObservableCollection <PackageReferenceSet>();
if (source.PackageAssemblyReferences != null)
{
PackageAssemblyReferences.AddRange(source.PackageAssemblyReferences);
}
MinClientVersion = source.MinClientVersion;
}
public void Populate(ManifestMetadata manifestMetadata)
{
IPackageMetadata metadata = manifestMetadata;
Id = metadata.Id;
Version = metadata.Version;
Title = metadata.Title;
Authors.AddRange(metadata.Authors);
Owners.AddRange(metadata.Owners);
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
DevelopmentDependency = metadata.DevelopmentDependency;
Description = metadata.Description;
Summary = metadata.Summary;
ReleaseNotes = metadata.ReleaseNotes;
Language = metadata.Language;
Copyright = metadata.Copyright;
MinClientVersion = metadata.MinClientVersion;
ContentFiles = new List <ManifestContentFiles>(manifestMetadata.ContentFiles);
if (metadata.Tags != null)
{
Tags.AddRange(ParseTags(metadata.Tags));
}
DependencyGroups.AddRange(metadata.DependencyGroups);
FrameworkReferences.AddRange(metadata.FrameworkReferences);
if (manifestMetadata.PackageAssemblyReferences != null)
{
PackageAssemblyReferences.AddRange(manifestMetadata.PackageAssemblyReferences);
}
}
public static IPackage BuildPackage(IPackageMetadata metadata, IEnumerable <IPackageFile> files)
{
var builder = new PackageBuilder();
CopyMetadata(metadata, builder);
builder.Files.AddRange(files);
return(builder.Build());
}
public static bool IsInstalled(this IPackageMetadata package, IPackageRepository repo)
{
if (package != null && package.Id != null)
{
return(repo.FindPackage(package.Id) != null);
}
return(false);
}
public static bool IsReleaseVersion(this IPackageMetadata packageMetadata)
{
if (packageMetadata is null)
{
throw new System.ArgumentNullException(nameof(packageMetadata));
}
return(packageMetadata.Version.IsPrerelease);
}
public static string GetFullName(this IPackageMetadata package)
{
if (package is null)
{
throw new System.ArgumentNullException(nameof(package));
}
return(package.Id + " " + package.Version);
}
internal RoslynReflector(IPackageMetadata package, Abstractions.INugetHelper nugetHelper)
{
_types = new Dictionary <string, TypeModel>();
_namespaces = new Dictionary <string, NamespaceModel>();
_extensions = new Dictionary <string, ExtensionModel>();
_package = package;
_nugetHelper = nugetHelper;
}
public bool Equals(IPackageMetadata other)
{
return(Id.Equals(other.Id) &&
Version.Equals(other.Version) &&
LocalPath.Equals(other.LocalPath) &&
AreTargetFrameworksEqual(TargetFrameworks, other.TargetFrameworks) &&
AreAssembliesEqual(Assemblies, other.Assemblies));
}
public bool Equals(IPackageMetadata other)
{
return Id.Equals(other.Id)
&& Version.Equals(other.Version)
&& LocalPath.Equals(other.LocalPath)
&& AreTargetFrameworksEqual(TargetFrameworks, other.TargetFrameworks)
&& AreAssembliesEqual(Assemblies, other.Assemblies);
}
private void EnsureManifest()
{
using (Stream stream = _streamFactory())
{
Package package = Package.Open(stream);
PackageRelationship relationshipType =
package.GetRelationshipsByType(Constants.PackageRelationshipNamespace +
PackageBuilder.ManifestRelationType).SingleOrDefault();
if (relationshipType == null)
{
throw new InvalidOperationException(NuGetResources.PackageDoesNotContainManifest);
}
PackagePart manifestPart = package.GetPart(relationshipType.TargetUri);
if (manifestPart == null)
{
throw new InvalidOperationException(NuGetResources.PackageDoesNotContainManifest);
}
using (Stream manifestStream = manifestPart.GetStream())
{
Manifest manifest = Manifest.ReadFrom(manifestStream);
IPackageMetadata metadata = manifest.Metadata;
Id = metadata.Id;
Version = metadata.Version;
Title = metadata.Title;
Authors = metadata.Authors;
Owners = metadata.Owners;
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
Description = metadata.Description;
Summary = metadata.Summary;
ReleaseNotes = metadata.ReleaseNotes;
Copyright = metadata.Copyright;
Language = metadata.Language;
Tags = metadata.Tags;
Serviceable = metadata.Serviceable;
DependencySets = metadata.DependencySets;
FrameworkAssemblies = metadata.FrameworkAssemblies;
PackageAssemblyReferences = metadata.PackageAssemblyReferences;
Published = File.GetLastWriteTimeUtc(_filePath);
MinClientVersion = metadata.MinClientVersion;
DevelopmentDependency = metadata.DevelopmentDependency;
// Ensure tags start and end with an empty " " so we can do contains filtering reliably
if (!String.IsNullOrEmpty(Tags))
{
Tags = " " + Tags + " ";
}
}
}
}
private static List <ManifestReferenceSet> CreateReferenceSets(IPackageMetadata metadata) =>
Enumerable.Select <PackageReferenceSet, ManifestReferenceSet>(metadata.PackageAssemblyReferences, delegate(PackageReferenceSet referenceSet) {
ManifestReferenceSet set1 = new ManifestReferenceSet();
ManifestReferenceSet set2 = new ManifestReferenceSet();
set2.TargetFramework = (referenceSet.TargetFramework != null) ? VersionUtility.GetFrameworkString(referenceSet.TargetFramework) : null;
ManifestReferenceSet local1 = set2;
local1.References = CreateReferences(referenceSet);
return(local1);
}).ToList <ManifestReferenceSet>();
private static List <ManifestDependencySet> CreateDependencySets(IPackageMetadata metadata) =>
(!metadata.DependencySets.IsEmpty <PackageDependencySet>() ? Enumerable.Select <PackageDependencySet, ManifestDependencySet>(metadata.DependencySets, delegate(PackageDependencySet dependencySet) {
ManifestDependencySet set1 = new ManifestDependencySet();
ManifestDependencySet set2 = new ManifestDependencySet();
set2.TargetFramework = (dependencySet.TargetFramework != null) ? VersionUtility.GetFrameworkString(dependencySet.TargetFramework) : null;
ManifestDependencySet local1 = set2;
local1.Dependencies = CreateDependencies(dependencySet.Dependencies);
return(local1);
}).ToList <ManifestDependencySet>() : null);
private static List <ManifestReferenceSet> CreateReferenceSets(IPackageMetadata metadata)
{
return((from referenceSet in metadata.PackageAssemblyReferences
select new ManifestReferenceSet
{
TargetFramework = referenceSet.TargetFramework != null ? VersionUtility.GetFrameworkString(referenceSet.TargetFramework) : null,
References = CreateReferences(referenceSet)
}).ToList());
}
public void NotifyFileAdded(IPackageMetadata package, string filepath, PackageType packageType)
{
var item = new MruItem {
Path = filepath.ToLowerInvariant(),
Id = package.Id,
Version = package.Version,
PackageType = packageType
};
AddFile(item);
}
public void GetProtobuildPackageBinary(IPackageMetadata metadata, out string archiveType, out byte[] packageData)
{
var protobuildPackageMetadata = metadata as ProtobuildPackageMetadata;
if (protobuildPackageMetadata == null)
{
throw new InvalidOperationException("Can't call GetProtobuildPackageBinary on non-Protobuild package metadata");
}
archiveType = protobuildPackageMetadata.BinaryFormat;
packageData = GetProtobuildBinaryPackage(protobuildPackageMetadata);
}
public IPackage DownloadPackage(IHttpClient downloadClient, byte[] packageHash, IPackageMetadata package)
{
if (downloadClient == null)
{
throw new ArgumentNullException("downloadClient");
}
if (packageHash == null)
{
throw new ArgumentNullException("packageHash");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
// Get the operation display text
string operation = String.Format(CultureInfo.CurrentCulture, NuGetResources.DownloadProgressStatus, package.Id, package.Version);
EventHandler<ProgressEventArgs> progressAvailableHandler = (sender, e) =>
{
OnPackageDownloadProgress(new ProgressEventArgs(operation, e.PercentComplete));
};
EventHandler<WebRequestEventArgs> beforeSendingRequesthandler = (sender, e) =>
{
OnSendingRequest(e.Request);
};
try
{
downloadClient.ProgressAvailable += progressAvailableHandler;
downloadClient.SendingRequest += beforeSendingRequesthandler;
// TODO: This gets held onto in memory which we want to get rid of eventually
byte[] buffer = downloadClient.DownloadData();
if (!_hashProvider.VerifyHash(buffer, packageHash))
{
throw new InvalidDataException(NuGetResources.PackageContentsVerifyError);
}
return _packageFactory.CreatePackage(() =>
{
return new MemoryStream(buffer);
});
}
finally
{
downloadClient.ProgressAvailable -= progressAvailableHandler;
downloadClient.SendingRequest -= beforeSendingRequesthandler;
}
}
public virtual void DownloadPackage(Uri uri, IPackageMetadata package, Stream targetStream)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
var downloadClient = new HttpClient(uri)
{
UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient)
};
DownloadPackage(downloadClient, package, targetStream);
}
static void checkIfNuspecHasRequiredFields(IPackageMetadata zp, string packageFile)
{
if (String.IsNullOrWhiteSpace(zp.Id))
throw new Exception(String.Format("Invalid 'id' value in nuspec file at '{0}'", packageFile));
if (String.IsNullOrWhiteSpace(zp.Version.ToString()))
throw new Exception(String.Format("Invalid 'version' value in nuspec file at '{0}'", packageFile));
if (zp.Authors.All(String.IsNullOrWhiteSpace))
throw new Exception(String.Format("Invalid 'authors' value in nuspec file at '{0}'", zp.Authors));
if (String.IsNullOrWhiteSpace(zp.Description))
throw new Exception(String.Format("Invalid 'description' value in nuspec file at '{0}'", zp.Description));
}
private void OutputDependencies(IPackageMetadata package)
{
if (package.DependencySets.Any())
{
Console.WriteLine("Package Dependencies:");
foreach (var dependencySet in package.DependencySets)
{
foreach (var dependency in dependencySet.Dependencies)
{
Console.WriteLine("".PadLeft(_indent) + string.Format("{0} - {1} {2}",dependencySet.TargetFramework, dependency.Id, dependency.VersionSpec));
}
}
}
}
public virtual IPackage DownloadPackage(Uri uri, IPackageMetadata package)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
var downloadClient = new HttpClient(uri)
{
UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient)
};
return DownloadPackage(downloadClient, package);
}
public void CreatePackage(string apiKey, Stream packageStream, IObserver<int> progressObserver, IPackageMetadata metadata = null)
{
var state = new PublishState {
PublishKey = apiKey,
PackageMetadata = metadata,
ProgressObserver = progressObserver
};
var url = new Uri(String.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}/nupkg", _baseGalleryServerUrl, CreatePackageService, apiKey));
WebClient client = new WebClient();
client.Proxy = _cachedProxy;
client.Headers[HttpRequestHeader.ContentType] = "application/octet-stream";
client.Headers[HttpRequestHeader.UserAgent] = _userAgent;
client.UploadProgressChanged += OnUploadProgressChanged;
client.UploadDataCompleted += OnCreatePackageCompleted;
client.UploadDataAsync(url, "POST", packageStream.ReadAllBytes(), state);
}
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);
}
public IPackage DownloadPackage(Uri uri, byte[] packageHash, IPackageMetadata package)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (packageHash == null)
{
throw new ArgumentNullException("packageHash");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
var downloadClient = new HttpClient(uri);
downloadClient.UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient);
return DownloadPackage(downloadClient, packageHash, package);
}
public void Resolve(IPackageMetadata metadata, string folder, string templateName, bool forceUpgrade)
{
var protobuildMetadata = metadata as ProtobuildPackageMetadata;
var transformedMetadata = metadata as TransformedPackageMetadata;
if (protobuildMetadata != null)
{
ResolveProtobuild(protobuildMetadata, folder, templateName, forceUpgrade);
return;
}
if (transformedMetadata != null)
{
ResolveTransformed(transformedMetadata, folder, templateName, forceUpgrade);
return;
}
throw new InvalidOperationException("Unexpected metadata type " + metadata.GetType().Name + " for binary resolve.");
}
public PackageContentsViewModel(IPackageMetadata packageMetadata, ICollection<User> owners, PackageItem rootFolder)
{
_packageMetadata = packageMetadata;
_rootFolder = rootFolder;
FlattenedAuthors = String.Join(", ", packageMetadata.Authors);
FlattenedOwners = String.Join(", ", owners.Select(o => o.Username));
IconUrl = packageMetadata.IconUrl == null ? null : packageMetadata.IconUrl.AbsoluteUri;
FrameworkAssemblies = packageMetadata.FrameworkAssemblies.Select(
f =>
{
if (f.SupportedFrameworks.Any())
{
return String.Format(CultureInfo.InvariantCulture, "{0} ({1})", f.AssemblyName, String.Join("; ", f.SupportedFrameworks));
}
else
{
return f.AssemblyName;
}
}).ToList();
}
public IPackage DownloadPackage(IHttpClient downloadClient, IPackageMetadata package)
{
if (downloadClient == null)
{
throw new ArgumentNullException("downloadClient");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
// Get the operation display text
string operation = String.Format(CultureInfo.CurrentCulture, NuGetResources.DownloadProgressStatus, package.Id, package.Version);
EventHandler<ProgressEventArgs> progressAvailableHandler = (sender, e) =>
{
OnPackageDownloadProgress(new ProgressEventArgs(operation, e.PercentComplete));
};
EventHandler<WebRequestEventArgs> beforeSendingRequesthandler = (sender, e) =>
{
OnSendingRequest(e.Request);
};
try
{
downloadClient.ProgressAvailable += progressAvailableHandler;
downloadClient.SendingRequest += beforeSendingRequesthandler;
// TODO: This gets held onto in memory which we want to get rid of eventually
byte[] buffer = downloadClient.DownloadData();
Func<Stream> streamFactory = () => new MemoryStream(buffer, writable: false);
return new ZipPackage(streamFactory, enableCaching: true);
}
finally
{
downloadClient.ProgressAvailable -= progressAvailableHandler;
downloadClient.SendingRequest -= beforeSendingRequesthandler;
}
}
/// <summary>
/// Constructs a ManifestMetadata instance from an IPackageMetadata instance
/// </summary>
public ManifestMetadata(IPackageMetadata copy)
{
Id = copy.Id?.Trim();
Version = copy.Version;
Title = copy.Title?.Trim();
Authors = copy.Authors;
Owners = copy.Owners;
Tags = string.IsNullOrEmpty(copy.Tags) ? null : copy.Tags.Trim();
LicenseUrl = copy.LicenseUrl;
ProjectUrl = copy.ProjectUrl;
IconUrl = copy.IconUrl;
RequireLicenseAcceptance = copy.RequireLicenseAcceptance;
Description = copy.Description?.Trim();
Copyright = copy.Copyright?.Trim();
Summary = copy.Summary?.Trim();
ReleaseNotes = copy.ReleaseNotes?.Trim();
Language = copy.Language?.Trim();
DependencySets = copy.DependencySets;
FrameworkAssemblies = copy.FrameworkAssemblies;
PackageAssemblyReferences = copy.PackageAssemblyReferences;
MinClientVersionString = copy.MinClientVersion?.ToString();
}
public void DownloadPackage(IHttpClient downloadClient, IPackageMetadata package, Stream targetStream)
{
if (downloadClient == null)
{
throw new ArgumentNullException("downloadClient");
}
if (targetStream == null)
{
throw new ArgumentNullException("targetStream");
}
// Get the operation display text
string operation = String.Format(CultureInfo.CurrentCulture, NuGetResources.DownloadProgressStatus, package.Id, package.Version);
EventHandler<ProgressEventArgs> progressAvailableHandler = (sender, e) =>
{
OnPackageDownloadProgress(new ProgressEventArgs(operation, e.PercentComplete));
};
EventHandler<WebRequestEventArgs> beforeSendingRequesthandler = (sender, e) =>
{
OnSendingRequest(e.Request);
};
try
{
downloadClient.ProgressAvailable += progressAvailableHandler;
downloadClient.SendingRequest += beforeSendingRequesthandler;
downloadClient.DownloadData(targetStream);
}
finally
{
downloadClient.ProgressAvailable -= progressAvailableHandler;
downloadClient.SendingRequest -= beforeSendingRequesthandler;
}
}
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;
}
private static List<ManifestFrameworkAssembly> CreateFrameworkAssemblies(IPackageMetadata metadata)
{
if (metadata.FrameworkAssemblies.IsEmpty())
{
return null;
}
return (from reference in metadata.FrameworkAssemblies
select new ManifestFrameworkAssembly
{
AssemblyName = reference.AssemblyName,
TargetFramework = String.Join(", ", reference.SupportedFrameworks.Select(VersionUtility.GetFrameworkString))
}).ToList();
}
private static List<ManifestReferenceSet> CreateReferenceSets(IPackageMetadata metadata)
{
return (from referenceSet in metadata.PackageAssemblyReferences
select new ManifestReferenceSet
{
TargetFramework = referenceSet.TargetFramework != null ? VersionUtility.GetFrameworkString(referenceSet.TargetFramework) : null,
References = CreateReferences(referenceSet)
}).ToList();
}
private static List<ManifestDependencySet> CreateDependencySets(IPackageMetadata metadata)
{
if (metadata.DependencySets.IsEmpty())
{
return null;
}
return (from dependencySet in metadata.DependencySets
select new ManifestDependencySet
{
TargetFramework = dependencySet.TargetFramework != null ? VersionUtility.GetFrameworkString(dependencySet.TargetFramework) : null,
Dependencies = CreateDependencies(dependencySet.Dependencies)
}).ToList();
}
