dependabot-nuget 0.321.3 → 0.322.1

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/FileWriters/FileWriterWorker.cs

@@ -32,13 +32,36 @@ public class FileWriterWorker
     )
     {
         var updateOperations = new List<UpdateOperationBase>();
-        var projectDirectory = Path.GetDirectoryName(projectPath.FullName)!;
-        var projectDirectoryRelativeToRepoRoot = Path.GetRelativePath(repoContentsPath.FullName, projectDirectory).FullyNormalizedRootedPath();
+        var initialProjectDirectory = new DirectoryInfo(Path.GetDirectoryName(projectPath.FullName)!);
 
         // first try non-project updates
+        var nonProjectUpdates = await ProcessNonProjectUpdatesAsync(repoContentsPath, initialProjectDirectory, dependencyName, oldDependencyVersion, newDependencyVersion);
+        updateOperations.AddRange(nonProjectUpdates);
+
+        // then try packages.config updates
+        var packagesConfigUpdates = await ProcessPackagesConfigUpdatesAsync(repoContentsPath, projectPath, dependencyName, oldDependencyVersion, newDependencyVersion);
+        updateOperations.AddRange(packagesConfigUpdates);
+
+        // then try project updates
+        var packageReferenceUpdates = await ProcessPackageReferenceUpdatesAsync(repoContentsPath, initialProjectDirectory, projectPath, dependencyName, newDependencyVersion);
+        updateOperations.AddRange(packageReferenceUpdates);
+
+        var normalizedUpdateOperations = UpdateOperationBase.NormalizeUpdateOperationCollection(repoContentsPath.FullName, updateOperations);
+        return normalizedUpdateOperations;
+    }
+
+    private async Task<ImmutableArray<UpdateOperationBase>> ProcessNonProjectUpdatesAsync(
+        DirectoryInfo repoContentsPath,
+        DirectoryInfo initialProjectDirectory,
+        string dependencyName,
+        NuGetVersion oldDependencyVersion,
+        NuGetVersion newDependencyVersion
+    )
+    {
+        var updateOperations = new List<UpdateOperationBase>();
         var updatedDotNetToolsPath = await DotNetToolsJsonUpdater.UpdateDependencyAsync(
             repoContentsPath.FullName,
-            projectDirectory,
+            initialProjectDirectory.FullName,
             dependencyName,
             oldDependencyVersion.ToString(),
             newDependencyVersion.ToString(),
@@ -57,7 +80,7 @@ public class FileWriterWorker
 
         var updatedGlobalJsonPath = await GlobalJsonUpdater.UpdateDependencyAsync(
             repoContentsPath.FullName,
-            projectDirectory,
+            initialProjectDirectory.FullName,
             dependencyName,
             oldDependencyVersion.ToString(),
             newDependencyVersion.ToString(),
@@ -74,33 +97,54 @@ public class FileWriterWorker
             });
         }
 
-        // then try packages.config updates
+        return [.. updateOperations];
+    }
+
+    private async Task<ImmutableArray<UpdateOperationBase>> ProcessPackagesConfigUpdatesAsync(
+        DirectoryInfo repoContentsPath,
+        FileInfo projectPath,
+        string dependencyName,
+        NuGetVersion oldDependencyVersion,
+        NuGetVersion newDependencyVersion
+    )
+    {
         var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(projectPath.FullName, ProjectHelper.PathFormat.Full);
         var packagesConfigFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesConfigFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-        if (packagesConfigFullPath is not null)
+        if (packagesConfigFullPath is null)
         {
-            var packagesConfigOperations = await PackagesConfigUpdater.UpdateDependencyAsync(
-                repoContentsPath.FullName,
-                projectPath.FullName,
-                dependencyName,
-                oldDependencyVersion.ToString(),
-                newDependencyVersion.ToString(),
-                packagesConfigFullPath,
-                _logger
-            );
-            var packagesConfigOperationsWithNormalizedPaths = packagesConfigOperations
-                .Select(op => op with { UpdatedFiles = [.. op.UpdatedFiles.Select(f => Path.GetRelativePath(repoContentsPath.FullName, f).FullyNormalizedRootedPath())] })
-                .ToArray();
-            updateOperations.AddRange(packagesConfigOperationsWithNormalizedPaths);
+            return [];
         }
 
-        // then try project updates
-        var initialDiscoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, projectDirectoryRelativeToRepoRoot);
+        var packagesConfigOperations = await PackagesConfigUpdater.UpdateDependencyAsync(
+            repoContentsPath.FullName,
+            projectPath.FullName,
+            dependencyName,
+            oldDependencyVersion.ToString(),
+            newDependencyVersion.ToString(),
+            packagesConfigFullPath,
+            _logger
+        );
+        var packagesConfigOperationsWithNormalizedPaths = packagesConfigOperations
+            .Select(op => op with { UpdatedFiles = [.. op.UpdatedFiles.Select(f => Path.GetRelativePath(repoContentsPath.FullName, f).FullyNormalizedRootedPath())] })
+            .ToImmutableArray();
+        return packagesConfigOperationsWithNormalizedPaths;
+    }
+
+    private async Task<ImmutableArray<UpdateOperationBase>> ProcessPackageReferenceUpdatesAsync(
+        DirectoryInfo repoContentsPath,
+        DirectoryInfo initialProjectDirectory,
+        FileInfo projectPath,
+        string dependencyName,
+        NuGetVersion newDependencyVersion
+    )
+    {
+        var initialProjectDirectoryRelativeToRepoRoot = Path.GetRelativePath(repoContentsPath.FullName, initialProjectDirectory.FullName).FullyNormalizedRootedPath();
+        var initialDiscoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, initialProjectDirectoryRelativeToRepoRoot);
         var initialProjectDiscovery = initialDiscoveryResult.GetProjectDiscoveryFromFullPath(repoContentsPath, projectPath);
         if (initialProjectDiscovery is null)
         {
             _logger.Info($"Unable to find project discovery for project {projectPath}.");
-            return [.. updateOperations];
+            return [];
         }
 
         var initialRequestedDependency = initialProjectDiscovery.Dependencies
@@ -108,14 +152,14 @@ public class FileWriterWorker
         if (initialRequestedDependency is null || initialRequestedDependency.Version is null)
         {
             _logger.Info($"Dependency {dependencyName} not found in initial project discovery.");
-            return [.. updateOperations];
+            return [];
         }
 
         var initialDependencyVersion = NuGetVersion.Parse(initialRequestedDependency.Version);
         if (initialDependencyVersion >= newDependencyVersion)
         {
             _logger.Info($"Dependency {dependencyName} is already at version {initialDependencyVersion}, no update needed.");
-            return [.. updateOperations];
+            return [];
         }
 
         var initialTopLevelDependencies = initialProjectDiscovery.Dependencies
@@ -126,6 +170,7 @@ public class FileWriterWorker
             ? initialTopLevelDependencies.Select(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase) ? newDependency : d).ToImmutableArray()
             : initialTopLevelDependencies.Concat([newDependency]).ToImmutableArray();
 
+        var updateOperations = new List<UpdateOperationBase>();
         foreach (var targetFramework in initialProjectDiscovery.TargetFrameworks)
         {
             var resolvedDependencies = await _dependencySolver.SolveAsync(initialTopLevelDependencies, desiredDependencies, targetFramework);
@@ -154,13 +199,13 @@ public class FileWriterWorker
             var orderedProjectDiscovery = GetProjectDiscoveryEvaluationOrder(repoContentsPath, initialDiscoveryResult, projectPath, _logger);
 
             // track original contents
-            var originalFileContents = await GetOriginalFileContentsAsync(repoContentsPath, new DirectoryInfo(projectDirectory), orderedProjectDiscovery);
+            var originalFileContents = await GetOriginalFileContentsAsync(repoContentsPath, initialProjectDirectory, orderedProjectDiscovery);
 
             var allUpdatedFiles = new List<string>();
             foreach (var projectDiscovery in orderedProjectDiscovery)
             {
                 var projectFullPath = Path.Join(repoContentsPath.FullName, initialDiscoveryResult.Path, projectDiscovery.FilePath).FullyNormalizedRootedPath();
-                var updatedFiles = await TryPerformFileWritesAsync(repoContentsPath, new FileInfo(projectFullPath), projectDiscovery, resolvedDependencies.Value);
+                var updatedFiles = await TryPerformFileWritesAsync(_fileWriter, repoContentsPath, initialProjectDirectory, projectDiscovery, resolvedDependencies.Value);
                 allUpdatedFiles.AddRange(updatedFiles);
             }
 
@@ -172,7 +217,7 @@ public class FileWriterWorker
             }
 
             // this final call to discover has the benefit of also updating the lock file if it exists
-            var finalDiscoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, projectDirectoryRelativeToRepoRoot);
+            var finalDiscoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, initialProjectDirectoryRelativeToRepoRoot);
             var finalProjectDiscovery = finalDiscoveryResult.GetProjectDiscoveryFromFullPath(repoContentsPath, projectPath);
             if (finalProjectDiscovery is null)
             {
@@ -205,7 +250,7 @@ public class FileWriterWorker
                 initialTopLevelDependencies,
                 desiredDependencies,
                 resolvedDependencies.Value,
-                new ExperimentsManager() { UseDirectDiscovery = true },
+                new ExperimentsManager(),
                 _logger);
             var filteredUpdateOperations = computedUpdateOperations
                 .Where(op =>
@@ -222,8 +267,7 @@ public class FileWriterWorker
             updateOperations.AddRange(computedOperationsWithUpdatedFiles);
         }
 
-        var normalizedUpdateOperations = UpdateOperationBase.NormalizeUpdateOperationCollection(repoContentsPath.FullName, updateOperations);
-        return normalizedUpdateOperations;
+        return [.. updateOperations];
     }
 
     internal static async Task<Dictionary<string, string>> GetOriginalFileContentsAsync(DirectoryInfo repoContentsPath, DirectoryInfo initialStartingDirectory, IEnumerable<ProjectDiscoveryResult> projectDiscoveryResults)
@@ -292,16 +336,22 @@ public class FileWriterWorker
         return projectDiscoveryOrder;
     }
 
-    private async Task<ImmutableArray<string>> TryPerformFileWritesAsync(DirectoryInfo repoContentsPath, FileInfo projectPath, ProjectDiscoveryResult projectDiscovery, ImmutableArray<Dependency> requiredPackageVersions)
+    internal static async Task<ImmutableArray<string>> TryPerformFileWritesAsync(
+        IFileWriter fileWriter,
+        DirectoryInfo repoContentsPath,
+        DirectoryInfo originalDiscoveryDirectory,
+        ProjectDiscoveryResult projectDiscovery,
+        ImmutableArray<Dependency> requiredPackageVersions
+    )
     {
-        var originalFileContents = await GetOriginalFileContentsAsync(repoContentsPath, projectPath.Directory!, [projectDiscovery]);
+        var originalFileContents = await GetOriginalFileContentsAsync(repoContentsPath, originalDiscoveryDirectory, [projectDiscovery]);
         var relativeFilePaths = originalFileContents.Keys
             .Select(p => Path.GetRelativePath(repoContentsPath.FullName, p).FullyNormalizedRootedPath())
             .ToImmutableArray();
 
         // try update
         var addPackageReferenceElementForPinnedPackages = !projectDiscovery.CentralPackageTransitivePinningEnabled;
-        var success = await _fileWriter.UpdatePackageVersionsAsync(repoContentsPath, [.. relativeFilePaths], projectDiscovery.Dependencies, requiredPackageVersions, addPackageReferenceElementForPinnedPackages);
+        var success = await fileWriter.UpdatePackageVersionsAsync(repoContentsPath, relativeFilePaths, projectDiscovery.Dependencies, requiredPackageVersions, addPackageReferenceElementForPinnedPackages);
         var updatedFiles = new List<string>();
         foreach (var (filePath, originalContents) in originalFileContents)
         {
@@ -320,7 +370,7 @@ public class FileWriterWorker
             await RestoreOriginalFileContentsAsync(originalFileContents);
         }
 
-        var sortedUpdatedFiles = updatedFiles.OrderBy(p => p, StringComparer.Ordinal);
-        return [.. sortedUpdatedFiles];
+        var sortedUpdatedFiles = updatedFiles.OrderBy(p => p, StringComparer.Ordinal).ToImmutableArray();
+        return sortedUpdatedFiles;
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/FileWriters/XmlFileWriter.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using System.Text.RegularExpressions;
+using System.Xml;
 using System.Xml.Linq;
 
 using NuGet.Versioning;
@@ -23,15 +24,20 @@ public class XmlFileWriter : IFileWriter
 
     private readonly ILogger _logger;
 
-    // these file extensions are XML and can be updated; everything else is ignored
-    private static readonly HashSet<string> SupportedFileExtensions =
-    [
+    // these file extensions are valid project entrypoints; everything else is ignored
+    private static readonly HashSet<string> SupportedProjectFileExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
         ".csproj",
         ".vbproj",
         ".fsproj",
+    };
+
+    // these file extensions are valid additional files and can be updated; everything else is ignored
+    private static readonly HashSet<string> SupportedAdditionalFileExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
         ".props",
         ".targets",
-    ];
+    };
 
     public XmlFileWriter(ILogger logger)
     {
@@ -54,8 +60,15 @@ public class XmlFileWriter : IFileWriter
 
         var updatesPerformed = requiredPackageVersions.ToDictionary(d => d.Name, _ => false, StringComparer.OrdinalIgnoreCase);
         var projectRelativePath = relativeFilePaths[0];
+        var projectExtension = Path.GetExtension(projectRelativePath);
+        if (!SupportedProjectFileExtensions.Contains(projectExtension))
+        {
+            _logger.Warn($"Project extension '{projectExtension}' not supported; skipping XML update.");
+            return false;
+        }
+
         var filesAndContentsTasks = relativeFilePaths
-            .Where(path => SupportedFileExtensions.Contains(Path.GetExtension(path)))
+            .Where(path => SupportedProjectFileExtensions.Contains(Path.GetExtension(path)) || SupportedAdditionalFileExtensions.Contains(Path.GetExtension(path)))
             .Select(async path =>
             {
                 var content = await ReadFileContentsAsync(repoContentsPath, path);
@@ -357,7 +370,7 @@ public class XmlFileWriter : IFileWriter
         {
             foreach (var (path, contents) in filesAndContents)
             {
-                await WriteFileContentsAsync(repoContentsPath, path, contents.ToString());
+                await WriteFileContentsAsync(repoContentsPath, path, contents);
             }
         }
 
@@ -421,10 +434,16 @@ public class XmlFileWriter : IFileWriter
         return contents;
     }
 
-    private static async Task WriteFileContentsAsync(DirectoryInfo repoContentsPath, string path, string contents)
+    private static async Task WriteFileContentsAsync(DirectoryInfo repoContentsPath, string path, XDocument document)
     {
         var fullPath = Path.Join(repoContentsPath.FullName, path);
-        await File.WriteAllTextAsync(fullPath, contents);
+        var writerSettings = new XmlWriterSettings()
+        {
+            Async = true,
+            OmitXmlDeclaration = document.Declaration is null,
+        };
+        using var writer = XmlWriter.Create(fullPath, writerSettings);
+        await document.SaveAsync(writer, CancellationToken.None);
     }
 
     public static string CreateUpdatedVersionRangeString(VersionRange existingRange, NuGetVersion existingVersion, NuGetVersion requiredVersion)