dependabot-nuget 0.287.0 → 0.289.0

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

@@ -2,5 +2,15 @@ namespace NuGetUpdater.Core;
 
 public interface ILogger
 {
-    void Log(string message);
+    void LogRaw(string message);
+}
+
+public static class LoggerExtensions
+{
+    public static void Info(this ILogger logger, string message) => logger.LogWithLevel("INFO", message);
+    public static void Warn(this ILogger logger, string message) => logger.LogWithLevel("WARN", message);
+    public static void Error(this ILogger logger, string message) => logger.LogWithLevel("ERROR", message);
+
+    private static void LogWithLevel(this ILogger logger, string level, string message) => logger.LogRaw($"{GetCurrentTimestamp()} {level} {message}");
+    private static string GetCurrentTimestamp() => DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss");
 }

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

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -13,7 +14,6 @@ using Microsoft.Build.Exceptions;
 using Microsoft.Build.Locator;
 using Microsoft.Extensions.FileSystemGlobbing;
 
-using NuGet;
 using NuGet.Configuration;
 using NuGet.Frameworks;
 using NuGet.Versioning;
@@ -39,19 +39,19 @@ internal static partial class MSBuildHelper
                 var defaultInstance = MSBuildLocator.QueryVisualStudioInstances().First();
                 MSBuildPath = defaultInstance.MSBuildPath;
                 MSBuildLocator.RegisterInstance(defaultInstance);
-                return Task.CompletedTask;
+                return Task.FromResult(0);
             }).Wait();
         }
     }
 
-    public static async Task SidelineGlobalJsonAsync(string currentDirectory, string rootDirectory, Func<Task> action, ILogger? logger = null, bool retainMSBuildSdks = false)
+    public static async Task<T> SidelineGlobalJsonAsync<T>(string currentDirectory, string rootDirectory, Func<Task<T>> action, ILogger? logger = null, bool retainMSBuildSdks = false)
     {
         logger ??= new ConsoleLogger();
         var candidateDirectories = PathHelper.GetAllDirectoriesToRoot(currentDirectory, rootDirectory);
         var globalJsonPaths = candidateDirectories.Select(d => Path.Combine(d, "global.json")).Where(File.Exists).Select(p => (p, p + Guid.NewGuid().ToString())).ToArray();
         foreach (var (globalJsonPath, tempGlobalJsonPath) in globalJsonPaths)
         {
-            logger.Log($"Temporarily removing `global.json` from `{Path.GetDirectoryName(globalJsonPath)}`{(retainMSBuildSdks ? " and retaining MSBuild SDK declarations" : string.Empty)}.");
+            logger.Info($"Temporarily removing `global.json` from `{Path.GetDirectoryName(globalJsonPath)}`{(retainMSBuildSdks ? " and retaining MSBuild SDK declarations" : string.Empty)}.");
             File.Move(globalJsonPath, tempGlobalJsonPath);
             if (retainMSBuildSdks)
             {
@@ -73,13 +73,14 @@ internal static partial class MSBuildHelper
 
         try
         {
-            await action();
+            var result = await action();
+            return result;
         }
         finally
         {
             foreach (var (globalJsonpath, tempGlobalJsonPath) in globalJsonPaths)
             {
-                logger.Log($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}`.");
+                logger.Info($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}`.");
                 File.Move(tempGlobalJsonPath, globalJsonpath, overwrite: retainMSBuildSdks);
             }
         }
@@ -326,7 +327,7 @@ internal static partial class MSBuildHelper
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         try
         {
-            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath], workingDirectory: tempDirectory.FullName);
 
             // NU1608: Detected package version outside of dependency constraint
@@ -346,7 +347,7 @@ internal static partial class MSBuildHelper
 
         try
         {
-            string tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            string tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath], workingDirectory: tempDirectory.FullName);
 
             // Add Dependency[] packages to List<PackageToUpdate> existingPackages
@@ -397,10 +398,10 @@ internal static partial class MSBuildHelper
             if (added == true)
             {
                 // Add existing versions to existing list
-                packageManager.UpdateExistingPackagesWithNewVersions(existingDuplicate, packagesToUpdate);
+                packageManager.UpdateExistingPackagesWithNewVersions(existingDuplicate, packagesToUpdate, logger);
 
                 // Make relationships
-                await packageManager.PopulatePackageDependenciesAsync(existingDuplicate, targetFramework, Path.GetDirectoryName(projectPath));
+                await packageManager.PopulatePackageDependenciesAsync(existingDuplicate, targetFramework, Path.GetDirectoryName(projectPath), logger);
 
                 // Update all to new versions
                 foreach (var package in existingDuplicate)
@@ -413,10 +414,10 @@ internal static partial class MSBuildHelper
             else
             {
                 // Add existing versions to existing list
-                packageManager.UpdateExistingPackagesWithNewVersions(existingPackages, packagesToUpdate);
+                packageManager.UpdateExistingPackagesWithNewVersions(existingPackages, packagesToUpdate, logger);
 
                 // Make relationships
-                await packageManager.PopulatePackageDependenciesAsync(existingPackages, targetFramework, Path.GetDirectoryName(projectPath));
+                await packageManager.PopulatePackageDependenciesAsync(existingPackages, targetFramework, Path.GetDirectoryName(projectPath), logger);
 
                 // Update all to new versions
                 foreach (var package in existingPackages)
@@ -502,7 +503,7 @@ internal static partial class MSBuildHelper
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         try
         {
-            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath], workingDirectory: tempDirectory.FullName);
             ThrowOnUnauthenticatedFeed(stdOut);
 
@@ -626,7 +627,7 @@ internal static partial class MSBuildHelper
         return projectRoot;
     }
 
-    private static IEnumerable<PackageSource>? LoadPackageSources(string nugetConfigPath)
+    private static IEnumerable<PackageSource>? LoadPackageSources(string nugetConfigPath, ILogger logger)
     {
         try
         {
@@ -637,8 +638,8 @@ internal static partial class MSBuildHelper
         }
         catch (NuGetConfigurationException ex)
         {
-            Console.WriteLine("Error while parsing NuGet.config");
-            Console.WriteLine(ex.Message);
+            logger.Warn("Error while parsing NuGet.config");
+            logger.Warn(ex.Message);
 
             // Nuget.config is invalid. Won't be able to do anything with specific sources.
             return null;
@@ -651,6 +652,7 @@ internal static partial class MSBuildHelper
         string projectPath,
         string targetFramework,
         IReadOnlyCollection<Dependency> packages,
+        ILogger logger,
         bool usePackageDownload = false)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath);
@@ -663,7 +665,7 @@ internal static partial class MSBuildHelper
             File.Copy(nugetConfigPath, Path.Combine(tempDir.FullName, "NuGet.Config"));
             var nugetConfigDir = Path.GetDirectoryName(nugetConfigPath);
 
-            var packageSources = LoadPackageSources(nugetConfigPath);
+            var packageSources = LoadPackageSources(nugetConfigPath, logger);
             if (packageSources is not null)
             {
                 // We need to copy local package sources from the NuGet.Config file to the temp directory
@@ -747,18 +749,70 @@ internal static partial class MSBuildHelper
         return tempProjectPath;
     }
 
+    internal static async Task<ImmutableArray<string>> GetTargetFrameworkValuesFromProject(string repoRoot, string projectPath, ILogger logger)
+    {
+        // TODO: once the updater image has all relevant SDKs installed, we won't have to sideline global.json anymore
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var (exitCode, stdOut, stdErr) = await SidelineGlobalJsonAsync(projectDirectory, repoRoot, async () =>
+        {
+            var targetsHelperPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!, "TargetFrameworkReporter.targets");
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["build", projectPath, "/t:ReportTargetFramework", $"/p:CustomAfterMicrosoftCommonCrossTargetingTargets={targetsHelperPath};CustomAfterMicrosoftCommonTargets={targetsHelperPath}"], workingDirectory: Path.GetDirectoryName(projectPath));
+            return (exitCode, stdOut, stdErr);
+        });
+        ThrowOnUnauthenticatedFeed(stdOut);
+        if (exitCode != 0)
+        {
+            logger.Warn($"Error determining target frameworks.\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
+        }
+
+        // There are 3 return values, all uses slightly differently.  Only one will be set, the others will be blank
+        //   ProjectData::TargetFrameworkVersion=.NETFramework,Version=v4.5     // non-SDK projects, commonly with `packages.config`
+        //   ProjectData::TargetFramework=net7.0                                // SDK-style projects
+        //   ProjectData::TargetFrameworks=net7.0;net8.0
+        var tfmPatterns = new Regex[]
+        {
+            new Regex("ProjectData::TargetFrameworkVersion=(?<Value>.*)$", RegexOptions.Multiline),
+            new Regex("ProjectData::TargetFramework=(?<Value>.*)$", RegexOptions.Multiline),
+            new Regex("ProjectData::TargetFrameworks=(?<Value>.*)$", RegexOptions.Multiline),
+        };
+        var tfms = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var tfmPattern in tfmPatterns)
+        {
+            var candidateTfms = tfmPattern.Matches(stdOut)
+                .Select(m => m.Groups["Value"].Value)
+                .SelectMany(v => v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+                .Where(v => !string.IsNullOrWhiteSpace(v))
+                .Select(v =>
+                {
+                    try
+                    {
+                        var framework = NuGetFramework.Parse(v);
+                        return framework.GetShortFolderName();
+                    }
+                    catch
+                    {
+                        return string.Empty;
+                    }
+                })
+                .Where(tfm => !string.IsNullOrEmpty(tfm));
+            tfms.AddRange(candidateTfms);
+        }
+
+        return tfms.ToImmutableArray();
+    }
+
     internal static async Task<Dependency[]> GetAllPackageDependenciesAsync(
         string repoRoot,
         string projectPath,
         string targetFramework,
         IReadOnlyCollection<Dependency> packages,
-        ILogger? logger = null)
+        ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-resolution_");
         try
         {
             var topLevelPackagesNames = packages.Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
-            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
 
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["build", tempProjectPath, "/t:_ReportDependencies"], workingDirectory: tempDirectory.FullName);
             ThrowOnUnauthenticatedFeed(stdout);
@@ -783,7 +837,7 @@ internal static partial class MSBuildHelper
             }
             else
             {
-                logger?.Log($"dotnet build in {nameof(GetAllPackageDependenciesAsync)} failed. STDOUT: {stdout} STDERR: {stderr}");
+                logger?.Warn($"dotnet build in {nameof(GetAllPackageDependenciesAsync)} failed. STDOUT: {stdout} STDERR: {stderr}");
                 return [];
             }
         }

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

@@ -4,28 +4,12 @@ namespace NuGetUpdater.Core;
 
 internal static class NuGetHelper
 {
-    internal const string PackagesConfigFileName = "packages.config";
-
-    public static bool TryGetPackagesConfigFile(string projectPath, [NotNullWhen(returnValue: true)] out string? packagesConfigPath)
-    {
-        var projectDirectory = Path.GetDirectoryName(projectPath);
-
-        packagesConfigPath = PathHelper.JoinPath(projectDirectory, PackagesConfigFileName);
-        if (File.Exists(packagesConfigPath))
-        {
-            return true;
-        }
-
-        packagesConfigPath = null;
-        return false;
-    }
-
     internal static async Task<bool> DownloadNuGetPackagesAsync(string repoRoot, string projectPath, IReadOnlyCollection<Dependency> packages, ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("msbuild_sdk_restore_");
         try
         {
-            var tempProjectPath = await MSBuildHelper.CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, "netstandard2.0", packages, usePackageDownload: true);
+            var tempProjectPath = await MSBuildHelper.CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, "netstandard2.0", packages, logger, usePackageDownload: true);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath]);
 
             return exitCode == 0;

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

@@ -0,0 +1,31 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace NuGetUpdater.Core.Utilities;
+
+public class PathComparer : IEqualityComparer<string>
+{
+    public static PathComparer Instance { get; } = new PathComparer();
+
+    public bool Equals(string? x, string? y)
+    {
+        x = x?.NormalizePathToUnix();
+        y = y?.NormalizePathToUnix();
+
+        if (x is null && y is null)
+        {
+            return true;
+        }
+
+        if (x is null || y is null)
+        {
+            return false;
+        }
+
+        return x.Equals(y, StringComparison.OrdinalIgnoreCase);
+    }
+
+    public int GetHashCode([DisallowNull] string obj)
+    {
+        return obj.NormalizePathToUnix().GetHashCode();
+    }
+}

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

@@ -1,3 +1,6 @@
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+
 namespace NuGetUpdater.Core;
 
 internal static class PathHelper
@@ -63,7 +66,17 @@ internal static class PathHelper
         return result;
     }
 
-    public static string FullyNormalizedRootedPath(this string path) => path.NormalizePathToUnix().NormalizeUnixPathParts().EnsurePrefix("/");
+    public static string FullyNormalizedRootedPath(this string path)
+    {
+        var normalizedPath = path.NormalizePathToUnix().NormalizeUnixPathParts();
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Regex.IsMatch(normalizedPath, @"^[a-z]:", RegexOptions.IgnoreCase))
+        {
+            // Windows path is ready to go
+            return normalizedPath;
+        }
+
+        return normalizedPath.EnsurePrefix("/");
+    }
 
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
@@ -92,7 +105,7 @@ internal static class PathHelper
     /// </summary>
     /// <param name="filePath">The file path to resolve.</param>
     /// <param name="repoRootPath">The root path of the repository.</param>
-    public static string? ResolveCaseInsensitivePathInsideRepoRoot(string filePath, string repoRootPath)
+    public static List<string>? ResolveCaseInsensitivePathsInsideRepoRoot(string filePath, string repoRootPath)
     {
         if (string.IsNullOrEmpty(filePath) || string.IsNullOrEmpty(repoRootPath))
         {
@@ -110,7 +123,7 @@ internal static class PathHelper
         }
 
         // Start resolving from the root path
-        var currentPath = normalizedRepoRoot;
+        var currentPaths = new List<string> { normalizedRepoRoot };
         var relativePath = normalizedFilePath.Substring(normalizedRepoRoot.Length).TrimStart('/');
 
         foreach (var part in relativePath.Split('/'))
@@ -120,20 +133,28 @@ internal static class PathHelper
                 continue;
             }
 
-            // Enumerate the current directory to find a case-insensitive match
-            var nextPath = Directory
-                .EnumerateFileSystemEntries(currentPath)
-                .FirstOrDefault(entry => string.Equals(Path.GetFileName(entry), part, StringComparison.OrdinalIgnoreCase));
+            var nextPaths = new List<string>();
+
+            // Iterate through all current paths to find matches for the current part
+            foreach (var currentPath in currentPaths)
+            {
+                var matches = Directory
+                    .EnumerateFileSystemEntries(currentPath)
+                    .Where(entry => string.Equals(Path.GetFileName(entry), part, StringComparison.OrdinalIgnoreCase));
+
+                nextPaths.AddRange(matches);
+            }
 
-            if (nextPath == null)
+            if (!nextPaths.Any())
             {
                 return null; // Part of the path does not exist
             }
 
-            currentPath = nextPath;
+            currentPaths = nextPaths;
         }
 
-        return currentPath; // Fully resolved path with correct casing
+        // Normalize all resulting paths to Unix format
+        return currentPaths.Select(path => path.NormalizePathToUnix()).ToList();
     }
 
     /// <summary>
@@ -212,4 +233,19 @@ internal static class PathHelper
 
         return false;
     }
+
+    public static bool IsFileUnderDirectory(DirectoryInfo directory, FileInfo candidateFile)
+    {
+        // n.b., using `DirectoryInfo` and `FileInfo` here to ensure that the callsite doesn't get confused with just strings
+        // the paths are then normalized to make the comparison easier.
+        var directoryPath = directory.FullName.NormalizePathToUnix();
+        if (!directoryPath.EndsWith("/"))
+        {
+            // ensuring a trailing slash means we can do a simple string check later on
+            directoryPath += "/";
+        }
+        var candidateFilePath = candidateFile.FullName.NormalizePathToUnix();
+
+        return candidateFilePath.StartsWith(directoryPath);
+    }
 }

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

@@ -0,0 +1,96 @@
+using System.Collections.Immutable;
+
+using Microsoft.Build.Construction;
+
+namespace NuGetUpdater.Core.Utilities;
+
+internal static class ProjectHelper
+{
+    public const string PackagesConfigFileName = "packages.config";
+    public const string AppConfigFileName = "app.config";
+    public const string WebConfigFileName = "web.config";
+    public const string PackagesLockJsonFileName = "packages.lock.json";
+
+    public enum PathFormat
+    {
+        Relative,
+        Full,
+    }
+
+    public static ImmutableArray<string> GetAllAdditionalFilesFromProject(string fullProjectPath, PathFormat pathFormat)
+    {
+        return GetAdditionalFilesFromProjectContent(fullProjectPath, pathFormat)
+            .AddRange(GetAdditionalFilesFromProjectLocation(fullProjectPath, pathFormat));
+    }
+
+    public static ImmutableArray<string> GetAdditionalFilesFromProjectContent(string fullProjectPath, PathFormat pathFormat)
+    {
+        var projectRootElement = ProjectRootElement.Open(fullProjectPath);
+        var additionalFilesWithFullPaths = new[]
+        {
+            projectRootElement.GetItemPathWithFileName(PackagesConfigFileName),
+            projectRootElement.GetItemPathWithFileName(AppConfigFileName),
+            projectRootElement.GetItemPathWithFileName(WebConfigFileName),
+        }.Where(p => p is not null).Cast<string>().ToImmutableArray();
+
+        var additionalFiles = additionalFilesWithFullPaths
+            .Select(p => MakePathAppropriateFormat(fullProjectPath, p, pathFormat))
+            .ToImmutableArray();
+        return additionalFiles;
+    }
+
+    public static ImmutableArray<string> GetAdditionalFilesFromProjectLocation(string fullProjectPath, PathFormat pathFormat)
+    {
+        var additionalFilesWithFullPaths = new[]
+        {
+            GetPathWithRegardsToProjectFile(fullProjectPath, PackagesLockJsonFileName),
+        }.Where(p => p is not null).Cast<string>().ToImmutableArray();
+
+        var additionalFiles = additionalFilesWithFullPaths
+            .Select(p => MakePathAppropriateFormat(fullProjectPath, p, pathFormat))
+            .ToImmutableArray();
+        return additionalFiles;
+    }
+
+    public static string? GetPackagesConfigPathFromProject(string fullProjectPath, PathFormat pathFormat)
+    {
+        var additionalFiles = GetAdditionalFilesFromProjectContent(fullProjectPath, pathFormat);
+        var packagesConfigFile = additionalFiles.FirstOrDefault(p => Path.GetFileName(p).Equals(PackagesConfigFileName, StringComparison.Ordinal));
+        return packagesConfigFile;
+    }
+
+    private static string MakePathAppropriateFormat(string fullProjectPath, string fullFilePath, PathFormat pathFormat)
+    {
+        var projectDirectory = Path.GetDirectoryName(fullProjectPath)!;
+        var updatedPath = pathFormat switch
+        {
+            PathFormat.Full => fullFilePath,
+            PathFormat.Relative => Path.GetRelativePath(projectDirectory, fullFilePath),
+            _ => throw new NotSupportedException(),
+        };
+        return updatedPath.NormalizePathToUnix();
+    }
+
+    private static string? GetItemPathWithFileName(this ProjectRootElement projectRootElement, string itemFileName)
+    {
+        var projectDirectory = Path.GetDirectoryName(projectRootElement.FullPath)!;
+        var packagesConfigPath = projectRootElement.Items
+            .Where(i => i.ElementName.Equals("None", StringComparison.OrdinalIgnoreCase) ||
+                        i.ElementName.Equals("Content", StringComparison.OrdinalIgnoreCase))
+            .Where(i => Path.GetFileName(i.Include).Equals(itemFileName, StringComparison.OrdinalIgnoreCase))
+            .Select(i => Path.GetFullPath(Path.Combine(projectDirectory, i.Include)))
+            .Where(File.Exists)
+            .FirstOrDefault()
+            ?.NormalizePathToUnix();
+        return packagesConfigPath;
+    }
+
+    private static string? GetPathWithRegardsToProjectFile(string fullProjectPath, string fileName)
+    {
+        var projectDirectory = Path.GetDirectoryName(fullProjectPath)!;
+        var filePath = Directory.EnumerateFiles(projectDirectory)
+            .Where(p => Path.GetFileName(p).Equals(fileName, StringComparison.Ordinal))
+            .FirstOrDefault();
+        return filePath;
+    }
+}