private PackageBuilder CreatePackageBuilderFromNuspec(string path)
{
// Set the version property if the flag is set
if (!string.IsNullOrEmpty(_packArgs.Version))
{
_packArgs.Properties["version"] = _packArgs.Version;
}
// If a nuspec file is being set via dotnet.exe then the warning properties and logger has already been initialized via PackTask.
if (_packArgs.WarningProperties == null)
{
_packArgs.WarningProperties = WarningProperties.GetWarningProperties(
treatWarningsAsErrors: _packArgs.GetPropertyValue("TreatWarningsAsErrors") ?? string.Empty,
warningsAsErrors: _packArgs.GetPropertyValue("WarningsAsErrors") ?? string.Empty,
noWarn: _packArgs.GetPropertyValue("NoWarn") ?? string.Empty);
_packArgs.Logger = new PackCollectorLogger(_packArgs.Logger, _packArgs.WarningProperties);
}
PackageBuilder packageBuilder;
if (string.IsNullOrEmpty(_packArgs.BasePath))
{
packageBuilder = new PackageBuilder(path, _packArgs.GetPropertyValue, !_packArgs.ExcludeEmptyDirectories);
}
else
{
packageBuilder = new PackageBuilder(path, _packArgs.BasePath, _packArgs.GetPropertyValue, !_packArgs.ExcludeEmptyDirectories);
}
InitCommonPackageBuilderProperties(packageBuilder);
return(packageBuilder);
}
public void Write_SerializesMembersAsJsonWithWarningPropertiesAndNo_NoWarn()
{
// Arrange && Act
var expectedWarningPropertiesJson = @"{
""allWarningsAsErrors"": true,
""warnAsError"": [
""NU1500"",
""NU1501""
]
}";
var allWarningsAsErrors = true;
var warningsAsErrors = new HashSet <NuGetLogCode> {
NuGetLogCode.NU1500, NuGetLogCode.NU1501
};
var noWarn = new HashSet <NuGetLogCode> {
};
var warningProperties = new WarningProperties(warningsAsErrors, noWarn, allWarningsAsErrors);
var packageSpec = CreatePackageSpec(withRestoreSettings: true, warningProperties: warningProperties);
var actualJson = packageSpec.ToJObject();
var actualWarningPropertiesJson = actualJson["restore"]["warningProperties"].ToString();
// Assert
Assert.NotNull(actualWarningPropertiesJson);
Assert.Equal(expectedWarningPropertiesJson, actualWarningPropertiesJson);
}
internal static WarningProperties GetProjectWideWarningProperties(IEnumerable targetFrameworks)
{
return(WarningProperties.GetWarningProperties(
treatWarningsAsErrors: GetSingleOrDefaultPropertyValue(targetFrameworks, ProjectBuildProperties.TreatWarningsAsErrors, e => e),
warningsAsErrors: GetSingleOrDefaultNuGetLogCodes(targetFrameworks, ProjectBuildProperties.WarningsAsErrors, e => MSBuildStringUtility.GetNuGetLogCodes(e)),
noWarn: GetSingleOrDefaultNuGetLogCodes(targetFrameworks, ProjectBuildProperties.NoWarn, e => MSBuildStringUtility.GetNuGetLogCodes(e))));
}
private static WarningProperties GetWarningProperties(IMSBuildItem specItem)
{
return(WarningProperties.GetWarningProperties(
treatWarningsAsErrors: specItem.GetProperty("TreatWarningsAsErrors"),
warningsAsErrors: specItem.GetProperty("WarningsAsErrors"),
noWarn: specItem.GetProperty("NoWarn")));
}
public PackCollectorLogger(ILogger innerLogger, WarningProperties warningProperties, PackCommand.PackageSpecificWarningProperties packageSpecificWarningProperties)
{
_innerLogger = innerLogger;
WarningProperties = warningProperties;
PackageSpecificWarningProperties = packageSpecificWarningProperties;
_errors = new ConcurrentQueue <ILogMessage>();
}
public void WarningPropertiesCloneTest()
{
// Set up
var allWarningsAsErrors = false;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var originalWarningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
//Act
var clone = originalWarningProperties.Clone();
// Assert
Assert.Equal(originalWarningProperties, clone);
Assert.False(object.ReferenceEquals(originalWarningProperties, clone));
Assert.False(object.ReferenceEquals(noWarn, clone.NoWarn));
// Act again
noWarn.Clear();
//Assert again
Assert.NotEqual(originalWarningProperties, clone);
Assert.Equal(2, clone.NoWarn.Count);
}
public WarningPropertiesCollection(WarningProperties projectWideWarningProperties,
PackageSpecificWarningProperties packageSpecificWarningProperties,
IReadOnlyList <NuGetFramework> projectFrameworks)
{
ProjectWideWarningProperties = projectWideWarningProperties;
PackageSpecificWarningProperties = packageSpecificWarningProperties;
ProjectFrameworks = projectFrameworks ?? new ReadOnlyCollection <NuGetFramework>(new List <NuGetFramework>());
}
static WarningProperties GetWarningProperties(IDotNetProject project)
{
return(WarningProperties.GetWarningProperties(
project.EvaluatedProperties.GetValue("TreatWarningsAsErrors"),
project.EvaluatedProperties.GetValue("WarningsAsErrors"),
project.EvaluatedProperties.GetValue("NoWarn")
));
}
private ProjectRestoreMetadata CreateProjectRestoreMetadata()
{
var projectRestoreMetadataFrameworkInfo = CreateProjectRestoreMetadataFrameworkInfo();
var allWarningsAsErrors = true;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var warningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
var originalProjectRestoreMetadata = new ProjectRestoreMetadata();
originalProjectRestoreMetadata.ProjectStyle = ProjectStyle.PackageReference;
originalProjectRestoreMetadata.ProjectPath = "ProjectPath";
originalProjectRestoreMetadata.ProjectJsonPath = "ProjectJsonPath";
originalProjectRestoreMetadata.OutputPath = "OutputPath";
originalProjectRestoreMetadata.ProjectName = "ProjectName";
originalProjectRestoreMetadata.ProjectUniqueName = "ProjectUniqueName";
originalProjectRestoreMetadata.PackagesPath = "PackagesPath";
originalProjectRestoreMetadata.CacheFilePath = "CacheFilePath";
originalProjectRestoreMetadata.CrossTargeting = true;
originalProjectRestoreMetadata.LegacyPackagesDirectory = true;
originalProjectRestoreMetadata.ValidateRuntimeAssets = true;
originalProjectRestoreMetadata.SkipContentFileWrite = true;
originalProjectRestoreMetadata.TargetFrameworks = new List <ProjectRestoreMetadataFrameworkInfo>()
{
projectRestoreMetadataFrameworkInfo
};
originalProjectRestoreMetadata.Sources = new List <PackageSource>()
{
new PackageSource("http://api.nuget.org/v3/index.json")
};
originalProjectRestoreMetadata.FallbackFolders = new List <string>()
{
"fallback1"
};
originalProjectRestoreMetadata.ConfigFilePaths = new List <string>()
{
"config1"
};
originalProjectRestoreMetadata.OriginalTargetFrameworks = new List <string>()
{
"net45"
};
originalProjectRestoreMetadata.Files = new List <ProjectRestoreMetadataFile>()
{
new ProjectRestoreMetadataFile("packagePath", "absolutePath")
};
originalProjectRestoreMetadata.ProjectWideWarningProperties = warningProperties;
return(originalProjectRestoreMetadata);
}
/// <summary>
/// Create warning properties from the msbuild property strings.
/// </summary>
public static WarningProperties GetWarningProperties(string treatWarningsAsErrors, string warningsAsErrors, string noWarn)
{
var props = new WarningProperties()
{
AllWarningsAsErrors = MSBuildStringUtility.IsTrue(treatWarningsAsErrors)
};
props.WarningsAsErrors.UnionWith(GetNuGetLogCodes(warningsAsErrors));
props.NoWarn.UnionWith(GetNuGetLogCodes(noWarn));
return(props);
}
/// <summary>
/// Method is used to check is a warning should be suppressed due to project wide no warn properties.
/// </summary>
/// <param name="message">Message to be checked for no warn.</param>
/// <returns>bool indicating if the ILogMessage should be suppressed or not.</returns>
public static bool ApplyProjectWideNoWarnProperties(ILogMessage message, WarningProperties warningProperties)
{
if (message.Level == LogLevel.Warning && warningProperties != null)
{
if (warningProperties.NoWarn.Contains(message.Code))
{
// If the project wide NoWarn contains the message code then suppress it.
return(true);
}
}
// the project wide NoWarn does contain the message code. do not suppress the warning.
return(false);
}
public void Write_SerializesMembersAsJsonWithEmptyWarningProperties()
{
// Arrange && Act
var allWarningsAsErrors = false;
var warningsAsErrors = new HashSet <NuGetLogCode> {
};
var noWarn = new HashSet <NuGetLogCode> {
};
var warningProperties = new WarningProperties(warningsAsErrors, noWarn, allWarningsAsErrors);
var packageSpec = CreatePackageSpec(withRestoreSettings: true, warningProperties: warningProperties);
var actualJson = packageSpec.ToJObject();
var actualWarningPropertiesJson = actualJson["restore"]["warningProperties"];
// Assert
Assert.Null(actualWarningPropertiesJson);
}
/// <summary>
/// Gets the restore metadata and target framework information for the specified project.
/// </summary>
/// <param name="project">An <see cref="IMSBuildProject" /> representing the project.</param>
/// <param name="projectsByTargetFramework">A <see cref="IReadOnlyDictionary{NuGetFramework,IMSBuildProject}" /> containing the inner nodes by target framework.</param>
/// <param name="settings">The <see cref="ISettings" /> of the specified project.</param>
/// <returns>A <see cref="Tuple" /> containing the <see cref="ProjectRestoreMetadata" /> and <see cref="List{TargetFrameworkInformation}" /> for the specified project.</returns>
private (ProjectRestoreMetadata RestoreMetadata, List <TargetFrameworkInformation> TargetFrameworkInfos) GetProjectRestoreMetadataAndTargetFrameworkInformation(IMSBuildProject project, IReadOnlyDictionary <NuGetFramework, IMSBuildProject> projectsByTargetFramework, ISettings settings)
{
var projectName = GetProjectName(project);
var outputPath = GetRestoreOutputPath(project);
var targetFrameworkInfos = GetTargetFrameworkInfos(projectsByTargetFramework);
var projectStyleResult = BuildTasksUtility.GetProjectRestoreStyle(
restoreProjectStyle: project.GetProperty("RestoreProjectStyle"),
hasPackageReferenceItems: targetFrameworkInfos.Any(i => i.Dependencies.Any()),
projectJsonPath: project.GetProperty("_CurrentProjectJsonPath"),
projectDirectory: project.Directory,
projectName: project.GetProperty("MSBuildProjectName"),
log: MSBuildLogger);
var projectStyle = projectStyleResult.ProjectStyle;
var innerNodes = projectsByTargetFramework.Values.ToList();
ProjectRestoreMetadata restoreMetadata;
if (projectStyle == ProjectStyle.PackagesConfig)
{
restoreMetadata = new PackagesConfigProjectRestoreMetadata
{
PackagesConfigPath = projectStyleResult.PackagesConfigFilePath,
RepositoryPath = GetRepositoryPath(project, settings)
};
}
else
{
restoreMetadata = new ProjectRestoreMetadata
{
CrossTargeting = (projectStyle == ProjectStyle.PackageReference || projectStyle == ProjectStyle.DotnetToolReference) && projectsByTargetFramework.Count > 1,
FallbackFolders = BuildTasksUtility.GetFallbackFolders(
project.Directory,
project.SplitPropertyValueOrNull("RestoreFallbackFolders"),
project.SplitPropertyValueOrNull("RestoreFallbackFoldersOverride"),
innerNodes.SelectMany(i => MSBuildStringUtility.Split(i.GetProperty("RestoreAdditionalProjectFallbackFolders"))),
innerNodes.SelectMany(i => MSBuildStringUtility.Split(i.GetProperty("RestoreAdditionalProjectFallbackFoldersExcludes"))),
settings),
SkipContentFileWrite = IsLegacyProject(project),
ValidateRuntimeAssets = project.IsPropertyTrue("ValidateRuntimeIdentifierCompatibility")
};
}
restoreMetadata.CacheFilePath = NoOpRestoreUtilities.GetProjectCacheFilePath(outputPath, project.FullPath);
restoreMetadata.ConfigFilePaths = settings.GetConfigFilePaths();
restoreMetadata.OutputPath = outputPath;
restoreMetadata.OriginalTargetFrameworks = GetOriginalTargetFrameworks(project, projectsByTargetFramework.Keys.ToList());
restoreMetadata.PackagesPath = GetPackagesPath(project, settings);
restoreMetadata.ProjectName = projectName;
restoreMetadata.ProjectPath = project.FullPath;
restoreMetadata.ProjectStyle = projectStyle;
restoreMetadata.ProjectUniqueName = project.FullPath;
restoreMetadata.ProjectWideWarningProperties = WarningProperties.GetWarningProperties(project.GetProperty("TreatWarningsAsErrors"), project.GetProperty("WarningsAsErrors"), project.GetProperty("NoWarn"));
restoreMetadata.RestoreLockProperties = new RestoreLockProperties(project.GetProperty("RestorePackagesWithLockFile"), project.GetProperty("NuGetLockFilePath"), project.IsPropertyTrue("RestoreLockedMode"));
restoreMetadata.Sources = GetSources(project, innerNodes, settings);
restoreMetadata.TargetFrameworks = GetProjectRestoreMetadataFrameworkInfos(projectsByTargetFramework);
return(restoreMetadata, targetFrameworkInfos);
}
private ProjectRestoreMetadata CreateProjectRestoreMetadata()
{
var projectReference = new ProjectRestoreReference();
projectReference.ProjectPath = "Path";
projectReference.ProjectUniqueName = "ProjectUniqueName";
projectReference.IncludeAssets = LibraryIncludeFlags.All;
projectReference.ExcludeAssets = LibraryIncludeFlags.Analyzers;
projectReference.PrivateAssets = LibraryIncludeFlags.Build;
var nugetFramework = NuGetFramework.Parse("net461");
var originalPRMFI = new ProjectRestoreMetadataFrameworkInfo(nugetFramework);
originalPRMFI.TargetAlias = Guid.NewGuid().ToString();
originalPRMFI.ProjectReferences = new List <ProjectRestoreReference>()
{
projectReference
};
var targetframeworks = new List <ProjectRestoreMetadataFrameworkInfo>()
{
originalPRMFI
};
var allWarningsAsErrors = true;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var warningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
var originalProjectRestoreMetadata = new ProjectRestoreMetadata();
originalProjectRestoreMetadata.ProjectStyle = ProjectStyle.PackageReference;
originalProjectRestoreMetadata.ProjectPath = "ProjectPath";
originalProjectRestoreMetadata.ProjectJsonPath = "ProjectJsonPath";
originalProjectRestoreMetadata.OutputPath = "OutputPath";
originalProjectRestoreMetadata.ProjectName = "ProjectName";
originalProjectRestoreMetadata.ProjectUniqueName = "ProjectUniqueName";
originalProjectRestoreMetadata.PackagesPath = "PackagesPath";
originalProjectRestoreMetadata.CacheFilePath = "CacheFilePath";
originalProjectRestoreMetadata.CrossTargeting = true;
originalProjectRestoreMetadata.LegacyPackagesDirectory = true;
originalProjectRestoreMetadata.ValidateRuntimeAssets = true;
originalProjectRestoreMetadata.SkipContentFileWrite = true;
originalProjectRestoreMetadata.TargetFrameworks = targetframeworks;
originalProjectRestoreMetadata.Sources = new List <PackageSource>()
{
new PackageSource("http://api.nuget.org/v3/index.json")
};;
originalProjectRestoreMetadata.FallbackFolders = new List <string>()
{
"fallback1"
};
originalProjectRestoreMetadata.ConfigFilePaths = new List <string>()
{
"config1"
};
originalProjectRestoreMetadata.OriginalTargetFrameworks = new List <string>()
{
"net45"
};
originalProjectRestoreMetadata.Files = new List <ProjectRestoreMetadataFile>()
{
new ProjectRestoreMetadataFile("packagePath", "absolutePath")
};
originalProjectRestoreMetadata.ProjectWideWarningProperties = warningProperties;
return(originalProjectRestoreMetadata);
}
/// <summary>
/// Emulates a JSON deserialization from project.json to PackageSpec in a post-project.json world
/// </summary>
private async Task <PackageSpec> GetPackageSpecAsync(ISettings settings)
{
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var projectReferences = await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(Common.NullLogger.Instance, CancellationToken.None);
var targetFramework = await _vsProjectAdapter.GetTargetFrameworkAsync();
var packageReferences = (await ProjectServices
.ReferencesReader
.GetPackageReferencesAsync(targetFramework, CancellationToken.None))
.ToList();
var packageTargetFallback = MSBuildStringUtility.Split(_vsProjectAdapter.PackageTargetFallback)
.Select(NuGetFramework.Parse)
.ToList();
var assetTargetFallback = MSBuildStringUtility.Split(_vsProjectAdapter.AssetTargetFallback)
.Select(NuGetFramework.Parse)
.ToList();
var projectTfi = new TargetFrameworkInformation
{
FrameworkName = targetFramework,
Dependencies = packageReferences,
};
// Apply fallback settings
AssetTargetFallbackUtility.ApplyFramework(projectTfi, packageTargetFallback, assetTargetFallback);
// Build up runtime information.
var runtimes = await _vsProjectAdapter.GetRuntimeIdentifiersAsync();
var supports = await _vsProjectAdapter.GetRuntimeSupportsAsync();
var runtimeGraph = new RuntimeGraph(runtimes, supports);
// In legacy CSProj, we only have one target framework per project
var tfis = new TargetFrameworkInformation[] { projectTfi };
var projectName = _projectName ?? _projectUniqueName;
return(new PackageSpec(tfis)
{
Name = projectName,
Version = new NuGetVersion(_vsProjectAdapter.Version),
Authors = new string[] { },
Owners = new string[] { },
Tags = new string[] { },
ContentFiles = new string[] { },
FilePath = _projectFullPath,
RuntimeGraph = runtimeGraph,
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectStyle = ProjectStyle.PackageReference,
OutputPath = GetMSBuildProjectExtensionsPath(),
ProjectPath = _projectFullPath,
ProjectName = projectName,
ProjectUniqueName = _projectFullPath,
OriginalTargetFrameworks = tfis
.Select(tfi => tfi.FrameworkName.GetShortFolderName())
.ToList(),
TargetFrameworks = new List <ProjectRestoreMetadataFrameworkInfo>
{
new ProjectRestoreMetadataFrameworkInfo(tfis[0].FrameworkName)
{
ProjectReferences = projectReferences?.ToList()
}
},
SkipContentFileWrite = true,
CacheFilePath = await GetCacheFilePathAsync(),
PackagesPath = GetPackagesPath(settings),
Sources = GetSources(settings),
FallbackFolders = GetFallbackFolders(settings),
ConfigFilePaths = GetConfigFilePaths(settings),
ProjectWideWarningProperties = WarningProperties.GetWarningProperties(
treatWarningsAsErrors: _vsProjectAdapter.TreatWarningsAsErrors,
noWarn: _vsProjectAdapter.NoWarn,
warningsAsErrors: _vsProjectAdapter.WarningsAsErrors)
}
});
}
private static PackageSpec CreatePackageSpec(bool withRestoreSettings, WarningProperties warningProperties = null)
{
var unsortedArray = new[] { "b", "a", "c" };
var unsortedReadOnlyList = new List <string>(unsortedArray).AsReadOnly();
var libraryRange = new LibraryRange("library", new VersionRange(new NuGetVersion("1.2.3")), LibraryDependencyTarget.Package);
var libraryRangeWithNoWarn = new LibraryRange("libraryWithNoWarn", new VersionRange(new NuGetVersion("1.2.3")), LibraryDependencyTarget.Package);
var libraryRangeWithNoWarnGlobal = new LibraryRange("libraryRangeWithNoWarnGlobal", new VersionRange(new NuGetVersion("1.2.3")), LibraryDependencyTarget.Package);
var libraryDependency = new LibraryDependency()
{
IncludeType = LibraryIncludeFlags.Build,
LibraryRange = libraryRange
};
var libraryDependencyWithNoWarn = new LibraryDependency()
{
IncludeType = LibraryIncludeFlags.Build,
LibraryRange = libraryRangeWithNoWarn,
NoWarn = new List <NuGetLogCode> {
NuGetLogCode.NU1500, NuGetLogCode.NU1601
}
};
var libraryDependencyWithNoWarnGlobal = new LibraryDependency()
{
IncludeType = LibraryIncludeFlags.Build,
LibraryRange = libraryRangeWithNoWarnGlobal,
NoWarn = new List <NuGetLogCode> {
NuGetLogCode.NU1500, NuGetLogCode.NU1608
}
};
var nugetFramework = new NuGetFramework("frameworkIdentifier", new Version("1.2.3"), "frameworkProfile");
var nugetFrameworkWithNoWarn = new NuGetFramework("frameworkIdentifierWithNoWarn", new Version("1.2.5"), "frameworkProfileWithNoWarn");
var packageSpec = new PackageSpec()
{
Authors = unsortedArray,
BuildOptions = new BuildOptions()
{
OutputName = "outputName"
},
ContentFiles = new List <string>(unsortedArray),
Copyright = "copyright",
Dependencies = new List <LibraryDependency>()
{
libraryDependency, libraryDependencyWithNoWarnGlobal
},
Description = "description",
FilePath = "filePath",
HasVersionSnapshot = true,
IconUrl = "iconUrl",
IsDefaultVersion = false,
Language = "language",
LicenseUrl = "licenseUrl",
Name = "name",
Owners = unsortedArray,
PackOptions = new PackOptions()
{
IncludeExcludeFiles = new IncludeExcludeFiles()
{
Exclude = unsortedReadOnlyList,
ExcludeFiles = unsortedReadOnlyList,
Include = unsortedReadOnlyList,
IncludeFiles = unsortedReadOnlyList
}
},
ProjectUrl = "projectUrl",
ReleaseNotes = "releaseNotes",
RequireLicenseAcceptance = true,
RestoreMetadata = new ProjectRestoreMetadata()
{
CrossTargeting = true,
FallbackFolders = unsortedReadOnlyList,
ConfigFilePaths = unsortedReadOnlyList,
LegacyPackagesDirectory = false,
OriginalTargetFrameworks = unsortedReadOnlyList,
OutputPath = "outputPath",
ProjectStyle = ProjectStyle.PackageReference,
PackagesPath = "packagesPath",
ProjectJsonPath = "projectJsonPath",
ProjectName = "projectName",
ProjectPath = "projectPath",
ProjectUniqueName = "projectUniqueName",
Sources = new List <PackageSource>()
{
new PackageSource("source", "name", isEnabled: true, isOfficial: false, isPersistable: true)
},
TargetFrameworks = new List <ProjectRestoreMetadataFrameworkInfo>()
{
new ProjectRestoreMetadataFrameworkInfo(nugetFramework)
}
},
Summary = "summary",
Tags = unsortedArray,
Title = "title",
Version = new NuGetVersion("1.2.3")
};
if (withRestoreSettings)
{
packageSpec.RestoreSettings = new ProjectRestoreSettings()
{
HideWarningsAndErrors = true
};
}
if (warningProperties != null)
{
packageSpec.RestoreMetadata.ProjectWideWarningProperties = warningProperties;
}
packageSpec.PackInclude.Add("b", "d");
packageSpec.PackInclude.Add("a", "e");
packageSpec.PackInclude.Add("c", "f");
var runtimeDependencySet = new RuntimeDependencySet("id", new[]
{
new RuntimePackageDependency("id", new VersionRange(new NuGetVersion("1.2.3")))
});
var runtimes = new List <RuntimeDescription>()
{
new RuntimeDescription("runtimeIdentifier", unsortedArray, new [] { runtimeDependencySet })
};
var compatibilityProfiles = new List <CompatibilityProfile>()
{
new CompatibilityProfile("name", new[] { new FrameworkRuntimePair(nugetFramework, "runtimeIdentifier") })
};
packageSpec.RuntimeGraph = new RuntimeGraph(runtimes, compatibilityProfiles);
packageSpec.Scripts.Add("b", unsortedArray);
packageSpec.Scripts.Add("a", unsortedArray);
packageSpec.Scripts.Add("c", unsortedArray);
packageSpec.TargetFrameworks.Add(new TargetFrameworkInformation()
{
Dependencies = new List <LibraryDependency>(),
FrameworkName = nugetFramework,
Imports = new List <NuGetFramework>()
{
nugetFramework
},
});
packageSpec.TargetFrameworks.Add(new TargetFrameworkInformation()
{
Dependencies = new List <LibraryDependency>()
{
libraryDependencyWithNoWarn
},
FrameworkName = nugetFrameworkWithNoWarn,
Imports = new List <NuGetFramework>()
{
nugetFrameworkWithNoWarn
},
Warn = true
});
return(packageSpec);
}
/// <summary>
/// Method is used to check is a warning should be treated as an error.
/// </summary>
/// <param name="message">Message which should be upgraded to error if needed.</param>
public static void ApplyProjectWideWarningsAsErrorProperties(ILogMessage message, WarningProperties warningProperties)
{
if (message.Level == LogLevel.Warning && warningProperties != null)
{
if ((warningProperties.AllWarningsAsErrors && message.Code > NuGetLogCode.Undefined) ||
warningProperties.WarningsAsErrors.Contains(message.Code))
{
// If the project wide AllWarningsAsErrors is true and the message has a valid code or
// Project wide WarningsAsErrors contains the message code then upgrade to error.
message.Level = LogLevel.Error;
}
}
}
/// <summary>
/// Emulates a JSON deserialization from project.json to PackageSpec in a post-project.json world
/// </summary>
private async Task <PackageSpec> GetPackageSpecAsync(ISettings settings)
{
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var projectReferences = await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(Common.NullLogger.Instance, CancellationToken.None);
var targetFramework = await _vsProjectAdapter.GetTargetFrameworkAsync();
var packageReferences = (await ProjectServices
.ReferencesReader
.GetPackageReferencesAsync(targetFramework, CancellationToken.None))
.ToList();
var packageTargetFallback = MSBuildStringUtility.Split(_vsProjectAdapter.PackageTargetFallback)
.Select(NuGetFramework.Parse)
.ToList();
var assetTargetFallback = MSBuildStringUtility.Split(_vsProjectAdapter.AssetTargetFallback)
.Select(NuGetFramework.Parse)
.ToList();
var projectTfi = new TargetFrameworkInformation
{
FrameworkName = targetFramework,
Dependencies = packageReferences,
};
bool isCpvmEnabled = await IsCentralPackageManagementVersionsEnabledAsync();
if (isCpvmEnabled)
{
// Add the central version information and merge the information to the package reference dependencies
projectTfi.CentralPackageVersions.AddRange(await GetCentralPackageVersionsAsync());
LibraryDependency.ApplyCentralVersionInformation(projectTfi.Dependencies, projectTfi.CentralPackageVersions);
}
// Apply fallback settings
AssetTargetFallbackUtility.ApplyFramework(projectTfi, packageTargetFallback, assetTargetFallback);
// Build up runtime information.
var runtimes = await _vsProjectAdapter.GetRuntimeIdentifiersAsync();
var supports = await _vsProjectAdapter.GetRuntimeSupportsAsync();
var runtimeGraph = new RuntimeGraph(runtimes, supports);
// In legacy CSProj, we only have one target framework per project
var tfis = new TargetFrameworkInformation[] { projectTfi };
var projectName = _projectName ?? _projectUniqueName;
string specifiedPackageId = await GetSpecifiedPackageIdAsync();
if (!string.IsNullOrWhiteSpace(specifiedPackageId))
{
projectName = specifiedPackageId;
}
else
{
string specifiedAssemblyName = await GetSpecifiedAssemblyNameAsync();
if (!string.IsNullOrWhiteSpace(specifiedAssemblyName))
{
projectName = specifiedAssemblyName;
}
}
return(new PackageSpec(tfis)
{
Name = projectName,
Version = new NuGetVersion(_vsProjectAdapter.Version),
FilePath = _projectFullPath,
RuntimeGraph = runtimeGraph,
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectStyle = ProjectStyle.PackageReference,
OutputPath = await GetMSBuildProjectExtensionsPathAsync(),
ProjectPath = _projectFullPath,
ProjectName = projectName,
ProjectUniqueName = _projectFullPath,
OriginalTargetFrameworks = tfis
.Select(tfi => tfi.FrameworkName.GetShortFolderName())
.ToList(),
TargetFrameworks = new List <ProjectRestoreMetadataFrameworkInfo>
{
new ProjectRestoreMetadataFrameworkInfo(tfis[0].FrameworkName)
{
ProjectReferences = projectReferences?.ToList()
}
},
SkipContentFileWrite = true,
CacheFilePath = await GetCacheFilePathAsync(),
PackagesPath = GetPackagesPath(settings),
Sources = GetSources(settings),
FallbackFolders = GetFallbackFolders(settings),
ConfigFilePaths = GetConfigFilePaths(settings),
ProjectWideWarningProperties = WarningProperties.GetWarningProperties(
treatWarningsAsErrors: _vsProjectAdapter.TreatWarningsAsErrors,
noWarn: _vsProjectAdapter.NoWarn,
warningsAsErrors: _vsProjectAdapter.WarningsAsErrors),
RestoreLockProperties = new RestoreLockProperties(
await _vsProjectAdapter.GetRestorePackagesWithLockFileAsync(),
await _vsProjectAdapter.GetNuGetLockFilePathAsync(),
await _vsProjectAdapter.IsRestoreLockedAsync()),
CentralPackageVersionsEnabled = isCpvmEnabled
}
});
}
public PackArgs GetPackArgs(IPackTaskRequest <IMSBuildItem> request)
{
var packArgs = new PackArgs
{
OutputDirectory = request.PackageOutputPath,
Serviceable = request.Serviceable,
Tool = request.IsTool,
Symbols = request.IncludeSymbols,
BasePath = request.NuspecBasePath,
NoPackageAnalysis = request.NoPackageAnalysis,
WarningProperties = WarningProperties.GetWarningProperties(request.TreatWarningsAsErrors, request.WarningsAsErrors, request.NoWarn),
PackTargetArgs = new MSBuildPackTargetArgs
{
AllowedOutputExtensionsInPackageBuildOutputFolder = InitOutputExtensions(request.AllowedOutputExtensionsInPackageBuildOutputFolder),
AllowedOutputExtensionsInSymbolsPackageBuildOutputFolder = InitOutputExtensions(request.AllowedOutputExtensionsInSymbolsPackageBuildOutputFolder),
TargetPathsToAssemblies = InitLibFiles(request.BuildOutputInPackage),
TargetPathsToSymbols = InitLibFiles(request.TargetPathsToSymbols),
AssemblyName = request.AssemblyName,
IncludeBuildOutput = request.IncludeBuildOutput,
BuildOutputFolder = request.BuildOutputFolder,
TargetFrameworks = ParseFrameworks(request)
}
};
packArgs.Logger = new PackCollectorLogger(request.Logger, packArgs.WarningProperties);
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5022, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
packArgs.MinClientVersion = version;
}
if (request.NuspecProperties != null && request.NuspecProperties.Any())
{
packArgs.Properties.AddRange(ParsePropertiesAsDictionary(request.NuspecProperties));
if (packArgs.Properties.ContainsKey("version"))
{
packArgs.Version = packArgs.Properties["version"];
}
}
InitCurrentDirectoryAndFileName(request, packArgs);
InitNuspecOutputPath(request, packArgs);
if (request.IncludeSource)
{
packArgs.PackTargetArgs.SourceFiles = GetSourceFiles(request, packArgs.CurrentDirectory);
packArgs.Symbols = request.IncludeSource;
}
PackCommandRunner.SetupCurrentDirectory(packArgs);
var contentFiles = ProcessContentToIncludeInPackage(request, packArgs);
packArgs.PackTargetArgs.ContentFiles = contentFiles;
return(packArgs);
}
private ProjectRestoreMetadata CreateProjectRestoreMetadata()
{
var projectReference = new ProjectRestoreReference
{
ProjectPath = "Path",
ProjectUniqueName = "ProjectUniqueName",
IncludeAssets = LibraryIncludeFlags.All,
ExcludeAssets = LibraryIncludeFlags.Analyzers,
PrivateAssets = LibraryIncludeFlags.Build
};
var nugetFramework = NuGetFramework.Parse("net461");
var originalPRMFI = new ProjectRestoreMetadataFrameworkInfo(nugetFramework)
{
ProjectReferences = new List <ProjectRestoreReference>()
{
projectReference
}
};
var targetframeworks = new List <ProjectRestoreMetadataFrameworkInfo>()
{
originalPRMFI
};
var allWarningsAsErrors = true;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var warningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
var restoreLockProperties = new RestoreLockProperties(restorePackagesWithLockFile: "true", nuGetLockFilePath: null, restoreLockedMode: false);
var originalProjectRestoreMetadata = new ProjectRestoreMetadata
{
ProjectStyle = ProjectStyle.PackageReference,
ProjectPath = "ProjectPath",
ProjectJsonPath = "ProjectJsonPath",
OutputPath = "OutputPath",
ProjectName = "ProjectName",
ProjectUniqueName = "ProjectUniqueName",
PackagesPath = "PackagesPath",
CacheFilePath = "CacheFilePath",
CrossTargeting = true,
LegacyPackagesDirectory = true,
ValidateRuntimeAssets = true,
SkipContentFileWrite = true,
TargetFrameworks = targetframeworks,
Sources = new List <PackageSource>()
{
new PackageSource("http://api.nuget.org/v3/index.json")
},
FallbackFolders = new List <string>()
{
"fallback1"
},
ConfigFilePaths = new List <string>()
{
"config1"
},
OriginalTargetFrameworks = new List <string>()
{
"net45"
},
Files = new List <ProjectRestoreMetadataFile>()
{
new ProjectRestoreMetadataFile("packagePath", "absolutePath")
},
ProjectWideWarningProperties = warningProperties,
RestoreLockProperties = restoreLockProperties
};
return(originalProjectRestoreMetadata);
}
/// <summary>
/// Build a package spec in memory to execute the tool restore as if it were
/// its own project. For now, we always restore for a null runtime and a single
/// constant framework.
/// </summary>
public static PackageSpec GetSpec(string projectFilePath, string id, VersionRange versionRange, NuGetFramework framework, string packagesPath, IList <string> fallbackFolders, IList <PackageSource> sources, WarningProperties projectWideWarningProperties)
{
var frameworkShortFolderName = framework.GetShortFolderName();
var name = GetUniqueName(id, frameworkShortFolderName, versionRange);
return(new PackageSpec()
{
Name = name, // make sure this package never collides with a dependency
FilePath = projectFilePath,
Dependencies = new List <LibraryDependency>(),
TargetFrameworks =
{
new TargetFrameworkInformation
{
TargetAlias = frameworkShortFolderName,
FrameworkName = framework,
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = new LibraryRange(id, versionRange, LibraryDependencyTarget.Package)
}
}
}
},
RestoreMetadata = new ProjectRestoreMetadata()
{
ProjectStyle = ProjectStyle.DotnetCliTool,
ProjectName = name,
ProjectUniqueName = name,
ProjectPath = projectFilePath,
PackagesPath = packagesPath,
FallbackFolders = fallbackFolders,
Sources = sources,
OriginalTargetFrameworks =
{
frameworkShortFolderName
},
TargetFrameworks =
{
new ProjectRestoreMetadataFrameworkInfo
{
TargetAlias = frameworkShortFolderName,
FrameworkName = framework,
ProjectReferences ={ }
}
},
ProjectWideWarningProperties = projectWideWarningProperties ?? new WarningProperties()
}
});
}
public PackCollectorLogger(ILogger innerLogger, WarningProperties warningProperties)
{
_innerLogger = innerLogger;
WarningProperties = warningProperties;
}
private static PackageSpec ToPackageSpec(ProjectNames projectNames, IVsProjectRestoreInfo projectRestoreInfo)
{
var tfis = projectRestoreInfo
.TargetFrameworks
.Cast <IVsTargetFrameworkInfo>()
.Select(ToTargetFrameworkInformation)
.ToArray();
var projectFullPath = Path.GetFullPath(projectNames.FullName);
var projectDirectory = Path.GetDirectoryName(projectFullPath);
// TODO: Remove temporary integration code NuGet/Home#3810
// Initialize OTF and CT values when original value of OTF property is not provided.
var originalTargetFrameworks = tfis
.Select(tfi => tfi.FrameworkName.GetShortFolderName())
.ToArray();
var crossTargeting = originalTargetFrameworks.Length > 1;
// if "TargetFrameworks" property presents in the project file prefer the raw value.
if (!string.IsNullOrWhiteSpace(projectRestoreInfo.OriginalTargetFrameworks))
{
originalTargetFrameworks = MSBuildStringUtility.Split(
projectRestoreInfo.OriginalTargetFrameworks);
// cross-targeting is always ON even in case of a single tfm in the list.
crossTargeting = true;
}
var outputPath = Path.GetFullPath(
Path.Combine(
projectDirectory,
projectRestoreInfo.BaseIntermediatePath));
var projectName = GetPackageId(projectNames, projectRestoreInfo.TargetFrameworks);
var packageSpec = new PackageSpec(tfis)
{
Name = projectName,
Version = GetPackageVersion(projectRestoreInfo.TargetFrameworks),
FilePath = projectFullPath,
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectName = projectName,
ProjectUniqueName = projectFullPath,
ProjectPath = projectFullPath,
OutputPath = outputPath,
ProjectStyle = ProjectStyle.PackageReference,
TargetFrameworks = projectRestoreInfo.TargetFrameworks
.Cast <IVsTargetFrameworkInfo>()
.Select(item => ToProjectRestoreMetadataFrameworkInfo(item, projectDirectory))
.ToList(),
OriginalTargetFrameworks = originalTargetFrameworks,
CrossTargeting = crossTargeting,
// Read project properties for settings. ISettings values will be applied later since
// this value is put in the nomination cache and ISettings could change.
PackagesPath = GetRestoreProjectPath(projectRestoreInfo.TargetFrameworks),
FallbackFolders = GetRestoreFallbackFolders(projectRestoreInfo.TargetFrameworks).AsList(),
Sources = GetRestoreSources(projectRestoreInfo.TargetFrameworks)
.Select(e => new PackageSource(e))
.ToList(),
ProjectWideWarningProperties = WarningProperties.GetWarningProperties(
treatWarningsAsErrors: GetNonEvaluatedPropertyOrNull(projectRestoreInfo.TargetFrameworks, TreatWarningsAsErrors, e => e),
warningsAsErrors: GetNonEvaluatedPropertyOrNull(projectRestoreInfo.TargetFrameworks, WarningsAsErrors, e => e),
noWarn: GetNonEvaluatedPropertyOrNull(projectRestoreInfo.TargetFrameworks, NoWarn, e => e)),
CacheFilePath = NoOpRestoreUtilities.GetProjectCacheFilePath(cacheRoot: outputPath, projectPath: projectFullPath)
},
RuntimeGraph = GetRuntimeGraph(projectRestoreInfo),
RestoreSettings = new ProjectRestoreSettings()
{
HideWarningsAndErrors = true
}
};
return(packageSpec);
}
public PackCollectorLogger(ILogger innerLogger, WarningProperties warningProperties)
{
_innerLogger = innerLogger;
WarningProperties = warningProperties;
_errors = new ConcurrentQueue <ILogMessage>();
}
public PackArgs GetPackArgs(IPackTaskRequest <IMSBuildItem> request)
{
var packArgs = new PackArgs
{
InstallPackageToOutputPath = request.InstallPackageToOutputPath,
OutputFileNamesWithoutVersion = request.OutputFileNamesWithoutVersion,
OutputDirectory = request.PackageOutputPath,
Serviceable = request.Serviceable,
Tool = request.IsTool,
Symbols = request.IncludeSymbols,
SymbolPackageFormat = PackArgs.GetSymbolPackageFormat(request.SymbolPackageFormat),
BasePath = request.NuspecBasePath,
NoPackageAnalysis = request.NoPackageAnalysis,
NoDefaultExcludes = request.NoDefaultExcludes,
WarningProperties = WarningProperties.GetWarningProperties(request.TreatWarningsAsErrors, request.WarningsAsErrors, request.NoWarn),
PackTargetArgs = new MSBuildPackTargetArgs()
};
packArgs.Logger = new PackCollectorLogger(request.Logger, packArgs.WarningProperties);
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5022, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
packArgs.MinClientVersion = version;
}
InitCurrentDirectoryAndFileName(request, packArgs);
InitNuspecOutputPath(request, packArgs);
PackCommandRunner.SetupCurrentDirectory(packArgs);
if (!string.IsNullOrEmpty(request.NuspecFile))
{
if (request.NuspecProperties != null && request.NuspecProperties.Any())
{
packArgs.Properties.AddRange(ParsePropertiesAsDictionary(request.NuspecProperties));
if (packArgs.Properties.ContainsKey("version"))
{
packArgs.Version = packArgs.Properties["version"];
}
}
}
else
{
// This only needs to happen when packing via csproj, not nuspec.
packArgs.PackTargetArgs.AllowedOutputExtensionsInPackageBuildOutputFolder = InitOutputExtensions(request.AllowedOutputExtensionsInPackageBuildOutputFolder);
packArgs.PackTargetArgs.AllowedOutputExtensionsInSymbolsPackageBuildOutputFolder = InitOutputExtensions(request.AllowedOutputExtensionsInSymbolsPackageBuildOutputFolder);
packArgs.PackTargetArgs.TargetPathsToAssemblies = InitLibFiles(request.BuildOutputInPackage);
packArgs.PackTargetArgs.TargetPathsToSymbols = InitLibFiles(request.TargetPathsToSymbols);
packArgs.PackTargetArgs.AssemblyName = request.AssemblyName;
packArgs.PackTargetArgs.IncludeBuildOutput = request.IncludeBuildOutput;
packArgs.PackTargetArgs.BuildOutputFolder = request.BuildOutputFolders;
packArgs.PackTargetArgs.TargetFrameworks = ParseFrameworks(request);
if (request.IncludeSource)
{
packArgs.PackTargetArgs.SourceFiles = GetSourceFiles(request, packArgs.CurrentDirectory);
packArgs.Symbols = request.IncludeSource;
}
var contentFiles = ProcessContentToIncludeInPackage(request, packArgs);
packArgs.PackTargetArgs.ContentFiles = contentFiles;
}
return(packArgs);
}
public PackCollectorLogger(ILogger innerLogger, WarningProperties warningProperties)
: this(innerLogger, warningProperties, null)
{
}
