public static PackageSpec GetPackageSpec(JObject rawPackageSpec, string name, string packageSpecPath, string snapshotValue) { var packageSpec = new PackageSpec(); // Parse properties we know about var version = rawPackageSpec["version"]; var authors = rawPackageSpec["authors"]; var contentFiles = rawPackageSpec["contentFiles"]; packageSpec.Name = name; packageSpec.FilePath = name == null ? null : Path.GetFullPath(packageSpecPath); if (version != null) { try { var versionString = version.Value <string>(); packageSpec.HasVersionSnapshot = PackageSpecUtility.IsSnapshotVersion(versionString); packageSpec.Version = PackageSpecUtility.SpecifySnapshot(versionString, snapshotValue); } catch (Exception ex) { var lineInfo = (IJsonLineInfo)version; throw FileFormatException.Create(ex, version, packageSpec.FilePath); } } var packInclude = rawPackageSpec["packInclude"] as JObject; if (packInclude != null) { foreach (var include in packInclude) { packageSpec.PackInclude.Add(new KeyValuePair <string, string>(include.Key, include.Value.ToString())); } } packageSpec.Title = rawPackageSpec.GetValue <string>("title"); packageSpec.Description = rawPackageSpec.GetValue <string>("description"); packageSpec.Authors = authors == null ? new string[] { } : authors.ValueAsArray <string>(); packageSpec.ContentFiles = contentFiles == null ? new string[] { } : contentFiles.ValueAsArray <string>(); packageSpec.Dependencies = new List <LibraryDependency>(); packageSpec.Copyright = rawPackageSpec.GetValue <string>("copyright"); packageSpec.Language = rawPackageSpec.GetValue <string>("language"); var buildOptions = rawPackageSpec["buildOptions"] as JObject; if (buildOptions != null) { packageSpec.BuildOptions = new BuildOptions() { OutputName = buildOptions.GetValue <string>("outputName") }; } var scripts = rawPackageSpec["scripts"] as JObject; if (scripts != null) { foreach (var script in scripts) { var value = script.Value; if (value.Type == JTokenType.String) { packageSpec.Scripts[script.Key] = new string[] { value.Value <string>() }; } else if (value.Type == JTokenType.Array) { packageSpec.Scripts[script.Key] = script.Value.ValueAsArray <string>(); } else { throw FileFormatException.Create( string.Format("The value of a script in '{0}' can only be a string or an array of strings", PackageSpec.PackageSpecFileName), value, packageSpec.FilePath); } } } BuildTargetFrameworks(packageSpec, rawPackageSpec); PopulateDependencies( packageSpec.FilePath, packageSpec.Dependencies, rawPackageSpec, "dependencies", isGacOrFrameworkReference: false); packageSpec.PackOptions = GetPackOptions(packageSpec, rawPackageSpec); packageSpec.RestoreSettings = GetRestoreSettings(packageSpec, rawPackageSpec); packageSpec.RestoreMetadata = GetMSBuildMetadata(packageSpec, rawPackageSpec); // Read the runtime graph packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec); // Read the name/path if it exists if (packageSpec.Name == null) { packageSpec.Name = packageSpec.RestoreMetadata?.ProjectName; } // Use the project.json path if one is set, otherwise use the project path if (packageSpec.FilePath == null) { packageSpec.FilePath = packageSpec.RestoreMetadata?.ProjectJsonPath ?? packageSpec.RestoreMetadata?.ProjectPath; } return(packageSpec); }
private static void PopulateDependencies( string packageSpecPath, IList <LibraryDependency> results, JObject settings, string propertyName, bool isGacOrFrameworkReference) { var dependencies = settings[propertyName] as JObject; if (dependencies != null) { foreach (var dependency in dependencies) { if (string.IsNullOrEmpty(dependency.Key)) { throw FileFormatException.Create( "Unable to resolve dependency ''.", dependency.Value, packageSpecPath); } // Support // "dependencies" : { // "Name" : "1.0" // } var dependencyValue = dependency.Value; var dependencyTypeValue = LibraryDependencyType.Default; var dependencyIncludeFlagsValue = LibraryIncludeFlags.All; var dependencyExcludeFlagsValue = LibraryIncludeFlags.None; var suppressParentFlagsValue = LibraryIncludeFlagUtils.DefaultSuppressParent; var noWarn = new List <NuGetLogCode>(); // This method handles both the dependencies and framework assembly sections. // Framework references should be limited to references. // Dependencies should allow everything but framework references. var targetFlagsValue = isGacOrFrameworkReference ? LibraryDependencyTarget.Reference : LibraryDependencyTarget.All & ~LibraryDependencyTarget.Reference; var autoReferenced = false; var generatePathProperty = false; string dependencyVersionValue = null; var dependencyVersionToken = dependencyValue; if (dependencyValue.Type == JTokenType.String) { dependencyVersionValue = dependencyValue.Value <string>(); } else { if (dependencyValue.Type == JTokenType.Object) { dependencyVersionToken = dependencyValue["version"]; if (dependencyVersionToken != null && dependencyVersionToken.Type == JTokenType.String) { dependencyVersionValue = dependencyVersionToken.Value <string>(); } } IEnumerable <string> strings; if (TryGetStringEnumerable(dependencyValue["type"], out strings)) { dependencyTypeValue = LibraryDependencyType.Parse(strings); // Types are used at pack time, they should be translated to suppressParent to // provide a matching effect for project to project references. // This should be set before suppressParent is checked. if (!dependencyTypeValue.Contains(LibraryDependencyTypeFlag.BecomesNupkgDependency)) { suppressParentFlagsValue = LibraryIncludeFlags.All; } else if (dependencyTypeValue.Contains(LibraryDependencyTypeFlag.SharedFramework)) { dependencyIncludeFlagsValue = LibraryIncludeFlags.Build | LibraryIncludeFlags.Compile | LibraryIncludeFlags.Analyzers; } } if (TryGetStringEnumerable(dependencyValue["include"], out strings)) { dependencyIncludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings); } if (TryGetStringEnumerable(dependencyValue["exclude"], out strings)) { dependencyExcludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings); } if (TryGetStringEnumerable(dependencyValue["suppressParent"], out strings)) { // This overrides any settings that came from the type property. suppressParentFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings); } noWarn = GetNuGetLogCodeEnumerableFromJArray(dependencyValue["noWarn"]) .ToList(); var targetToken = dependencyValue["target"]; if (targetToken != null) { var targetString = targetToken.Value <string>(); targetFlagsValue = LibraryDependencyTargetUtils.Parse(targetString); // Verify that the value specified is package, project, or external project if (!ValidateDependencyTarget(targetFlagsValue)) { var message = string.Format( CultureInfo.CurrentCulture, Strings.InvalidDependencyTarget, targetString); throw FileFormatException.Create(message, targetToken, packageSpecPath); } } autoReferenced = GetBoolOrFalse(dependencyValue, "autoReferenced", packageSpecPath); generatePathProperty = GetBoolOrFalse(dependencyValue, "generatePathProperty", packageSpecPath); } VersionRange dependencyVersionRange = null; if (!string.IsNullOrEmpty(dependencyVersionValue)) { try { dependencyVersionRange = VersionRange.Parse(dependencyVersionValue); } catch (Exception ex) { throw FileFormatException.Create( ex, dependencyVersionToken, packageSpecPath); } } // Projects and References may have empty version ranges, Packages may not if (dependencyVersionRange == null) { if ((targetFlagsValue & LibraryDependencyTarget.Package) == LibraryDependencyTarget.Package) { throw FileFormatException.Create( new ArgumentException(Strings.MissingVersionOnDependency), dependency.Value, packageSpecPath); } else { // Projects and references with no version property allow all versions dependencyVersionRange = VersionRange.All; } } // the dependency flags are: Include flags - Exclude flags var includeFlags = dependencyIncludeFlagsValue & ~dependencyExcludeFlagsValue; results.Add(new LibraryDependency() { LibraryRange = new LibraryRange() { Name = dependency.Key, TypeConstraint = targetFlagsValue, VersionRange = dependencyVersionRange, }, Type = dependencyTypeValue, IncludeType = includeFlags, SuppressParent = suppressParentFlagsValue, AutoReferenced = autoReferenced, NoWarn = noWarn.ToList(), GeneratePathProperty = generatePathProperty }); } } }
private static PackOptions GetPackOptions(PackageSpec packageSpec, JObject rawPackageSpec) { var rawPackOptions = rawPackageSpec.Value <JToken>(PackOptions) as JObject; if (rawPackOptions == null) { packageSpec.Owners = new string[] { }; packageSpec.Tags = new string[] { }; return(new PackOptions { PackageType = new PackageType[0] }); } var owners = rawPackOptions["owners"]; var tags = rawPackOptions["tags"]; packageSpec.Owners = owners == null?Array.Empty <string>() : owners.ValueAsArray <string>(); packageSpec.Tags = tags == null?Array.Empty <string>() : tags.ValueAsArray <string>(); packageSpec.ProjectUrl = rawPackOptions.GetValue <string>("projectUrl"); packageSpec.IconUrl = rawPackOptions.GetValue <string>("iconUrl"); packageSpec.Summary = rawPackOptions.GetValue <string>("summary"); packageSpec.ReleaseNotes = rawPackOptions.GetValue <string>("releaseNotes"); packageSpec.LicenseUrl = rawPackOptions.GetValue <string>("licenseUrl"); packageSpec.RequireLicenseAcceptance = GetBoolOrFalse(rawPackOptions, "requireLicenseAcceptance", packageSpec.FilePath); var rawPackageType = rawPackOptions[PackageType]; if (rawPackageType != null && rawPackageType.Type != JTokenType.String && (rawPackageType.Type != JTokenType.Array || // The array must be all strings. rawPackageType.Type == JTokenType.Array && rawPackageType.Any(t => t.Type != JTokenType.String)) && rawPackageType.Type != JTokenType.Null) { throw FileFormatException.Create( string.Format( CultureInfo.CurrentCulture, Strings.InvalidPackageType, PackageSpec.PackageSpecFileName), rawPackageType, packageSpec.FilePath); } IEnumerable <string> packageTypeNames; if (!TryGetStringEnumerableFromJArray(rawPackageType, out packageTypeNames)) { packageTypeNames = Enumerable.Empty <string>(); } Dictionary <string, IncludeExcludeFiles> mappings = null; IncludeExcludeFiles files = null; var rawFiles = rawPackOptions[Files] as JObject; if (rawFiles != null) { files = new IncludeExcludeFiles(); if (!files.HandleIncludeExcludeFiles(rawFiles)) { files = null; } var rawMappings = rawFiles["mappings"] as JObject; if (rawMappings != null) { mappings = new Dictionary <string, IncludeExcludeFiles>(); foreach (var pair in rawMappings) { var key = pair.Key; var value = pair.Value; if (value.Type == JTokenType.String || value.Type == JTokenType.Array) { IEnumerable <string> includeFiles; TryGetStringEnumerableFromJArray(value, out includeFiles); var includeExcludeFiles = new IncludeExcludeFiles() { Include = includeFiles?.ToList() }; mappings.Add(key, includeExcludeFiles); } else if (value.Type == JTokenType.Object) { var includeExcludeFiles = new IncludeExcludeFiles(); if (includeExcludeFiles.HandleIncludeExcludeFiles(value as JObject)) { mappings.Add(key, includeExcludeFiles); } } } } } return(new PackOptions { PackageType = packageTypeNames .Select(name => new PackageType(name, Packaging.Core.PackageType.EmptyVersion)) .ToList(), IncludeExcludeFiles = files, Mappings = mappings }); }
private static void PopulateDownloadDependencies(IList <DownloadDependency> downloadDependencies, JObject properties, string packageSpecPath) { var splitChars = new[] { ';' }; var seenIds = new HashSet <string>(); var downloadDependenciesProperty = properties["downloadDependencies"] as JArray; if (downloadDependenciesProperty != null) { foreach (var dependency in downloadDependenciesProperty.Values <JToken>()) { if (dependency["name"] == null) { throw FileFormatException.Create( "Unable to resolve downloadDependency ''.", dependency, packageSpecPath); } var name = dependency["name"].Value <string>(); if (!seenIds.Add(name)) { // package ID already seen, only use first definition. continue; } string versionValue = null; var dependencyVersionToken = dependency["version"]; if (dependencyVersionToken != null && dependencyVersionToken.Type == JTokenType.String) { versionValue = dependencyVersionToken.Value <string>(); } VersionRange version = null; if (!string.IsNullOrEmpty(versionValue)) { var versions = versionValue.Split(splitChars, StringSplitOptions.RemoveEmptyEntries); foreach (var singleVersionValue in versions) { try { version = VersionRange.Parse(singleVersionValue); downloadDependencies.Add(new DownloadDependency(name, version)); } catch (Exception ex) { throw FileFormatException.Create( ex, dependencyVersionToken, packageSpecPath); } } } else { throw FileFormatException.Create( "The version cannot be null or empty", dependencyVersionToken, packageSpecPath); } } } }
public static PackageSpec GetPackageSpec(Stream stream, string name, string packageSpecPath) { // Load the raw JSON into the package spec object var reader = new JsonTextReader(new StreamReader(stream)); JObject rawPackageSpec; try { rawPackageSpec = JObject.Load(reader); } catch (JsonReaderException ex) { throw FileFormatException.Create(ex, packageSpecPath); } var packageSpec = new PackageSpec(rawPackageSpec); // Parse properties we know about var version = rawPackageSpec["version"]; var authors = rawPackageSpec["authors"]; var owners = rawPackageSpec["owners"]; var tags = rawPackageSpec["tags"]; var contentFiles = rawPackageSpec["contentFiles"]; packageSpec.Name = name; packageSpec.FilePath = Path.GetFullPath(packageSpecPath); if (version == null) { packageSpec.Version = new NuGetVersion("1.0.0"); packageSpec.IsDefaultVersion = true; } else { try { packageSpec.Version = SpecifySnapshot(version.Value <string>(), snapshotValue: string.Empty); } catch (Exception ex) { var lineInfo = (IJsonLineInfo)version; throw FileFormatException.Create(ex, version, packageSpec.FilePath); } } var packInclude = rawPackageSpec["packInclude"] as JObject; if (packInclude != null) { foreach (var include in packInclude) { packageSpec.PackInclude.Add(new KeyValuePair <string, string>(include.Key, include.Value.ToString())); } } packageSpec.Title = rawPackageSpec.GetValue <string>("title"); packageSpec.Description = rawPackageSpec.GetValue <string>("description"); packageSpec.Authors = authors == null ? new string[] { } : authors.ValueAsArray <string>(); packageSpec.Owners = owners == null ? new string[] { } : owners.ValueAsArray <string>(); packageSpec.ContentFiles = contentFiles == null ? new string[] { } : contentFiles.ValueAsArray <string>(); packageSpec.Dependencies = new List <LibraryDependency>(); packageSpec.ProjectUrl = rawPackageSpec.GetValue <string>("projectUrl"); packageSpec.IconUrl = rawPackageSpec.GetValue <string>("iconUrl"); packageSpec.LicenseUrl = rawPackageSpec.GetValue <string>("licenseUrl"); packageSpec.Copyright = rawPackageSpec.GetValue <string>("copyright"); packageSpec.Language = rawPackageSpec.GetValue <string>("language"); packageSpec.Summary = rawPackageSpec.GetValue <string>("summary"); packageSpec.ReleaseNotes = rawPackageSpec.GetValue <string>("releaseNotes"); var requireLicenseAcceptance = rawPackageSpec["requireLicenseAcceptance"]; if (requireLicenseAcceptance != null) { try { packageSpec.RequireLicenseAcceptance = rawPackageSpec.GetValue <bool?>("requireLicenseAcceptance") ?? false; } catch (Exception ex) { throw FileFormatException.Create(ex, requireLicenseAcceptance, packageSpecPath); } } packageSpec.Tags = tags == null ? new string[] { } : tags.ValueAsArray <string>(); var scripts = rawPackageSpec["scripts"] as JObject; if (scripts != null) { foreach (var script in scripts) { var value = script.Value; if (value.Type == JTokenType.String) { packageSpec.Scripts[script.Key] = new string[] { value.Value <string>() }; } else if (value.Type == JTokenType.Array) { packageSpec.Scripts[script.Key] = script.Value.ValueAsArray <string>(); } else { throw FileFormatException.Create( string.Format("The value of a script in '{0}' can only be a string or an array of strings", PackageSpec.PackageSpecFileName), value, packageSpec.FilePath); } } } BuildTargetFrameworks(packageSpec, rawPackageSpec); PopulateDependencies( packageSpec.FilePath, packageSpec.Dependencies, rawPackageSpec, "dependencies", isGacOrFrameworkReference: false); packageSpec.Tools = ReadTools(packageSpec, rawPackageSpec).ToList(); packageSpec.PackOptions = GetPackOptions(packageSpec, rawPackageSpec); // Read the runtime graph packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec); return(packageSpec); }
private static IEnumerable <ToolDependency> ReadTools(PackageSpec packageSpec, JObject rawPackageSpec) { var tools = rawPackageSpec["tools"] as JObject; if (tools != null) { foreach (var tool in tools) { if (string.IsNullOrEmpty(tool.Key)) { throw FileFormatException.Create( Strings.MissingToolName, tool.Value, packageSpec.FilePath); } var value = tool.Value; JToken versionToken = null; string versionValue = null; var imports = new List <NuGetFramework>(); if (value.Type == JTokenType.String) { versionToken = value; versionValue = value.Value <string>(); } else { if (value.Type == JTokenType.Object) { versionToken = value["version"]; if (versionToken != null && versionToken.Type == JTokenType.String) { versionValue = versionToken.Value <string>(); } imports.AddRange(GetImports((JObject)value, packageSpec)); } } if (versionValue == null) { throw FileFormatException.Create( Strings.MissingVersionOnTool, tool.Value, packageSpec.FilePath); } VersionRange versionRange; try { versionRange = VersionRange.Parse(versionValue); } catch (Exception ex) { throw FileFormatException.Create( ex, versionToken, packageSpec.FilePath); } yield return(new ToolDependency { LibraryRange = new LibraryRange { Name = tool.Key, TypeConstraint = LibraryDependencyTarget.Package, VersionRange = versionRange }, Imports = imports }); } } }