public RestoreRequest(PackageSpec project, IEnumerable<PackageSource> sources, string packagesDirectory) { Project = project; Sources = sources.ToList().AsReadOnly(); PackagesDirectory = packagesDirectory; ExternalProjects = new List<ExternalProjectReference>(); WriteMSBuildFiles = true; }
public PackageSpecResolver(PackageSpec packageSpec) { // Preload the cache with the package spec provided _projects[packageSpec.Name] = new PackageSpecInformation() { Name = packageSpec.Name, FullPath = packageSpec.FilePath, PackageSpec = packageSpec }; var rootPath = ResolveRootDirectory(packageSpec.FilePath); Initialize(packageSpec.FilePath, rootPath); }
public bool TryResolvePackageSpec(string name, out PackageSpec project) { project = null; PackageSpecInformation projectInfo; if (_projects.TryGetValue(name, out projectInfo)) { project = projectInfo.PackageSpec; return project != null; } return false; }
public bool IsValidForPackageSpec(PackageSpec spec) { if (Version != LockFileFormat.Version) { return false; } var actualTargetFrameworks = spec.TargetFrameworks; // The lock file should contain dependencies for each framework plus dependencies shared by all frameworks if (ProjectFileDependencyGroups.Count != actualTargetFrameworks.Count() + 1) { return false; } foreach (var group in ProjectFileDependencyGroups) { IOrderedEnumerable<string> actualDependencies; var expectedDependencies = group.Dependencies.OrderBy(x => x); // If the framework name is empty, the associated dependencies are shared by all frameworks if (string.IsNullOrEmpty(group.FrameworkName)) { actualDependencies = spec.Dependencies.Select(x => RuntimeStyleLibraryRangeToString(x.LibraryRange)).OrderBy(x => x); } else { var framework = actualTargetFrameworks .FirstOrDefault(f => string.Equals(f.FrameworkName.ToString(), group.FrameworkName, StringComparison.OrdinalIgnoreCase)); if (framework == null) { return false; } actualDependencies = framework.Dependencies.Select(d => RuntimeStyleLibraryRangeToString(d.LibraryRange)).OrderBy(x => x); } if (!actualDependencies.SequenceEqual(expectedDependencies)) { return false; } } return true; }
private int LibraryDetail(PackageSpec project, LockFile lockfile, string targetName, string library) { var lib = lockfile.Libraries.FirstOrDefault(l => l.Name.Equals(library, StringComparison.OrdinalIgnoreCase)); if (lib == null) { _log.LogError($"Library not found: {library}"); return -1; } _log.LogInformation($"{lib.Name} {lib.Version}"); _log.LogInformation($"Servicable: {lib.IsServiceable}"); _log.LogInformation($"SHA512 Hash: {lib.Sha512}"); _log.LogInformation($"Files:"); foreach (var file in lib.Files) { _log.LogInformation($" * {file}"); } IEnumerable<LockFileTarget> targets = lockfile.Targets; if (!string.IsNullOrEmpty(targetName)) { var parts = targetName.Split('/'); var tfm = NuGetFramework.Parse(parts[0]); var rid = parts[1]; targets = targets.Where(t => string.Equals(rid, t.RuntimeIdentifier, StringComparison.Ordinal) && tfm.Equals(t.TargetFramework)); } var libraryTargets = targets.Select(t => new { Target = t, Library = t.Libraries.FirstOrDefault(l => string.Equals(l.Name, library, StringComparison.OrdinalIgnoreCase)) }); foreach (var libraryTarget in libraryTargets) { _log.LogInformation($"Target: {libraryTarget.Target.TargetFramework}/{libraryTarget.Target.RuntimeIdentifier}"); if (libraryTarget.Library == null) { _log.LogInformation(" Not supported"); } else { WriteList(Compile, libraryTarget.Library.CompileTimeAssemblies.Select(f => f.Path)); WriteList(Runtime, libraryTarget.Library.RuntimeAssemblies.Select(f => f.Path)); WriteList(Native, libraryTarget.Library.NativeLibraries.Select(f => f.Path)); WriteList(Framework, libraryTarget.Library.FrameworkAssemblies); } } return 0; }
public Project(PackageSpec packageSpec) { BaseDirectory = Path.GetDirectoryName(packageSpec.FilePath); Metadata = packageSpec; Files = new ProjectFilesCollection(packageSpec.Properties, packageSpec.BaseDirectory, packageSpec.FilePath); // Load additional metadata from the project json EntryPoint = Metadata.Properties.GetValue<string>("entryPoint"); var commands = Metadata.Properties["commands"] as JObject; if (commands != null) { foreach (var command in commands) { Commands[command.Key] = command.Value.Value<string>(); } } }
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); }
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)); var rawPackageSpec = JObject.Load(reader); 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 buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION"); packageSpec.Name = name; packageSpec.FilePath = Path.GetFullPath(packageSpecPath); if (version == null) { packageSpec.Version = new NuGetVersion("1.0.0"); } else { try { packageSpec.Version = SpecifySnapshot(version.Value<string>(), buildVersion); } catch (Exception ex) { var lineInfo = (IJsonLineInfo)version; throw PackageSpecFormatException.Create(ex, version, packageSpec.FilePath); } } 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.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.RequireLicenseAcceptance = rawPackageSpec.GetValue<bool?>("requireLicenseAcceptance") ?? false; 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 PackageSpecFormatException.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); // Read the runtime graph packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec); return packageSpec; }
public bool IsValidForPackageSpec(PackageSpec spec) { return(IsValidForPackageSpec(spec, Version)); }
private static bool BuildTargetFrameworkNode(PackageSpec packageSpec, KeyValuePair <string, JToken> targetFramework, string filePath) { var frameworkName = GetFramework(targetFramework.Key); var properties = targetFramework.Value.Value <JObject>(); var assetTargetFallback = GetBoolOrFalse(properties, "assetTargetFallback", filePath); var importFrameworks = GetImports(properties, packageSpec); // If a fallback framework exists, update the framework to contain both. var updatedFramework = frameworkName; if (importFrameworks.Count != 0) { if (assetTargetFallback) { updatedFramework = new AssetTargetFallbackFramework(frameworkName, importFrameworks); } else { updatedFramework = new FallbackFramework(frameworkName, importFrameworks); } } var targetFrameworkInformation = new TargetFrameworkInformation { FrameworkName = updatedFramework, Dependencies = new List <LibraryDependency>(), Imports = importFrameworks, Warn = GetWarnSetting(properties), AssetTargetFallback = assetTargetFallback, RuntimeIdentifierGraphPath = GetRuntimeIdentifierGraphPath(properties) }; PopulateDependencies( packageSpec.FilePath, targetFrameworkInformation.Dependencies, properties, "dependencies", isGacOrFrameworkReference: false); PopulateDownloadDependencies( targetFrameworkInformation.DownloadDependencies, properties, packageSpec.FilePath); var frameworkAssemblies = new List <LibraryDependency>(); PopulateDependencies( packageSpec.FilePath, frameworkAssemblies, properties, "frameworkAssemblies", isGacOrFrameworkReference: true); PopulateFrameworkReferences( targetFrameworkInformation.FrameworkReferences, properties, "frameworkReferences", packageSpec.FilePath ); frameworkAssemblies.ForEach(d => targetFrameworkInformation.Dependencies.Add(d)); packageSpec.TargetFrameworks.Add(targetFrameworkInformation); return(true); }
private int SummarizeLockfile(PackageSpec project, LockFile lockfile, string targetName) { _log.LogInformation($"Locked: {lockfile.IsLocked}"); if (project == null) { _log.LogInformation($"Up-to-date: Unknown"); } else { _log.LogInformation($"Up-to-date: {lockfile.IsValidForPackageSpec(project)}"); } _log.LogInformation("Project Dependencies:"); foreach (var group in lockfile.ProjectFileDependencyGroups) { var fxName = string.IsNullOrEmpty(group.FrameworkName) ? "All Frameworks" : group.FrameworkName; if (group.Dependencies.Any()) { _log.LogInformation($" {fxName}"); foreach (var dep in group.Dependencies) { _log.LogInformation($" * {dep}"); } } else { _log.LogInformation($" {fxName}: none"); } } _log.LogInformation("All Libraries:"); foreach (var lib in lockfile.Libraries) { _log.LogInformation($"* {lib.Name} {lib.Version}"); } IEnumerable<LockFileTarget> targets = lockfile.Targets; if (!string.IsNullOrEmpty(targetName)) { var parts = targetName.Split('/'); var tfm = NuGetFramework.Parse(parts[0]); var rid = parts[1]; targets = targets.Where(t => string.Equals(rid, t.RuntimeIdentifier, StringComparison.Ordinal) && tfm.Equals(t.TargetFramework)); } foreach (var target in targets) { _log.LogInformation($"Target: {target.TargetFramework} {target.RuntimeIdentifier}"); foreach (var lib in target.Libraries) { var provides = string.Empty; if (lib.NativeLibraries.Any()) { provides += Native + ","; } if (lib.RuntimeAssemblies.Any()) { provides += Runtime + ","; } if (lib.CompileTimeAssemblies.Any()) { provides += Compile + ","; } if (lib.FrameworkAssemblies.Any()) { provides += Framework + ","; } provides = provides.TrimEnd(','); if (string.IsNullOrEmpty(provides)) { provides = Nothing; } _log.LogInformation($" * [{provides}] {lib.Name} {lib.Version}"); } } return 0; }
/// <summary> /// The lock file will get invalidated if one or more of the below are true /// 1. The target frameworks list of the current project was updated. /// 2. The runtime list of the current project waw updated. /// 3. The packages of the current project were updated. /// 4. The packages of the dependent projects were updated. /// 5. The framework list of the dependent projects were updated with frameworks incompatible with the main project framework. /// 6. If the version of the <paramref name="nuGetLockFile"/> is larger than the current tools <see cref="PackagesLockFileFormat.PackagesLockFileVersion"/>. /// </summary> /// <param name="dgSpec">The <see cref="DependencyGraphSpec"/> for the new project defintion.</param> /// <param name="nuGetLockFile">The current <see cref="PackagesLockFile"/>.</param> /// <returns>Returns LockFileValidityWithInvalidReasons object with IsValid set to true if the lock file is valid false otherwise. /// The second return type is a localized message that indicates in further detail the reason for the inconsistency.</returns> public static LockFileValidationResult IsLockFileValid(DependencyGraphSpec dgSpec, PackagesLockFile nuGetLockFile) { if (dgSpec == null) { throw new ArgumentNullException(nameof(dgSpec)); } if (nuGetLockFile == null) { throw new ArgumentNullException(nameof(nuGetLockFile)); } List <string> invalidReasons = new List <string>(); // Current tools know how to read only previous formats including the current if (PackagesLockFileFormat.PackagesLockFileVersion < nuGetLockFile.Version) { invalidReasons.Add(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_IncompatibleLockFileVersion, PackagesLockFileFormat.PackagesLockFileVersion )); return(new LockFileValidationResult(false, invalidReasons)); } var uniqueName = dgSpec.Restore.First(); var project = dgSpec.GetProjectSpec(uniqueName); // Validate all the direct dependencies NuGetFramework[] lockFileFrameworks = nuGetLockFile.Targets .Where(t => t.TargetFramework != null) .Select(t => t.TargetFramework) .Distinct() .ToArray(); if (project.TargetFrameworks.Count != lockFileFrameworks.Length) { invalidReasons.Add(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_MismatchedTargetFrameworks, string.Join(",", project.TargetFrameworks.Select(e => e.FrameworkName.GetShortFolderName())), string.Join(",", lockFileFrameworks.Select(e => e.GetShortFolderName())) )); } else { // Validate the runtimes for the current project did not change. var projectRuntimesKeys = project.RuntimeGraph.Runtimes.Select(r => r.Key).Where(k => k != null); var lockFileRuntimes = nuGetLockFile.Targets.Select(t => t.RuntimeIdentifier).Where(r => r != null).Distinct(); if (!projectRuntimesKeys.OrderedEquals( lockFileRuntimes, x => x, StringComparer.InvariantCultureIgnoreCase, StringComparer.InvariantCultureIgnoreCase)) { invalidReasons.Add(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_RuntimeIdentifiersChanged, string.Join(";", projectRuntimesKeys.OrderBy(e => e)), string.Join(";", lockFileRuntimes.OrderBy(e => e)) )); } foreach (var framework in project.TargetFrameworks) { var target = nuGetLockFile.Targets.FirstOrDefault( t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, framework.FrameworkName)); if (target == null) { // a new target found in the dgSpec so invalidate existing lock file. invalidReasons.Add(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_NewTargetFramework, framework.FrameworkName.GetShortFolderName()) ); continue; } IEnumerable <LockFileDependency> directDependencies = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.Direct); (var hasProjectDependencyChanged, var pmessage) = HasDirectPackageDependencyChanged(framework.Dependencies, directDependencies, target.TargetFramework); if (hasProjectDependencyChanged) { // lock file is out of sync invalidReasons.Add(pmessage); } var transitiveDependenciesEnforcedByCentralVersions = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.CentralTransitive).ToList(); var transitiveDependencies = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.Transitive).ToList(); (var hasTransitiveDependencyChanged, var tmessage) = HasProjectTransitiveDependencyChanged(framework.CentralPackageVersions, transitiveDependenciesEnforcedByCentralVersions, transitiveDependencies); if (hasTransitiveDependencyChanged) { // lock file is out of sync invalidReasons.Add(tmessage); } } // Validate all P2P references foreach (var restoreMetadataFramework in project.RestoreMetadata.TargetFrameworks) { var target = nuGetLockFile.Targets.FirstOrDefault( t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, restoreMetadataFramework.FrameworkName)); if (target == null) { continue; } var queue = new Queue <Tuple <string, string> >(); var visitedP2PReference = new HashSet <string>(); foreach (var projectReference in restoreMetadataFramework.ProjectReferences) { if (visitedP2PReference.Add(projectReference.ProjectUniqueName)) { PackageSpec spec = dgSpec.GetProjectSpec(projectReference.ProjectUniqueName); queue.Enqueue(new Tuple <string, string>(spec.Name, projectReference.ProjectUniqueName)); while (queue.Count > 0) { var projectNames = queue.Dequeue(); var p2pUniqueName = projectNames.Item2; var p2pProjectName = projectNames.Item1; var projectDependency = target.Dependencies.FirstOrDefault( dep => dep.Type == PackageDependencyType.Project && StringComparer.OrdinalIgnoreCase.Equals(dep.Id, p2pProjectName)); if (projectDependency == null) { // new direct project dependency. // If there are changes in the P2P2P references, they will be caught in HasP2PDependencyChanged. invalidReasons.Add(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_ProjectReferenceAdded, p2pProjectName, target.TargetFramework.GetShortFolderName() )); continue; } var p2pSpec = dgSpec.GetProjectSpec(p2pUniqueName); if (p2pSpec != null) { TargetFrameworkInformation p2pSpecTargetFrameworkInformation = default; if (p2pSpec.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig || p2pSpec.RestoreMetadata.ProjectStyle == ProjectStyle.Unknown) { // Skip compat check and dependency check for non PR projects. // Projects that are not PR do not undergo compat checks by NuGet and do not contribute anything transitively. p2pSpecTargetFrameworkInformation = p2pSpec.TargetFrameworks.FirstOrDefault(); } else { // This does not consider ATF. p2pSpecTargetFrameworkInformation = NuGetFrameworkUtility.GetNearest(p2pSpec.TargetFrameworks, restoreMetadataFramework.FrameworkName, e => e.FrameworkName); } // No compatible framework found if (p2pSpecTargetFrameworkInformation != null) { // We need to compare the main framework only. Ignoring fallbacks. var p2pSpecProjectRestoreMetadataFrameworkInfo = p2pSpec.RestoreMetadata.TargetFrameworks.FirstOrDefault( t => NuGetFramework.Comparer.Equals(p2pSpecTargetFrameworkInformation.FrameworkName, t.FrameworkName)); if (p2pSpecProjectRestoreMetadataFrameworkInfo != null) { (var hasChanged, var message) = HasP2PDependencyChanged(p2pSpecTargetFrameworkInformation.Dependencies, p2pSpecProjectRestoreMetadataFrameworkInfo.ProjectReferences, projectDependency, dgSpec); if (hasChanged) { // P2P transitive package dependencies have changed invalidReasons.Add(message); } foreach (var reference in p2pSpecProjectRestoreMetadataFrameworkInfo.ProjectReferences) { // Do not add private assets for processing. if (visitedP2PReference.Add(reference.ProjectUniqueName) && reference.PrivateAssets != LibraryIncludeFlags.All) { var referenceSpec = dgSpec.GetProjectSpec(reference.ProjectUniqueName); queue.Enqueue(new Tuple <string, string>(referenceSpec.Name, reference.ProjectUniqueName)); } } } else // This should never happen. { throw new Exception(string.Format(CultureInfo.CurrentCulture, Strings.PackagesLockFile_RestoreMetadataMissingTfms)); } } else { invalidReasons.Add(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_ProjectReferenceHasNoCompatibleTargetFramework, p2pProjectName, restoreMetadataFramework.FrameworkName.GetShortFolderName() )); } } else // This can't happen. When adding the queue, the referenceSpec HAS to be discovered. If the project is otherwise missing, it will be discovered in HasP2PDependencyChanged { throw new Exception(string.Format( CultureInfo.CurrentCulture, Strings.PackagesLockFile_UnableToLoadPackagespec, p2pUniqueName)); } } } } } } bool isLockFileValid = invalidReasons.Count == 0; return(new LockFileValidationResult(isLockFileValid, invalidReasons)); }
public static void AddOrUpdateDependency(PackageSpec spec, PackageIdentity identity) { AddOrUpdateDependency(spec, new PackageDependency(identity.Id, new VersionRange(identity.Version))); }
/// <summary> /// Writes a PackageSpec to an <c>NuGet.Common.IObjectWriter</c> instance. /// </summary> /// <param name="packageSpec">A <c>PackageSpec</c> instance.</param> /// <param name="writer">An <c>NuGet.Common.IObjectWriter</c> instance.</param> public static void Write(PackageSpec packageSpec, IObjectWriter writer) { Write(packageSpec, writer, hashing: false); }
/// <summary> /// Get restore metadata framework. This is based on the project's target frameworks, then an /// exact match is found under restore metadata. /// </summary> public static ProjectRestoreMetadataFrameworkInfo GetRestoreMetadataFramework(this PackageSpec project, NuGetFramework targetFramework) { ProjectRestoreMetadataFrameworkInfo frameworkInfo = null; var projectFrameworkInfo = GetTargetFramework(project, targetFramework); if (projectFrameworkInfo.FrameworkName != null) { frameworkInfo = project.RestoreMetadata?.TargetFrameworks .FirstOrDefault(f => f.FrameworkName.Equals(projectFrameworkInfo.FrameworkName)); } return(frameworkInfo ?? new ProjectRestoreMetadataFrameworkInfo()); }
public static void WritePackageSpec(PackageSpec packageSpec, JObject json) { SetValue(json, "title", packageSpec.Title); if (!packageSpec.IsDefaultVersion) { SetValue(json, "version", packageSpec.Version?.ToNormalizedString()); } SetValue(json, "description", packageSpec.Description); SetArrayValue(json, "authors", packageSpec.Authors); SetArrayValue(json, "owners", packageSpec.Owners); SetArrayValue(json, "tags", packageSpec.Tags); SetValue(json, "projectUrl", packageSpec.ProjectUrl); SetValue(json, "iconUrl", packageSpec.IconUrl); SetValue(json, "licenseUrl", packageSpec.LicenseUrl); SetValue(json, "copyright", packageSpec.Copyright); SetValue(json, "language", packageSpec.Language); SetValue(json, "summary", packageSpec.Summary); SetValue(json, "releaseNotes", packageSpec.ReleaseNotes); SetValue(json, "requireLicenseAcceptance", packageSpec.RequireLicenseAcceptance.ToString()); SetArrayValue(json, "contentFiles", packageSpec.ContentFiles); SetDictionaryValue(json, "packInclude", packageSpec.PackInclude); SetPackOptions(json, packageSpec.PackOptions); SetDictionaryValues(json, "scripts", packageSpec.Scripts); if (packageSpec.Dependencies.Any()) { SetDependencies(json, packageSpec.Dependencies); } if (packageSpec.Tools.Any()) { JObject tools = new JObject(); foreach (var tool in packageSpec.Tools) { JObject toolObject = new JObject(); toolObject["version"] = tool.LibraryRange.VersionRange.ToNormalizedString(); if (tool.Imports.Any()) { SetImports(toolObject, tool.Imports); } tools[tool.LibraryRange.Name] = toolObject; } SetValue(json, "tools", tools); } if (packageSpec.TargetFrameworks.Any()) { JObject frameworks = new JObject(); foreach (var framework in packageSpec.TargetFrameworks) { JObject frameworkObject = new JObject(); SetDependencies(frameworkObject, framework.Dependencies); SetImports(frameworkObject, framework.Imports); frameworks[framework.FrameworkName.GetShortFolderName()] = frameworkObject; } SetValue(json, "frameworks", frameworks); } JsonRuntimeFormat.WriteRuntimeGraph(json, packageSpec.RuntimeGraph); }
private static void SetMSBuildMetadata(IObjectWriter writer, PackageSpec packageSpec) { var msbuildMetadata = packageSpec.RestoreMetadata; if (msbuildMetadata == null) { return; } if (msbuildMetadata.ProjectUniqueName == null && msbuildMetadata.ProjectName == null && msbuildMetadata.ProjectPath == null && msbuildMetadata.ProjectJsonPath == null && msbuildMetadata.PackagesPath == null && msbuildMetadata.OutputPath == null) { return; } writer.WriteObjectStart(JsonPackageSpecReader.RestoreOptions); SetValue(writer, "projectUniqueName", msbuildMetadata.ProjectUniqueName); SetValue(writer, "projectName", msbuildMetadata.ProjectName); SetValue(writer, "projectPath", msbuildMetadata.ProjectPath); SetValue(writer, "projectJsonPath", msbuildMetadata.ProjectJsonPath); SetValue(writer, "packagesPath", msbuildMetadata.PackagesPath); SetValue(writer, "outputPath", msbuildMetadata.OutputPath); if (msbuildMetadata.ProjectStyle != ProjectStyle.Unknown) { SetValue(writer, "projectStyle", msbuildMetadata.ProjectStyle.ToString()); } SetValueIfTrue(writer, "crossTargeting", msbuildMetadata.CrossTargeting); SetValueIfTrue( writer, "legacyPackagesDirectory", msbuildMetadata.LegacyPackagesDirectory); SetValueIfTrue( writer, "validateRuntimeAssets", msbuildMetadata.ValidateRuntimeAssets); SetValueIfTrue( writer, "skipContentFileWrite", msbuildMetadata.SkipContentFileWrite); SetArrayValue(writer, "fallbackFolders", msbuildMetadata.FallbackFolders); SetArrayValue(writer, "originalTargetFrameworks", msbuildMetadata.OriginalTargetFrameworks); if (msbuildMetadata.Sources?.Count > 0) { writer.WriteObjectStart("sources"); foreach (var source in msbuildMetadata.Sources) { // "source": {} writer.WriteObjectStart(source.Source); writer.WriteObjectEnd(); } writer.WriteObjectEnd(); } if (msbuildMetadata.Files?.Count > 0) { writer.WriteObjectStart("files"); foreach (var file in msbuildMetadata.Files) { SetValue(writer, file.PackagePath, file.AbsolutePath); } writer.WriteObjectEnd(); } if (msbuildMetadata.TargetFrameworks?.Count > 0) { writer.WriteObjectStart("frameworks"); var frameworkNames = new HashSet <string>(); foreach (var framework in msbuildMetadata.TargetFrameworks) { var frameworkName = framework.FrameworkName.GetShortFolderName(); if (!frameworkNames.Contains(frameworkName)) { frameworkNames.Add(frameworkName); writer.WriteObjectStart(frameworkName); writer.WriteObjectStart("projectReferences"); foreach (var project in framework.ProjectReferences) { writer.WriteObjectStart(project.ProjectUniqueName); writer.WriteNameValue("projectPath", project.ProjectPath); if (project.IncludeAssets != LibraryIncludeFlags.All) { writer.WriteNameValue("includeAssets", LibraryIncludeFlagUtils.GetFlagString(project.IncludeAssets)); } if (project.ExcludeAssets != LibraryIncludeFlags.None) { writer.WriteNameValue("excludeAssets", LibraryIncludeFlagUtils.GetFlagString(project.ExcludeAssets)); } if (project.PrivateAssets != LibraryIncludeFlagUtils.DefaultSuppressParent) { writer.WriteNameValue("privateAssets", LibraryIncludeFlagUtils.GetFlagString(project.PrivateAssets)); } writer.WriteObjectEnd(); } writer.WriteObjectEnd(); writer.WriteObjectEnd(); } } writer.WriteObjectEnd(); } writer.WriteObjectEnd(); }
public static bool IsNuGetLockFileEnabled(PackageSpec project) { var restorePackagesWithLockFile = project.RestoreMetadata?.RestoreLockProperties.RestorePackagesWithLockFile; return(MSBuildStringUtility.IsTrue(restorePackagesWithLockFile) || File.Exists(GetNuGetLockFilePath(project))); }
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 }); }
public static bool HasPackage(PackageSpec spec, string packageId) { return(GetExistingDependencies(spec, packageId).Any()); }
private static bool BuildTargetFrameworkNode(PackageSpec packageSpec, KeyValuePair<string, JToken> targetFramework) { var frameworkName = GetFramework(targetFramework.Key); // If it's not unsupported then keep it if (frameworkName == NuGetFramework.UnsupportedFramework) { // REVIEW: Should we skip unsupported target frameworks return false; } var targetFrameworkInformation = new TargetFrameworkInformation { FrameworkName = frameworkName, Dependencies = new List<LibraryDependency>() }; var properties = targetFramework.Value.Value<JObject>(); PopulateDependencies( packageSpec.FilePath, targetFrameworkInformation.Dependencies, properties, "dependencies", isGacOrFrameworkReference: false); var frameworkAssemblies = new List<LibraryDependency>(); PopulateDependencies( packageSpec.FilePath, frameworkAssemblies, properties, "frameworkAssemblies", isGacOrFrameworkReference: true); frameworkAssemblies.ForEach(d => targetFrameworkInformation.Dependencies.Add(d)); packageSpec.TargetFrameworks.Add(targetFrameworkInformation); return true; }
private static ProjectRestoreMetadata GetMSBuildMetadata(PackageSpec packageSpec, JObject rawPackageSpec) { var rawMSBuildMetadata = rawPackageSpec.Value <JToken>(RestoreOptions) as JObject; if (rawMSBuildMetadata == null) { return(null); } var projectStyleString = rawMSBuildMetadata.GetValue <string>("projectStyle"); ProjectStyle?projectStyle = null; if (!string.IsNullOrEmpty(projectStyleString) && Enum.TryParse <ProjectStyle>(projectStyleString, ignoreCase: true, result: out var projectStyleValue)) { projectStyle = projectStyleValue; } var msbuildMetadata = projectStyle == ProjectStyle.PackagesConfig ? new PackagesConfigProjectRestoreMetadata() : new ProjectRestoreMetadata(); if (projectStyle.HasValue) { msbuildMetadata.ProjectStyle = projectStyle.Value; } msbuildMetadata.ProjectUniqueName = rawMSBuildMetadata.GetValue <string>("projectUniqueName"); msbuildMetadata.OutputPath = rawMSBuildMetadata.GetValue <string>("outputPath"); msbuildMetadata.PackagesPath = rawMSBuildMetadata.GetValue <string>("packagesPath"); msbuildMetadata.ProjectJsonPath = rawMSBuildMetadata.GetValue <string>("projectJsonPath"); msbuildMetadata.ProjectName = rawMSBuildMetadata.GetValue <string>("projectName"); msbuildMetadata.ProjectPath = rawMSBuildMetadata.GetValue <string>("projectPath"); msbuildMetadata.CrossTargeting = GetBoolOrFalse(rawMSBuildMetadata, "crossTargeting", packageSpec.FilePath); msbuildMetadata.LegacyPackagesDirectory = GetBoolOrFalse(rawMSBuildMetadata, "legacyPackagesDirectory", packageSpec.FilePath); msbuildMetadata.ValidateRuntimeAssets = GetBoolOrFalse(rawMSBuildMetadata, "validateRuntimeAssets", packageSpec.FilePath); msbuildMetadata.SkipContentFileWrite = GetBoolOrFalse(rawMSBuildMetadata, "skipContentFileWrite", packageSpec.FilePath); msbuildMetadata.Sources = new List <PackageSource>(); var sourcesObj = rawMSBuildMetadata.GetValue <JObject>("sources"); if (sourcesObj != null) { foreach (var prop in sourcesObj.Properties()) { msbuildMetadata.Sources.Add(new PackageSource(prop.Name)); } } var filesObj = rawMSBuildMetadata.GetValue <JObject>("files"); if (filesObj != null) { foreach (var prop in filesObj.Properties()) { msbuildMetadata.Files.Add(new ProjectRestoreMetadataFile(prop.Name, prop.Value.ToObject <string>())); } } var frameworksObj = rawMSBuildMetadata.GetValue <JObject>("frameworks"); if (frameworksObj != null) { foreach (var frameworkProperty in frameworksObj.Properties()) { var framework = NuGetFramework.Parse(frameworkProperty.Name); var frameworkGroup = new ProjectRestoreMetadataFrameworkInfo(framework); var projectsObj = frameworkProperty.Value.GetValue <JObject>("projectReferences"); if (projectsObj != null) { foreach (var prop in projectsObj.Properties()) { frameworkGroup.ProjectReferences.Add(new ProjectRestoreReference() { ProjectUniqueName = prop.Name, ProjectPath = prop.Value.GetValue <string>("projectPath"), IncludeAssets = LibraryIncludeFlagUtils.GetFlags( flags: prop.Value.GetValue <string>("includeAssets"), defaultFlags: LibraryIncludeFlags.All), ExcludeAssets = LibraryIncludeFlagUtils.GetFlags( flags: prop.Value.GetValue <string>("excludeAssets"), defaultFlags: LibraryIncludeFlags.None), PrivateAssets = LibraryIncludeFlagUtils.GetFlags( flags: prop.Value.GetValue <string>("privateAssets"), defaultFlags: LibraryIncludeFlagUtils.DefaultSuppressParent), }); } } msbuildMetadata.TargetFrameworks.Add(frameworkGroup); } } // Add the config file paths to the equals method msbuildMetadata.ConfigFilePaths = new List <string>(); var configFilePaths = rawMSBuildMetadata.GetValue <JArray>("configFilePaths"); if (configFilePaths != null) { foreach (var fallbackFolder in configFilePaths.Select(t => t.Value <string>())) { msbuildMetadata.ConfigFilePaths.Add(fallbackFolder); } } msbuildMetadata.FallbackFolders = new List <string>(); var fallbackObj = rawMSBuildMetadata.GetValue <JArray>("fallbackFolders"); if (fallbackObj != null) { foreach (var fallbackFolder in fallbackObj.Select(t => t.Value <string>())) { msbuildMetadata.FallbackFolders.Add(fallbackFolder); } } msbuildMetadata.OriginalTargetFrameworks = new List <string>(); var originalFrameworksObj = rawMSBuildMetadata.GetValue <JArray>("originalTargetFrameworks"); if (originalFrameworksObj != null) { foreach (var orignalFramework in originalFrameworksObj.Select(t => t.Value <string>())) { msbuildMetadata.OriginalTargetFrameworks.Add(orignalFramework); } } var warningPropertiesObj = rawMSBuildMetadata.GetValue <JObject>("warningProperties"); if (warningPropertiesObj != null) { var allWarningsAsErrors = warningPropertiesObj.GetValue <bool>("allWarningsAsErrors"); var warnAsError = new HashSet <NuGetLogCode>(GetNuGetLogCodeEnumerableFromJArray(warningPropertiesObj["warnAsError"])); var noWarn = new HashSet <NuGetLogCode>(GetNuGetLogCodeEnumerableFromJArray(warningPropertiesObj["noWarn"])); msbuildMetadata.ProjectWideWarningProperties = new WarningProperties(warnAsError, noWarn, allWarningsAsErrors); } // read NuGet lock file msbuild properties var restoreLockProperties = rawMSBuildMetadata.GetValue <JObject>("restoreLockProperties"); if (restoreLockProperties != null) { msbuildMetadata.RestoreLockProperties = new RestoreLockProperties( restoreLockProperties.GetValue <string>("restorePackagesWithLockFile"), restoreLockProperties.GetValue <string>("nuGetLockFilePath"), GetBoolOrFalse(restoreLockProperties, "restoreLockedMode", packageSpec.FilePath)); } if (msbuildMetadata is PackagesConfigProjectRestoreMetadata pcMsbuildMetadata) { pcMsbuildMetadata.PackagesConfigPath = rawMSBuildMetadata.GetValue <string>("packagesConfigPath"); } return(msbuildMetadata); }
private void WriteTargetsAndProps(PackageSpec project, List<RestoreTargetGraph> targetGraphs, NuGetv3LocalRepository repository) { // Get the runtime-independent graphs var tfmGraphs = targetGraphs.Where(g => string.IsNullOrEmpty(g.RuntimeIdentifier)).ToList(); if (tfmGraphs.Count > 1) { var name = $"{project.Name}.nuget.targets"; var path = Path.Combine(project.BaseDirectory, name); _log.LogInformation($"Generating MSBuild file {name}"); GenerateMSBuildErrorFile(path); return; } var graph = tfmGraphs[0]; var pathResolver = new DefaultPackagePathResolver(repository.RepositoryRoot); var targets = new List<string>(); var props = new List<string>(); foreach (var library in graph.Flattened.Distinct().OrderBy(g => g.Data.Match.Library)) { var package = repository.FindPackagesById(library.Key.Name).FirstOrDefault(p => p.Version == library.Key.Version); if (package != null) { var criteria = graph.Conventions.Criteria.ForFramework(graph.Framework); var contentItemCollection = new ContentItemCollection(); using (var nupkgStream = File.OpenRead(package.ZipPath)) { var reader = new PackageReader(nupkgStream); contentItemCollection.Load(reader.GetFiles()); } // Find MSBuild thingies var buildItems = contentItemCollection.FindBestItemGroup(criteria, graph.Conventions.Patterns.MSBuildFiles); if (buildItems != null) { // We need to additionally filter to items that are named "{packageId}.targets" and "{packageId}.props" // Filter by file name here and we'll filter by extension when we add things to the lists. var items = buildItems.Items .Where(item => Path.GetFileNameWithoutExtension(item.Path).Equals(package.Id, StringComparison.OrdinalIgnoreCase)) .ToList(); targets.AddRange(items .Select(c => c.Path) .Where(path => Path.GetExtension(path).Equals(".targets", StringComparison.OrdinalIgnoreCase)) .Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar)))); props.AddRange(items .Select(c => c.Path) .Where(path => Path.GetExtension(path).Equals(".props", StringComparison.OrdinalIgnoreCase)) .Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar)))); } } } // Generate the files as needed var targetsName = $"{project.Name}.nuget.targets"; var propsName = $"{project.Name}.nuget.props"; var targetsPath = Path.Combine(project.BaseDirectory, targetsName); var propsPath = Path.Combine(project.BaseDirectory, propsName); if (targets.Any()) { _log.LogInformation($"Generating MSBuild file {targetsName}"); GenerateImportsFile(repository, targetsPath, targets); } else if (File.Exists(targetsPath)) { File.Delete(targetsPath); } if (props.Any()) { _log.LogInformation($"Generating MSBuild file {propsName}"); GenerateImportsFile(repository, propsPath, props); } else if (File.Exists(propsPath)) { File.Delete(propsPath); } }
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) { 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 LockFile CreateLockFile(PackageSpec project, List<RestoreTargetGraph> targetGraphs, NuGetv3LocalRepository repository) { var lockFile = new LockFile(); using (var sha512 = SHA512.Create()) { foreach (var item in targetGraphs.SelectMany(g => g.Flattened).Distinct().OrderBy(x => x.Data.Match.Library)) { var library = item.Data.Match.Library; var packageInfo = repository.FindPackagesById(library.Name) .FirstOrDefault(p => p.Version == library.Version); if (packageInfo == null) { continue; } var lockFileLib = CreateLockFileLibrary( packageInfo, sha512, correctedPackageName: library.Name); lockFile.Libraries.Add(lockFileLib); } } // Use empty string as the key of dependencies shared by all frameworks lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup( string.Empty, project.Dependencies.Select(x => x.LibraryRange.ToString()))); foreach (var frameworkInfo in project.TargetFrameworks) { lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup( frameworkInfo.FrameworkName.ToString(), frameworkInfo.Dependencies.Select(x => x.LibraryRange.ToString()))); } // Add the targets foreach (var targetGraph in targetGraphs) { var target = new LockFileTarget(); target.TargetFramework = targetGraph.Framework; target.RuntimeIdentifier = targetGraph.RuntimeIdentifier; foreach (var library in targetGraph.Flattened.Select(g => g.Key).OrderBy(x => x)) { var packageInfo = repository.FindPackagesById(library.Name) .FirstOrDefault(p => p.Version == library.Version); if (packageInfo == null) { continue; } var targetLibrary = CreateLockFileTargetLibrary( packageInfo, targetGraph, new DefaultPackagePathResolver(repository.RepositoryRoot), correctedPackageName: library.Name); target.Libraries.Add(targetLibrary); } lockFile.Targets.Add(target); } return lockFile; }
public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework) { Library library = null; var name = libraryRange.Name; ExternalProjectReference externalReference = null; PackageSpec packageSpec = null; // This must exist in the external references if (_externalProjectsByUniqueName.TryGetValue(name, out externalReference)) { packageSpec = externalReference.PackageSpec; } if (externalReference == null && packageSpec == null) { // unable to find any projects return(null); } // create a dictionary of dependencies to make sure that no duplicates exist var dependencies = new List <LibraryDependency>(); var projectStyle = packageSpec?.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown; // Read references from external project - we don't care about dotnettool projects, since they don't have project refs if (projectStyle == ProjectStyle.PackageReference) { // NETCore dependencies.AddRange(GetDependenciesFromSpecRestoreMetadata(packageSpec, targetFramework)); } else { // UWP dependencies.AddRange(GetDependenciesFromExternalReference(externalReference, packageSpec, targetFramework)); } // Remove duplicate dependencies. A reference can exist both in csproj and project.json // dependencies is already ordered by importance here var uniqueDependencies = new List <LibraryDependency>(dependencies.Count); var projectNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (var project in dependencies) { if (projectNames.Add(project.Name)) { uniqueDependencies.Add(project); } } library = new Library { LibraryRange = libraryRange, Identity = new LibraryIdentity { Name = externalReference?.ProjectName ?? packageSpec.Name, Version = packageSpec?.Version ?? new NuGetVersion(1, 0, 0), Type = LibraryType.Project, }, Path = packageSpec?.FilePath, Dependencies = uniqueDependencies, Resolved = true }; // Add msbuild path var msbuildPath = externalReference?.MSBuildProjectPath; if (msbuildPath != null) { library[KnownLibraryProperties.MSBuildProjectPath] = msbuildPath; } if (packageSpec != null) { // Additional library properties AddLibraryProperties(library, packageSpec, targetFramework, msbuildPath); } return(library); }
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)); var rawPackageSpec = JObject.Load(reader); 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 buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION"); packageSpec.Name = name; packageSpec.FilePath = Path.GetFullPath(packageSpecPath); if (version == null) { packageSpec.Version = new NuGetVersion("1.0.0"); } else { try { packageSpec.Version = SpecifySnapshot(version.Value <string>(), buildVersion); } catch (Exception ex) { var lineInfo = (IJsonLineInfo)version; throw PackageSpecFormatException.Create(ex, version, packageSpec.FilePath); } } 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.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.RequireLicenseAcceptance = rawPackageSpec.GetValue <bool?>("requireLicenseAcceptance") ?? false; 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 PackageSpecFormatException.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); // Read the runtime graph packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec); return(packageSpec); }
/// <summary> /// PackageSpec -> id /// </summary> private static string GetPackageSpecId(PackageSpec spec) { return(spec.RestoreMetadata.ProjectUniqueName); }
/// <summary> /// Writes a PackageSpec to an <c>NuGet.Common.IObjectWriter</c> instance. /// </summary> /// <param name="packageSpec">A <c>PackageSpec</c> instance.</param> /// <param name="writer">An <c>NuGet.Common.IObjectWriter</c> instance.</param> public static void Write(PackageSpec packageSpec, IObjectWriter writer) { Write(packageSpec, writer, compressed: false); }
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 }); } } }
private static void BuildTargetFrameworks(PackageSpec packageSpec, JObject rawPackageSpec) { // The frameworks node is where target frameworks go /* { "frameworks": { "net45": { }, "aspnet50": { } } } */ var frameworks = rawPackageSpec["frameworks"] as JObject; if (frameworks != null) { foreach (var framework in frameworks) { try { BuildTargetFrameworkNode(packageSpec, framework); } catch (Exception ex) { throw PackageSpecFormatException.Create(ex, framework.Value, packageSpec.FilePath); } } } }