/// <summary>
/// The central transitive dependecy groups are used for pack operation.
/// The metadata needed for pack is composed from:
/// Name, IncludeType, SuppressParent and Version
/// </summary>
internal static void SetCentralTransitveDependencyGroup(IObjectWriter writer, string name, IEnumerable <LibraryDependency> libraryDependencies)
{
if (!libraryDependencies.Any())
{
return;
}
writer.WriteObjectStart(name);
foreach (var dependency in libraryDependencies.OrderBy(e => e.Name, StringComparer.Ordinal))
{
var versionRange = dependency.LibraryRange.VersionRange ?? VersionRange.All;
var versionString = versionRange.ToNormalizedString();
writer.WriteObjectStart(dependency.Name);
if (dependency.IncludeType != LibraryIncludeFlags.All)
{
SetValue(writer, "include", dependency.IncludeType.ToString());
}
if (dependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
SetValue(writer, "suppressParent", dependency.SuppressParent.ToString());
}
SetValue(writer, "version", versionString);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
private static void SetFrameworks(IObjectWriter writer, IList <TargetFrameworkInformation> frameworks)
{
if (frameworks.Any())
{
writer.WriteObjectStart("frameworks");
var frameworkSorter = new NuGetFrameworkSorter();
foreach (var framework in frameworks.OrderBy(c => c.FrameworkName, frameworkSorter))
{
writer.WriteObjectStart(framework.FrameworkName.GetShortFolderName());
SetDependencies(writer, framework.Dependencies);
SetCentralDependencies(writer, framework.CentralPackageVersions.Values);
SetImports(writer, framework.Imports);
SetValueIfTrue(writer, "assetTargetFallback", framework.AssetTargetFallback);
SetValueIfTrue(writer, "warn", framework.Warn);
SetDownloadDependencies(writer, framework.DownloadDependencies);
SetFrameworkReferences(writer, framework.FrameworkReferences);
SetValueIfNotNull(writer, "runtimeIdentifierGraphPath", framework.RuntimeIdentifierGraphPath);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
}
public static void WriteRuntimeGraph(IObjectWriter writer, RuntimeGraph runtimeGraph)
{
if (runtimeGraph != null)
{
if (runtimeGraph.Runtimes.Any() == true)
{
writer.WriteObjectStart("runtimes");
var sortedRuntimes = runtimeGraph.Runtimes.Values
.OrderBy(runtime => runtime.RuntimeIdentifier, StringComparer.Ordinal);
foreach (var runtime in sortedRuntimes)
{
WriteRuntimeDescription(writer, runtime);
}
writer.WriteObjectEnd();
}
if (runtimeGraph.Supports.Any() == true)
{
writer.WriteObjectStart("supports");
var sortedSupports = runtimeGraph.Supports.Values
.OrderBy(runtime => runtime.Name, StringComparer.Ordinal);
foreach (var support in sortedSupports)
{
WriteCompatibilityProfile(writer, support);
}
writer.WriteObjectEnd();
}
}
}
private static void WriteMetadataTargetFrameworks(IObjectWriter writer, ProjectRestoreMetadata msbuildMetadata)
{
if (msbuildMetadata.TargetFrameworks?.Count > 0)
{
writer.WriteObjectStart("frameworks");
var frameworkNames = new HashSet <string>();
var frameworkSorter = new NuGetFrameworkSorter();
foreach (var framework in msbuildMetadata.TargetFrameworks.OrderBy(c => c.FrameworkName, frameworkSorter))
{
var frameworkName = framework.FrameworkName.GetShortFolderName();
if (!frameworkNames.Contains(frameworkName))
{
frameworkNames.Add(frameworkName);
writer.WriteObjectStart(frameworkName);
SetValueIfNotNull(writer, "targetAlias", framework.TargetAlias);
writer.WriteObjectStart("projectReferences");
foreach (var project in framework.ProjectReferences.OrderBy(e => e.ProjectPath, PathUtility.GetStringComparerBasedOnOS()))
{
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();
}
}
private static void WriteMetadataTargetFrameworks(IObjectWriter writer, ProjectRestoreMetadata msbuildMetadata)
{
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();
}
}
private static void SetFrameworkReferences(IObjectWriter writer, ISet <FrameworkDependency> frameworkReferences)
{
if (frameworkReferences?.Any() == true)
{
writer.WriteObjectStart("frameworkReferences");
foreach (var dependency in frameworkReferences.OrderBy(dep => dep))
{
writer.WriteObjectStart(dependency.Name);
SetValue(writer, "privateAssets", FrameworkDependencyFlagsUtils.GetFlagString(dependency.PrivateAssets));
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
}
private static void WriteMetadataSources(IObjectWriter writer, ProjectRestoreMetadata msbuildMetadata)
{
if (msbuildMetadata.Sources?.Count > 0)
{
writer.WriteObjectStart("sources");
foreach (var source in msbuildMetadata.Sources.OrderBy(e => e.Source, StringComparer.Ordinal))
{
writer.WriteObjectStart(source.Source);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
}
private static void SetWarningProperties(IObjectWriter writer, ProjectRestoreMetadata msbuildMetadata)
{
if (msbuildMetadata.ProjectWideWarningProperties != null &&
(msbuildMetadata.ProjectWideWarningProperties.AllWarningsAsErrors ||
msbuildMetadata.ProjectWideWarningProperties.NoWarn.Count > 0 ||
msbuildMetadata.ProjectWideWarningProperties.WarningsAsErrors.Count > 0))
{
writer.WriteObjectStart("warningProperties");
SetValueIfTrue(writer, "allWarningsAsErrors", msbuildMetadata.ProjectWideWarningProperties.AllWarningsAsErrors);
if (msbuildMetadata.ProjectWideWarningProperties.NoWarn.Count > 0)
{
SetArrayValue(writer, "noWarn", msbuildMetadata
.ProjectWideWarningProperties
.NoWarn
.ToArray()
.OrderBy(c => c)
.Select(c => c.GetName()));
}
if (msbuildMetadata.ProjectWideWarningProperties.WarningsAsErrors.Count > 0)
{
SetArrayValue(writer, "warnAsError", msbuildMetadata
.ProjectWideWarningProperties
.WarningsAsErrors
.ToArray()
.OrderBy(c => c)
.Select(c => c.GetName()));
}
writer.WriteObjectEnd();
}
}
private static void SetCentralDependencies(IObjectWriter writer, ICollection <CentralPackageVersion> centralPackageVersions, bool hashing)
{
if (!centralPackageVersions.Any())
{
return;
}
writer.WriteObjectStart("centralPackageVersions");
if (hashing)
{
foreach (var dependency in centralPackageVersions)
{
writer.WriteNameValue(name: dependency.Name, value: dependency.VersionRange.OriginalString ?? dependency.VersionRange.ToNormalizedString());
}
}
else
{
foreach (var dependency in centralPackageVersions.OrderBy(dep => dep.Name))
{
writer.WriteNameValue(name: dependency.Name, value: dependency.VersionRange.ToNormalizedString());
}
}
writer.WriteObjectEnd();
}
private static void SetFrameworks(IObjectWriter writer, IList <TargetFrameworkInformation> frameworks)
{
if (frameworks.Any())
{
writer.WriteObjectStart("frameworks");
foreach (var framework in frameworks)
{
writer.WriteObjectStart(framework.FrameworkName.GetShortFolderName());
SetDependencies(writer, framework.Dependencies);
SetImports(writer, framework.Imports);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
}
private static void WriteLockFile(JsonWriter writer, IObjectWriter jsonObjectWriter, LockFile lockFile)
{
writer.WriteStartObject();
writer.WritePropertyName(VersionProperty);
writer.WriteValue(lockFile.Version);
writer.WritePropertyName(TargetsProperty);
JsonUtility.WriteObject(writer, lockFile.Targets, WriteTarget);
writer.WritePropertyName(LibrariesProperty);
JsonUtility.WriteObject(writer, lockFile.Libraries, WriteLibrary);
writer.WritePropertyName(ProjectFileDependencyGroupsProperty);
JsonUtility.WriteObject(writer, lockFile.ProjectFileDependencyGroups, WriteProjectFileDependencyGroup);
if (lockFile.PackageFolders?.Any() == true)
{
writer.WritePropertyName(PackageFoldersProperty);
JsonUtility.WriteObject(writer, lockFile.PackageFolders, WriteFileItem);
}
if (lockFile.Version >= 2)
{
if (lockFile.PackageSpec != null)
{
writer.WritePropertyName(PackageSpecProperty);
jsonObjectWriter.WriteObjectStart();
PackageSpecWriter.Write(lockFile.PackageSpec, jsonObjectWriter);
jsonObjectWriter.WriteObjectEnd();
}
}
if (lockFile.Version >= 3)
{
if (lockFile.LogMessages.Count > 0)
{
var projectPath = lockFile.PackageSpec?.RestoreMetadata?.ProjectPath;
writer.WritePropertyName(LogsProperty);
WriteLogMessages(writer, lockFile.LogMessages, projectPath);
}
}
if (lockFile.CentralTransitiveDependencyGroups.Any())
{
writer.WritePropertyName(CentralTransitiveDependencyGroupsProperty);
WriteCentralTransitiveDependencyGroup(jsonObjectWriter, lockFile.CentralTransitiveDependencyGroups);
}
writer.WriteEndObject();
}
private static void WriteCentralTransitiveDependencyGroup(IObjectWriter writer, IList <CentralTransitiveDependencyGroup> centralTransitiveDependencyGroups)
{
writer.WriteObjectStart();
foreach (var centralTransitiveDepGroup in centralTransitiveDependencyGroups.OrderBy(ptdg => ptdg.FrameworkName))
{
PackageSpecWriter.SetCentralTransitveDependencyGroup(writer, centralTransitiveDepGroup.FrameworkName, centralTransitiveDepGroup.TransitiveDependencies);
}
writer.WriteObjectEnd();
}
private static void SetFrameworks(IObjectWriter writer, IList <TargetFrameworkInformation> frameworks)
{
if (frameworks.Any())
{
writer.WriteObjectStart("frameworks");
foreach (var framework in frameworks)
{
writer.WriteObjectStart(framework.FrameworkName.GetShortFolderName());
SetDependencies(writer, framework.Dependencies);
SetFrameworkArrayToProperty(writer, framework.Imports, "imports");
SetFrameworkArrayToProperty(writer, framework.AssetTargetFallback, "assetTargetFallback");
SetValueIfTrue(writer, "warn", framework.Warn);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
}
private static void SetFrameworks(IObjectWriter writer, IList <TargetFrameworkInformation> frameworks)
{
if (frameworks.Any())
{
writer.WriteObjectStart("frameworks");
var frameworkSorter = new NuGetFrameworkSorter();
foreach (var framework in frameworks.OrderBy(c => c.FrameworkName, frameworkSorter))
{
writer.WriteObjectStart(framework.FrameworkName.GetShortFolderName());
SetDependencies(writer, framework.Dependencies);
SetImports(writer, framework.Imports);
SetValueIfTrue(writer, "assetTargetFallback", framework.AssetTargetFallback);
SetValueIfTrue(writer, "warn", framework.Warn);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
}
/// <summary>
/// This method sets the msbuild metadata that's important for restore. Ensures that frameworks regardless of which way they're stores in the metadata(full name or short tfm name) are written out the same.
/// </summary>
private static void SetMSBuildMetadata(IObjectWriter writer, PackageSpec packageSpec)
{
var msbuildMetadata = packageSpec.RestoreMetadata;
if (!IsMetadataValid(msbuildMetadata))
{
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());
}
WriteMetadataBooleans(writer, msbuildMetadata);
SetArrayValue(writer, "fallbackFolders", msbuildMetadata.FallbackFolders);
SetArrayValue(writer, "configFilePaths", msbuildMetadata.ConfigFilePaths);
if (msbuildMetadata.CrossTargeting)
{
SetArrayValue(writer, "originalTargetFrameworks", msbuildMetadata.OriginalTargetFrameworks.OrderBy(c => c, StringComparer.Ordinal)); // This need to stay the original strings because the nuget.g.targets have conditional imports based on the original framework name
}
else
{
SetArrayValue(writer, "originalTargetFrameworks", msbuildMetadata.OriginalTargetFrameworks.Select(e => NuGetFramework.Parse(e).GetShortFolderName()).OrderBy(c => c, StringComparer.Ordinal));
}
WriteMetadataSources(writer, msbuildMetadata);
WriteMetadataFiles(writer, msbuildMetadata);
WriteMetadataTargetFrameworks(writer, msbuildMetadata);
SetWarningProperties(writer, msbuildMetadata);
// write NuGet lock file msbuild properties
WriteNuGetLockFileProperties(writer, msbuildMetadata);
if (msbuildMetadata is PackagesConfigProjectRestoreMetadata pcMsbuildMetadata)
{
SetValue(writer, "packagesConfigPath", pcMsbuildMetadata.PackagesConfigPath);
}
writer.WriteObjectEnd();
}
private static void WriteMetadataFiles(IObjectWriter writer, ProjectRestoreMetadata msbuildMetadata)
{
if (msbuildMetadata.Files?.Count > 0)
{
writer.WriteObjectStart("files");
foreach (var file in msbuildMetadata.Files)
{
SetValue(writer, file.PackagePath, file.AbsolutePath);
}
writer.WriteObjectEnd();
}
}
private static void WriteRuntimeDependencySet(IObjectWriter writer, RuntimeDependencySet data)
{
writer.WriteObjectStart(data.Id);
var sortedDependencies = data.Dependencies
.OrderBy(pair => pair.Key, StringComparer.Ordinal)
.Select(pair => pair.Value);
foreach (var dependency in sortedDependencies)
{
WritePackageDependency(writer, dependency);
}
writer.WriteObjectEnd();
}
private static void SetRestoreSettings(IObjectWriter writer, PackageSpec packageSpec)
{
var restoreSettings = packageSpec.RestoreSettings;
// Do not write Restore Setting if the HideWarningsAndErrors is false
// This should be changed in the future as more properties are added to ProjectRestoreSettings
if (restoreSettings == null || !restoreSettings.HideWarningsAndErrors)
{
return;
}
writer.WriteObjectStart(JsonPackageSpecReader.RestoreSettings);
SetValueIfTrue(writer, JsonPackageSpecReader.HideWarningsAndErrors, restoreSettings.HideWarningsAndErrors);
writer.WriteObjectEnd();
}
private static void SetDictionaryValues(IObjectWriter writer, string name, IDictionary <string, IEnumerable <string> > values)
{
if (values != null && values.Any())
{
writer.WriteObjectStart(name);
var sortedValues = values.OrderBy(pair => pair.Key, StringComparer.Ordinal);
foreach (var pair in sortedValues)
{
writer.WriteNameArray(pair.Key, pair.Value);
}
writer.WriteObjectEnd();
}
}
private static void WriteNuGetLockFileProperties(IObjectWriter writer, ProjectRestoreMetadata msbuildMetadata)
{
if (msbuildMetadata.RestoreLockProperties != null &&
(!string.IsNullOrEmpty(msbuildMetadata.RestoreLockProperties.RestorePackagesWithLockFile) ||
!string.IsNullOrEmpty(msbuildMetadata.RestoreLockProperties.NuGetLockFilePath) ||
msbuildMetadata.RestoreLockProperties.RestoreLockedMode))
{
writer.WriteObjectStart("restoreLockProperties");
SetValue(writer, "restorePackagesWithLockFile", msbuildMetadata.RestoreLockProperties.RestorePackagesWithLockFile);
SetValue(writer, "nuGetLockFilePath", msbuildMetadata.RestoreLockProperties.NuGetLockFilePath);
SetValueIfTrue(writer, "restoreLockedMode", msbuildMetadata.RestoreLockProperties.RestoreLockedMode);
writer.WriteObjectEnd();
}
}
private static void SetPackOptions(IObjectWriter writer, PackageSpec packageSpec)
{
var packOptions = packageSpec.PackOptions;
if (packOptions == null)
{
return;
}
if ((packageSpec.Owners == null || packageSpec.Owners.Length == 0) &&
(packageSpec.Tags == null || packageSpec.Tags.Length == 0) &&
packageSpec.ProjectUrl == null && packageSpec.IconUrl == null && packageSpec.Summary == null &&
packageSpec.ReleaseNotes == null && packageSpec.LicenseUrl == null &&
!packageSpec.RequireLicenseAcceptance &&
(packOptions.PackageType == null || packOptions.PackageType.Count == 0))
{
return;
}
writer.WriteObjectStart(JsonPackageSpecReader.PackOptions);
SetArrayValue(writer, "owners", packageSpec.Owners);
SetArrayValue(writer, "tags", packageSpec.Tags);
SetValue(writer, "projectUrl", packageSpec.ProjectUrl);
SetValue(writer, "iconUrl", packageSpec.IconUrl);
SetValue(writer, "summary", packageSpec.Summary);
SetValue(writer, "releaseNotes", packageSpec.ReleaseNotes);
SetValue(writer, "licenseUrl", packageSpec.LicenseUrl);
SetValueIfTrue(writer, "requireLicenseAcceptance", packageSpec.RequireLicenseAcceptance);
if (packOptions.PackageType != null)
{
if (packOptions.PackageType.Count == 1)
{
SetValue(writer, JsonPackageSpecReader.PackageType, packOptions.PackageType[0].Name);
}
else if (packOptions.PackageType.Count > 1)
{
var packageTypeNames = packOptions.PackageType.Select(p => p.Name);
SetArrayValue(writer, JsonPackageSpecReader.PackageType, packageTypeNames);
}
}
writer.WriteObjectEnd();
}
private static void WriteRuntimeDescription(IObjectWriter writer, RuntimeDescription data)
{
writer.WriteObjectStart(data.RuntimeIdentifier);
writer.WriteNameArray("#import", data.InheritedRuntimes);
var sortedDependencySets = data.RuntimeDependencySets
.OrderBy(pair => pair.Key, StringComparer.Ordinal)
.Select(pair => pair.Value);
foreach (var set in sortedDependencySets)
{
WriteRuntimeDependencySet(writer, set);
}
writer.WriteObjectEnd();
}
private static void SetDownloadDependencies(IObjectWriter writer, IList <DownloadDependency> downloadDependencies)
{
if (!downloadDependencies.Any())
{
return;
}
writer.WriteArrayStart("downloadDependencies");
foreach (var dependency in downloadDependencies.OrderBy(dep => dep))
{
writer.WriteObjectInArrayStart();
SetValue(writer, "name", dependency.Name);
SetValue(writer, "version", dependency.VersionRange.ToNormalizedString());
writer.WriteObjectEnd();
}
writer.WriteArrayEnd();
}
private static void SetCentralDependencies(IObjectWriter writer, ICollection <CentralPackageVersion> centralPackageVersions, bool compressed)
{
if (!centralPackageVersions.Any())
{
return;
}
if (compressed)
{
SetValue(writer, "centralPackageVersionsHash", GetHash(centralPackageVersions).ToString());
return;
}
writer.WriteObjectStart("centralPackageVersions");
foreach (var dependency in centralPackageVersions.OrderBy(dep => dep.Name))
{
writer.WriteNameValue(name: dependency.Name, value: dependency.VersionRange.ToNormalizedString());
}
writer.WriteObjectEnd();
}
private static void SetDownloadDependencies(IObjectWriter writer, IList <DownloadDependency> downloadDependencies)
{
if (!downloadDependencies.Any())
{
return;
}
writer.WriteArrayStart("downloadDependencies");
foreach (var dependency in downloadDependencies.GroupBy(dep => dep.Name).OrderBy(dep => dep.Key))
{
var version = string.Join(";", dependency.Select(dep => dep.VersionRange).OrderBy(dep => dep.MinVersion).Select(dep => dep.ToNormalizedString()));
writer.WriteObjectInArrayStart();
SetValue(writer, "name", dependency.Key);
SetValue(writer, "version", version);
writer.WriteObjectEnd();
}
writer.WriteArrayEnd();
}
private static void WriteCompatibilityProfile(IObjectWriter writer, CompatibilityProfile data)
{
writer.WriteObjectStart(data.Name);
var frameworkGroups = data.RestoreContexts.GroupBy(context => context.Framework);
foreach (var frameworkGroup in frameworkGroups)
{
var name = frameworkGroup.Key.GetShortFolderName();
var runtimes = frameworkGroup.ToList();
if (runtimes.Count == 1)
{
// Write a string
writer.WriteNameValue(name, runtimes[0].RuntimeIdentifier);
}
else if (runtimes.Count > 0)
{
writer.WriteNameArray(name, runtimes.Select(rt => rt.RuntimeIdentifier));
}
}
writer.WriteObjectEnd();
}
/// <summary>
/// This method sets the msbuild metadata that's important for restore. Ensures that frameworks regardless of which way they're stores in the metadata(full name or short tfm name) are written out the same.
/// </summary>
private static void SetMSBuildMetadata(IObjectWriter writer, PackageSpec packageSpec)
{
var msbuildMetadata = packageSpec.RestoreMetadata;
if (!IsMetadataValid(msbuildMetadata))
{
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());
}
WriteMetadataBooleans(writer, msbuildMetadata);
SetArrayValue(writer, "fallbackFolders", msbuildMetadata.FallbackFolders);
SetArrayValue(writer, "configFilePaths", msbuildMetadata.ConfigFilePaths);
SetArrayValue(writer, "originalTargetFrameworks", msbuildMetadata.OriginalTargetFrameworks.Select(e => NuGetFramework.Parse(e).GetShortFolderName()));
WriteMetadataSources(writer, msbuildMetadata);
WriteMetadataFiles(writer, msbuildMetadata);
WriteMetadataTargetFrameworks(writer, msbuildMetadata);
SetWarningProperties(writer, msbuildMetadata);
writer.WriteObjectEnd();
}
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();
}
/// <summary>
/// This method sorts the libraries based on the name
/// This method also writes out the normalized versions to avoid cases where original string is set because it was gotten through project system vs being installed from PM UI
/// </summary>
private static void SetDependencies(IObjectWriter writer, string name, IEnumerable <LibraryDependency> libraryDependencies)
{
if (!libraryDependencies.Any())
{
return;
}
writer.WriteObjectStart(name);
foreach (var dependency in libraryDependencies.OrderBy(e => e.Name, StringComparer.Ordinal))
{
var expandedMode = dependency.IncludeType != LibraryIncludeFlags.All ||
dependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent ||
dependency.Type != LibraryDependencyType.Default ||
dependency.AutoReferenced ||
(dependency.LibraryRange.TypeConstraint != LibraryDependencyTarget.Reference &&
dependency.LibraryRange.TypeConstraint != (LibraryDependencyTarget.All & ~LibraryDependencyTarget.Reference));
var versionRange = dependency.LibraryRange.VersionRange ?? VersionRange.All;
var versionString = versionRange.ToNormalizedString();
if (expandedMode)
{
writer.WriteObjectStart(dependency.Name);
if (dependency.IncludeType != LibraryIncludeFlags.All)
{
SetValue(writer, "include", dependency.IncludeType.ToString());
}
if (dependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
SetValue(writer, "suppressParent", dependency.SuppressParent.ToString());
}
if (dependency.Type != LibraryDependencyType.Default)
{
SetValue(writer, "type", dependency.Type.ToString());
}
if (dependency.LibraryRange.TypeConstraint != LibraryDependencyTarget.Reference &&
dependency.LibraryRange.TypeConstraint != (LibraryDependencyTarget.All & ~LibraryDependencyTarget.Reference))
{
SetValue(writer, "target", dependency.LibraryRange.TypeConstraint.ToString());
}
if (VersionRange.All.Equals(versionRange) &&
!dependency.LibraryRange.TypeConstraintAllows(LibraryDependencyTarget.Package) &&
!dependency.LibraryRange.TypeConstraintAllows(LibraryDependencyTarget.Reference) &&
!dependency.LibraryRange.TypeConstraintAllows(LibraryDependencyTarget.ExternalProject))
{
// Allow this specific case to skip the version property
}
else
{
SetValue(writer, "version", versionString);
}
SetValueIfTrue(writer, "autoReferenced", dependency.AutoReferenced);
if (dependency.NoWarn.Count > 0)
{
SetArrayValue(writer, "noWarn", dependency
.NoWarn
.OrderBy(c => c)
.Distinct()
.Select(code => code.GetName())
.Where(s => !string.IsNullOrEmpty(s)));
}
SetValueIfTrue(writer, "generatePathProperty", dependency.GeneratePathProperty);
SetValueIfTrue(writer, "versionCentrallyManaged", dependency.VersionCentrallyManaged);
writer.WriteObjectEnd();
}
else
{
writer.WriteNameValue(dependency.Name, versionString);
}
}
writer.WriteObjectEnd();
}
public void WriteObjectEnd()
{
innerWriter.WriteObjectEnd();
}
