static HashSet <string> GetFrameworksStrings(ProjectItem item) { var frameworks = new HashSet <string> (StringComparer.OrdinalIgnoreCase); string frameworksString = item.Metadata.GetValue("TargetFrameworks"); if (!string.IsNullOrEmpty(frameworksString)) { frameworks.UnionWith(MSBuildStringUtility.Split(frameworksString)); } return(frameworks); }
static LibraryIncludeFlags GetIncludeFlags(string value, LibraryIncludeFlags defaultValue) { var parts = MSBuildStringUtility.Split(value); if (parts.Length > 0) { return(LibraryIncludeFlagUtils.GetFlags(parts)); } else { return(defaultValue); } }
static void AddSources(List <PackageSource> sources, IDotNetProject project, string propertyName) { string sourcesProperty = project.EvaluatedProperties.GetValue(propertyName); if (string.IsNullOrEmpty(sourcesProperty)) { return; } var additionalPackageSources = MSBuildStringUtility.Split(sourcesProperty) .Select(source => CreatePackageSource(project.BaseDirectory, source)); sources.AddRange(additionalPackageSources); }
static void AddFolders(List <string> folders, IDotNetProject project, string propertyName) { string foldersProperty = project.EvaluatedProperties.GetValue(propertyName); if (string.IsNullOrEmpty(foldersProperty)) { return; } var normalizedFolders = MSBuildStringUtility.Split(foldersProperty) .Select(folder => NormalizeFolder(project.BaseDirectory, folder)); folders.AddRange(normalizedFolders); }
/// <summary> /// Helper method to join across multiple values of a commandline option. /// E.g. - /// Input - { "net45; netcoreapp1.1", "netstandard1.6; net46", "net451"} /// Output - [ "net45", "netcoreapp1.1", "netstandard1.6", "net46", "net451" ] /// </summary> /// <param name="inputs">List of values.</param> /// <returns>A string array of values joined from across multiple input values.</returns> public static string[] SplitAndJoinAcrossMultipleValues(IList <string> inputs) { var result = new List <string>(); if (inputs?.Count > 0) { foreach (var input in inputs) { result.AddRange(MSBuildStringUtility.Split(input)); } } return(result.ToArray()); }
static RuntimeGraph GetRuntimeGraph(IDotNetProject project) { var runtimes = MSBuildStringUtility.Split(project.EvaluatedProperties.GetValue("RuntimeIdentifiers")) .Distinct(StringComparer.Ordinal) .Select(rid => new RuntimeDescription(rid)) .ToList(); var supports = MSBuildStringUtility.Split(project.EvaluatedProperties.GetValue("RuntimeSupports")) .Distinct(StringComparer.Ordinal) .Select(s => new CompatibilityProfile(s)) .ToList(); return(new RuntimeGraph(runtimes, supports)); }
internal static TargetFrameworkInformation ToTargetFrameworkInformation( IVsTargetFrameworkInfo targetFrameworkInfo) { var tfi = new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse(targetFrameworkInfo.TargetFrameworkMoniker) }; var ptf = MSBuildStringUtility.Split(GetPropertyValueOrNull(targetFrameworkInfo.Properties, ProjectBuildProperties.PackageTargetFallback)) .Select(NuGetFramework.Parse) .ToList(); var atf = MSBuildStringUtility.Split(GetPropertyValueOrNull(targetFrameworkInfo.Properties, ProjectBuildProperties.AssetTargetFallback)) .Select(NuGetFramework.Parse) .ToList(); // Update TFI with fallback properties AssetTargetFallbackUtility.ApplyFramework(tfi, ptf, atf); if (targetFrameworkInfo.PackageReferences != null) { tfi.Dependencies.AddRange( targetFrameworkInfo.PackageReferences .Cast <IVsReferenceItem>() .Select(ToPackageLibraryDependency)); } if (targetFrameworkInfo is IVsTargetFrameworkInfo2 targetFrameworkInfo2) { if (targetFrameworkInfo2.PackageDownloads != null) { tfi.DownloadDependencies.AddRange( targetFrameworkInfo2.PackageDownloads .Cast <IVsReferenceItem>() .Select(ToPackageDownloadDependency)); } if (targetFrameworkInfo2.FrameworkReferences != null) { tfi.FrameworkReferences.AddRange( targetFrameworkInfo2.FrameworkReferences .Cast <IVsReferenceItem>() .Select(e => e.Name)); } } return(tfi); }
public async Task <string[]> GetProjectTypeGuidsAsync() { var typeGuid = Project.GetProjectTypeGuids(); var projectTypeGuids = await BuildProperties.GetPropertyValueAsync(ProjectBuildProperties.ProjectTypeGuids); if (!string.IsNullOrEmpty(projectTypeGuids)) { return(MSBuildStringUtility.Split(projectTypeGuids)); } else if (!string.IsNullOrEmpty(typeGuid)) { return(MSBuildStringUtility.Split(typeGuid)); } return(Array.Empty <string>()); }
private static IEnumerable <string> GetProjectFrameworks(Project project) { var frameworks = project .AllEvaluatedProperties .Where(p => p.Name.Equals(FRAMEWORK_TAG, StringComparison.OrdinalIgnoreCase)) .Select(p => p.EvaluatedValue); if (!frameworks.Any()) { var frameworksString = project .AllEvaluatedProperties .Where(p => p.Name.Equals(FRAMEWORKS_TAG, StringComparison.OrdinalIgnoreCase)) .Select(p => p.EvaluatedValue) .FirstOrDefault(); frameworks = MSBuildStringUtility.Split(frameworksString); } return(frameworks); }
/// <summary> /// Gets the framework references per target framework for the specified project. /// </summary> /// <param name="project">The <see cref="ProjectInstance" /> to get framework references for.</param> /// <returns>A <see cref="List{FrameworkDependency}" /> containing the framework references for the specified project.</returns> internal static List <FrameworkDependency> GetFrameworkReferences(IMSBuildProject project) { // Get the unique FrameworkReference items, ignoring duplicates var frameworkReferenceItems = project.GetItems("FrameworkReference").Distinct(ProjectItemInstanceEvaluatedIncludeComparer.Instance).ToList(); // For best performance, its better to create a list with the exact number of items needed rather than using a LINQ statement or AddRange. This is because if the list // is not allocated with enough items, the list has to be grown which can slow things down var frameworkDependencies = new List <FrameworkDependency>(frameworkReferenceItems.Count); foreach (var frameworkReferenceItem in frameworkReferenceItems) { var privateAssets = MSBuildStringUtility.Split(frameworkReferenceItem.GetProperty("PrivateAssets")); frameworkDependencies.Add(new FrameworkDependency(frameworkReferenceItem.Identity, FrameworkDependencyFlagsUtils.GetFlags(privateAssets))); } return(frameworkDependencies); }
static IEnumerable <string> GetOriginalTargetFrameworks(IDotNetProject project) { var properties = project.EvaluatedProperties; if (properties != null) { string targetFramework = properties.GetValue("TargetFramework"); if (targetFramework != null) { return(new [] { targetFramework }); } string targetFrameworks = properties.GetValue("TargetFrameworks"); return(MSBuildStringUtility.Split(targetFrameworks)); } return(new string[0]); }
public static SimpleTestProjectContext CreateProject(string projectName, SimpleTestPathContext pathContext, string projectFrameworks) { var settings = Settings.LoadDefaultSettings(Path.GetDirectoryName(pathContext.NuGetConfig), Path.GetFileName(pathContext.NuGetConfig), null); var project = SimpleTestProjectContext.CreateNETCoreWithSDK( projectName: projectName, solutionRoot: pathContext.SolutionRoot, frameworks: MSBuildStringUtility.Split(projectFrameworks)); project.FallbackFolders = (IList <string>)SettingsUtility.GetFallbackPackageFolders(settings); project.GlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings); var packageSourceProvider = new PackageSourceProvider(settings); project.Sources = packageSourceProvider.LoadPackageSources(); project.Save(); return(project); }
/// <summary> /// Adds a dependency to the current package. /// </summary> /// <param name="id">The identifier of the dependency.</param> /// <param name="version">The <see cref="VersionRange" /> of the dependency.</param> /// <param name="targetFramework">The <see cref="NuGetFramework" /> for the dependency.</param> /// <param name="include">An optional <see cref="LibraryIncludeFlags" /> representing the assets to include for the dependency.</param> /// <param name="exclude">An optional <see cref="LibraryIncludeFlags" /> representing the assets to exclude from the dependency.</param> /// <returns>The current <see cref="PackageRepository" />.</returns> public PackageRepository Dependency(string id, VersionRange version, NuGetFramework targetFramework, LibraryIncludeFlags?include = null, LibraryIncludeFlags?exclude = null) { _packageManifest.Metadata.DependencyGroups = _packageManifest.Metadata.DependencyGroups.Concat(new List <PackageDependencyGroup> { new PackageDependencyGroup( targetFramework ?? NuGetFramework.AnyFramework, new List <PackageDependency> { new PackageDependency( id, version, include == null ? null : MSBuildStringUtility.Split(include.ToString(), ','), exclude == null ? null : MSBuildStringUtility.Split(exclude.ToString(), ',')), }), }); _packageManifest.Save(); return(this); }
private IList <string> GetFallbackFolders(ISettings settings, bool shouldThrow = true) { ThreadHelper.ThrowIfNotOnUIThread(); var fallbackFolders = MSBuildStringUtility.Split(_vsProjectAdapter.RestoreFallbackFolders).AsEnumerable(); if (ShouldReadFromSettings(fallbackFolders)) { fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings); } else { fallbackFolders = VSRestoreSettingsUtilities.HandleClear(fallbackFolders); } // Add additional fallback folders fallbackFolders = fallbackFolders.Concat(MSBuildStringUtility.Split(_vsProjectAdapter.RestoreAdditionalProjectFallbackFolders)); return(fallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(_projectFullPath, e)).ToList()); }
private IList <PackageSource> GetSources(ISettings settings, bool shouldThrow = true) { ThreadHelper.ThrowIfNotOnUIThread(); var sources = MSBuildStringUtility.Split(_vsProjectAdapter.RestoreSources).AsEnumerable(); if (ShouldReadFromSettings(sources)) { sources = SettingsUtility.GetEnabledSources(settings).Select(e => e.Source); } else { sources = VSRestoreSettingsUtilities.HandleClear(sources); } // Add additional sources sources = sources.Concat(MSBuildStringUtility.Split(_vsProjectAdapter.RestoreAdditionalProjectSources)); return(sources.Select(e => new PackageSource(UriUtility.GetAbsolutePathFromFile(_projectFullPath, e))).ToList()); }
public async Task VSSolutionRestoreService_VSRestoreSettingsUtilities_Integration(string restoreSources, string restoreAdditionalProjectSources, string expectedRestoreSources, string restoreFallbackFolders, string restoreAdditionalFallbackFolders, string expectedFallbackFolders) { var cps = NewCpsProject(@"{ }"); var pri = cps.Builder .WithTool("Foo.Test", "2.0.0") .WithTargetFrameworkInfo( new VsTargetFrameworkInfo( "netcoreapp2.0", Enumerable.Empty <IVsReferenceItem>(), Enumerable.Empty <IVsReferenceItem>(), new[] { new VsProjectProperty("RestoreSources", restoreSources), new VsProjectProperty("RestoreFallbackFolders", restoreFallbackFolders), new VsProjectProperty("RestoreAdditionalProjectSources", restoreAdditionalProjectSources), new VsProjectProperty("RestoreAdditionalProjectFallbackFolders", restoreAdditionalFallbackFolders) })) .Build(); var projectFullPath = cps.ProjectFullPath; // Act var actualRestoreSpec = await CaptureNominateResultAsync(projectFullPath, pri); // Assert SpecValidationUtility.ValidateDependencySpec(actualRestoreSpec); var actualProjectSpec = actualRestoreSpec.GetProjectSpec(projectFullPath); Assert.NotNull(actualProjectSpec); var specSources = VSRestoreSettingsUtilities.GetSources(NullSettings.Instance, actualProjectSpec).Select(e => e.Source); var expectedSources = MSBuildStringUtility.Split(expectedRestoreSources); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); var specFallback = VSRestoreSettingsUtilities.GetFallbackFolders(NullSettings.Instance, actualProjectSpec); var expectedFallback = MSBuildStringUtility.Split(expectedFallbackFolders); Assert.True( Enumerable.SequenceEqual(expectedFallback.OrderBy(t => t), specFallback.OrderBy(t => t)), "expected: " + string.Join(",", expectedFallback.ToArray()) + "\nactual: " + string.Join(",", specFallback.ToArray())); }
public static SimpleTestPackageContext CreatePackage(string packageId = "packageX", string packageVersion = "1.0.0", string frameworkString = null) { var package = new SimpleTestPackageContext() { Id = packageId, Version = packageVersion }; var frameworks = MSBuildStringUtility.Split(frameworkString); // Make the package Compatible with specific frameworks frameworks? .ToList() .ForEach(f => package.AddFile($"lib/{f}/a.dll")); // To ensure that the nuspec does not have System.Runtime.dll package.Nuspec = GetNetCoreNuspec(packageId, packageVersion); return(package); }
public static PackageReferenceArgs GetPackageReferenceArgs(string packageId, string packageVersion, SimpleTestProjectContext project, string frameworks = "", string packageDirectory = "", string sources = "", bool noRestore = false, bool noVersion = false) { var logger = new TestCommandOutputLogger(); var packageDependency = new PackageDependency(packageId, VersionRange.Parse(packageVersion)); var dgFilePath = string.Empty; if (!noRestore) { dgFilePath = CreateDGFileForProject(project); } return(new PackageReferenceArgs(project.ProjectPath, packageDependency, logger) { Frameworks = MSBuildStringUtility.Split(frameworks), Sources = MSBuildStringUtility.Split(sources), PackageDirectory = packageDirectory, NoRestore = noRestore, NoVersion = noVersion, DgFilePath = dgFilePath }); }
/// <summary> /// Gets the package downloads for the specified project. /// </summary> /// <param name="project">The <see cref="ProjectInstance" /> to get package downloads for.</param> /// <returns>An <see cref="IEnumerable{DownloadDependency}" /> containing the package downloads for the specified project.</returns> internal static IEnumerable <DownloadDependency> GetPackageDownloads(IMSBuildProject project) { // Get the distinct PackageDownload items, ignoring duplicates foreach (var projectItemInstance in project.GetItems("PackageDownload").Distinct(ProjectItemInstanceEvaluatedIncludeComparer.Instance)) { string id = projectItemInstance.Identity; // PackageDownload items can contain multiple versions foreach (var version in MSBuildStringUtility.Split(projectItemInstance.GetProperty("Version"))) { // Validate the version range VersionRange versionRange = !string.IsNullOrWhiteSpace(version) ? VersionRange.Parse(version) : VersionRange.All; if (!(versionRange.HasLowerAndUpperBounds && versionRange.MinVersion.Equals(versionRange.MaxVersion))) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_PackageDownload_OnlyExactVersionsAreAllowed, versionRange.OriginalString)); } yield return(new DownloadDependency(id, versionRange)); } } }
public static SimpleTestProjectContext CreateProject(string projectName, SimpleTestPathContext pathContext, SimpleTestPackageContext package, string projectFrameworks, string packageFramework = null) { var project = SimpleTestProjectContext.CreateNETCoreWithSDK( projectName: projectName, solutionRoot: pathContext.SolutionRoot, frameworks: MSBuildStringUtility.Split(projectFrameworks)); if (packageFramework == null) { project.AddPackageToAllFrameworks(package); } else { project.AddPackageToFramework(packageFramework, package); } project.Save(); return(project); }
static IEnumerable <string> GetOriginalTargetFrameworks(IDotNetProject project) { var properties = project.EvaluatedProperties; if (properties != null) { string targetFramework = properties.GetValue("TargetFramework"); if (targetFramework != null) { return(new [] { targetFramework }); } string targetFrameworks = properties.GetValue("TargetFrameworks"); if (targetFrameworks != null) { return(MSBuildStringUtility.Split(targetFrameworks)); } } var framework = NuGetFramework.Parse(project.TargetFrameworkMoniker.ToString()); return(new [] { framework.GetShortFolderName() }); }
private ITaskItem AssignPropertiesForSingleReference(ITaskItem project, NuGetFramework currentProjectTargetFramework) { var itemWithProperties = new TaskItem(project); var targetFrameworks = project.GetMetadata("TargetFrameworks"); if (string.IsNullOrEmpty(targetFrameworks)) { // No target frameworks set, nothing to do. return(itemWithProperties); } var possibleTargetFrameworks = MSBuildStringUtility.Split(targetFrameworks); var nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(possibleTargetFrameworks, currentProjectTargetFramework, NuGetFramework.Parse); itemWithProperties.SetMetadata("NearestTargetFramework", nearestNuGetFramework ?? FrameworkConstants.SpecialIdentifiers.Unsupported); if (nearestNuGetFramework == null) { Log.LogError(string.Format(Strings.NoCompatibleTargetFramework, project.ItemSpec, CurrentProjectTargetFramework, targetFrameworks)); } return(itemWithProperties); }
public async Task NominateProjectAsync_RestoreSettingsClear(string restorePackagesPath, string restoreSources, string fallbackFolders) { var cps = NewCpsProject("{ }"); var projectFullPath = cps.ProjectFullPath; var pri = cps.Builder .WithTargetFrameworkInfo( new VsTargetFrameworkInfo( "netcoreapp1.0", Enumerable.Empty <IVsReferenceItem>(), Enumerable.Empty <IVsReferenceItem>(), new[] { new VsProjectProperty("RestorePackagesPath", restorePackagesPath), new VsProjectProperty("RestoreSources", restoreSources), new VsProjectProperty("RestoreFallbackFolders", fallbackFolders) })) .Build(); // Act var actualRestoreSpec = await CaptureNominateResultAsync(projectFullPath, cps.ProjectRestoreInfo); // Assert SpecValidationUtility.ValidateDependencySpec(actualRestoreSpec); var actualProjectSpec = actualRestoreSpec.GetProjectSpec(projectFullPath); Assert.NotNull(actualProjectSpec); Assert.Equal(restorePackagesPath, actualProjectSpec.RestoreMetadata.PackagesPath); var specSources = actualProjectSpec.RestoreMetadata.Sources?.Select(e => e.Source); var expectedSources = MSBuildStringUtility.Split(restoreSources).Any(e => StringComparer.OrdinalIgnoreCase.Equals("clear", e)) ? new string[] { "Clear" } : MSBuildStringUtility.Split(restoreSources); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); var specFallback = actualProjectSpec.RestoreMetadata.FallbackFolders; var expectedFallback = MSBuildStringUtility.Split(fallbackFolders).Any(e => StringComparer.OrdinalIgnoreCase.Equals("clear", e)) ? new string[] { "Clear" } : MSBuildStringUtility.Split(fallbackFolders); Assert.True(Enumerable.SequenceEqual(expectedFallback.OrderBy(t => t), specFallback.OrderBy(t => t))); }
public async Task <string[]> GetProjectTypeGuidsAsync() { if (!IsDeferred) { return(VsHierarchyUtility.GetProjectTypeGuids(Project)); } else { // Get ProjectTypeGuids from msbuild property, if it doesn't exist, fall back to projectTypeGuid. var projectTypeGuids = await BuildProperties.GetPropertyValueAsync(ProjectBuildProperties.ProjectTypeGuids); if (!string.IsNullOrEmpty(projectTypeGuids)) { return(MSBuildStringUtility.Split(projectTypeGuids)); } if (!string.IsNullOrEmpty(_projectTypeGuid)) { return(new string[] { _projectTypeGuid }); } return(Array.Empty <string>()); } }
// The targetpaths returned from this function contain the directory in the nuget package where the file would go to. The filename is added later on to the target path. // whether or not the filename is added later on is dependent upon the fact that does the targetpath resolved here ends with a directory separator char or not. private IEnumerable <ContentMetadata> GetContentMetadata(IMSBuildItem packageFile, string sourcePath, PackArgs packArgs, string[] contentTargetFolders) { var targetPaths = contentTargetFolders .Select(PathUtility.EnsureTrailingSlash) .ToList(); var isPackagePathSpecified = packageFile.Properties.Contains("PackagePath"); // if user specified a PackagePath, then use that. Look for any ** which are indicated by the RecrusiveDir metadata in msbuild. if (isPackagePathSpecified) { // The rule here is that if the PackagePath is an empty string, then we add the file to the root of the package. // Instead if it is a ';' delimited string, then the user needs to specify a '\' to indicate that the file should go to the root of the package. var packagePathString = packageFile.GetProperty("PackagePath"); targetPaths = packagePathString == null ? new string[] { string.Empty }.ToList() : MSBuildStringUtility.Split(packagePathString) .Distinct() .ToList(); var recursiveDir = packageFile.GetProperty("RecursiveDir"); // The below NuGetRecursiveDir workaround needs to be done due to msbuild bug https://github.com/Microsoft/msbuild/issues/3121 recursiveDir = string.IsNullOrEmpty(recursiveDir) ? packageFile.GetProperty("NuGetRecursiveDir") : recursiveDir; if (!string.IsNullOrEmpty(recursiveDir)) { var newTargetPaths = new List <string>(); var fileName = Path.GetFileName(sourcePath); foreach (var targetPath in targetPaths) { newTargetPaths.Add(PathUtility.GetStringComparerBasedOnOS(). Compare(Path.GetExtension(fileName), Path.GetExtension(targetPath)) == 0 && !string.IsNullOrEmpty(Path.GetExtension(fileName)) ? targetPath : Path.Combine(targetPath, recursiveDir)); } targetPaths = newTargetPaths; } } var buildActionString = packageFile.GetProperty("BuildAction"); var buildAction = BuildAction.Parse(string.IsNullOrEmpty(buildActionString) ? "None" : buildActionString); // TODO: Do the work to get the right language of the project, tracked via https://github.com/NuGet/Home/issues/4100 var language = buildAction.Equals(BuildAction.Compile) ? "cs" : "any"; var setOfTargetPaths = new HashSet <string>(targetPaths, PathUtility.GetStringComparerBasedOnOS()); // If package path wasn't specified, then we expand the "contentFiles" value we // got from ContentTargetFolders and expand it to contentFiles/any/<TFM>/ if (!isPackagePathSpecified) { if (setOfTargetPaths.Remove("contentFiles" + Path.DirectorySeparatorChar) || setOfTargetPaths.Remove("contentFiles")) { foreach (var framework in packArgs.PackTargetArgs.TargetFrameworks) { setOfTargetPaths.Add(PathUtility.EnsureTrailingSlash( Path.Combine("contentFiles", language, framework.GetShortFolderName() ))); } } } // this if condition means there is no package path provided, file is within the project directory // and the target path should preserve this relative directory structure. // This case would be something like : // <Content Include= "folderA\folderB\abc.txt"> // Since the package path wasn't specified, we will add this to the package paths obtained via ContentTargetFolders and preserve // relative directory structure if (!isPackagePathSpecified && sourcePath.StartsWith(packArgs.CurrentDirectory, StringComparison.CurrentCultureIgnoreCase) && !Path.GetFileName(sourcePath) .Equals(packageFile.GetProperty(IdentityProperty), StringComparison.CurrentCultureIgnoreCase)) { var newTargetPaths = new List <string>(); var identity = packageFile.GetProperty(IdentityProperty); // Identity can be a rooted absolute path too, in which case find the path relative to the current directory if (Path.IsPathRooted(identity)) { identity = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(packArgs.CurrentDirectory), identity); identity = Path.GetDirectoryName(identity); } // If identity is not a rooted path, then it is a relative path to the project directory else if (identity.EndsWith(Path.GetFileName(sourcePath), StringComparison.CurrentCultureIgnoreCase)) { identity = Path.GetDirectoryName(identity); } foreach (var targetPath in setOfTargetPaths) { var newTargetPath = Path.Combine(targetPath, identity); // We need to do this because evaluated identity in the above line of code can be an empty string // in the case when the original identity string was the absolute path to a file in project directory, and is in // the same directory as the csproj file. newTargetPath = PathUtility.EnsureTrailingSlash(newTargetPath); newTargetPaths.Add(newTargetPath); } setOfTargetPaths = new HashSet <string>(newTargetPaths, PathUtility.GetStringComparerBasedOnOS()); } // we take the final set of evaluated target paths and append the file name to it if not // already done. we check whether the extension of the target path is the same as the extension // of the source path and add the filename accordingly. var totalSetOfTargetPaths = new List <string>(); foreach (var targetPath in setOfTargetPaths) { var currentPath = targetPath; var fileName = Path.GetFileName(sourcePath); if (string.IsNullOrEmpty(Path.GetExtension(fileName)) || !Path.GetExtension(fileName) .Equals(Path.GetExtension(targetPath), StringComparison.OrdinalIgnoreCase)) { currentPath = Path.Combine(targetPath, fileName); } totalSetOfTargetPaths.Add(currentPath); } return(totalSetOfTargetPaths.Select(target => new ContentMetadata() { BuildAction = buildAction.Value, Source = sourcePath, Target = target, CopyToOutput = packageFile.GetProperty("PackageCopyToOutput"), Flatten = packageFile.GetProperty("PackageFlatten") })); }
public async Task NominateProjectAsync_WithRestoreAdditionalSourcesAndFallbackFolders(string restoreSources, string restoreAdditionalProjectSources, string restoreFallbackFolders, string restoreAdditionalFallbackFolders) { var cps = NewCpsProject(@"{ }"); var pri = cps.Builder .WithTool("Foo.Test", "2.0.0") .WithTargetFrameworkInfo( new VsTargetFrameworkInfo( "netcoreapp2.0", Enumerable.Empty <IVsReferenceItem>(), Enumerable.Empty <IVsReferenceItem>(), new[] { new VsProjectProperty("RestoreSources", restoreSources), new VsProjectProperty("RestoreFallbackFolders", restoreFallbackFolders), new VsProjectProperty("RestoreAdditionalProjectSources", restoreAdditionalProjectSources), new VsProjectProperty("RestoreAdditionalProjectFallbackFolders", restoreAdditionalFallbackFolders) })) .Build(); var projectFullPath = cps.ProjectFullPath; // Act var actualRestoreSpec = await CaptureNominateResultAsync(projectFullPath, pri); // Assert SpecValidationUtility.ValidateDependencySpec(actualRestoreSpec); var actualProjectSpec = actualRestoreSpec.GetProjectSpec(projectFullPath); Assert.NotNull(actualProjectSpec); var specSources = actualProjectSpec.RestoreMetadata.Sources?.Select(e => e.Source); var expectedSources = (MSBuildStringUtility.Split(restoreSources).Any(e => StringComparer.OrdinalIgnoreCase.Equals("clear", e)) ? new string[] { "Clear" } : MSBuildStringUtility.Split(restoreSources)). Concat( restoreAdditionalProjectSources != null ? new List <string>() { VSRestoreSettingsUtilities.AdditionalValue }.Concat(MSBuildStringUtility.Split(restoreAdditionalProjectSources)): new string[] { } ); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); var specFallback = actualProjectSpec.RestoreMetadata.FallbackFolders; var expectedFallback = (MSBuildStringUtility.Split(restoreFallbackFolders).Any(e => StringComparer.OrdinalIgnoreCase.Equals("clear", e)) ? new string[] { "Clear" } : MSBuildStringUtility.Split(restoreFallbackFolders)). Concat( restoreAdditionalFallbackFolders != null ? new List <string>() { VSRestoreSettingsUtilities.AdditionalValue }.Concat(MSBuildStringUtility.Split(restoreAdditionalFallbackFolders)) : new string[] { } ); Assert.True( Enumerable.SequenceEqual(expectedFallback.OrderBy(t => t), specFallback.OrderBy(t => t)), "expected: " + string.Join(",", expectedFallback.ToArray()) + "\nactual: " + string.Join(",", specFallback.ToArray())); }
/// <summary> /// Splits the value of the specified property and returns an array if the property has a value, otherwise returns <code>null</code>. /// </summary> /// <param name="item">The <see cref="IMSBuildItem" /> to get the property value from.</param> /// <param name="name">The name of the property to get the value of and split.</param> /// <returns>A <see cref="T:string[]" /> containing the split value of the property if the property had a value, otherwise <code>null</code>.</returns> public static string[] SplitGlobalPropertyValueOrNull(this IMSBuildProject item, string name) { string value = item.GetGlobalProperty(name); return(value == null ? null : MSBuildStringUtility.Split(value)); }
public async Task GetPackageSpecsAsync_ReadSettingsWithFullPaths(string restorePackagesPath, string sources, string fallbackFolders) { // Arrange using (var testDirectory = TestDirectory.Create()) { var projectAdapter = CreateProjectAdapter(testDirectory); Mock.Get(projectAdapter) .SetupGet(x => x.RestorePackagesPath) .Returns(restorePackagesPath); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreSources) .Returns(sources); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreFallbackFolders) .Returns(fallbackFolders); var projectServices = new TestProjectSystemServices(); var testProject = new LegacyPackageReferenceProject( projectAdapter, Guid.NewGuid().ToString(), projectServices, _threadingService); var settings = NullSettings.Instance; var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings); await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); // Act var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext); // Assert Assert.NotNull(packageSpecs); var actualRestoreSpec = packageSpecs.Single(); SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec); // Assert packagespath Assert.Equal(restorePackagesPath != null ? restorePackagesPath : SettingsUtility.GetGlobalPackagesFolder(settings), actualRestoreSpec.RestoreMetadata.PackagesPath); // assert sources var specSources = actualRestoreSpec.RestoreMetadata.Sources.Select(e => e.Source); var expectedSources = sources != null?MSBuildStringUtility.Split(sources) : SettingsUtility.GetEnabledSources(settings).Select(e => e.Source); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); // assert fallbackfolders var specFallback = actualRestoreSpec.RestoreMetadata.FallbackFolders; var expectedFolders = fallbackFolders != null?MSBuildStringUtility.Split(fallbackFolders) : SettingsUtility.GetFallbackPackageFolders(settings); Assert.True(Enumerable.SequenceEqual(expectedFolders.OrderBy(t => t), specFallback.OrderBy(t => t))); // Verify Mock.Get(projectAdapter) .Verify(x => x.RestorePackagesPath, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreSources, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreFallbackFolders, Times.Once); } }
/// <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 async Task <bool> ExecuteAsync(Common.ILogger log) { if (RestoreGraphItems.Length < 1) { log.LogWarning(Strings.NoProjectsProvidedToTask); return(true); } // Set user agent and connection settings. ConfigureProtocol(); // Convert to the internal wrapper var wrappedItems = RestoreGraphItems.Select(MSBuildUtility.WrapMSBuildItem); //var graphLines = RestoreGraphItems; var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = RestoreNoCache; cacheContext.IgnoreFailedSources = RestoreIgnoreFailedSources; // Pre-loaded request provider containing the graph file var providers = new List <IPreLoadedRestoreRequestProvider>(); var dgFile = MSBuildRestoreUtility.GetDependencySpec(wrappedItems); if (dgFile.Restore.Count < 1) { // Restore will fail if given no inputs, but here we should skip it and provide a friendly message. log.LogMinimal(Strings.NoProjectsToRestore); return(true); } // Add all child projects if (RestoreRecursive) { BuildTasksUtility.AddAllProjectsForRestore(dgFile); } providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgFile)); var defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null); var sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings)); var restoreContext = new RestoreArgs() { CacheContext = cacheContext, LockFileVersion = LockFileFormat.Version, ConfigFile = MSBuildStringUtility.TrimAndGetNullForEmpty(RestoreConfigFile), DisableParallel = RestoreDisableParallel, GlobalPackagesFolder = RestorePackagesPath, Log = log, MachineWideSettings = new XPlatMachineWideSetting(), PreLoadedRequestProviders = providers, CachingSourceProvider = sourceProvider, AllowNoOp = !RestoreForce, HideWarningsAndErrors = HideWarningsAndErrors }; if (!string.IsNullOrEmpty(RestoreSources)) { var sources = MSBuildStringUtility.Split(RestoreSources); restoreContext.Sources.AddRange(sources); } if (restoreContext.DisableParallel) { HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore(); } _cts.Token.ThrowIfCancellationRequested(); var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token); // Summary RestoreSummary.Log(log, restoreSummaries); return(restoreSummaries.All(x => x.Success)); } }