dependabot-nuget 0.288.0 → 0.290.0

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

@@ -30,7 +30,7 @@ internal static class PackageReferenceUpdater
         ILogger logger)
     {
         // PackageReference project; modify the XML directly
-        logger.Log("  Running 'PackageReference' project direct XML update");
+        logger.Info("  Running 'PackageReference' project direct XML update");
 
         (ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
 
@@ -61,6 +61,11 @@ internal static class PackageReferenceUpdater
         }
         else
         {
+            if (peerDependencies is null)
+            {
+                return;
+            }
+
             await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, logger);
         }
 
@@ -105,7 +110,7 @@ internal static class PackageReferenceUpdater
                 var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, topLevelDependencies, dependenciesToUpdate, logger);
                 if (resolvedDependencies is null)
                 {
-                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    logger.Warn($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
                     continue;
                 }
 
@@ -184,14 +189,14 @@ internal static class PackageReferenceUpdater
         // Skip updating the project if the dependency does not exist in the graph
         if (!packageFound)
         {
-            logger.Log($"    Package [{dependencyName}] Does not exist as a dependency in [{projectPath}].");
+            logger.Info($"    Package [{dependencyName}] Does not exist as a dependency in [{projectPath}].");
             return false;
         }
 
         // Skip updating the project if the dependency version meets or exceeds the newDependencyVersion
         if (!needsUpdate)
         {
-            logger.Log($"    Package [{dependencyName}] already meets the requested dependency version in [{projectPath}].");
+            logger.Info($"    Package [{dependencyName}] already meets the requested dependency version in [{projectPath}].");
             return false;
         }
 
@@ -242,7 +247,7 @@ internal static class PackageReferenceUpdater
                                               a.Value.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)))
             .FirstOrDefault();
 
-        logger.Log($"    Pinning [{dependencyName}/{newDependencyVersion}] as a package version.");
+        logger.Info($"    Pinning [{dependencyName}/{newDependencyVersion}] as a package version.");
 
         var lastPackageVersion = directoryPackages.ItemNodes
             .Where(e => e.Name.Equals("PackageVersion", StringComparison.OrdinalIgnoreCase))
@@ -250,7 +255,7 @@ internal static class PackageReferenceUpdater
 
         if (lastPackageVersion is null)
         {
-            logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not pinned.");
+            logger.Info($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not pinned.");
             return;
         }
 
@@ -260,7 +265,7 @@ internal static class PackageReferenceUpdater
         if (existingPackageVersionElement is null)
         {
             // need to add a new entry
-            logger.Log("      New PackageVersion element added.");
+            logger.Info("      New PackageVersion element added.");
             var leadingTrivia = lastPackageVersion.AsNode.GetLeadingTrivia();
             var packageVersionElement = XmlExtensions.CreateSingleLineXmlElementSyntax("PackageVersion", new SyntaxList<SyntaxNode>(leadingTrivia))
                 .WithAttribute("Include", dependencyName)
@@ -274,19 +279,19 @@ internal static class PackageReferenceUpdater
             if (versionAttribute is null)
             {
                 // need to add the version
-                logger.Log("      Adding version attribute to element.");
+                logger.Info("      Adding version attribute to element.");
                 updatedPackageVersionElement = existingPackageVersionElement.WithAttribute("Version", newDependencyVersion);
             }
             else if (!versionAttribute.Value.Equals(newDependencyVersion, StringComparison.OrdinalIgnoreCase))
             {
                 // need to update the version
-                logger.Log($"      Updating version attribute of [{versionAttribute.Value}].");
+                logger.Info($"      Updating version attribute of [{versionAttribute.Value}].");
                 var updatedVersionAttribute = versionAttribute.WithValue(newDependencyVersion);
                 updatedPackageVersionElement = existingPackageVersionElement.ReplaceAttribute(versionAttribute, updatedVersionAttribute);
             }
             else
             {
-                logger.Log("      Existing PackageVersion element version was already correct.");
+                logger.Info("      Existing PackageVersion element version was already correct.");
                 return;
             }
 
@@ -302,14 +307,14 @@ internal static class PackageReferenceUpdater
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
         {
-            logger.Log($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
+            logger.Info($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
 
             // see https://learn.microsoft.com/nuget/consume-packages/install-use-packages-dotnet-cli
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["add", projectPath, "package", dependencyName, "--version", newDependencyVersion], workingDirectory: projectDirectory);
             MSBuildHelper.ThrowOnUnauthenticatedFeed(stdout);
             if (exitCode != 0)
             {
-                logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
+                logger.Warn($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
             }
 
             return exitCode;
@@ -339,7 +344,7 @@ internal static class PackageReferenceUpdater
         var unupgradableTfms = tfmsAndDependencies.Where(kvp => !kvp.Value.Any()).Select(kvp => kvp.Key);
         if (unupgradableTfms.Any())
         {
-            logger.Log($"    The following target frameworks could not find packages to upgrade: {string.Join(", ", unupgradableTfms)}");
+            logger.Info($"    The following target frameworks could not find packages to upgrade: {string.Join(", ", unupgradableTfms)}");
             return null;
         }
 
@@ -354,7 +359,7 @@ internal static class PackageReferenceUpdater
                 if (packagesAndVersions.TryGetValue(packageName, out var existingVersion) &&
                     existingVersion != packageVersion)
                 {
-                    logger.Log($"    Package [{packageName}] tried to update to version [{packageVersion}], but found conflicting package version of [{existingVersion}].");
+                    logger.Info($"    Package [{packageName}] tried to update to version [{packageVersion}], but found conflicting package version of [{existingVersion}].");
                     conflictingPackageVersionsFound = true;
                 }
                 else
@@ -387,7 +392,7 @@ internal static class PackageReferenceUpdater
         var result = TryUpdateDependencyVersion(buildFiles, dependencyName, previousDependencyVersion, newDependencyVersion, logger);
         if (result == UpdateResult.NotFound)
         {
-            logger.Log($"    Root package [{dependencyName}/{previousDependencyVersion}] was not updated; skipping dependencies.");
+            logger.Info($"    Root package [{dependencyName}/{previousDependencyVersion}] was not updated; skipping dependencies.");
             return;
         }
 
@@ -405,7 +410,7 @@ internal static class PackageReferenceUpdater
                 var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflictsWithBruteForce(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, logger);
                 if (resolvedDependencies is null)
                 {
-                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    logger.Info($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
                     continue;
                 }
 
@@ -413,13 +418,13 @@ internal static class PackageReferenceUpdater
                 var specificResolvedDependency = resolvedDependencies.Where(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
                 if (specificResolvedDependency is null)
                 {
-                    logger.Log($"    Unable to resolve requested dependency for {dependencyName} in {projectFile.Path}.");
+                    logger.Info($"    Unable to resolve requested dependency for {dependencyName} in {projectFile.Path}.");
                     continue;
                 }
 
                 if (!newDependencyVersion.Equals(specificResolvedDependency.Version, StringComparison.OrdinalIgnoreCase))
                 {
-                    logger.Log($"    Inconsistent resolution for {dependencyName}; attempted upgrade to {newDependencyVersion} but resolved {specificResolvedDependency.Version}.");
+                    logger.Info($"    Inconsistent resolution for {dependencyName}; attempted upgrade to {newDependencyVersion} but resolved {specificResolvedDependency.Version}.");
                     continue;
                 }
 
@@ -476,12 +481,12 @@ internal static class PackageReferenceUpdater
                         var currentVersion = versionAttribute.Value.TrimStart('[', '(').TrimEnd(']', ')');
                         if (currentVersion.Contains(',') || currentVersion.Contains('*'))
                         {
-                            logger.Log($"    Found unsupported [{packageNode.Name}] version attribute value [{versionAttribute.Value}] in [{buildFile.RelativePath}].");
+                            logger.Warn($"    Found unsupported [{packageNode.Name}] version attribute value [{versionAttribute.Value}] in [{buildFile.RelativePath}].");
                             foundUnsupported = true;
                         }
                         else if (string.Equals(currentVersion, previousDependencyVersion, StringComparison.Ordinal))
                         {
-                            logger.Log($"    Found incorrect [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found incorrect [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
                             updateNodes.Add(versionAttribute);
                         }
                         else if (previousDependencyVersion == null && NuGetVersion.TryParse(currentVersion, out var previousVersion))
@@ -491,13 +496,13 @@ internal static class PackageReferenceUpdater
                             {
                                 previousPackageVersion = currentVersion;
 
-                                logger.Log($"    Found incorrect peer [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
+                                logger.Info($"    Found incorrect peer [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
                                 updateNodes.Add(versionAttribute);
                             }
                         }
                         else if (string.Equals(currentVersion, newDependencyVersion, StringComparison.Ordinal))
                         {
-                            logger.Log($"    Found correct [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found correct [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
                             foundCorrect = true;
                         }
                     }
@@ -514,12 +519,12 @@ internal static class PackageReferenceUpdater
                         var currentVersion = versionValue.TrimStart('[', '(').TrimEnd(']', ')');
                         if (currentVersion.Contains(',') || currentVersion.Contains('*'))
                         {
-                            logger.Log($"    Found unsupported [{packageNode.Name}] version node value [{versionValue}] in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found unsupported [{packageNode.Name}] version node value [{versionValue}] in [{buildFile.RelativePath}].");
                             foundUnsupported = true;
                         }
                         else if (currentVersion == previousDependencyVersion)
                         {
-                            logger.Log($"    Found incorrect [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found incorrect [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
                             if (versionElement is XmlElementSyntax elementSyntax)
                             {
                                 updateNodes.Add(elementSyntax);
@@ -536,7 +541,7 @@ internal static class PackageReferenceUpdater
                             {
                                 previousPackageVersion = currentVersion;
 
-                                logger.Log($"    Found incorrect peer [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
+                                logger.Info($"    Found incorrect peer [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
                                 if (versionElement is XmlElementSyntax elementSyntax)
                                 {
                                     updateNodes.Add(elementSyntax);
@@ -550,7 +555,7 @@ internal static class PackageReferenceUpdater
                         }
                         else if (currentVersion == newDependencyVersion)
                         {
-                            logger.Log($"    Found correct [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found correct [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
                             foundCorrect = true;
                         }
                     }
@@ -558,7 +563,7 @@ internal static class PackageReferenceUpdater
                 else
                 {
                     // We weren't able to find the version node. Central package management?
-                    logger.Log("    Found package reference but was unable to locate version information.");
+                    logger.Warn("    Found package reference but was unable to locate version information.");
                 }
             }
 
@@ -626,12 +631,12 @@ internal static class PackageReferenceUpdater
                         var currentVersion = propertyContents.TrimStart('[', '(').TrimEnd(']', ')');
                         if (currentVersion.Contains(',') || currentVersion.Contains('*'))
                         {
-                            logger.Log($"    Found unsupported version property [{propertyElement.Name}] value [{propertyContents}] in [{buildFile.RelativePath}].");
+                            logger.Warn($"    Found unsupported version property [{propertyElement.Name}] value [{propertyContents}] in [{buildFile.RelativePath}].");
                             foundUnsupported = true;
                         }
                         else if (currentVersion == previousDependencyVersion)
                         {
-                            logger.Log($"    Found incorrect version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found incorrect version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
                             updateProperties.Add((XmlElementSyntax)propertyElement.AsNode);
                         }
                         else if (previousDependencyVersion is null && NuGetVersion.TryParse(currentVersion, out var previousVersion))
@@ -641,13 +646,13 @@ internal static class PackageReferenceUpdater
                             {
                                 previousPackageVersion = currentVersion;
 
-                                logger.Log($"    Found incorrect peer version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
+                                logger.Info($"    Found incorrect peer version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
                                 updateProperties.Add((XmlElementSyntax)propertyElement.AsNode);
                             }
                         }
                         else if (currentVersion == newDependencyVersion)
                         {
-                            logger.Log($"    Found correct version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found correct version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
                             foundCorrect = true;
                         }
                     }
@@ -701,7 +706,7 @@ internal static class PackageReferenceUpdater
             var dependenciesAreCoherent = await MSBuildHelper.DependenciesAreCoherentAsync(repoRootPath, projectPath, tfm, updatedPackages, logger);
             if (!dependenciesAreCoherent)
             {
-                logger.Log($"    Package [{dependencyName}] could not be updated in [{projectPath}] because it would cause a dependency conflict.");
+                logger.Warn($"    Package [{dependencyName}] could not be updated in [{projectPath}] because it would cause a dependency conflict.");
                 return false;
             }
         }
@@ -715,7 +720,7 @@ internal static class PackageReferenceUpdater
         {
             if (await buildFile.SaveAsync())
             {
-                logger.Log($"    Saved [{buildFile.RelativePath}].");
+                logger.Info($"    Saved [{buildFile.RelativePath}].");
             }
         }
     }

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

@@ -9,6 +9,7 @@ using Microsoft.Language.Xml;
 using NuGet.CommandLine;
 
 using NuGetUpdater.Core.Updater;
+using NuGetUpdater.Core.Utilities;
 
 using Console = System.Console;
 
@@ -22,7 +23,7 @@ namespace NuGetUpdater.Core;
 /// See: https://learn.microsoft.com/en-us/nuget/reference/packages-config
 ///      https://learn.microsoft.com/en-us/nuget/resources/check-project-format
 /// <remarks>
-internal static class PackagesConfigUpdater
+internal static partial class PackagesConfigUpdater
 {
     public static async Task UpdateDependencyAsync(
         string repoRootPath,
@@ -35,18 +36,18 @@ internal static class PackagesConfigUpdater
     )
     {
         // packages.config project; use NuGet.exe to perform update
-        logger.Log($"  Found '{NuGetHelper.PackagesConfigFileName}' project; running NuGet.exe update");
+        logger.Info($"  Found '{ProjectHelper.PackagesConfigFileName}' project; running NuGet.exe update");
 
         // ensure local packages directory exists
         var projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
         var packagesSubDirectory = GetPathToPackagesDirectory(projectBuildFile, dependencyName, previousDependencyVersion, packagesConfigPath);
         if (packagesSubDirectory is null)
         {
-            logger.Log($"    Project [{projectPath}] does not reference this dependency.");
+            logger.Info($"    Project [{projectPath}] does not reference this dependency.");
             return;
         }
 
-        logger.Log($"    Using packages directory [{packagesSubDirectory}] for project [{projectPath}].");
+        logger.Info($"    Using packages directory [{packagesSubDirectory}] for project [{projectPath}].");
 
         var projectDirectory = Path.GetDirectoryName(projectPath);
         var packagesDirectory = PathHelper.JoinPath(projectDirectory, packagesSubDirectory);
@@ -74,7 +75,7 @@ internal static class PackagesConfigUpdater
             "-NonInteractive",
         };
 
-        logger.Log("    Finding MSBuild...");
+        logger.Info("    Finding MSBuild...");
         var msbuildDirectory = MSBuildHelper.MSBuildPath;
         if (msbuildDirectory is not null)
         {
@@ -96,7 +97,7 @@ internal static class PackagesConfigUpdater
         // Update binding redirects
         await BindingRedirectManager.UpdateBindingRedirectsAsync(projectBuildFile, dependencyName, newDependencyVersion);
 
-        logger.Log("    Writing project file back to disk");
+        logger.Info("    Writing project file back to disk");
         await projectBuildFile.SaveAsync();
     }
 
@@ -118,12 +119,12 @@ internal static class PackagesConfigUpdater
             var retryingAfterRestore = false;
 
         doRestore:
-            logger.Log($"    Running NuGet.exe with args: {string.Join(" ", updateArgs)}");
+            logger.Info($"    Running NuGet.exe with args: {string.Join(" ", updateArgs)}");
             outputBuilder.Clear();
             var result = Program.Main(updateArgs.ToArray());
             var fullOutput = outputBuilder.ToString();
-            logger.Log($"    Result: {result}");
-            logger.Log($"    Output:\n{fullOutput}");
+            logger.Info($"    Result: {result}");
+            logger.Info($"    Output:\n{fullOutput}");
             if (result != 0)
             {
                 // The initial `update` command can fail for several reasons:
@@ -140,7 +141,7 @@ internal static class PackagesConfigUpdater
                 if (!retryingAfterRestore && OutputIndicatesRestoreIsRequired(fullOutput))
                 {
                     retryingAfterRestore = true;
-                    logger.Log($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
+                    logger.Info($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
                     outputBuilder.Clear();
                     var exitCodeAgain = Program.Main(restoreArgs.ToArray());
                     var restoreOutput = outputBuilder.ToString();
@@ -164,7 +165,7 @@ internal static class PackagesConfigUpdater
         }
         catch (Exception e)
         {
-            logger.Log($"Error: {e}");
+            logger.Info($"Error: {e}");
             throw;
         }
         finally
@@ -178,7 +179,7 @@ internal static class PackagesConfigUpdater
             var deltaSpawnedProcesses = currentSpawnedProcesses.Except(existingSpawnedProcesses).ToArray();
             foreach (var credProvider in deltaSpawnedProcesses)
             {
-                logger.Log($"Ending spawned credential provider process");
+                logger.Info($"Ending spawned credential provider process");
                 credProvider.Kill();
             }
         }
@@ -214,7 +215,7 @@ internal static class PackagesConfigUpdater
         var hintPathSubString = $"{dependencyName}.{dependencyVersion}";
 
         string? partialPathMatch = null;
-        var specificHintPathNodes = projectBuildFile.Contents.Descendants().Where(e => e.IsHintPathNodeForDependency(dependencyName)).ToArray();
+        var specificHintPathNodes = projectBuildFile.Contents.Descendants().Where(e => e.IsHintPathNodeForDependency(dependencyName, dependencyVersion)).ToArray();
         foreach (var hintPathNode in specificHintPathNodes)
         {
             var hintPath = hintPathNode.GetContentValue();
@@ -265,8 +266,7 @@ internal static class PackagesConfigUpdater
                     foreach (var hintPathNode in genericHintPathNodes)
                     {
                         var hintPath = hintPathNode.GetContentValue();
-                        var match = Regex.Match(hintPath, @"^(?<PackagesPath>.*)[/\\](?<PackageNameAndVersion>[^/\\]+)[/\\]lib[/\\](?<Tfm>[^/\\]+)[/\\](?<AssemblyName>[^/\\]+)$");
-                        // e.g.,                              ..\..\packages     \    Some.Package.1.2.3              \    lib\     net45          \   Some.Package.dll
+                        var match = PackageAssemblyHintPathPattern().Match(hintPath);
                         if (match.Success)
                         {
                             partialPathMatch = match.Groups["PackagesPath"].Value;
@@ -296,17 +296,15 @@ internal static class PackagesConfigUpdater
         return false;
     }
 
-    private static bool IsHintPathNodeForDependency(this IXmlElementSyntax element, string dependencyName)
+    private static bool IsHintPathNodeForDependency(this IXmlElementSyntax element, string dependencyName, string dependencyVersion)
     {
         if (element.IsHintPathNode())
         {
-            // the include attribute will look like one of the following:
-            //   <Reference Include="Some.Dependency, Version=1.0.0.0, Culture=neutral, PublicKeyToken=abcd">
-            // or
-            //   <Reference Include="Some.Dependency">
-            string includeAttributeValue = element.Parent.GetAttributeValue("Include", StringComparison.OrdinalIgnoreCase);
-            if (includeAttributeValue.Equals(dependencyName, StringComparison.OrdinalIgnoreCase) ||
-                includeAttributeValue.StartsWith($"{dependencyName},", StringComparison.OrdinalIgnoreCase))
+            // the hint path will look similar to this:
+            //   ..\packages\Some.Package.1.2.3\lib\net45\Some.Package.dll
+            var assemblyPath = element.GetContentValue();
+            var match = PackageAssemblyHintPathPattern().Match(assemblyPath);
+            if (match.Success)
             {
                 return true;
             }
@@ -325,4 +323,8 @@ internal static class PackagesConfigUpdater
 
         return subpath;
     }
+
+    [GeneratedRegex(@"^(?<PackagesPath>.*)[/\\](?<PackageNameAndVersion>[^/\\]+)[/\\]lib[/\\](?<Tfm>[^/\\]+)[/\\](?<AssemblyName>[^/\\]+)$", RegexOptions.IgnoreCase)]
+    // e.g.,            ..\..\packages      \   Some.Package.1.2.3                \  lib  \   net45           \   Some.Package.dll
+    private static partial Regex PackageAssemblyHintPathPattern();
 }

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

@@ -4,6 +4,7 @@ using System.Text.Json.Serialization;
 
 using NuGetUpdater.Core.Analyze;
 using NuGetUpdater.Core.Updater;
+using NuGetUpdater.Core.Utilities;
 
 namespace NuGetUpdater.Core;
 
@@ -114,11 +115,11 @@ public class UpdaterWorker : IUpdaterWorker
                 await RunForProjectAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             default:
-                _logger.Log($"File extension [{extension}] is not supported.");
+                _logger.Info($"File extension [{extension}] is not supported.");
                 break;
         }
 
-        _logger.Log("Update complete.");
+        _logger.Info("Update complete.");
 
         _processedProjectPaths.Clear();
         return new UpdateOperationResult();
@@ -126,7 +127,7 @@ public class UpdaterWorker : IUpdaterWorker
 
     internal static async Task WriteResultFile(UpdateOperationResult result, string resultOutputPath, ILogger logger)
     {
-        logger.Log($"  Writing update result to [{resultOutputPath}].");
+        logger.Info($"  Writing update result to [{resultOutputPath}].");
 
         var resultJson = JsonSerializer.Serialize(result, SerializerOptions);
         await File.WriteAllTextAsync(resultOutputPath, resultJson);
@@ -140,7 +141,7 @@ public class UpdaterWorker : IUpdaterWorker
         string newDependencyVersion,
         bool isTransitive)
     {
-        _logger.Log($"Running for solution [{Path.GetRelativePath(repoRootPath, solutionPath)}]");
+        _logger.Info($"Running for solution [{Path.GetRelativePath(repoRootPath, solutionPath)}]");
         var projectPaths = MSBuildHelper.GetProjectPathsFromSolution(solutionPath);
         foreach (var projectPath in projectPaths)
         {
@@ -156,10 +157,10 @@ public class UpdaterWorker : IUpdaterWorker
         string newDependencyVersion,
         bool isTransitive)
     {
-        _logger.Log($"Running for proj file [{Path.GetRelativePath(repoRootPath, projFilePath)}]");
+        _logger.Info($"Running for proj file [{Path.GetRelativePath(repoRootPath, projFilePath)}]");
         if (!File.Exists(projFilePath))
         {
-            _logger.Log($"File [{projFilePath}] does not exist.");
+            _logger.Info($"File [{projFilePath}] does not exist.");
             return;
         }
 
@@ -182,10 +183,10 @@ public class UpdaterWorker : IUpdaterWorker
         string newDependencyVersion,
         bool isTransitive)
     {
-        _logger.Log($"Running for project file [{Path.GetRelativePath(repoRootPath, projectPath)}]");
+        _logger.Info($"Running for project file [{Path.GetRelativePath(repoRootPath, projectPath)}]");
         if (!File.Exists(projectPath))
         {
-            _logger.Log($"File [{projectPath}] does not exist.");
+            _logger.Info($"File [{projectPath}] does not exist.");
             return;
         }
 
@@ -215,18 +216,21 @@ public class UpdaterWorker : IUpdaterWorker
 
         _processedProjectPaths.Add(projectPath);
 
-        _logger.Log($"Updating project [{projectPath}]");
+        _logger.Info($"Updating project [{projectPath}]");
 
-        if (NuGetHelper.TryGetPackagesConfigFile(projectPath, out var packagesConfigPath))
+        var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(projectPath, ProjectHelper.PathFormat.Full);
+        var packagesConfigFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesConfigFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+        if (packagesConfigFullPath is not null)
         {
-            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigPath, _logger);
+            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigFullPath, _logger);
         }
 
         // Some repos use a mix of packages.config and PackageReference
         await PackageReferenceUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _experimentsManager, _logger);
 
         // Update lock file if exists
-        if (File.Exists(Path.Combine(Path.GetDirectoryName(projectPath), "packages.lock.json")))
+        var packagesLockFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesLockJsonFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+        if (packagesLockFullPath is not null)
         {
             await LockFileUpdater.UpdateLockFileAsync(repoRootPath, projectPath, _logger);
         }

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

@@ -2,7 +2,7 @@ namespace NuGetUpdater.Core;
 
 public sealed class ConsoleLogger : ILogger
 {
-    public void Log(string message)
+    public void LogRaw(string message)
     {
         Console.WriteLine(message);
     }