public void IncludeFlag_SuppressParentFlags()
{
// Arrange
var json = @"{
""dependencies"": {
""packageA"": {
""version"": ""1.0.0"",
""suppressParent"": ""build,contentFiles,runtime,native""
}
},
""frameworks"": {
""net46"": {}
}
}";
// Act
var spec = JsonPackageSpecReader.GetPackageSpec(json, "TestProject", "project.json");
var dependency = spec.Dependencies.Single();
// Assert
var expected = LibraryIncludeFlagUtils.GetFlags(
new string[]
{ "build", "runtime", "contentFiles", "native" });
Assert.Equal(expected, dependency.SuppressParent);
}
public void GetFlags_WhenFlagsIsNull_Throws()
{
ArgumentNullException exception = Assert.Throws <ArgumentNullException>(
() => LibraryIncludeFlagUtils.GetFlags(flags: null));
Assert.Equal("flags", exception.ParamName);
}
public void IncludeFlag_UnknownFlagsParse()
{
// Arrange
var json = @"{
""dependencies"": {
""packageA"": {
""version"": ""1.0.0"",
""include"": ""futureFlag"",
""exclude"": ""futureFlag2"",
""suppressParent"": ""futureFlag""
}
},
""frameworks"": {
""net46"": {}
}
}";
// Act
var spec = JsonPackageSpecReader.GetPackageSpec(json, "TestProject", "project.json");
var dependency = spec.Dependencies.Single();
var futureFlag = LibraryIncludeFlagUtils.GetFlags(new string[] { "futureFlag" });
// Assert
Assert.Equal(LibraryIncludeFlags.None, futureFlag);
}
private void UpdatePackageReferenceItems(IEnumerable <ProjectItem> packageReferencesItems,
LibraryDependency libraryDependency)
{
// We validate that the operation does not update any imported items
// If it does then we throw a user friendly exception without making any changes
ValidateNoImportedItemsAreUpdated(packageReferencesItems, libraryDependency, UPDATE_OPERATION);
foreach (var packageReferenceItem in packageReferencesItems)
{
var packageVersion = libraryDependency.LibraryRange.VersionRange.OriginalString ??
libraryDependency.LibraryRange.VersionRange.MinVersion.ToString();
packageReferenceItem.SetMetadataValue(VERSION_TAG, packageVersion);
if (libraryDependency.IncludeType != LibraryIncludeFlags.All)
{
var includeFlags = MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(libraryDependency.IncludeType));
packageReferenceItem.SetMetadataValue(IncludeAssets, includeFlags);
}
if (libraryDependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
var suppressParent = MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(libraryDependency.SuppressParent));
packageReferenceItem.SetMetadataValue(PrivateAssets, suppressParent);
}
Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgUpdated,
libraryDependency.Name,
packageVersion,
packageReferenceItem.Xml.ContainingProject.FullPath));
}
}
private void AddPackageReferenceIntoItemGroup(ProjectItemGroupElement itemGroup,
LibraryDependency libraryDependency)
{
var packageVersion = libraryDependency.LibraryRange.VersionRange.OriginalString ??
libraryDependency.LibraryRange.VersionRange.MinVersion.ToString();
var item = itemGroup.AddItem(PACKAGE_REFERENCE_TYPE_TAG, libraryDependency.Name);
item.AddMetadata(VERSION_TAG, packageVersion, expressAsAttribute: true);
if (libraryDependency.IncludeType != LibraryIncludeFlags.All)
{
var includeFlags = MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(libraryDependency.IncludeType));
item.AddMetadata(IncludeAssets, includeFlags, expressAsAttribute: false);
}
if (libraryDependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
var suppressParent = MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(libraryDependency.SuppressParent));
item.AddMetadata(PrivateAssets, suppressParent, expressAsAttribute: false);
}
Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgAdded,
libraryDependency.Name,
packageVersion,
itemGroup.ContainingProject.FullPath));
}
/// <summary>
/// Convert a nuspec dependency to a library dependency.
/// </summary>
public static LibraryDependency GetLibraryDependencyFromNuspec(Packaging.Core.PackageDependency dependency)
{
// Start with the default. For package to package this is everything but content v2.
var includeType = LibraryIncludeFlagUtils.NoContent;
// Add includes
if (dependency.Include.Count > 0)
{
includeType = LibraryIncludeFlagUtils.GetFlags(dependency.Include);
}
// Remove excludes
if (dependency.Exclude.Count > 0)
{
var excludeType = LibraryIncludeFlagUtils.GetFlags(dependency.Exclude);
includeType = includeType & ~excludeType;
}
// Create the library
// Nuspec references cannot contain suppress parent flags
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = dependency.Id,
VersionRange = dependency.VersionRange,
TypeConstraint = LibraryDependencyTarget.PackageProjectExternal
},
IncludeType = includeType,
SuppressParent = LibraryIncludeFlags.None
};
return(libraryDependency);
}
public async Task AddOrUpdatePackageReferenceAsync(LibraryDependency packageReference, CancellationToken _)
{
Assumes.Present(packageReference);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var includeFlags = packageReference.IncludeType;
var privateAssetsFlag = packageReference.SuppressParent;
var metadataElements = new List <string>();
var metadataValues = new List <string>();
if (includeFlags != LibraryIncludeFlags.All)
{
metadataElements.Add(ProjectItemProperties.IncludeAssets);
metadataValues.Add(LibraryIncludeFlagUtils.GetFlagString(includeFlags).Replace(',', ';'));
}
if (privateAssetsFlag != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
metadataElements.Add(ProjectItemProperties.PrivateAssets);
metadataValues.Add(LibraryIncludeFlagUtils.GetFlagString(privateAssetsFlag).Replace(',', ';'));
}
AddOrUpdatePackageReference(
packageReference.Name,
packageReference.LibraryRange.VersionRange,
metadataElements.ToArray(),
metadataValues.ToArray());
}
public void GetFlags_WhenFlagsIsSingleValue_ReturnsFlag(
LibraryIncludeFlags input,
LibraryIncludeFlags expectedResult)
{
LibraryIncludeFlags actualResult = LibraryIncludeFlagUtils.GetFlags(new[] { input.ToString() });
Assert.Equal(expectedResult, actualResult);
}
public void IncludeFlag_RoundTrip(string expected, string flags)
{
// Arrange & Act
var parsed = LibraryIncludeFlagUtils.GetFlags(flags.Split('|'));
var actual = LibraryIncludeFlagUtils.GetFlagString(parsed);
// Assert
Assert.Equal(expected, actual);
}
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();
}
}
/// <summary>
/// Gets the <see cref="LibraryIncludeFlags" /> for the specified value.
/// </summary>
/// <param name="value">A semicolon delimited list of include flags.</param>
/// <param name="defaultValue">The default value ot return if the value contains no flags.</param>
/// <returns>The <see cref="LibraryIncludeFlags" /> for the specified value, otherwise the <paramref name="defaultValue" />.</returns>
private static LibraryIncludeFlags GetLibraryIncludeFlags(string value, LibraryIncludeFlags defaultValue)
{
if (string.IsNullOrWhiteSpace(value))
{
return(defaultValue);
}
string[] parts = MSBuildStringUtility.Split(value);
return(parts.Length > 0 ? LibraryIncludeFlagUtils.GetFlags(parts) : defaultValue);
}
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 LibraryIncludeFlags GetIncludeFlags(string value, LibraryIncludeFlags defaultValue)
{
var parts = MSBuildStringUtility.Split(value);
if (parts.Length > 0)
{
return(LibraryIncludeFlagUtils.GetFlags(parts));
}
else
{
return(defaultValue);
}
}
public void GetFlags_WhenFlagsIsMultipleValues_ReturnsCombinationOfValues()
{
LibraryIncludeFlags[] expectedFlags = new[]
{
LibraryIncludeFlags.Runtime,
LibraryIncludeFlags.Compile,
LibraryIncludeFlags.Build
};
LibraryIncludeFlags flags = LibraryIncludeFlagUtils.GetFlags(expectedFlags.Select(flag => flag.ToString()));
Assert.Equal("Runtime, Compile, Build", flags.ToString());
}
private static async Task MigrateDependenciesAsync(LegacyCSProjPackageReferenceProject project, PackageSpec packageSpec)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (packageSpec.TargetFrameworks.Count > 1)
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
Strings.Error_MultipleFrameworks,
project.MSBuildProjectPath));
}
var dependencies = new List <LibraryDependency>();
foreach (var targetFramework in packageSpec.TargetFrameworks)
{
dependencies.AddRange(targetFramework.Dependencies);
}
dependencies.AddRange(packageSpec.Dependencies);
foreach (var dependency in dependencies)
{
var includeFlags = dependency.IncludeType;
var privateAssetsFlag = dependency.SuppressParent;
var metadataElements = new List <string>();
var metadataValues = new List <string>();
if (includeFlags != LibraryIncludeFlags.All)
{
metadataElements.Add("IncludeAssets");
metadataValues.Add(LibraryIncludeFlagUtils.GetFlagString(includeFlags).Replace(',', ';'));
}
if (privateAssetsFlag != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
metadataElements.Add("PrivateAssets");
metadataValues.Add(LibraryIncludeFlagUtils.GetFlagString(privateAssetsFlag).Replace(',', ';'));
}
await project.InstallPackageWithMetadataAsync(dependency.Name, dependency.LibraryRange.VersionRange, metadataElements, metadataValues);
}
}
public void IncludeFlag_IncludeOnlyContent()
{
// Arrange
var json = @"{
""dependencies"": {
""packageA"": {
""version"": ""1.0.0"",
""include"": ""contentFiles""
}
},
""frameworks"": {
""net46"": {}
}
}";
// Act
var spec = JsonPackageSpecReader.GetPackageSpec(json, "TestProject", "project.json");
var dependency = spec.Dependencies.Single();
// Assert
Assert.True(dependency.IncludeType
== LibraryIncludeFlagUtils.GetFlags(new string[] { "contentFiles" }));
}
public void GetFlags_WhenFlagsIsEmpty_ReturnsNone()
{
LibraryIncludeFlags flags = LibraryIncludeFlagUtils.GetFlags(Enumerable.Empty <string>());
Assert.Equal(LibraryIncludeFlags.None, flags);
}
public void GetFlags_WhenFlagsCasingDiffers_ReturnsFlag(string flag)
{
LibraryIncludeFlags flags = LibraryIncludeFlagUtils.GetFlags(new[] { flag });
Assert.Equal(LibraryIncludeFlags.Compile, flags);
}
private static void PopulateDependencies(
string projectPath,
IList <ProjectLibraryDependency> results,
JObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings.Value <JToken>(propertyName) as JObject;
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
if (string.IsNullOrEmpty(dependency.Key))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependency.Key,
projectPath);
}
var dependencyValue = dependency.Value;
var dependencyTypeValue = LibraryDependencyType.Default;
var dependencyIncludeFlagsValue = LibraryIncludeFlags.All;
var dependencyExcludeFlagsValue = LibraryIncludeFlags.None;
var suppressParentFlagsValue = LibraryIncludeFlagUtils.DefaultSuppressParent;
var target = isGacOrFrameworkReference ? LibraryDependencyTarget.Reference : LibraryDependencyTarget.All;
string dependencyVersionAsString = null;
if (dependencyValue.Type == JTokenType.Object)
{
// "dependencies" : { "Name" : { "version": "1.0", "type": "build", "target": "project" } }
dependencyVersionAsString = dependencyValue.Value <string>("version");
var type = dependencyValue.Value <string>("type");
if (type != null)
{
dependencyTypeValue = LibraryDependencyType.Parse(new [] { type });
}
// Read the target if specified
if (!isGacOrFrameworkReference)
{
var targetStr = dependencyValue.Value <string>("target");
target = LibraryDependencyTargetUtils.Parse(targetStr);
}
IEnumerable <string> strings;
if (TryGetStringEnumerable(dependencyValue["include"], out strings))
{
dependencyIncludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["exclude"], out strings))
{
dependencyExcludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["suppressParent"], out strings))
{
// This overrides any settings that came from the type property.
suppressParentFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
}
else if (dependencyValue.Type == JTokenType.String)
{
// "dependencies" : { "Name" : "1.0" }
dependencyVersionAsString = dependencyValue.Value <string>();
}
else
{
throw FileFormatException.Create(
string.Format(
"Invalid dependency version: {0}. The format is not recognizable.",
dependency.Key),
dependencyValue,
projectPath);
}
VersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionAsString))
{
try
{
dependencyVersionRange = VersionRange.Parse(dependencyVersionAsString);
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, dependencyValue, projectPath);
}
}
// the dependency flags are: Include flags - Exclude flags
var includeFlags = dependencyIncludeFlagsValue & ~dependencyExcludeFlagsValue;
var lineInfo = (IJsonLineInfo)dependencyValue;
results.Add(new ProjectLibraryDependency
{
LibraryRange = new LibraryRange(
dependency.Key,
dependencyVersionRange,
target),
Type = dependencyTypeValue,
IncludeType = includeFlags,
SuppressParent = suppressParentFlagsValue,
SourceFilePath = projectPath,
SourceLine = lineInfo.LineNumber,
SourceColumn = lineInfo.LinePosition
});
}
}
}
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 override Task <bool> InstallPackageAsync(string packageId, VersionRange range, INuGetProjectContext nuGetProjectContext, BuildIntegratedInstallationContext installationContext, CancellationToken token)
{
var formattedRange = range.MinVersion.ToNormalizedString();
nuGetProjectContext.Log(MessageLevel.Info, "Installing {0}", $"{packageId} {formattedRange}");
if (installationContext.SuccessfulFrameworks.Any() && installationContext.UnsuccessfulFrameworks.Any())
{
foreach (var framework in installationContext.SuccessfulFrameworks)
{
if (!installationContext.OriginalFrameworks.TryGetValue(framework, out string originalFramework))
{
originalFramework = framework.GetShortFolderName();
}
var metadata = new Dictionary <string, string>();
// SuppressParent could be set to All if developmentDependency flag is true in package nuspec file.
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
metadata = new Dictionary <string, string> {
{ ProjectItemProperties.PrivateAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)) },
{ ProjectItemProperties.IncludeAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)) }
};
}
AddOrUpdatePackageReference(packageId, formattedRange, metadata, TargetFrameworkCondition, originalFramework);
}
}
else
{
// Install the package to all frameworks.
var metadata = new Dictionary <string, string>();
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
metadata.Add(ProjectItemProperties.PrivateAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)));
metadata.Add(ProjectItemProperties.IncludeAssets, MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)));
}
AddOrUpdatePackageReference(packageId, formattedRange, metadata, null, null);
}
return(Task.FromResult(true));
}
internal static void SetMetadataValue(this IPropertySet propertySet, string name, LibraryIncludeFlags flags)
{
string value = MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(flags));
propertySet.SetValue(name, value);
}
private static ProjectRestoreMetadata GetMSBuildMetadata(PackageSpec packageSpec, JObject rawPackageSpec)
{
var rawMSBuildMetadata = rawPackageSpec.Value <JToken>(RestoreOptions) as JObject;
if (rawMSBuildMetadata == null)
{
return(null);
}
var msbuildMetadata = new ProjectRestoreMetadata();
msbuildMetadata.ProjectUniqueName = rawMSBuildMetadata.GetValue <string>("projectUniqueName");
msbuildMetadata.OutputPath = rawMSBuildMetadata.GetValue <string>("outputPath");
var projectStyleString = rawMSBuildMetadata.GetValue <string>("projectStyle");
ProjectStyle projectStyle;
if (!string.IsNullOrEmpty(projectStyleString) &&
Enum.TryParse <ProjectStyle>(projectStyleString, ignoreCase: true, result: out projectStyle))
{
msbuildMetadata.ProjectStyle = projectStyle;
}
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);
}
return(msbuildMetadata);
}
private static bool GenerateLockFile(string dir, string assetsFilePath)
{
if (!File.Exists(assetsFilePath))
{
// TODO auto-restore?
Console.Error.WriteLine("Could not find project.assets.json. Make sure to run 'dotnet restore' first before locking the file");
return(false);
}
var lockFilePath = Path.Combine(dir, LockFileName);
var assetsFile = LockFileUtilities.GetLockFile(assetsFilePath, NullLogger.Instance);
var proj = new XElement("Project");
var doc = new XDocument(proj);
// details
var props = new XElement("PropertyGroup");
props.Add(new XElement("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)"));
props.Add(new XElement("NuGetLockFileVersion", GetVersion()));
props.Add(new XElement("NuGetLockFileImported", "true"));
// force NuGet to error out if there are issues
props.Add(new XElement("WarningsAsErrors", "$(WarningsAsErrors)" + FatalErrors.Aggregate(string.Empty, (sum, piece) => $"{sum};{piece}")));
proj.Add(props);
// clear all package reference items
proj.Add(new XElement("ItemGroup",
new XElement("PackageReference", new XAttribute("Remove", "@(PackageReference)"))));
// also naive. Multiple targets make exist if there are runtime identifiers
foreach (var target in assetsFile.Targets.OrderBy(t => t.TargetFramework.GetShortFolderName()))
{
var spec = assetsFile.PackageSpec.GetTargetFramework(target.TargetFramework);
var itemGroup = new XElement("ItemGroup", new XAttribute("Condition", $"'$(TargetFramework)' == '{target.TargetFramework.GetShortFolderName()}'"));
proj.Add(itemGroup);
foreach (var library in target.Libraries.OrderBy(l => l.Name).Where(l => !l.Type.Equals("project", StringComparison.Ordinal)))
{
// TODO re-add PrivateAssets, ExcludeAssets, etc. where appropriate
var reference = new XElement("PackageReference", new XAttribute("Include", library.Name), new XAttribute("Version", library.Version.ToNormalizedString()));
var refSpec = spec.Dependencies.FirstOrDefault(l => l.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase));
if (refSpec != null)
{
if (refSpec.AutoReferenced)
{
reference.Add(new XAttribute("IsImplicitlyDefined", "true"));
}
if (refSpec.NoWarn.Any())
{
reference.Add(new XAttribute("NoWarn", refSpec.NoWarn.Aggregate(string.Empty, (a, b) => $"{a};{b}")));
}
if (refSpec.SuppressParent == LibraryIncludeFlags.All)
{
reference.Add(new XAttribute("PrivateAssets", "All"));
}
if (refSpec.IncludeType != LibraryIncludeFlags.All)
{
reference.Add(
new XAttribute("IncludeAssets", LibraryIncludeFlagUtils.GetFlagString(refSpec.IncludeType).Replace(", ", ";")));
}
}
else
{
bool IsEmptyFile(LockFileItem item)
{
return(Path.GetFileName(item.Path).Equals("_._", StringComparison.Ordinal));
}
// Attempt to make this as similar to a transitive dependency as possible
// This info is just for us. No one uses it (yet).
reference.Add(new XAttribute("Transitive", "true"));
// Add PrivateAssets="All" to ensure only top-level dependencies end up in the generated nuspec
reference.Add(new XAttribute("PrivateAssets", "All"));
// in some cases, the parent package may exclude assets from their nuspec.
// We don't want to change the compile graph by lifting this to be a top-level PackageRef
var excludeFlags = LibraryIncludeFlags.None;
if (library.CompileTimeAssemblies.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Compile;
}
if (library.RuntimeAssemblies.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Runtime;
}
if (library.NativeLibraries.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Native;
}
if (library.Build.Count(IsEmptyFile) == 1 ||
library.BuildMultiTargeting.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Build;
}
reference.Add(new XAttribute("ExcludeAssets", LibraryIncludeFlagUtils.GetFlagString(excludeFlags)));
}
itemGroup.Add(reference);
}
}
#if NETCOREAPP1_0
using (var stream = File.Open(lockFilePath, FileMode.Create))
{
doc.Save(stream);
}
#elif NETCOREAPP2_0
doc.Save(lockFilePath);
#else
#error Update target frameworks
#endif
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write($"Generated lock file: ");
Console.ResetColor();
Console.WriteLine(lockFilePath);
Console.WriteLine("This file should be commited to source control.");
return(true);
}
private static void PopulateDependencies(
string packageSpecPath,
IList <LibraryDependency> results,
JObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings[propertyName] as JObject;
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
if (string.IsNullOrEmpty(dependency.Key))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependency.Value,
packageSpecPath);
}
// Support
// "dependencies" : {
// "Name" : "1.0"
// }
var dependencyValue = dependency.Value;
var dependencyTypeValue = LibraryDependencyType.Default;
var dependencyIncludeFlagsValue = LibraryIncludeFlags.All;
var dependencyExcludeFlagsValue = LibraryIncludeFlags.None;
var suppressParentFlagsValue = LibraryIncludeFlagUtils.DefaultSuppressParent;
var noWarn = new List <NuGetLogCode>();
// This method handles both the dependencies and framework assembly sections.
// Framework references should be limited to references.
// Dependencies should allow everything but framework references.
var targetFlagsValue = isGacOrFrameworkReference
? LibraryDependencyTarget.Reference
: LibraryDependencyTarget.All & ~LibraryDependencyTarget.Reference;
var autoReferenced = false;
string dependencyVersionValue = null;
var dependencyVersionToken = dependencyValue;
if (dependencyValue.Type == JTokenType.String)
{
dependencyVersionValue = dependencyValue.Value <string>();
}
else
{
if (dependencyValue.Type == JTokenType.Object)
{
dependencyVersionToken = dependencyValue["version"];
if (dependencyVersionToken != null &&
dependencyVersionToken.Type == JTokenType.String)
{
dependencyVersionValue = dependencyVersionToken.Value <string>();
}
}
IEnumerable <string> strings;
if (TryGetStringEnumerable(dependencyValue["type"], out strings))
{
dependencyTypeValue = LibraryDependencyType.Parse(strings);
// Types are used at pack time, they should be translated to suppressParent to
// provide a matching effect for project to project references.
// This should be set before suppressParent is checked.
if (!dependencyTypeValue.Contains(LibraryDependencyTypeFlag.BecomesNupkgDependency))
{
suppressParentFlagsValue = LibraryIncludeFlags.All;
}
else if (dependencyTypeValue.Contains(LibraryDependencyTypeFlag.SharedFramework))
{
dependencyIncludeFlagsValue =
LibraryIncludeFlags.Build |
LibraryIncludeFlags.Compile |
LibraryIncludeFlags.Analyzers;
}
}
if (TryGetStringEnumerable(dependencyValue["include"], out strings))
{
dependencyIncludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["exclude"], out strings))
{
dependencyExcludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["suppressParent"], out strings))
{
// This overrides any settings that came from the type property.
suppressParentFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
noWarn = GetNuGetLogCodeEnumerableFromJArray(dependencyValue["noWarn"])
.ToList();
var targetToken = dependencyValue["target"];
if (targetToken != null)
{
var targetString = targetToken.Value <string>();
targetFlagsValue = LibraryDependencyTargetUtils.Parse(targetString);
// Verify that the value specified is package, project, or external project
if (!ValidateDependencyTarget(targetFlagsValue))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidDependencyTarget,
targetString);
throw FileFormatException.Create(message, targetToken, packageSpecPath);
}
}
autoReferenced = GetBoolOrFalse(dependencyValue, "autoReferenced", packageSpecPath);
}
VersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionValue))
{
try
{
dependencyVersionRange = VersionRange.Parse(dependencyVersionValue);
}
catch (Exception ex)
{
throw FileFormatException.Create(
ex,
dependencyVersionToken,
packageSpecPath);
}
}
// Projects and References may have empty version ranges, Packages may not
if (dependencyVersionRange == null)
{
if ((targetFlagsValue & LibraryDependencyTarget.Package) == LibraryDependencyTarget.Package)
{
throw FileFormatException.Create(
new ArgumentException(Strings.MissingVersionOnDependency),
dependency.Value,
packageSpecPath);
}
else
{
// Projects and references with no version property allow all versions
dependencyVersionRange = VersionRange.All;
}
}
// the dependency flags are: Include flags - Exclude flags
var includeFlags = dependencyIncludeFlagsValue & ~dependencyExcludeFlagsValue;
results.Add(new LibraryDependency()
{
LibraryRange = new LibraryRange()
{
Name = dependency.Key,
TypeConstraint = targetFlagsValue,
VersionRange = dependencyVersionRange,
},
Type = dependencyTypeValue,
IncludeType = includeFlags,
SuppressParent = suppressParentFlagsValue,
AutoReferenced = autoReferenced,
NoWarn = noWarn.ToList()
});
}
}
}
public override async Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
var formattedRange = range.OriginalString ?? range.MinVersion.ToNormalizedString();
nuGetProjectContext.Log(MessageLevel.Info, Strings.InstallingPackage, $"{packageId} {formattedRange}");
if (installationContext.SuccessfulFrameworks.Any() && installationContext.UnsuccessfulFrameworks.Any())
{
// This is the "partial install" case. That is, install the package to only a subset of the frameworks
// supported by this project.
var conditionalService = _unconfiguredProject
.Services
.ExportProvider
.GetExportedValue <IConditionalPackageReferencesService>();
if (conditionalService == null)
{
throw new InvalidOperationException(string.Format(
Strings.UnableToGetCPSPackageInstallationService,
ProjectFullPath));
}
foreach (var framework in installationContext.SuccessfulFrameworks)
{
string originalFramework;
if (!installationContext.OriginalFrameworks.TryGetValue(framework, out originalFramework))
{
originalFramework = framework.GetShortFolderName();
}
var reference = await conditionalService.AddAsync(
packageId,
formattedRange,
TargetFrameworkCondition,
originalFramework);
// SuppressParent could be set to All if developmentDependency flag is true in package nuspec file.
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
await SetPackagePropertyValueAsync(
reference.Metadata,
ProjectItemProperties.PrivateAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)));
await SetPackagePropertyValueAsync(
reference.Metadata,
ProjectItemProperties.IncludeAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)));
}
}
}
else
{
// Install the package to all frameworks.
var configuredProject = await _unconfiguredProject.GetSuggestedConfiguredProjectAsync();
var result = await configuredProject
.Services
.PackageReferences
.AddAsync(packageId, formattedRange);
// This is the update operation
if (!result.Added)
{
var existingReference = result.Reference;
await existingReference.Metadata.SetPropertyValueAsync("Version", formattedRange);
}
if (installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent &&
installationContext.IncludeType != LibraryIncludeFlags.All)
{
await SetPackagePropertyValueAsync(
result.Reference.Metadata,
ProjectItemProperties.PrivateAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.SuppressParent)));
await SetPackagePropertyValueAsync(
result.Reference.Metadata,
ProjectItemProperties.IncludeAssets,
MSBuildStringUtility.Convert(LibraryIncludeFlagUtils.GetFlagString(installationContext.IncludeType)));
}
}
return(true);
}
