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); }