dependabot-nuget 0.287.0 → 0.289.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/RunWorker.cs

@@ -113,8 +113,8 @@ public class RunWorker
     {
         var discoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, repoDirectory);
 
-        _logger.Log("Discovery JSON content:");
-        _logger.Log(JsonSerializer.Serialize(discoveryResult, DiscoveryWorker.SerializerOptions));
+        _logger.Info("Discovery JSON content:");
+        _logger.Info(JsonSerializer.Serialize(discoveryResult, DiscoveryWorker.SerializerOptions));
 
         // report dependencies
         var discoveredUpdatedDependencies = GetUpdatedDependencyListFromDiscovery(discoveryResult, repoContentsPath.FullName);
@@ -134,35 +134,28 @@ public class RunWorker
             });
 
             // track original contents for later handling
-            async Task TrackOriginalContentsAsync(string directory, string fileName, string? replacementFileName = null)
+            async Task TrackOriginalContentsAsync(string directory, string fileName)
             {
-                var repoFullPath = Path.Join(directory, fileName);
-                if (replacementFileName is not null)
-                {
-                    repoFullPath = Path.Join(Path.GetDirectoryName(repoFullPath)!, replacementFileName);
-                }
-
-                repoFullPath = repoFullPath.FullyNormalizedRootedPath();
+                var repoFullPath = Path.Join(directory, fileName).FullyNormalizedRootedPath();
                 var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
-
-                if (!File.Exists(localFullPath))
-                {
-                    return;
-                }
-
                 var content = await File.ReadAllTextAsync(localFullPath);
                 originalDependencyFileContents[repoFullPath] = content;
             }
 
             foreach (var project in discoveryResult.Projects)
             {
+                var projectDirectory = Path.GetDirectoryName(project.FilePath);
                 await TrackOriginalContentsAsync(discoveryResult.Path, project.FilePath);
-                await TrackOriginalContentsAsync(discoveryResult.Path, project.FilePath, replacementFileName: "packages.config");
+                foreach (var extraFile in project.ImportedFiles.Concat(project.AdditionalFiles))
+                {
+                    var extraFilePath = Path.Join(projectDirectory, extraFile);
+                    await TrackOriginalContentsAsync(discoveryResult.Path, extraFilePath);
+                }
                 // TODO: include global.json, etc.
             }
 
             // do update
-            _logger.Log($"Running update in directory {repoDirectory}");
+            _logger.Info($"Running update in directory {repoDirectory}");
             foreach (var project in discoveryResult.Projects)
             {
                 foreach (var dependency in project.Dependencies.Where(d => !d.IsTransitive))
@@ -192,13 +185,7 @@ public class RunWorker
                     // TODO: log analysisResult
                     if (analysisResult.CanUpdate)
                     {
-                        var dependencyLocation = Path.Join(discoveryResult.Path, project.FilePath);
-                        if (dependency.Type == DependencyType.PackagesConfig)
-                        {
-                            dependencyLocation = Path.Join(Path.GetDirectoryName(dependencyLocation)!, "packages.config");
-                        }
-
-                        dependencyLocation = dependencyLocation.FullyNormalizedRootedPath();
+                        var dependencyLocation = Path.Join(discoveryResult.Path, project.FilePath).FullyNormalizedRootedPath();
 
                         // TODO: this is inefficient, but not likely causing a bottleneck
                         var previousDependency = discoveredUpdatedDependencies.Dependencies
@@ -241,48 +228,46 @@ public class RunWorker
             }
 
             // create PR - we need to manually check file contents; we can't easily use `git status` in tests
-            var updatedDependencyFiles = new List<DependencyFile>();
-            async Task AddUpdatedFileIfDifferentAsync(string directory, string fileName, string? replacementFileName = null)
+            var updatedDependencyFiles = new Dictionary<string, DependencyFile>();
+            async Task AddUpdatedFileIfDifferentAsync(string directory, string fileName)
             {
-                var repoFullPath = Path.Join(directory, fileName);
-                if (replacementFileName is not null)
-                {
-                    repoFullPath = Path.Join(Path.GetDirectoryName(repoFullPath)!, replacementFileName);
-                }
-
-                repoFullPath = repoFullPath.FullyNormalizedRootedPath();
-                var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
-
-                if (!File.Exists(localFullPath))
-                {
-                    return;
-                }
-
+                var repoFullPath = Path.Join(directory, fileName).FullyNormalizedRootedPath();
+                var localFullPath = Path.GetFullPath(Path.Join(repoContentsPath.FullName, repoFullPath));
                 var originalContent = originalDependencyFileContents[repoFullPath];
                 var updatedContent = await File.ReadAllTextAsync(localFullPath);
                 if (updatedContent != originalContent)
                 {
-                    updatedDependencyFiles.Add(new DependencyFile()
+                    updatedDependencyFiles[localFullPath] = new DependencyFile()
                     {
                         Name = Path.GetFileName(repoFullPath),
                         Directory = Path.GetDirectoryName(repoFullPath)!.NormalizePathToUnix(),
                         Content = updatedContent,
-                    });
+                    };
                 }
             }
 
             foreach (var project in discoveryResult.Projects)
             {
                 await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, project.FilePath);
-                await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, project.FilePath, replacementFileName: "packages.config");
+                var projectDirectory = Path.GetDirectoryName(project.FilePath);
+                foreach (var extraFile in project.ImportedFiles.Concat(project.AdditionalFiles))
+                {
+                    var extraFilePath = Path.Join(projectDirectory, extraFile);
+                    await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, extraFilePath);
+                }
+                // TODO: handle global.json, etc.
             }
 
             if (updatedDependencyFiles.Count > 0)
             {
+                var updatedDependencyFileList = updatedDependencyFiles
+                    .OrderBy(kvp => kvp.Key)
+                    .Select(kvp => kvp.Value)
+                    .ToArray();
                 var createPullRequest = new CreatePullRequest()
                 {
                     Dependencies = actualUpdatedDependencies.ToArray(),
-                    UpdatedDependencyFiles = updatedDependencyFiles.ToArray(),
+                    UpdatedDependencyFiles = updatedDependencyFileList,
                     BaseCommitSha = baseCommitSha,
                     CommitMessage = "TODO: message",
                     PrTitle = "TODO: title",
@@ -303,7 +288,7 @@ public class RunWorker
 
         var result = new RunResult()
         {
-            Base64DependencyFiles = originalDependencyFileContents.Select(kvp =>
+            Base64DependencyFiles = originalDependencyFileContents.OrderBy(kvp => kvp.Key).Select(kvp =>
             {
                 var fullPath = kvp.Key.FullyNormalizedRootedPath();
                 return new DependencyFile()
@@ -335,22 +320,24 @@ public class RunWorker
         {
             auxiliaryFiles.Add(GetFullRepoPath(discoveryResult.DotNetToolsJson.FilePath));
         }
-        if (discoveryResult.DirectoryPackagesProps is not null)
-        {
-            auxiliaryFiles.Add(GetFullRepoPath(discoveryResult.DirectoryPackagesProps.FilePath));
-        }
 
         foreach (var project in discoveryResult.Projects)
         {
             var projectDirectory = Path.GetDirectoryName(project.FilePath);
-            var pathToPackagesConfig = Path.Join(pathToContents, discoveryResult.Path, projectDirectory, "packages.config");
-
-            if (File.Exists(pathToPackagesConfig))
+            foreach (var extraFile in project.ImportedFiles.Concat(project.AdditionalFiles))
             {
-                auxiliaryFiles.Add(GetFullRepoPath(Path.Join(projectDirectory, "packages.config")));
+                var extraFileFullPath = Path.Join(projectDirectory, extraFile);
+                var extraFileRepoPath = GetFullRepoPath(extraFileFullPath);
+                auxiliaryFiles.Add(extraFileRepoPath);
             }
         }
 
+        var dependencyFiles = discoveryResult.Projects
+            .Select(p => GetFullRepoPath(p.FilePath))
+            .Concat(auxiliaryFiles)
+            .Distinct()
+            .OrderBy(p => p)
+            .ToArray();
         var updatedDependencyList = new UpdatedDependencyList()
         {
             Dependencies = discoveryResult.Projects.SelectMany(p =>
@@ -361,9 +348,7 @@ public class RunWorker
                         Name = d.Name,
                         Requirements = d.IsTransitive ? [] : [new ReportedRequirement()
                         {
-                            File = d.Type == DependencyType.PackagesConfig
-                                ? Path.Join(Path.GetDirectoryName(GetFullRepoPath(p.FilePath))!, "packages.config").FullyNormalizedRootedPath()
-                                : GetFullRepoPath(p.FilePath),
+                            File = GetFullRepoPath(p.FilePath),
                             Requirement = d.Version!,
                             Groups = ["dependencies"],
                         }],
@@ -371,7 +356,7 @@ public class RunWorker
                     }
                 );
             }).ToArray(),
-            DependencyFiles = discoveryResult.Projects.Select(p => GetFullRepoPath(p.FilePath)).Concat(auxiliaryFiles).ToArray(),
+            DependencyFiles = dependencyFiles,
         };
         return updatedDependencyList;
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/TargetFrameworkReporter.targets

@@ -0,0 +1,13 @@
+<Project>
+  <Import Project="DependencyDiscovery.props" />
+
+  <Target Name="ReportTargetFramework">
+    <!-- this property is for non-SDK projects, commonly with `packages.config -->
+    <!-- e.g., returns ".NETFramework,Version=v4.5" -->
+    <Message Text="ProjectData::TargetFrameworkVersion=$(TargetFrameworkIdentifier),Version=$(TargetFrameworkVersion)" Importance="High" Condition="'$(TargetFrameworkIdentifier)' != '' AND '' != '$(TargetFrameworkVersion)'" />
+
+    <!-- these properties are for SDK projects -->
+    <Message Text="ProjectData::TargetFramework=$(TargetFramework)" Importance="High" Condition="'$(TargetFramework)' != ''" />
+    <Message Text="ProjectData::TargetFrameworks=$(TargetFrameworks)" Importance="High" Condition="'$(TargetFrameworks)' != ''" />
+  </Target>
+</Project>

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

@@ -8,6 +8,8 @@ using Microsoft.Language.Xml;
 
 using NuGet.ProjectManagement;
 
+using NuGetUpdater.Core.Utilities;
+
 using Runtime_AssemblyBinding = CoreV2::NuGet.Runtime.AssemblyBinding;
 
 namespace NuGetUpdater.Core;
@@ -32,7 +34,7 @@ internal static class BindingRedirectManager
     /// <param name="updatedPackageVersion">The version of the package that was updated</param>
     public static async ValueTask UpdateBindingRedirectsAsync(ProjectBuildFile projectBuildFile, string updatedPackageName, string updatedPackageVersion)
     {
-        var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile);
+        var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile.Path);
         if (configFile is null)
         {
             // no runtime config file so no need to add binding redirects
@@ -124,56 +126,24 @@ internal static class BindingRedirectManager
         }
     }
 
-    private static async ValueTask<ConfigurationFile?> TryGetRuntimeConfigurationFile(ProjectBuildFile projectBuildFile)
+    private static async ValueTask<ConfigurationFile?> TryGetRuntimeConfigurationFile(string fullProjectPath)
     {
-        var directoryPath = Path.GetDirectoryName(projectBuildFile.Path);
-        if (directoryPath is null)
-        {
-            return null;
-        }
-
-        var configFile = projectBuildFile.ItemNodes
-            .Where(IsConfigFile)
-            .FirstOrDefault();
+        var additionalFiles = ProjectHelper.GetAdditionalFilesFromProjectContent(fullProjectPath, ProjectHelper.PathFormat.Full);
+        var configFilePath = additionalFiles
+            .FirstOrDefault(p =>
+            {
+                var fileName = Path.GetFileName(p);
+                return fileName.Equals(ProjectHelper.AppConfigFileName, StringComparison.OrdinalIgnoreCase)
+                    || fileName.Equals(ProjectHelper.WebConfigFileName, StringComparison.OrdinalIgnoreCase);
+            });
 
-        if (configFile is null)
+        if (configFilePath is null)
         {
             return null;
         }
 
-        var configFilePath = Path.GetFullPath(Path.Combine(directoryPath, GetValue(configFile)));
         var configFileContents = await File.ReadAllTextAsync(configFilePath);
         return new ConfigurationFile(configFilePath, configFileContents, false);
-
-        static string GetValue(IXmlElementSyntax element)
-        {
-            var content = element.GetAttributeValue("Include");
-            if (!string.IsNullOrEmpty(content))
-            {
-                return content;
-            }
-
-            content = element.GetContentValue();
-            if (!string.IsNullOrEmpty(content))
-            {
-                return content;
-            }
-
-            return string.Empty;
-        }
-
-        static bool IsConfigFile(IXmlElementSyntax element)
-        {
-            var content = GetValue(element);
-            if (content is null)
-            {
-                return false;
-            }
-
-            var path = Path.GetFileName(content);
-            return (element.Name == "None" && string.Equals(path, "app.config", StringComparison.OrdinalIgnoreCase))
-                   || (element.Name == "Content" && string.Equals(path, "web.config", StringComparison.OrdinalIgnoreCase));
-        }
     }
 
     private static string AddBindingRedirects(ConfigurationFile configFile, IEnumerable<(Runtime_AssemblyBinding Binding, string AssemblyPath)> bindingRedirectsAndAssemblyPaths, string assemblyPathPrefix)

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

@@ -12,18 +12,18 @@ internal static class DotNetToolsJsonUpdater
     {
         if (!MSBuildHelper.TryGetDotNetToolsJsonPath(repoRootPath, workspacePath, out var dotnetToolsJsonPath))
         {
-            logger.Log("  No dotnet-tools.json file found.");
+            logger.Info("  No dotnet-tools.json file found.");
             return;
         }
 
         var dotnetToolsJsonFile = DotNetToolsJsonBuildFile.Open(repoRootPath, dotnetToolsJsonPath, logger);
 
-        logger.Log($"  Updating [{dotnetToolsJsonFile.RelativePath}] file.");
+        logger.Info($"  Updating [{dotnetToolsJsonFile.RelativePath}] file.");
 
         var containsDependency = dotnetToolsJsonFile.GetDependencies().Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
         if (!containsDependency)
         {
-            logger.Log($"    Dependency [{dependencyName}] not found.");
+            logger.Info($"    Dependency [{dependencyName}] not found.");
             return;
         }
 
@@ -39,7 +39,7 @@ internal static class DotNetToolsJsonUpdater
 
             if (await dotnetToolsJsonFile.SaveAsync())
             {
-                logger.Log($"    Saved [{dotnetToolsJsonFile.RelativePath}].");
+                logger.Info($"    Saved [{dotnetToolsJsonFile.RelativePath}].");
             }
         }
     }

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

@@ -12,25 +12,25 @@ internal static class GlobalJsonUpdater
     {
         if (!MSBuildHelper.TryGetGlobalJsonPath(repoRootPath, workspacePath, out var globalJsonPath))
         {
-            logger.Log("  No global.json file found.");
+            logger.Info("  No global.json file found.");
             return;
         }
 
         var globalJsonFile = GlobalJsonBuildFile.Open(repoRootPath, globalJsonPath, logger);
 
-        logger.Log($"  Updating [{globalJsonFile.RelativePath}] file.");
+        logger.Info($"  Updating [{globalJsonFile.RelativePath}] file.");
 
         var containsDependency = globalJsonFile.GetDependencies().Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
         if (!containsDependency)
         {
-            logger.Log($"    Dependency [{dependencyName}] not found.");
+            logger.Info($"    Dependency [{dependencyName}] not found.");
             return;
         }
 
         if (globalJsonFile.MSBuildSdks?.TryGetPropertyValue(dependencyName, out var version) != true
             || version?.GetValue<string>() is not string versionString)
         {
-            logger.Log("    Unable to determine dependency version.");
+            logger.Info("    Unable to determine dependency version.");
             return;
         }
 
@@ -43,7 +43,7 @@ internal static class GlobalJsonUpdater
 
         if (await globalJsonFile.SaveAsync())
         {
-            logger.Log($"    Saved [{globalJsonFile.RelativePath}].");
+            logger.Info($"    Saved [{globalJsonFile.RelativePath}].");
         }
     }
 }

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

@@ -7,22 +7,15 @@ internal static class LockFileUpdater
         string projectPath,
         ILogger logger)
     {
-        var projectDirectory = Path.GetDirectoryName(projectPath);
-        var lockPath = Path.Combine(projectDirectory, "packages.lock.json");
-        logger.Log($"    Updating lock file");
-        if (!File.Exists(lockPath))
-        {
-            logger.Log($"      File [{Path.GetRelativePath(repoRootPath, lockPath)}] does not exist.");
-            return;
-        }
-
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
         {
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["restore", "--force-evaluate", projectPath], workingDirectory: projectDirectory);
             if (exitCode != 0)
             {
-                logger.Log($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
+                logger.Error($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
             }
+            return (exitCode, stdout, stderr);
         }, logger, retainMSBuildSdks: true);
     }
 }