dependabot-nuget 0.287.0 → 0.289.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/VersionFinder.cs

@@ -62,7 +62,7 @@ internal static class VersionFinder
             var feed = await sourceRepository.GetResourceAsync<MetadataResource>();
             if (feed is null)
             {
-                logger.Log($"Failed to get MetadataResource for [{source.Source}]");
+                logger.Warn($"Failed to get MetadataResource for [{source.Source}]");
                 continue;
             }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Clone/ShellGitCommandHandler.cs

@@ -13,7 +13,7 @@ public class ShellGitCommandHandler : IGitCommandHandler
 
     public async Task RunGitCommandAsync(IReadOnlyCollection<string> args, string? workingDirectory = null)
     {
-        _logger.Log($"Running command: git {string.Join(" ", args)}{(workingDirectory is null ? "" : $" in directory {workingDirectory}")}");
+        _logger.Info($"Running command: git {string.Join(" ", args)}{(workingDirectory is null ? "" : $" in directory {workingDirectory}")}");
         var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("git", args, workingDirectory);
         HandleErrorsFromOutput(stdout, stderr);
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/DependencyDiscovery.props

@@ -0,0 +1,7 @@
+<Project>
+  <!-- The following properties enable target framework and dependency discovery when OS-specific workloads are required -->
+  <PropertyGroup>
+    <DesignTimeBuild>true</DesignTimeBuild>
+    <TargetPlatformVersion Condition=" $(TargetFramework.Contains('-')) ">1.0</TargetPlatformVersion>
+  </PropertyGroup>
+</Project>

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

@@ -0,0 +1,10 @@
+<Project>
+  <Import Project="DependencyDiscovery.props" />
+
+  <Target Name="_DiscoverDependencies" DependsOnTargets="GenerateBuildDependencyFile;ResolvePackageAssets">
+    <!--
+    The target GenerateBuildDependencyFile is sufficient for projects targeting .NET Standard or .NET Core.
+    The target ResolvePackageAssets is necessary for projects targeting .NET Framework.
+    -->
+  </Target>
+</Project>

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

@@ -16,8 +16,9 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 {
     public const string DiscoveryResultFileName = "./.dependabot/discovery.json";
 
+    private readonly ExperimentsManager _experimentsManager;
     private readonly ILogger _logger;
-    private readonly HashSet<string> _processedProjectPaths = new(StringComparer.OrdinalIgnoreCase); private readonly HashSet<string> _restoredMSBuildSdks = new(StringComparer.OrdinalIgnoreCase);
+    private readonly HashSet<string> _processedProjectPaths = new(StringComparer.Ordinal); private readonly HashSet<string> _restoredMSBuildSdks = new(StringComparer.OrdinalIgnoreCase);
 
     internal static readonly JsonSerializerOptions SerializerOptions = new()
     {
@@ -25,8 +26,9 @@ public partial class DiscoveryWorker : IDiscoveryWorker
         Converters = { new JsonStringEnumConverter() },
     };
 
-    public DiscoveryWorker(ILogger logger)
+    public DiscoveryWorker(ExperimentsManager experimentsManager, ILogger logger)
     {
+        _experimentsManager = experimentsManager;
         _logger = logger;
     }
 
@@ -60,7 +62,7 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
     public async Task<WorkspaceDiscoveryResult> RunAsync(string repoRootPath, string workspacePath)
     {
-        MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
+        MSBuildHelper.RegisterMSBuild(repoRootPath, workspacePath);
 
         // the `workspacePath` variable is relative to a repository root, so a rooted path actually isn't rooted; the
         // easy way to deal with this is to just trim the leading "/" if it exists
@@ -74,14 +76,13 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
         DotNetToolsJsonDiscoveryResult? dotNetToolsJsonDiscovery = null;
         GlobalJsonDiscoveryResult? globalJsonDiscovery = null;
-        DirectoryPackagesPropsDiscoveryResult? directoryPackagesPropsDiscovery = null;
 
         ImmutableArray<ProjectDiscoveryResult> projectResults = [];
         WorkspaceDiscoveryResult result;
 
         if (Directory.Exists(workspacePath))
         {
-            _logger.Log($"Discovering build files in workspace [{workspacePath}].");
+            _logger.Info($"Discovering build files in workspace [{workspacePath}].");
 
             dotNetToolsJsonDiscovery = DotNetToolsJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
             globalJsonDiscovery = GlobalJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
@@ -93,17 +94,10 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
             // this next line should throw or something
             projectResults = await RunForDirectoryAsnyc(repoRootPath, workspacePath);
-
-            directoryPackagesPropsDiscovery = DirectoryPackagesPropsDiscovery.Discover(repoRootPath, workspacePath, projectResults, _logger);
-
-            if (directoryPackagesPropsDiscovery is not null)
-            {
-                projectResults = projectResults.Remove(projectResults.First(p => p.FilePath.Equals(directoryPackagesPropsDiscovery.FilePath, StringComparison.OrdinalIgnoreCase)));
-            }
         }
         else
         {
-            _logger.Log($"Workspace path [{workspacePath}] does not exist.");
+            _logger.Info($"Workspace path [{workspacePath}] does not exist.");
         }
 
         result = new WorkspaceDiscoveryResult
@@ -111,11 +105,10 @@ public partial class DiscoveryWorker : IDiscoveryWorker
             Path = initialWorkspacePath,
             DotNetToolsJson = dotNetToolsJsonDiscovery,
             GlobalJson = globalJsonDiscovery,
-            DirectoryPackagesProps = directoryPackagesPropsDiscovery,
             Projects = projectResults.OrderBy(p => p.FilePath).ToImmutableArray(),
         };
 
-        _logger.Log("Discovery complete.");
+        _logger.Info("Discovery complete.");
         _processedProjectPaths.Clear();
 
         return result;
@@ -142,19 +135,19 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
         _restoredMSBuildSdks.AddRange(keys);
 
-        _logger.Log($"  Restoring MSBuild SDKs: {string.Join(", ", keys)}");
+        _logger.Info($"  Restoring MSBuild SDKs: {string.Join(", ", keys)}");
 
         return await NuGetHelper.DownloadNuGetPackagesAsync(repoRootPath, workspacePath, msbuildSdks, logger);
     }
 
     private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForDirectoryAsnyc(string repoRootPath, string workspacePath)
     {
-        _logger.Log($"  Discovering projects beneath [{Path.GetRelativePath(repoRootPath, workspacePath)}].");
+        _logger.Info($"  Discovering projects beneath [{Path.GetRelativePath(repoRootPath, workspacePath)}].");
         var entryPoints = FindEntryPoints(workspacePath);
         var projects = ExpandEntryPointsIntoProjects(entryPoints);
         if (projects.IsEmpty)
         {
-            _logger.Log("  No project files found.");
+            _logger.Info("  No project files found.");
             return [];
         }
 
@@ -271,62 +264,80 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
     private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForProjectPathsAsync(string repoRootPath, string workspacePath, IEnumerable<string> projectPaths)
     {
-        var results = new Dictionary<string, ProjectDiscoveryResult>(StringComparer.OrdinalIgnoreCase);
+        var results = new Dictionary<string, ProjectDiscoveryResult>(StringComparer.Ordinal);
         foreach (var projectPath in projectPaths)
         {
             // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
             // Ensure file existence is checked case-insensitively
-            var actualProjectPath = PathHelper.ResolveCaseInsensitivePathInsideRepoRoot(projectPath, repoRootPath);
-            if (actualProjectPath == null)
-            {
-                continue;
-            }
+            var actualProjectPaths = PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(projectPath, repoRootPath);
 
-            if (_processedProjectPaths.Contains(actualProjectPath))
+            if (actualProjectPaths == null)
             {
                 continue;
             }
-            _processedProjectPaths.Add(actualProjectPath);
 
-            var relativeProjectPath = Path.GetRelativePath(workspacePath, actualProjectPath);
-            var packagesConfigDependencies = PackagesConfigDiscovery.Discover(workspacePath, projectPath, _logger)
-                    ?.Dependencies;
-
-            var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _logger);
-
-            // Determine if there were unrestored MSBuildSdks
-            var msbuildSdks = projectResults.SelectMany(p => p.Dependencies.Where(d => d.Type == DependencyType.MSBuildSdk)).ToImmutableArray();
-            if (msbuildSdks.Length > 0)
+            foreach (var actualProjectPath in actualProjectPaths)
             {
-                // If new SDKs were restored, then we need to rerun SdkProjectDiscovery.
-                if (await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, msbuildSdks, _logger))
+                if (_processedProjectPaths.Contains(actualProjectPath))
                 {
-                    projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _logger);
+                    continue;
                 }
-            }
 
-            foreach (var projectResult in projectResults)
-            {
-                if (results.ContainsKey(projectResult.FilePath))
+                _processedProjectPaths.Add(actualProjectPath);
+
+                var relativeProjectPath = Path.GetRelativePath(workspacePath, actualProjectPath).NormalizePathToUnix();
+                var packagesConfigResult = await PackagesConfigDiscovery.Discover(repoRootPath, workspacePath, actualProjectPath, _logger);
+                var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _experimentsManager, _logger);
+
+                // Determine if there were unrestored MSBuildSdks
+                var msbuildSdks = projectResults.SelectMany(p => p.Dependencies.Where(d => d.Type == DependencyType.MSBuildSdk)).ToImmutableArray();
+                if (msbuildSdks.Length > 0)
                 {
-                    continue;
+                    // If new SDKs were restored, then we need to rerun SdkProjectDiscovery.
+                    if (await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, msbuildSdks, _logger))
+                    {
+                        projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _experimentsManager, _logger);
+                    }
                 }
 
-                // If we had packages.config dependencies, merge them with the project dependencies
-                if (projectResult.FilePath == relativeProjectPath && packagesConfigDependencies is not null)
+                foreach (var projectResult in projectResults)
                 {
-                    packagesConfigDependencies = packagesConfigDependencies.Value
-                        .Select(d => d with { TargetFrameworks = projectResult.TargetFrameworks })
-                        .ToImmutableArray();
+                    if (results.ContainsKey(projectResult.FilePath))
+                    {
+                        continue;
+                    }
 
-                    results[projectResult.FilePath] = projectResult with
+                    // If we had packages.config dependencies, merge them with the project dependencies
+                    if (projectResult.FilePath == relativeProjectPath && packagesConfigResult is not null)
                     {
-                        Dependencies = [.. projectResult.Dependencies, .. packagesConfigDependencies],
-                    };
+                        var packagesConfigDependencies = packagesConfigResult.Dependencies
+                            .Select(d => d with { TargetFrameworks = projectResult.TargetFrameworks })
+                            .ToImmutableArray();
+
+                        results[projectResult.FilePath] = projectResult with
+                        {
+                            Dependencies = [.. projectResult.Dependencies, .. packagesConfigDependencies],
+                        };
+                    }
+                    else
+                    {
+                        results[projectResult.FilePath] = projectResult;
+                    }
                 }
-                else
+
+                if (!results.ContainsKey(relativeProjectPath) &&
+                    packagesConfigResult is not null &&
+                    packagesConfigResult.Dependencies.Length > 0)
                 {
-                    results[projectResult.FilePath] = projectResult;
+                    // project contained only packages.config dependencies
+                    results[relativeProjectPath] = new ProjectDiscoveryResult()
+                    {
+                        FilePath = relativeProjectPath,
+                        Dependencies = packagesConfigResult.Dependencies,
+                        TargetFrameworks = packagesConfigResult.TargetFrameworks,
+                        ImportedFiles = [], // no imported files resolved for packages.config scenarios
+                        AdditionalFiles = packagesConfigResult.AdditionalFiles,
+                    };
                 }
             }
         }

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

@@ -8,13 +8,13 @@ internal static class DotNetToolsJsonDiscovery
     {
         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 null;
         }
 
         var dotnetToolsJsonFile = DotNetToolsJsonBuildFile.Open(workspacePath, dotnetToolsJsonPath, logger);
 
-        logger.Log($"  Discovered [{dotnetToolsJsonFile.RelativePath}] file.");
+        logger.Info($"  Discovered [{dotnetToolsJsonFile.RelativePath}] file.");
 
         var dependencies = BuildFile.GetDependencies(dotnetToolsJsonFile)
             .OrderBy(d => d.Name)

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

@@ -8,13 +8,13 @@ internal static class GlobalJsonDiscovery
     {
         if (!MSBuildHelper.TryGetGlobalJsonPath(repoRootPath, workspacePath, out var globalJsonPath))
         {
-            logger.Log("  No global.json file found.");
+            logger.Info("  No global.json file found.");
             return null;
         }
 
         var globalJsonFile = GlobalJsonBuildFile.Open(workspacePath, globalJsonPath, logger);
 
-        logger.Log($"  Discovered [{globalJsonFile.RelativePath}] file.");
+        logger.Info($"  Discovered [{globalJsonFile.RelativePath}] file.");
 
         var dependencies = BuildFile.GetDependencies(globalJsonFile)
             .OrderBy(d => d.Name)

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

@@ -1,29 +1,41 @@
 using System.Collections.Immutable;
 
+using NuGetUpdater.Core.Utilities;
+
 namespace NuGetUpdater.Core.Discover;
 
 internal static class PackagesConfigDiscovery
 {
-    public static PackagesConfigDiscoveryResult? Discover(string workspacePath, string projectPath, ILogger logger)
+    public static async Task<PackagesConfigDiscoveryResult?> Discover(string repoRootPath, string workspacePath, string projectPath, ILogger logger)
     {
-        if (!NuGetHelper.TryGetPackagesConfigFile(projectPath, out var packagesConfigPath))
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(projectPath, ProjectHelper.PathFormat.Full);
+        var packagesConfigPath = additionalFiles.FirstOrDefault(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesConfigFileName, StringComparison.Ordinal));
+
+        if (packagesConfigPath is null)
         {
-            logger.Log("  No packages.config file found.");
+            logger.Info("  No packages.config file found.");
             return null;
         }
 
         var packagesConfigFile = PackagesConfigBuildFile.Open(workspacePath, packagesConfigPath);
 
-        logger.Log($"  Discovered [{packagesConfigFile.RelativePath}] file.");
+        logger.Info($"  Discovered [{packagesConfigFile.RelativePath}] file.");
 
         var dependencies = BuildFile.GetDependencies(packagesConfigFile)
             .OrderBy(d => d.Name)
             .ToImmutableArray();
 
+        // generate `$(TargetFramework)` via MSBuild
+        var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, projectPath, logger);
+
+        var additionalFilesRelative = additionalFiles.Select(p => Path.GetRelativePath(projectDirectory, p).NormalizePathToUnix()).ToImmutableArray();
         return new()
         {
             FilePath = packagesConfigFile.RelativePath,
-            Dependencies = dependencies,
+            Dependencies = dependencies.Select(d => d with { TargetFrameworks = tfms }).ToImmutableArray(),
+            TargetFrameworks = tfms,
+            AdditionalFiles = additionalFilesRelative,
         };
     }
 }

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

@@ -6,5 +6,7 @@ public sealed record PackagesConfigDiscoveryResult : IDiscoveryResultWithDepende
 {
     public required string FilePath { get; init; }
     public bool IsSuccess { get; init; } = true;
-    public ImmutableArray<Dependency> Dependencies { get; init; }
+    public required ImmutableArray<Dependency> Dependencies { get; init; }
+    public required ImmutableArray<string> TargetFrameworks { get; init; }
+    public required ImmutableArray<string> AdditionalFiles { get; init; }
 }

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

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Text.Json.Serialization;
 
 namespace NuGetUpdater.Core.Discover;
 
@@ -10,4 +11,6 @@ public record ProjectDiscoveryResult : IDiscoveryResultWithDependencies
     public ImmutableArray<Property> Properties { get; init; } = [];
     public ImmutableArray<string> TargetFrameworks { get; init; } = [];
     public ImmutableArray<string> ReferencedProjectPaths { get; init; } = [];
+    public required ImmutableArray<string> ImportedFiles { get; init; }
+    public required ImmutableArray<string> AdditionalFiles { get; init; }
 }