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 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();
}
/// <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);
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.WriteObjectStart();
SetValue(writer, "name", dependency.Key);
SetValue(writer, "version", version);
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 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();
}
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())
.Where(c => !string.IsNullOrEmpty(c)));
}
if (msbuildMetadata.ProjectWideWarningProperties.WarningsAsErrors.Count > 0)
{
SetArrayValue(writer, "warnAsError", msbuildMetadata
.ProjectWideWarningProperties
.WarningsAsErrors
.ToArray()
.OrderBy(c => c)
.Select(c => c.GetName())
.Where(c => !string.IsNullOrEmpty(c)));
}
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();
}
/// <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 WriteObjectStart(string name)
{
innerWriter.WriteObjectStart(name);
}
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();
}
private static void SetDependencies(IObjectWriter writer, string name, IEnumerable <LibraryDependency> libraryDependencies)
{
if (!libraryDependencies.Any())
{
return;
}
writer.WriteObjectStart(name);
foreach (var dependency in libraryDependencies)
{
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.OriginalString;
if (string.IsNullOrEmpty(versionString))
{
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);
writer.WriteObjectEnd();
}
else
{
writer.WriteNameValue(dependency.Name, versionString);
}
}
writer.WriteObjectEnd();
}