dependabot-nuget 0.251.0 → 0.253.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de6f0b0f318838044e74746451b7c9b006d1c7d02a5f0eb9dd435be71e531324
-  data.tar.gz: a79152fa48bdead211a0116e40a8e2583fbb780c7a84ae9e11c5a61fed9cd243
+  metadata.gz: 272069533f6bea5533fb423db28c745b469884c904e393d9708091398a93f9a3
+  data.tar.gz: dd0c3fad1ab56f2bc32e509f89552068cc59b02cd21b1878ef1edcca84af45ba
 SHA512:
-  metadata.gz: dbb569b37e215ec868f66117759bacc09d3de783add60b2274f261d81a1b55ef0a4fffa77c172db4183490dc0fc390551377ba7a404ddd8e1bf1a4d836f43986
-  data.tar.gz: be749544dda69391923d1843c254619cf9f2f9afcc9d5de8a58fc7cf1388352084a2de6f2989d002b9fdd4e5d56c55563cbf6a477a3696757522678ddee73599
+  metadata.gz: a66d28929da003117a1a5ef125be1acd2dd91a522f715fa1c263610a63e333e5b60ec3343836a1d19b6516527595b88425aed9f7df7a5c3f254579b1a12ec77c
+  data.tar.gz: 4fa773a0ff8f2c5e423fd505d111eaf7f84439f99111b68a87e77700290ae0ae97d52318ec9ddabc4d5c80e953bdaef761da96730c82baa8f5c0e36034798e3b

data/helpers/lib/NuGetUpdater/Directory.Common.props

@@ -10,6 +10,7 @@
       2. Update tests as needed at `NuGetUpdater\NuGetUpdater.Core.Test\FrameworkChecker\CompatibilityCheckerFacts.cs`
     -->
     <CommonTargetFramework>net8.0</CommonTargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
     <UseArtifactsOutput>true</UseArtifactsOutput>
     <ArtifactsPath>$(MSBuildThisFileDirectory)artifacts</ArtifactsPath>
   </PropertyGroup>

data/helpers/lib/NuGetUpdater/Directory.Packages.props

@@ -0,0 +1,26 @@
+<Project>
+
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="DiffPlex" Version="1.7.1" />
+
+    <PackageVersion Include="GuiLabs.Language.Xml" Version="1.2.60" />
+
+    <PackageVersion Include="Microsoft.Build.Locator" Version="1.6.1" />
+    <PackageVersion Include="Microsoft.Build" Version="17.5.0" ExcludeAssets="Runtime" PrivateAssets="All" />
+    <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="17.5.0" ExcludeAssets="Runtime" PrivateAssets="All" />
+
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+
+    <PackageVersion Include="NuGet.Core" Version="2.14.0-rtm-832" Aliases="CoreV2" />
+
+    <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+
+    <PackageVersion Include="xunit" Version="2.4.2" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="2.4.5" />
+  </ItemGroup>
+
+</Project>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Commands/DiscoverCommand.cs

@@ -0,0 +1,35 @@
+using System.CommandLine;
+
+using NuGetUpdater.Core;
+using NuGetUpdater.Core.Discover;
+
+namespace NuGetUpdater.Cli.Commands;
+
+internal static class DiscoverCommand
+{
+    internal static readonly Option<DirectoryInfo> RepoRootOption = new("--repo-root", () => new DirectoryInfo(Environment.CurrentDirectory)) { IsRequired = false };
+    internal static readonly Option<FileSystemInfo> WorkspaceOption = new("--workspace") { IsRequired = true };
+    internal static readonly Option<string> OutputOption = new("--output", () => DiscoveryWorker.DiscoveryResultFileName) { IsRequired = false };
+    internal static readonly Option<bool> VerboseOption = new("--verbose", getDefaultValue: () => false);
+
+    internal static Command GetCommand(Action<int> setExitCode)
+    {
+        Command command = new("discover", "Generates a report of the workspace dependencies and where they are located.")
+        {
+            RepoRootOption,
+            WorkspaceOption,
+            OutputOption,
+            VerboseOption
+        };
+
+        command.TreatUnmatchedTokensAsErrors = true;
+
+        command.SetHandler(async (repoRoot, workspace, outputPath, verbose) =>
+        {
+            var worker = new DiscoveryWorker(new Logger(verbose));
+            await worker.RunAsync(repoRoot.FullName, workspace.FullName, outputPath);
+        }, RepoRootOption, WorkspaceOption, OutputOption, VerboseOption);
+
+        return command;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/NuGetUpdater.Cli.csproj

@@ -10,7 +10,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+    <PackageReference Include="System.CommandLine" />
   </ItemGroup>
 
   <ItemGroup>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Program.cs

@@ -1,6 +1,4 @@
-using System;
 using System.CommandLine;
-using System.Threading.Tasks;
 
 using NuGetUpdater.Cli.Commands;
 
@@ -16,16 +14,15 @@ internal sealed class Program
         var command = new RootCommand
         {
             FrameworkCheckCommand.GetCommand(setExitCode),
+            DiscoverCommand.GetCommand(setExitCode),
             UpdateCommand.GetCommand(setExitCode),
         };
         command.TreatUnmatchedTokensAsErrors = true;
 
         var result = await command.InvokeAsync(args);
-        if (result != 0)
-        {
-            exitCode = result;
-        }
 
-        return exitCode;
+        return result == 0
+            ? exitCode
+            : result;
     }
 }

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

@@ -0,0 +1,251 @@
+using System.Collections.Immutable;
+using System.Text;
+
+using NuGetUpdater.Core;
+using NuGetUpdater.Core.Test.Discover;
+
+using Xunit;
+
+namespace NuGetUpdater.Cli.Test;
+
+using TestFile = (string Path, string Content);
+
+public partial class EntryPointTests
+{
+    public class Discover : DiscoveryWorkerTestBase
+    {
+        [Fact]
+        public async Task WithSolution()
+        {
+            string solutionPath = "path/to/solution.sln";
+            await RunAsync(path =>
+            [
+                "discover",
+                "--repo-root",
+                path,
+                "--workspace",
+                path,
+            ],
+            new[]
+            {
+                (solutionPath, """
+                    Microsoft Visual Studio Solution File, Format Version 12.00
+                    # Visual Studio 14
+                    VisualStudioVersion = 14.0.22705.0
+                    MinimumVisualStudioVersion = 10.0.40219.1
+                    Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "my", "my.csproj", "{782E0C0A-10D3-444D-9640-263D03D2B20C}"
+                    EndProject
+                    Global
+                      GlobalSection(SolutionConfigurationPlatforms) = preSolution
+                        Debug|Any CPU = Debug|Any CPU
+                        Release|Any CPU = Release|Any CPU
+                      EndGlobalSection
+                      GlobalSection(ProjectConfigurationPlatforms) = postSolution
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.Build.0 = Release|Any CPU
+                      EndGlobalSection
+                      GlobalSection(SolutionProperties) = preSolution
+                        HideSolutionNode = FALSE
+                      EndGlobalSection
+                    EndGlobal
+                    """),
+                ("path/to/my.csproj", """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                          <HintPath>packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                ("path/to/packages.config", """
+                    <packages>
+                      <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+                    </packages>
+                    """)
+            },
+            expectedResult: new()
+            {
+                FilePath = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "path/to/my.csproj",
+                        TargetFrameworks = ["net45"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 2, // Should we ignore Microsoft.NET.ReferenceAssemblies?
+                        Dependencies = [
+                            new("Newtonsoft.Json", "7.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net45"]),
+                        ],
+                        Properties = [
+                            new("TargetFrameworkVersion", "v4.5", "path/to/my.csproj"),
+                        ],
+                    }
+                ]
+            });
+        }
+
+        [Fact]
+        public async Task WithProject()
+        {
+            var projectPath = "path/to/my.csproj";
+            await RunAsync(path =>
+            [
+                "discover",
+                "--repo-root",
+                path,
+                "--workspace",
+                path,
+            ],
+            new[]
+            {
+                (projectPath, """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                          <HintPath>packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                ("path/to/packages.config", """
+                    <packages>
+                      <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+                    </packages>
+                    """)
+            },
+            expectedResult: new()
+            {
+                FilePath = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = projectPath,
+                        TargetFrameworks = ["net45"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 2, // Should we ignore Microsoft.NET.ReferenceAssemblies?
+                        Dependencies = [
+                            new("Newtonsoft.Json", "7.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net45"])
+                        ],
+                        Properties = [
+                            new("TargetFrameworkVersion", "v4.5", "path/to/my.csproj"),
+                        ],
+                    }
+                ]
+            });
+        }
+
+        [Fact]
+        public async Task WithDirectory()
+        {
+            var workspacePath = "path/to/";
+            await RunAsync(path =>
+            [
+                "discover",
+                "--repo-root",
+                path,
+                "--workspace",
+                Path.Combine(path, workspacePath),
+            ],
+            new[]
+            {
+                ("path/to/my.csproj", """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                          <HintPath>packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                ("path/to/packages.config", """
+                    <packages>
+                      <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+                    </packages>
+                    """)
+            },
+            expectedResult: new()
+            {
+                FilePath = workspacePath,
+                Projects = [
+                    new()
+                    {
+                        FilePath = "my.csproj",
+                        TargetFrameworks = ["net45"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 2, // Should we ignore Microsoft.NET.ReferenceAssemblies?
+                        Dependencies = [
+                            new("Newtonsoft.Json", "7.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net45"])
+                        ],
+                        Properties = [
+                            new("TargetFrameworkVersion", "v4.5", "path/to/my.csproj"),
+                        ],
+                    }
+                ]
+            });
+        }
+
+        private static async Task RunAsync(
+            Func<string, string[]> getArgs,
+            TestFile[] initialFiles,
+            ExpectedWorkspaceDiscoveryResult expectedResult)
+        {
+            var actualResult = await RunDiscoveryAsync(initialFiles, async path =>
+            {
+                var sb = new StringBuilder();
+                var writer = new StringWriter(sb);
+
+                var originalOut = Console.Out;
+                var originalErr = Console.Error;
+                Console.SetOut(writer);
+                Console.SetError(writer);
+
+                try
+                {
+                    var args = getArgs(path);
+                    var result = await Program.Main(args);
+                    if (result != 0)
+                    {
+                        throw new Exception($"Program exited with code {result}.\nOutput:\n\n{sb}");
+                    }
+                }
+                finally
+                {
+                    Console.SetOut(originalOut);
+                    Console.SetError(originalErr);
+                }
+            });
+
+            ValidateWorkspaceResult(expectedResult, actualResult);
+        }
+    }
+}

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.Cli.Test/NuGetUpdater.Cli.Test.csproj

@@ -12,9 +12,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
   </ItemGroup>
 
   <ItemGroup>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Dependency.cs

@@ -1,3 +1,58 @@
+using System.Collections.Immutable;
+
+using NuGetUpdater.Core.Utilities;
+
 namespace NuGetUpdater.Core;
 
-public sealed record Dependency(string Name, string? Version, DependencyType Type, bool IsDevDependency = false, bool IsOverride = false, bool IsUpdate = false);
+public sealed record Dependency(
+    string Name,
+    string? Version,
+    DependencyType Type,
+    EvaluationResult? EvaluationResult = null,
+    ImmutableArray<string>? TargetFrameworks = null,
+    bool IsDevDependency = false,
+    bool IsDirect = false,
+    bool IsTransitive = false,
+    bool IsOverride = false,
+    bool IsUpdate = false) : IEquatable<Dependency>
+{
+    public bool Equals(Dependency? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, other))
+        {
+            return true;
+        }
+
+        return Name == other.Name &&
+               Version == other.Version &&
+               Type == other.Type &&
+               EvaluationResult == other.EvaluationResult &&
+               TargetFrameworks.SequenceEqual(other.TargetFrameworks) &&
+               IsDevDependency == other.IsDevDependency &&
+               IsDirect == other.IsDirect &&
+               IsTransitive == other.IsTransitive &&
+               IsOverride == other.IsOverride &&
+               IsUpdate == other.IsUpdate;
+    }
+
+    public override int GetHashCode()
+    {
+        HashCode hash = new();
+        hash.Add(Name);
+        hash.Add(Version);
+        hash.Add(Type);
+        hash.Add(EvaluationResult);
+        hash.Add(TargetFrameworks);
+        hash.Add(IsDevDependency);
+        hash.Add(IsDirect);
+        hash.Add(IsTransitive);
+        hash.Add(IsOverride);
+        hash.Add(IsUpdate);
+        return hash.ToHashCode();
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/DependencyType.cs

@@ -3,7 +3,7 @@ namespace NuGetUpdater.Core;
 public enum DependencyType
 {
     Unknown,
-    PackageConfig,
+    PackagesConfig,
     PackageReference,
     PackageVersion,
     GlobalPackageReference,

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

@@ -0,0 +1,69 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+internal static class DirectoryPackagesPropsDiscovery
+{
+    public static DirectoryPackagesPropsDiscoveryResult? Discover(string repoRootPath, string workspacePath, ImmutableArray<ProjectDiscoveryResult> projectResults, Logger logger)
+    {
+        var projectResult = projectResults.FirstOrDefault(
+            p => p.Properties.FirstOrDefault(prop => prop.Name.Equals("ManagePackageVersionsCentrally", StringComparison.OrdinalIgnoreCase)) is Property property
+                && string.Equals(property.Value, "true", StringComparison.OrdinalIgnoreCase));
+        if (projectResult is null)
+        {
+            logger.Log("  Central Package Management is not enabled.");
+            return null;
+        }
+
+        var projectFilePath = Path.GetFullPath(projectResult.FilePath, workspacePath);
+        if (!MSBuildHelper.TryGetDirectoryPackagesPropsPath(repoRootPath, projectFilePath, out var directoryPackagesPropsPath))
+        {
+            logger.Log("  No Directory.Packages.props file found.");
+            return null;
+        }
+
+        var relativeDirectoryPackagesPropsPath = Path.GetRelativePath(workspacePath, directoryPackagesPropsPath);
+        var directoryPackagesPropsFile = projectResults.FirstOrDefault(p => p.FilePath.Equals(relativeDirectoryPackagesPropsPath, StringComparison.OrdinalIgnoreCase));
+        if (directoryPackagesPropsFile is null)
+        {
+            logger.Log($"  No project file found for [{relativeDirectoryPackagesPropsPath}].");
+            return null;
+        }
+
+        logger.Log($"  Discovered [{directoryPackagesPropsFile.FilePath}] file.");
+
+        var isTransitivePinningEnabled = projectResult.Properties.FirstOrDefault(prop => prop.Name.Equals("EnableTransitivePinning", StringComparison.OrdinalIgnoreCase)) is Property property
+            && string.Equals(property.Value, "true", StringComparison.OrdinalIgnoreCase);
+        var properties = projectResult.Properties.ToImmutableDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
+        var dependencies = GetDependencies(workspacePath, directoryPackagesPropsPath, properties)
+            .OrderBy(d => d.Name)
+            .ToImmutableArray();
+
+        return new()
+        {
+            FilePath = directoryPackagesPropsFile.FilePath,
+            IsTransitivePinningEnabled = isTransitivePinningEnabled,
+            Dependencies = dependencies,
+        };
+    }
+
+    private static IEnumerable<Dependency> GetDependencies(string workspacePath, string directoryPackagesPropsPath, ImmutableDictionary<string, Property> properties)
+    {
+        var dependencies = ProjectBuildFile.Open(workspacePath, directoryPackagesPropsPath).GetDependencies();
+        return dependencies.Select(d =>
+        {
+            if (d.Version == null)
+            {
+                return d;
+            }
+
+            var evaluation = MSBuildHelper.GetEvaluatedValue(d.Version, properties);
+            return d with
+            {
+                Version = evaluation.EvaluatedValue,
+                EvaluationResult = evaluation,
+                IsDirect = true,
+            };
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public sealed record DirectoryPackagesPropsDiscoveryResult : IDiscoveryResultWithDependencies
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public bool IsTransitivePinningEnabled { get; init; }
+    public ImmutableArray<Dependency> Dependencies { get; init; }
+}