dependabot-nuget 0.240.0 → 0.241.0

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

@@ -0,0 +1,31 @@
+using System;
+using System.CommandLine;
+using System.Threading.Tasks;
+
+using NuGetUpdater.Cli.Commands;
+
+namespace NuGetUpdater.Cli;
+
+internal sealed class Program
+{
+    internal static async Task<int> Main(string[] args)
+    {
+        var exitCode = 0;
+        Action<int> setExitCode = (int code) => exitCode = code;
+
+        var command = new RootCommand()
+        {
+            FrameworkCheckCommand.GetCommand(setExitCode),
+            UpdateCommand.GetCommand(setExitCode),
+        };
+        command.TreatUnmatchedTokensAsErrors = true;
+
+        var result = await command.InvokeAsync(args);
+        if (result != 0)
+        {
+            exitCode = result;
+        }
+
+        return exitCode;
+    }
+}

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

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+using Xunit;
+
+namespace NuGetUpdater.Cli.Test;
+
+public partial class EntryPointTests
+{
+    public class FrameworkCheck
+    {
+        [Theory]
+        [InlineData("net7.0", "net5.0")]
+        [InlineData("net7.0 net472", "net5.0 net461")]
+        [InlineData("net7.0 net472", "netstandard2.0")]
+        public Task Compatible(string projectTfms, string packageTfms)
+            => Run(projectTfms, packageTfms, expectedExitCode: 0);
+
+        [Theory]
+        [InlineData("net5.0", "net7.0")]
+        [InlineData("net5.0 net461", "net7.0 net472")]
+        [InlineData("net5.0 net45", "netstandard2.0")]
+        public Task Incompatible(string projectTfms, string packageTfms)
+            => Run(projectTfms, packageTfms, expectedExitCode: 1);
+
+        private static async Task Run(string projectTfms, string packageTfms, int expectedExitCode)
+        {
+            var args = new List<string>();
+            args.Add("framework-check");
+            args.Add("--project-tfms");
+            args.AddRange(projectTfms.Split(' ', StringSplitOptions.TrimEntries));
+            args.Add("--package-tfms");
+            args.AddRange(packageTfms.Split(' ', StringSplitOptions.TrimEntries));
+            args.Add("--verbose");
+
+            var actual = await Program.Main(args.ToArray());
+
+            Assert.Equal(expectedExitCode, actual);
+        }
+    }
+}

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

@@ -0,0 +1,323 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+using NuGetUpdater.Core.Test.Update;
+
+using Xunit;
+
+namespace NuGetUpdater.Cli.Test;
+
+public partial class EntryPointTests
+{
+    public class Update : UpdateWorkerTestBase
+    {
+        [Fact]
+        public async Task WithSolution()
+        {
+            await Run(path => new[]
+            {
+                "update",
+                "--repo-root",
+                path,
+                "--solution-or-project",
+                Path.Combine(path, "path/to/solution.sln"),
+                "--dependency",
+                "Newtonsoft.Json",
+                "--new-version",
+                "13.0.1",
+                "--previous-version",
+                "7.0.1",
+            },
+            new[]
+            {
+                ("path/to/solution.sln", """
+                    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>
+                    """)
+            },
+            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=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                          <HintPath>packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                ("path/to/packages.config", """
+                    <?xml version="1.0" encoding="utf-8"?>
+                    <packages>
+                      <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
+                    </packages>
+                    """)
+            });
+        }
+
+        [Fact]
+        public async Task WithProject()
+        {
+            await Run(path => new[]
+            {
+                "update",
+                "--repo-root",
+                path,
+                "--solution-or-project",
+                Path.Combine(path, "path/to/my.csproj"),
+                "--dependency",
+                "Newtonsoft.Json",
+                "--new-version",
+                "13.0.1",
+                "--previous-version",
+                "7.0.1",
+                "--verbose"
+            },
+            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>
+                    """)
+            },
+            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=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                          <HintPath>packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                ("path/to/packages.config", """
+                    <?xml version="1.0" encoding="utf-8"?>
+                    <packages>
+                      <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
+                    </packages>
+                    """)
+            });
+        }
+
+        [Fact]
+        public async Task WithDirsProjAndDirectoryBuildPropsThatIsOutOfDirectoryButStillMatchingThePackage()
+        {
+            await Run(path => new[]
+                {
+                    "update",
+                    "--repo-root", path,
+                    "--solution-or-project", $"{path}/some-dir/dirs.proj",
+                    "--dependency", "NuGet.Versioning",
+                    "--new-version", "6.6.1",
+                    "--previous-version", "6.1.0",
+                    "--verbose"
+                },
+                initialFiles: new[]
+                {
+                    ("some-dir/dirs.proj", """
+                        <Project Sdk="Microsoft.Build.Traversal">
+                          <ItemGroup>
+                            <ProjectFile Include="project1/project.csproj" />
+                            <ProjectReference Include="project2/project.csproj" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("some-dir/project1/project.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <OutputType>Exe</OutputType>
+                            <TargetFramework>net6.0</TargetFramework>
+                            <ImplicitUsings>enable</ImplicitUsings>
+                            <Nullable>enable</Nullable>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="NuGet.Versioning" Version="6.1.0" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("some-dir/project2/project.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <OutputType>Exe</OutputType>
+                            <TargetFramework>net6.0</TargetFramework>
+                            <ImplicitUsings>enable</ImplicitUsings>
+                            <Nullable>enable</Nullable>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="NuGet.Versioning" Version="6.1.0" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("other-dir/Directory.Build.props", """
+                        <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+                          <ItemGroup>
+                            <PackageReference Include="NuGet.Versioning" Version="6.1.0" />
+                          </ItemGroup>
+
+                        </Project>
+                        """)
+                },
+                expectedFiles: new[]
+                {
+                    ("some-dir/dirs.proj", """
+                        <Project Sdk="Microsoft.Build.Traversal">
+                          <ItemGroup>
+                            <ProjectFile Include="project1/project.csproj" />
+                            <ProjectReference Include="project2/project.csproj" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("some-dir/project1/project.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <OutputType>Exe</OutputType>
+                            <TargetFramework>net6.0</TargetFramework>
+                            <ImplicitUsings>enable</ImplicitUsings>
+                            <Nullable>enable</Nullable>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="NuGet.Versioning" Version="6.6.1" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("some-dir/project2/project.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <OutputType>Exe</OutputType>
+                            <TargetFramework>net6.0</TargetFramework>
+                            <ImplicitUsings>enable</ImplicitUsings>
+                            <Nullable>enable</Nullable>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="NuGet.Versioning" Version="6.6.1" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("other-dir/Directory.Build.props", """
+                        <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+                          <ItemGroup>
+                            <PackageReference Include="NuGet.Versioning" Version="6.1.0" />
+                          </ItemGroup>
+
+                        </Project>
+                        """)
+                }
+            );
+        }
+
+        private static async Task Run(Func<string, string[]> getArgs, (string Path, string Content)[] initialFiles, (string, string)[] expectedFiles)
+        {
+            var actualFiles = await RunUpdate(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);
+                }
+            });
+
+            AssertContainsFiles(expectedFiles, actualFiles);
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>$(CommonTargetFramework)</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NuGetUpdater.Cli\NuGetUpdater.Cli.csproj" />
+    <ProjectReference Include="..\NuGetUpdater.Core.Test\NuGetUpdater.Core.Test.csproj" />
+  </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" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,3 @@
+namespace NuGetUpdater.Core;
+
+public sealed record Dependency(string Name, string? Version, DependencyType Type, bool IsDevDependency = false, bool IsOverride = false);

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

@@ -0,0 +1,12 @@
+namespace NuGetUpdater.Core;
+
+public enum DependencyType
+{
+    Unknown,
+    PackageConfig,
+    PackageReference,
+    PackageVersion,
+    GlobalPackageReference,
+    DotNetTool,
+    MSBuildSdk
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/BuildFile.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+using DiffPlex;
+using DiffPlex.DiffBuilder;
+using DiffPlex.DiffBuilder.Model;
+
+namespace NuGetUpdater.Core;
+
+internal abstract class BuildFile
+{
+    public string RepoRootPath { get; }
+    public string Path { get; }
+    public string RepoRelativePath => System.IO.Path.GetRelativePath(RepoRootPath, Path);
+
+    public BuildFile(string repoRootPath, string path)
+    {
+        RepoRootPath = repoRootPath;
+        Path = path;
+    }
+
+    public abstract Task<bool> SaveAsync();
+
+    public static IEnumerable<Dependency> GetDependencies(BuildFile buildFile)
+    {
+        return buildFile switch
+        {
+            ProjectBuildFile projectBuildFile => projectBuildFile.GetDependencies(),
+            PackagesConfigBuildFile packagesConfigBuildFile => packagesConfigBuildFile.GetDependencies(),
+            GlobalJsonBuildFile globalJsonBuildFile => globalJsonBuildFile.GetDependencies(),
+            DotNetToolsJsonBuildFile dotnetToolsJsonBuildFile => dotnetToolsJsonBuildFile.GetDependencies(),
+            _ => throw new NotSupportedException($"Build files of type [{buildFile.GetType().Name}] are not supported.")
+        };
+    }
+}
+
+internal abstract partial class BuildFile<T>
+    : BuildFile where T : class
+{
+    public T Contents { get; private set; }
+
+    private string _originalContentsText;
+
+    public BuildFile(string repoRootPath, string path, T contents) : base(repoRootPath, path)
+    {
+        Contents = contents;
+        _originalContentsText = GetContentsString(contents);
+    }
+
+    public void Update(T contents)
+    {
+        Contents = contents;
+    }
+
+    public override async Task<bool> SaveAsync()
+    {
+        var currentContentsText = GetContentsString(Contents);
+
+        if (!HasAnyNonWhitespaceChanges(_originalContentsText, currentContentsText))
+        {
+            return false;
+        }
+
+        await File.WriteAllTextAsync(Path, currentContentsText);
+        _originalContentsText = currentContentsText;
+        return true;
+    }
+
+    protected abstract string GetContentsString(T contents);
+
+    private static bool HasAnyNonWhitespaceChanges(string oldText, string newText)
+    {
+        // Ignore white space
+        oldText = WhitespaceRegex().Replace(oldText, string.Empty);
+        newText = WhitespaceRegex().Replace(newText, string.Empty);
+
+        var diffBuilder = new InlineDiffBuilder(new Differ());
+        var diff = diffBuilder.BuildDiffModel(oldText, newText);
+        foreach (var line in diff.Lines)
+        {
+            if (line.Type is ChangeType.Inserted ||
+                line.Type is ChangeType.Deleted ||
+                line.Type is ChangeType.Modified)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    [GeneratedRegex("\\s+")]
+    private static partial Regex WhitespaceRegex();
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/DotNetToolsJsonBuildFile.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json.Nodes;
+
+namespace NuGetUpdater.Core;
+
+internal sealed class DotNetToolsJsonBuildFile : JsonBuildFile
+{
+    public static DotNetToolsJsonBuildFile Open(string repoRootPath, string path)
+        => new(repoRootPath, path, File.ReadAllText(path));
+
+    public DotNetToolsJsonBuildFile(string repoRootPath, string path, string contents)
+        : base(repoRootPath, path, contents)
+    {
+    }
+
+    public IEnumerable<KeyValuePair<string, JsonNode?>> Tools
+        => Node.Value?["tools"]?.AsObject().ToArray() ?? Enumerable.Empty<KeyValuePair<string, JsonNode?>>();
+
+    public IEnumerable<Dependency> GetDependencies() => Tools.Select(
+        t => new Dependency(t.Key, t.Value?.AsObject()["version"]?.GetValue<string>() ?? string.Empty, DependencyType.DotNetTool));
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/GlobalJsonBuildFile.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json.Nodes;
+
+namespace NuGetUpdater.Core;
+
+internal sealed class GlobalJsonBuildFile : JsonBuildFile
+{
+    public static GlobalJsonBuildFile Open(string repoRootPath, string path)
+        => new(repoRootPath, path, File.ReadAllText(path));
+
+    public GlobalJsonBuildFile(string repoRootPath, string path, string contents)
+        : base(repoRootPath, path, contents)
+    {
+    }
+
+    public JsonObject? Sdk => Node.Value?["sdk"]?.AsObject();
+
+    public JsonObject? MSBuildSdks =>
+        Node.Value?["msbuild-sdks"]?.AsObject();
+
+    public IEnumerable<Dependency> GetDependencies() => MSBuildSdks?.AsObject().Select(
+        t => new Dependency(t.Key, t.Value?.GetValue<string>() ?? string.Empty, DependencyType.MSBuildSdk)) ?? Enumerable.Empty<Dependency>();
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/JsonBuildFile.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Text.Json.Nodes;
+
+using NuGetUpdater.Core.Utilities;
+
+namespace NuGetUpdater.Core;
+
+internal abstract class JsonBuildFile : BuildFile<string>
+{
+    protected Lazy<JsonNode?> Node;
+
+    public JsonBuildFile(string repoRootPath, string path, string contents)
+        : base(repoRootPath, path, contents)
+    {
+        Node = new Lazy<JsonNode?>(() => null);
+        ResetNode();
+    }
+
+    protected override string GetContentsString(string _contents) => Contents;
+
+    public void UpdateProperty(string[] propertyPath, string newValue)
+    {
+        var updatedContents = JsonHelper.UpdateJsonProperty(Contents, propertyPath, newValue, StringComparison.OrdinalIgnoreCase);
+        Update(updatedContents);
+        ResetNode();
+    }
+
+    private void ResetNode()
+    {
+        Node = new Lazy<JsonNode?>(() => JsonHelper.ParseNode(Contents));
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/PackagesConfigBuildFile.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core;
+
+internal sealed class PackagesConfigBuildFile : XmlBuildFile
+{
+    public static PackagesConfigBuildFile Open(string repoRootPath, string path)
+        => Parse(repoRootPath, path, File.ReadAllText(path));
+    public static PackagesConfigBuildFile Parse(string repoRootPath, string path, string xml)
+        => new(repoRootPath, path, Parser.ParseText(xml));
+
+    public PackagesConfigBuildFile(string repoRootPath, string path, XmlDocumentSyntax contents)
+        : base(repoRootPath, path, contents)
+    {
+    }
+
+    public IEnumerable<IXmlElementSyntax> Packages => Contents.RootSyntax.GetElements("package", StringComparison.OrdinalIgnoreCase);
+
+    public IEnumerable<Dependency> GetDependencies() => Packages
+        .Where(p => p.GetAttribute("id") is not null && p.GetAttribute("version") is not null)
+        .Select(p => new Dependency(
+            p.GetAttributeValue("id", StringComparison.OrdinalIgnoreCase),
+            p.GetAttributeValue("version", StringComparison.OrdinalIgnoreCase),
+            DependencyType.PackageConfig,
+            (p.GetAttribute("developmentDependency", StringComparison.OrdinalIgnoreCase)?.Value ?? "false").Equals(true.ToString(), StringComparison.OrdinalIgnoreCase)));
+}