dependabot-nuget 0.252.0 → 0.254.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6658fe5d81acc16548fe2d8fa0aa6ad631e0699588a4595e6b8de2f382a163d8
-  data.tar.gz: 3ced8b77f453319a715b76ccff47787a8798cb92366fe6a86d6894b855a984bf
+  metadata.gz: c86cede5ca7a7c4b299c2ec8562eedac9a80f12b3d3087be4270b37f21a41861
+  data.tar.gz: 8ea3c1c970f4606fed97261c70ebd493645037bdd635ab4368e38956ab1d17f9
 SHA512:
-  metadata.gz: 958fba1507fdc26ec2e0bc3978702b9103543558552c79188e7cca93b85248f46c1d485686da353076fbab234ea150cc1bb7e11231a1765e87071cf068b2e95c
-  data.tar.gz: 5262c02eeff331fbf8c1399ec2d8fc49bd8942f83f2c1d67a4c9f48a3c7515b0f52710cb5e9f1409c23b025719cbb68d6c43ea2db44f15fe9aa353d80a5b1bd8
+  metadata.gz: 26ee476b689434e34f322153afc7f825e15555bf7c7061014e4b58bdb5962699226942ac64797d436d38b5aed780d4e57d818bd7ef64f6ed6e1961984129139e
+  data.tar.gz: 28e0103dbcb88c4fabb9352a51891f0f69a0533959c7fe052c8b3396c00fcabfe33ae1d3cb28347ffc44f01464c8517397a11783c0c88a66e4bd04fd9f5b37e3

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli.Test/EntryPointTests.Update.cs

@@ -293,22 +293,30 @@ public partial class EntryPointTests
             );
         }
 
-        [Fact]
-        public async Task UpdaterDoesNotUseRepoGlobalJsonForMSBuildTasks()
+        [Theory]
+        [InlineData(null)]
+        [InlineData("src")]
+        public async Task UpdaterDoesNotUseRepoGlobalJsonForMSBuildTasks(string? workingDirectoryPath)
         {
             // This is a _very_ specific scenario where the `NuGetUpdater.Cli` tool might pick up a `global.json` from
             // the root of the repo under test and use it's `sdk` property when trying to locate MSBuild.  To properly
             // test this, it must be tested in a new process where MSBuild has not been loaded yet and the runner tool
             // must be started with its working directory at the test repo's root.
             using var tempDir = new TemporaryDirectory();
-            await File.WriteAllTextAsync(Path.Join(tempDir.DirectoryPath, "global.json"), """
+            var globalJsonPath = Path.Join(tempDir.DirectoryPath, "global.json");
+            var srcGlobalJsonPath = Path.Join(tempDir.DirectoryPath, "src", "global.json");
+            string globalJsonContent = """
                 {
                   "sdk": {
                     "version": "99.99.99"
                   }
                 }
-                """);
-            await File.WriteAllTextAsync(Path.Join(tempDir.DirectoryPath, "project.csproj"), """
+                """;
+            await File.WriteAllTextAsync(globalJsonPath, globalJsonContent);
+            Directory.CreateDirectory(Path.Join(tempDir.DirectoryPath, "src"));
+            await File.WriteAllTextAsync(srcGlobalJsonPath, globalJsonContent);
+            var projectPath = Path.Join(tempDir.DirectoryPath, "src", "project.csproj");
+            await File.WriteAllTextAsync(projectPath, """
                 <Project Sdk="Microsoft.NET.Sdk">
                   <PropertyGroup>
                     <TargetFramework>net8.0</TargetFramework>
@@ -325,7 +333,7 @@ public partial class EntryPointTests
                 "--repo-root",
                 tempDir.DirectoryPath,
                 "--solution-or-project",
-                Path.Join(tempDir.DirectoryPath, "project.csproj"),
+                projectPath,
                 "--dependency",
                 "Newtonsoft.Json",
                 "--new-version",
@@ -336,15 +344,25 @@ public partial class EntryPointTests
             ]);
 
             // verify base run
-            var (exitCode, output, error) = await ProcessEx.RunAsync(executableName, executableArgs, workingDirectory: tempDir.DirectoryPath);
+            var workingDirectory = tempDir.DirectoryPath;
+            if (workingDirectoryPath is not null)
+            {
+                workingDirectory = Path.Join(workingDirectory, workingDirectoryPath);
+            }
+
+            var (exitCode, output, error) = await ProcessEx.RunAsync(executableName, executableArgs, workingDirectory: workingDirectory);
             Assert.True(exitCode == 0, $"Error running update on unsupported SDK.\nSTDOUT:\n{output}\nSTDERR:\n{error}");
 
             // verify project update
-            var updatedProjectContents = await File.ReadAllTextAsync(Path.Join(tempDir.DirectoryPath, "project.csproj"));
+            var updatedProjectContents = await File.ReadAllTextAsync(projectPath);
             Assert.Contains("13.0.1", updatedProjectContents);
 
             // verify `global.json` untouched
-            var updatedGlobalJsonContents = await File.ReadAllTextAsync(Path.Join(tempDir.DirectoryPath, "global.json"));
+            var updatedGlobalJsonContents = await File.ReadAllTextAsync(globalJsonPath);
+            Assert.Contains("99.99.99", updatedGlobalJsonContents);
+
+            // verify `src/global.json` untouched
+            var updatedSrcGlobalJsonContents = await File.ReadAllTextAsync(srcGlobalJsonPath);
             Assert.Contains("99.99.99", updatedGlobalJsonContents);
         }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DiscoveryWorker.cs

@@ -26,7 +26,7 @@ public partial class DiscoveryWorker
 
     public async Task RunAsync(string repoRootPath, string workspacePath, string outputPath)
     {
-        MSBuildHelper.RegisterMSBuild();
+        MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
 
         // When running under unit tests, the workspace path may not be rooted.
         if (!Path.IsPathRooted(workspacePath) || !Directory.Exists(workspacePath))

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/SdkProjectDiscovery.cs

@@ -9,86 +9,87 @@ internal static class SdkProjectDiscovery
     public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string projectPath, Logger logger)
     {
         // Determine which targets and props files contribute to the build.
-        var buildFiles = await MSBuildHelper.LoadBuildFilesAsync(repoRootPath, projectPath, includeSdkPropsAndTargets: true);
+        var (buildFiles, projectTargetFrameworks) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
+        var tfms = projectTargetFrameworks.Order().ToImmutableArray();
 
         // Get all the dependencies which are directly referenced from the project file or indirectly referenced from
         // targets and props files.
         var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles);
 
         var results = ImmutableArray.CreateBuilder<ProjectDiscoveryResult>();
-        foreach (var buildFile in buildFiles)
+        if (tfms.Length > 0)
         {
-            // Only include build files that exist beneath the RepoRootPath.
-            if (buildFile.IsOutsideBasePath)
+            foreach (var buildFile in buildFiles)
             {
-                continue;
-            }
-
-            // The build file dependencies have the correct DependencyType and the TopLevelDependencies have the evaluated version.
-            // Combine them to have the set of dependencies that are directly referenced from the build file.
-            var fileDependencies = BuildFile.GetDependencies(buildFile)
-                .ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
-            var sdkDependencies = fileDependencies.Values
-                .Where(d => d.Type == DependencyType.MSBuildSdk)
-                .ToImmutableArray();
-            var indirectDependencies = topLevelDependencies
-                .Where(d => !fileDependencies.ContainsKey(d.Name))
-                .ToImmutableArray();
-            var directDependencies = topLevelDependencies
-                .Where(d => fileDependencies.ContainsKey(d.Name))
-                .Select(d =>
+                // Only include build files that exist beneath the RepoRootPath.
+                if (buildFile.IsOutsideBasePath)
                 {
-                    var dependency = fileDependencies[d.Name];
-                    return d with
-                    {
-                        Type = dependency.Type,
-                        IsDirect = true
-                    };
-                }).ToImmutableArray();
-
-            if (buildFile.GetFileType() == ProjectBuildFileType.Project)
-            {
-                // Collect information that is specific to the project file.
-                var tfms = MSBuildHelper.GetTargetFrameworkMonikers(buildFiles)
-                    .OrderBy(tfm => tfm)
-                    .ToImmutableArray();
-                var properties = MSBuildHelper.GetProperties(buildFiles).Values
-                    .Where(p => !p.SourceFilePath.StartsWith(".."))
-                    .OrderBy(p => p.Name)
-                    .ToImmutableArray();
-                var referencedProjectPaths = MSBuildHelper.GetProjectPathsFromProject(projectPath)
-                    .Select(path => Path.GetRelativePath(workspacePath, path))
-                    .OrderBy(p => p)
-                    .ToImmutableArray();
+                    continue;
+                }
 
-                // Get the complete set of dependencies including transitive dependencies.
-                var dependencies = indirectDependencies.Concat(directDependencies).ToImmutableArray();
-                dependencies = dependencies
-                    .Select(d => d with { TargetFrameworks = tfms })
+                // The build file dependencies have the correct DependencyType and the TopLevelDependencies have the evaluated version.
+                // Combine them to have the set of dependencies that are directly referenced from the build file.
+                var fileDependencies = BuildFile.GetDependencies(buildFile)
+                    .ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
+                var sdkDependencies = fileDependencies.Values
+                    .Where(d => d.Type == DependencyType.MSBuildSdk)
                     .ToImmutableArray();
-                var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, logger);
-                ImmutableArray<Dependency> allDependencies = dependencies.Concat(transitiveDependencies).Concat(sdkDependencies)
-                    .OrderBy(d => d.Name)
+                var indirectDependencies = topLevelDependencies
+                    .Where(d => !fileDependencies.ContainsKey(d.Name))
                     .ToImmutableArray();
+                var directDependencies = topLevelDependencies
+                    .Where(d => fileDependencies.ContainsKey(d.Name))
+                    .Select(d =>
+                    {
+                        var dependency = fileDependencies[d.Name];
+                        return d with
+                        {
+                            Type = dependency.Type,
+                            IsDirect = true
+                        };
+                    }).ToImmutableArray();
 
-                results.Add(new()
+                if (buildFile.GetFileType() == ProjectBuildFileType.Project)
                 {
-                    FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
-                    Properties = properties,
-                    TargetFrameworks = tfms,
-                    ReferencedProjectPaths = referencedProjectPaths,
-                    Dependencies = allDependencies,
-                });
-            }
-            else
-            {
-                results.Add(new()
-                {
-                    FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
-                    Dependencies = directDependencies.Concat(sdkDependencies)
+                    // Collect information that is specific to the project file.
+                    var properties = MSBuildHelper.GetProperties(buildFiles).Values
+                        .Where(p => !p.SourceFilePath.StartsWith(".."))
+                        .OrderBy(p => p.Name)
+                        .ToImmutableArray();
+                    var referencedProjectPaths = MSBuildHelper.GetProjectPathsFromProject(projectPath)
+                        .Select(path => Path.GetRelativePath(workspacePath, path))
+                        .OrderBy(p => p)
+                        .ToImmutableArray();
+
+                    // Get the complete set of dependencies including transitive dependencies.
+                    var dependencies = indirectDependencies.Concat(directDependencies).ToImmutableArray();
+                    dependencies = dependencies
+                        .Select(d => d with { TargetFrameworks = tfms })
+                        .ToImmutableArray();
+                    var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, logger);
+                    ImmutableArray<Dependency> allDependencies = dependencies.Concat(transitiveDependencies).Concat(sdkDependencies)
                         .OrderBy(d => d.Name)
-                        .ToImmutableArray(),
-                });
+                        .ToImmutableArray();
+
+                    results.Add(new()
+                    {
+                        FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
+                        Properties = properties,
+                        TargetFrameworks = tfms,
+                        ReferencedProjectPaths = referencedProjectPaths,
+                        Dependencies = allDependencies,
+                    });
+                }
+                else
+                {
+                    results.Add(new()
+                    {
+                        FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
+                        Dependencies = directDependencies.Concat(sdkDependencies)
+                            .OrderBy(d => d.Name)
+                            .ToImmutableArray(),
+                    });
+                }
             }
         }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/PackagesConfigUpdater.cs

@@ -174,11 +174,7 @@ internal static class PackagesConfigUpdater
         var hintPathSubString = $"{dependencyName}.{dependencyVersion}";
 
         string? partialPathMatch = null;
-        var hintPathNodes = projectBuildFile.Contents.Descendants()
-            .Where(e =>
-                e.Name.Equals("HintPath", StringComparison.OrdinalIgnoreCase) &&
-                e.Parent.Name.Equals("Reference", StringComparison.OrdinalIgnoreCase) &&
-                e.Parent.GetAttributeValue("Include", StringComparison.OrdinalIgnoreCase)?.StartsWith($"{dependencyName},", StringComparison.OrdinalIgnoreCase) == true);
+        var hintPathNodes = projectBuildFile.Contents.Descendants().Where(e => e.IsHintPathNodeForDependency(dependencyName));
         foreach (var hintPathNode in hintPathNodes)
         {
             var hintPath = hintPathNode.GetContentValue();
@@ -210,6 +206,26 @@ internal static class PackagesConfigUpdater
         return partialPathMatch;
     }
 
+    private static bool IsHintPathNodeForDependency(this IXmlElementSyntax element, string dependencyName)
+    {
+        if (element.Name.Equals("HintPath", StringComparison.OrdinalIgnoreCase) &&
+            element.Parent.Name.Equals("Reference", StringComparison.OrdinalIgnoreCase))
+        {
+            // the include attribute will look like one of the following:
+            //   <Reference Include="Some.Dependency, Version=1.0.0.0, Culture=neutral, PublicKeyToken=abcd">
+            // or
+            //   <Reference Include="Some.Dependency">
+            string includeAttributeValue = element.Parent.GetAttributeValue("Include", StringComparison.OrdinalIgnoreCase);
+            if (includeAttributeValue.Equals(dependencyName, StringComparison.OrdinalIgnoreCase) ||
+                includeAttributeValue.StartsWith($"{dependencyName},", StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     private static string GetUpToIndexWithoutTrailingDirectorySeparator(string path, int index)
     {
         var subpath = path[..index];

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/SdkPackageUpdater.cs

@@ -20,8 +20,7 @@ internal static class SdkPackageUpdater
         // SDK-style project, modify the XML directly
         logger.Log("  Running for SDK-style project");
 
-        var buildFiles = await MSBuildHelper.LoadBuildFilesAsync(repoRootPath, projectPath);
-        var tfms = MSBuildHelper.GetTargetFrameworkMonikers(buildFiles);
+        (ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
 
         // Get the set of all top-level dependencies in the current project
         var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
@@ -42,7 +41,7 @@ internal static class SdkPackageUpdater
                 return;
             }
 
-            UpdateTopLevelDepdendency(buildFiles, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
+            await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
         }
 
         if (!await AreDependenciesCoherentAsync(repoRootPath, projectPath, dependencyName, logger, buildFiles, tfms))
@@ -226,10 +225,10 @@ internal static class SdkPackageUpdater
         logger.Log($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
 
         // see https://learn.microsoft.com/nuget/consume-packages/install-use-packages-dotnet-cli
-        var (exitCode, _, _) = await ProcessEx.RunAsync("dotnet", $"add {projectPath} package {dependencyName} --version {newDependencyVersion}", workingDirectory: Path.GetDirectoryName(projectPath));
+        var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", $"add {projectPath} package {dependencyName} --version {newDependencyVersion}", workingDirectory: Path.GetDirectoryName(projectPath));
         if (exitCode != 0)
         {
-            logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.");
+            logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
         }
     }
 
@@ -288,8 +287,10 @@ internal static class SdkPackageUpdater
         return packagesAndVersions;
     }
 
-    private static void UpdateTopLevelDepdendency(
+    private static async Task UpdateTopLevelDepdendency(
+        string repoRootPath,
         ImmutableArray<ProjectBuildFile> buildFiles,
+        string[] targetFrameworks,
         string dependencyName,
         string previousDependencyVersion,
         string newDependencyVersion,
@@ -307,6 +308,43 @@ internal static class SdkPackageUpdater
         {
             TryUpdateDependencyVersion(buildFiles, packageName, previousDependencyVersion: null, newDependencyVersion: packageVersion, logger);
         }
+
+        // now make all dependency requirements coherent
+        Dependency[] updatedTopLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
+        foreach (ProjectBuildFile projectFile in buildFiles)
+        {
+            foreach (string tfm in targetFrameworks)
+            {
+                Dependency[]? resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, logger);
+                if (resolvedDependencies is null)
+                {
+                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    continue;
+                }
+
+                // ensure the originally requested dependency was resolved to the correct version
+                var specificResolvedDependency = resolvedDependencies.Where(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+                if (specificResolvedDependency is null)
+                {
+                    logger.Log($"    Unable resolve requested dependency for {dependencyName} in {projectFile.Path}.");
+                    continue;
+                }
+
+                if (!newDependencyVersion.Equals(specificResolvedDependency.Version, StringComparison.OrdinalIgnoreCase))
+                {
+                    logger.Log($"    Inconsistent resolution for {dependencyName}; attempted upgrade to {newDependencyVersion} but resolved {specificResolvedDependency.Version}.");
+                    continue;
+                }
+
+                // update all other dependencies
+                foreach (Dependency resolvedDependency in resolvedDependencies
+                                                          .Where(d => !d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase))
+                                                          .Where(d => d.Version is not null))
+                {
+                    TryUpdateDependencyVersion(buildFiles, resolvedDependency.Name, previousDependencyVersion: null, newDependencyVersion: resolvedDependency.Version!, logger);
+                }
+            }
+        }
     }
 
     private static UpdateResult TryUpdateDependencyVersion(

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/UpdaterWorker.cs

@@ -12,7 +12,7 @@ public class UpdaterWorker
 
     public async Task RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
     {
-        MSBuildHelper.RegisterMSBuild();
+        MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
 
         if (!Path.IsPathRooted(workspacePath) || !File.Exists(workspacePath))
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/JsonHelper.cs

@@ -145,13 +145,14 @@ namespace NuGetUpdater.Core.Utilities
 
             // single line comments might have had a trailing comma appended by the property writer that we can't
             // control, so we have to manually correct for it
-            var originalJsonLines = json.Split('\n').Select(l => l.TrimEnd('\r')).ToArray();
+            var originalJsonLines = json.Split('\n').Select(l => l.TrimEnd('\r')).Where(l => !string.IsNullOrWhiteSpace(l)).ToArray();
             var updatedJsonLines = resultJson.Split('\n').Select(l => l.TrimEnd('\r')).ToArray();
             for (int i = 0; i < Math.Min(originalJsonLines.Length, updatedJsonLines.Length); i++)
             {
-                if (updatedJsonLines[i].EndsWith(",") && !originalJsonLines[i].EndsWith(","))
+                var updatedLine = updatedJsonLines[i];
+                if (updatedLine.EndsWith(',') && updatedLine.Contains("//", StringComparison.Ordinal) && !originalJsonLines[i].EndsWith(','))
                 {
-                    updatedJsonLines[i] = updatedJsonLines[i][..^1];
+                    updatedJsonLines[i] = updatedLine[..^1];
                 }
             }