dependabot-nuget 0.242.1 → 0.244.0

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

@@ -5,7 +5,7 @@ using System.Threading.Tasks;
 
 namespace NuGetUpdater.Core;
 
-public partial class UpdaterWorker
+public class UpdaterWorker
 {
     private readonly Logger _logger;
     private readonly HashSet<string> _processedGlobalJsonPaths = new(StringComparer.OrdinalIgnoreCase);
@@ -15,33 +15,33 @@ public partial class UpdaterWorker
         _logger = logger;
     }
 
-    public async Task RunAsync(string repoRootPath, string filePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
+    public async Task RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
     {
         MSBuildHelper.RegisterMSBuild();
 
-        if (!Path.IsPathRooted(filePath) || !File.Exists(filePath))
+        if (!Path.IsPathRooted(workspacePath) || !File.Exists(workspacePath))
         {
-            filePath = Path.GetFullPath(Path.Join(repoRootPath, filePath));
+            workspacePath = Path.GetFullPath(Path.Join(repoRootPath, workspacePath));
         }
 
         if (!isTransitive)
         {
-            await DotNetToolsJsonUpdater.UpdateDependencyAsync(repoRootPath, dependencyName, previousDependencyVersion, newDependencyVersion, _logger);
+            await DotNetToolsJsonUpdater.UpdateDependencyAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, _logger);
         }
 
-        var extension = Path.GetExtension(filePath).ToLowerInvariant();
+        var extension = Path.GetExtension(workspacePath).ToLowerInvariant();
         switch (extension)
         {
             case ".sln":
-                await RunForSolutionAsync(repoRootPath, filePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                await RunForSolutionAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             case ".proj":
-                await RunForProjFileAsync(repoRootPath, filePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                await RunForProjFileAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             case ".csproj":
             case ".fsproj":
             case ".vbproj":
-                await RunForProjectAsync(repoRootPath, filePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                await RunForProjectAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             default:
                 _logger.Log($"File extension [{extension}] is not supported.");
@@ -51,7 +51,13 @@ public partial class UpdaterWorker
         _processedGlobalJsonPaths.Clear();
     }
 
-    private async Task RunForSolutionAsync(string repoRootPath, string solutionPath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
+    private async Task RunForSolutionAsync(
+        string repoRootPath,
+        string solutionPath,
+        string dependencyName,
+        string previousDependencyVersion,
+        string newDependencyVersion,
+        bool isTransitive)
     {
         _logger.Log($"Running for solution [{Path.GetRelativePath(repoRootPath, solutionPath)}]");
         var projectPaths = MSBuildHelper.GetProjectPathsFromSolution(solutionPath);
@@ -61,7 +67,13 @@ public partial class UpdaterWorker
         }
     }
 
-    private async Task RunForProjFileAsync(string repoRootPath, string projFilePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
+    private async Task RunForProjFileAsync(
+        string repoRootPath,
+        string projFilePath,
+        string dependencyName,
+        string previousDependencyVersion,
+        string newDependencyVersion,
+        bool isTransitive)
     {
         _logger.Log($"Running for proj file [{Path.GetRelativePath(repoRootPath, projFilePath)}]");
         if (!File.Exists(projFilePath))
@@ -69,6 +81,7 @@ public partial class UpdaterWorker
             _logger.Log($"File [{projFilePath}] does not exist.");
             return;
         }
+
         var projectFilePaths = MSBuildHelper.GetProjectPathsFromProject(projFilePath);
         foreach (var projectFullPath in projectFilePaths)
         {
@@ -80,12 +93,18 @@ public partial class UpdaterWorker
         }
     }
 
-    private async Task RunForProjectAsync(string repoRootPath, string projectPath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
+    private async Task RunForProjectAsync(
+        string repoRootPath,
+        string projectPath,
+        string dependencyName,
+        string previousDependencyVersion,
+        string newDependencyVersion,
+        bool isTransitive)
     {
         _logger.Log($"Running for project [{projectPath}]");
 
         if (!isTransitive
-            && MSBuildHelper.GetGlobalJsonPath(repoRootPath, projectPath) is string globalJsonPath
+            && MSBuildHelper.GetGlobalJsonPath(repoRootPath, projectPath) is { } globalJsonPath
             && !_processedGlobalJsonPaths.Contains(globalJsonPath))
         {
             _processedGlobalJsonPaths.Add(globalJsonPath);

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

@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core.Updater
+{
+    internal class WebApplicationTargetsConditionPatcher : IDisposable
+    {
+        private string? _capturedCondition;
+        private readonly XmlFilePreAndPostProcessor _processor;
+
+        public WebApplicationTargetsConditionPatcher(string projectFilePath)
+        {
+            _processor = new XmlFilePreAndPostProcessor(
+                getContent: () => File.ReadAllText(projectFilePath),
+                setContent: s => File.WriteAllText(projectFilePath, s),
+                nodeFinder: doc => doc.Descendants()
+                    .FirstOrDefault(e => e.Name == "Import" && e.GetAttributeValue("Project") == @"$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets")
+                    as XmlNodeSyntax,
+                preProcessor: n =>
+                {
+                    var element = (IXmlElementSyntax)n;
+                    _capturedCondition = element.GetAttributeValue("Condition");
+                    return (XmlNodeSyntax)element.RemoveAttributeByName("Condition").WithAttribute("Condition", "false");
+                },
+                postProcessor: n =>
+                {
+                    var element = (IXmlElementSyntax)n;
+                    var newElement = element.RemoveAttributeByName("Condition");
+                    if (_capturedCondition is not null)
+                    {
+                        newElement = newElement.WithAttribute("Condition", _capturedCondition);
+                    }
+
+                    return (XmlNodeSyntax)newElement;
+                }
+            );
+        }
+
+        public void Dispose()
+        {
+            _processor.Dispose();
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+using System;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core.Updater
+{
+    internal class XmlFilePreAndPostProcessor : IDisposable
+    {
+        public Func<string> GetContent { get; }
+        public Action<string> SetContent { get; }
+        public Func<XmlDocumentSyntax, XmlNodeSyntax?> NodeFinder { get; }
+        public Func<XmlNodeSyntax, XmlNodeSyntax> PreProcessor { get; }
+        public Func<XmlNodeSyntax, XmlNodeSyntax> PostProcessor { get; }
+
+        public XmlFilePreAndPostProcessor(Func<string> getContent, Action<string> setContent, Func<XmlDocumentSyntax, XmlNodeSyntax?> nodeFinder, Func<XmlNodeSyntax, XmlNodeSyntax> preProcessor, Func<XmlNodeSyntax, XmlNodeSyntax> postProcessor)
+        {
+            GetContent = getContent;
+            SetContent = setContent;
+            NodeFinder = nodeFinder;
+            PreProcessor = preProcessor;
+            PostProcessor = postProcessor;
+            PreProcess();
+        }
+
+        public void Dispose()
+        {
+            PostProcess();
+        }
+
+        private void PreProcess() => RunProcessor(PreProcessor);
+
+        private void PostProcess() => RunProcessor(PostProcessor);
+
+        private void RunProcessor(Func<XmlNodeSyntax, XmlNodeSyntax> processor)
+        {
+            var content = GetContent();
+            var xml = Parser.ParseText(content);
+            if (xml is null)
+            {
+                return;
+            }
+
+            var node = NodeFinder(xml);
+            if (node is null)
+            {
+                return;
+            }
+
+            var replacementElement = processor(node);
+            var replacementXml = xml.ReplaceNode(node, replacementElement);
+            var replacementString = replacementXml.ToFullString();
+            SetContent(replacementString);
+        }
+    }
+}

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

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Text.Encodings.Web;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
@@ -11,7 +12,7 @@ namespace NuGetUpdater.Core.Utilities
 {
     internal static class JsonHelper
     {
-        public static JsonDocumentOptions DocumentOptions { get; } = new JsonDocumentOptions()
+        public static JsonDocumentOptions DocumentOptions { get; } = new JsonDocumentOptions
         {
             CommentHandling = JsonCommentHandling.Skip,
         };
@@ -24,16 +25,16 @@ namespace NuGetUpdater.Core.Utilities
 
         public static string UpdateJsonProperty(string json, string[] propertyPath, string newValue, StringComparison comparisonType = StringComparison.Ordinal)
         {
-            var readerOptions = new JsonReaderOptions()
+            var readerOptions = new JsonReaderOptions
             {
                 CommentHandling = JsonCommentHandling.Allow,
             };
             var bytes = Encoding.UTF8.GetBytes(json);
             var reader = new Utf8JsonReader(bytes, readerOptions);
             using var ms = new MemoryStream();
-            var writerOptions = new JsonWriterOptions()
+            var writerOptions = new JsonWriterOptions
             {
-                Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+                Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                 Indented = true,
             };
             var writer = new Utf8JsonWriter(ms, writerOptions);
@@ -70,6 +71,7 @@ namespace NuGetUpdater.Core.Utilities
                                 // let the default block comment writer handle it
                                 writer.WriteCommentValue(reader.GetComment());
                             }
+
                             break;
                         case JsonTokenType.EndArray:
                             writer.WriteEndArray();
@@ -126,7 +128,7 @@ namespace NuGetUpdater.Core.Utilities
                     {
                         currentPath.RemoveAt(currentPath.Count - 1);
                     }
-                    
+
                     currentPath[pathDepth] = pathValue;
                     if (IsPathMatch(currentPath, propertyPath, comparisonType))
                     {
@@ -187,18 +189,19 @@ namespace NuGetUpdater.Core.Utilities
                         // quit at newline, modulo some special cases
                         if (c == '\n')
                         {
-                            // check for preceeding CR
+                            // check for preceding CR
                             if (IsPreceedingCharacterEqual(originalJson, prefixStart, '\r'))
                             {
                                 prefixStart--;
                             }
                         }
 
-                        // check for preceeding comma
+                        // check for preceding comma
                         if (IsPreceedingCharacterEqual(originalJson, prefixStart, ','))
                         {
                             prefixStart--;
                         }
+
                         goto done;
                     default:
                         // found regular character; move forward one and quit
@@ -215,8 +218,8 @@ namespace NuGetUpdater.Core.Utilities
         private static bool IsPreceedingCharacterEqual(string originalText, int currentIndex, char expectedCharacter)
         {
             return currentIndex > 0
-                && currentIndex < originalText.Length
-                && originalText[currentIndex - 1] == expectedCharacter;
+                   && currentIndex < originalText.Length
+                   && originalText[currentIndex - 1] == expectedCharacter;
         }
     }
 }

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

@@ -15,6 +15,7 @@ using Microsoft.Build.Definition;
 using Microsoft.Build.Evaluation;
 using Microsoft.Build.Exceptions;
 using Microsoft.Build.Locator;
+using Microsoft.Extensions.FileSystemGlobbing;
 
 using NuGetUpdater.Core.Utilities;
 
@@ -101,6 +102,7 @@ internal static partial class MSBuildHelper
     {
         var projectStack = new Stack<(string folderPath, ProjectRootElement)>();
         var projectRootElement = ProjectRootElement.Open(projFilePath);
+        var processedProjectFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 
         projectStack.Push((Path.GetFullPath(Path.GetDirectoryName(projFilePath)!), projectRootElement));
 
@@ -114,27 +116,42 @@ internal static partial class MSBuildHelper
                     continue;
                 }
 
-                projectPath = PathHelper.GetFullPathFromRelative(folderPath, projectPath);
+                Matcher matcher = new Matcher();
+                matcher.AddInclude(PathHelper.NormalizePathToUnix(projectReference.Include));
 
-                var projectExtension = Path.GetExtension(projectPath).ToLowerInvariant();
-                if (projectExtension == ".proj")
+                string searchDirectory = PathHelper.NormalizePathToUnix(folderPath);
+
+                IEnumerable<string> files = matcher.GetResultsInFullPath(searchDirectory);
+
+                foreach (var file in files)
                 {
-                    // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
-                    if (File.Exists(projectPath))
+                    // Check that we haven't already processed this file
+                    if (processedProjectFiles.Contains(file))
                     {
-                        var additionalProjectRootElement = ProjectRootElement.Open(projectPath);
-                        projectStack.Push((Path.GetFullPath(Path.GetDirectoryName(projectPath)!), additionalProjectRootElement));
+                        continue;
+                    }
+
+                    var projectExtension = Path.GetExtension(file).ToLowerInvariant();
+                    if (projectExtension == ".proj")
+                    {
+                        // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
+                        if (File.Exists(file))
+                        {
+                            var additionalProjectRootElement = ProjectRootElement.Open(file);
+                            projectStack.Push((Path.GetFullPath(Path.GetDirectoryName(file)!), additionalProjectRootElement));
+                            processedProjectFiles.Add(file);
+                        }
+                    }
+                    else if (projectExtension == ".csproj" || projectExtension == ".vbproj" || projectExtension == ".fsproj")
+                    {
+                        yield return file;
                     }
-                }
-                else if (projectExtension == ".csproj" || projectExtension == ".vbproj" || projectExtension == ".fsproj")
-                {
-                    yield return projectPath;
                 }
             }
         }
     }
 
-    public static IEnumerable<Dependency> GetTopLevelPackageDependenyInfos(ImmutableArray<ProjectBuildFile> buildFiles)
+    public static IEnumerable<Dependency> GetTopLevelPackageDependencyInfos(ImmutableArray<ProjectBuildFile> buildFiles)
     {
         Dictionary<string, (string, bool)> packageInfo = new(StringComparer.OrdinalIgnoreCase);
         Dictionary<string, string> packageVersionInfo = new(StringComparer.OrdinalIgnoreCase);
@@ -145,11 +162,11 @@ internal static partial class MSBuildHelper
             var projectRoot = CreateProjectRootElement(buildFile);
 
             foreach (var packageItem in projectRoot.Items
-                .Where(i => (i.ItemType == "PackageReference" || i.ItemType == "GlobalPackageReference")))
+                         .Where(i => (i.ItemType == "PackageReference" || i.ItemType == "GlobalPackageReference")))
             {
                 var versionSpecification = packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("Version", StringComparison.OrdinalIgnoreCase))?.Value
-                    ?? packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("VersionOverride", StringComparison.OrdinalIgnoreCase))?.Value
-                    ?? string.Empty;
+                                           ?? packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("VersionOverride", StringComparison.OrdinalIgnoreCase))?.Value
+                                           ?? string.Empty;
                 foreach (var attributeValue in new[] { packageItem.Include, packageItem.Update })
                 {
                     if (!string.IsNullOrWhiteSpace(attributeValue))
@@ -175,10 +192,10 @@ internal static partial class MSBuildHelper
             }
 
             foreach (var packageItem in projectRoot.Items
-                .Where(i => i.ItemType == "PackageVersion" && !string.IsNullOrEmpty(i.Include)))
+                         .Where(i => i.ItemType == "PackageVersion" && !string.IsNullOrEmpty(i.Include)))
             {
                 packageVersionInfo[packageItem.Include] = packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("Version", StringComparison.OrdinalIgnoreCase))?.Value
-                    ?? string.Empty;
+                                                          ?? string.Empty;
             }
 
             foreach (var property in projectRoot.Properties)
@@ -187,7 +204,8 @@ internal static partial class MSBuildHelper
                 // going to be used, and even then we might not be able to update it.  As a best guess, we'll simply
                 // skip any property that has a condition _or_ where the condition is checking for an empty string.
                 var hasEmptyCondition = string.IsNullOrEmpty(property.Condition);
-                var conditionIsCheckingForEmptyString = string.Equals(property.Condition, $"$({property.Name}) == ''", StringComparison.OrdinalIgnoreCase);
+                var conditionIsCheckingForEmptyString = string.Equals(property.Condition, $"$({property.Name}) == ''", StringComparison.OrdinalIgnoreCase) ||
+                                                        string.Equals(property.Condition, $"'$({property.Name})' == ''", StringComparison.OrdinalIgnoreCase);
                 if (hasEmptyCondition || conditionIsCheckingForEmptyString)
                 {
                     propertyInfo[property.Name] = property.Value;
@@ -285,7 +303,12 @@ internal static partial class MSBuildHelper
         return projectRoot;
     }
 
-    private static async Task<string> CreateTempProjectAsync(DirectoryInfo tempDir, string repoRoot, string projectPath, string targetFramework, Dependency[] packages)
+    private static async Task<string> CreateTempProjectAsync(
+        DirectoryInfo tempDir,
+        string repoRoot,
+        string projectPath,
+        string targetFramework,
+        IReadOnlyCollection<Dependency> packages)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath);
         projectDirectory ??= repoRoot;
@@ -299,39 +322,40 @@ internal static partial class MSBuildHelper
         var packageReferences = string.Join(
             Environment.NewLine,
             packages
-                .Where(p => !string.IsNullOrWhiteSpace(p.Version)) // empty `Version` attributes will cause the temporary project to not build
+                // empty `Version` attributes will cause the temporary project to not build
+                .Where(p => !string.IsNullOrWhiteSpace(p.Version))
                 // If all PackageReferences for a package are update-only mark it as such, otherwise it can cause package incoherence errors which do not exist in the repo.
                 .Select(static p => $"<PackageReference {(p.IsUpdate ? "Update" : "Include")}=\"{p.Name}\" Version=\"[{p.Version}]\" />"));
 
         var projectContents = $"""
-                <Project Sdk="Microsoft.NET.Sdk">
-                  <PropertyGroup>
-                    <TargetFramework>{targetFramework}</TargetFramework>
-                    <GenerateDependencyFile>true</GenerateDependencyFile>
-                    <RunAnalyzers>false</RunAnalyzers>
-                  </PropertyGroup>
-                  <ItemGroup>
-                    {packageReferences}
-                  </ItemGroup>
-                  <Target Name="_CollectDependencies" DependsOnTargets="GenerateBuildDependencyFile">
-                    <ItemGroup>
-                      <_NuGetPackageData Include="@(NativeCopyLocalItems)" />
-                      <_NuGetPackageData Include="@(ResourceCopyLocalItems)" />
-                      <_NuGetPackageData Include="@(RuntimeCopyLocalItems)" />
-                      <_NuGetPackageData Include="@(ResolvedAnalyzers)" />
-                      <_NuGetPackageData Include="@(_PackageDependenciesDesignTime)">
-                        <NuGetPackageId>%(_PackageDependenciesDesignTime.Name)</NuGetPackageId>
-                        <NuGetPackageVersion>%(_PackageDependenciesDesignTime.Version)</NuGetPackageVersion>
-                      </_NuGetPackageData>
-                    </ItemGroup>
-                  </Target>
-                  <Target Name="_ReportDependencies" DependsOnTargets="_CollectDependencies">
-                    <Message Text="NuGetData::Package=%(_NuGetPackageData.NuGetPackageId), Version=%(_NuGetPackageData.NuGetPackageVersion)"
-                             Condition="'%(_NuGetPackageData.NuGetPackageId)' != '' AND '%(_NuGetPackageData.NuGetPackageVersion)' != ''"
-                             Importance="High" />
-                  </Target>
-                </Project>
-                """;
+            <Project Sdk="Microsoft.NET.Sdk">
+              <PropertyGroup>
+                <TargetFramework>{targetFramework}</TargetFramework>
+                <GenerateDependencyFile>true</GenerateDependencyFile>
+                <RunAnalyzers>false</RunAnalyzers>
+              </PropertyGroup>
+              <ItemGroup>
+                {packageReferences}
+              </ItemGroup>
+              <Target Name="_CollectDependencies" DependsOnTargets="GenerateBuildDependencyFile">
+                <ItemGroup>
+                  <_NuGetPackageData Include="@(NativeCopyLocalItems)" />
+                  <_NuGetPackageData Include="@(ResourceCopyLocalItems)" />
+                  <_NuGetPackageData Include="@(RuntimeCopyLocalItems)" />
+                  <_NuGetPackageData Include="@(ResolvedAnalyzers)" />
+                  <_NuGetPackageData Include="@(_PackageDependenciesDesignTime)">
+                    <NuGetPackageId>%(_PackageDependenciesDesignTime.Name)</NuGetPackageId>
+                    <NuGetPackageVersion>%(_PackageDependenciesDesignTime.Version)</NuGetPackageVersion>
+                  </_NuGetPackageData>
+                </ItemGroup>
+              </Target>
+              <Target Name="_ReportDependencies" DependsOnTargets="_CollectDependencies">
+                <Message Text="NuGetData::Package=%(_NuGetPackageData.NuGetPackageId), Version=%(_NuGetPackageData.NuGetPackageVersion)"
+                         Condition="'%(_NuGetPackageData.NuGetPackageId)' != '' AND '%(_NuGetPackageData.NuGetPackageVersion)' != ''"
+                         Importance="High" />
+              </Target>
+            </Project>
+            """;
         var tempProjectPath = Path.Combine(tempDir.FullName, "Project.csproj");
         await File.WriteAllTextAsync(tempProjectPath, projectContents);
 
@@ -344,7 +368,7 @@ internal static partial class MSBuildHelper
     }
 
     internal static async Task<Dependency[]> GetAllPackageDependenciesAsync(
-        string repoRoot, string projectPath, string targetFramework, Dependency[] packages, Logger? logger = null)
+        string repoRoot, string projectPath, string targetFramework, IReadOnlyCollection<Dependency> packages, Logger? logger = null)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-resolution_");
         try
@@ -368,7 +392,7 @@ internal static partial class MSBuildHelper
             else
             {
                 logger?.Log($"dotnet build in {nameof(GetAllPackageDependenciesAsync)} failed. STDOUT: {stdout} STDERR: {stderr}");
-                return Array.Empty<Dependency>();
+                return [];
             }
         }
         finally
@@ -390,7 +414,7 @@ internal static partial class MSBuildHelper
 
     internal static async Task<ImmutableArray<ProjectBuildFile>> LoadBuildFiles(string repoRootPath, string projectPath)
     {
-        var buildFileList = new List<string>()
+        var buildFileList = new List<string>
         {
             projectPath.NormalizePathToUnix() // always include the starting project
         };
@@ -409,12 +433,12 @@ internal static partial class MSBuildHelper
                 // create a safe version with only certain top-level keys
                 var globalJsonContent = await File.ReadAllTextAsync(safeGlobalJsonName);
                 var json = JsonHelper.ParseNode(globalJsonContent);
-                var sdks = json["msbuild-sdks"];
+                var sdks = json?["msbuild-sdks"];
                 if (sdks is not null)
                 {
                     var newObject = new Dictionary<string, object>()
                     {
-                        { "msbuild-sdks", sdks }
+                        ["msbuild-sdks"] = sdks,
                     };
                     var newContent = JsonSerializer.Serialize(newObject);
                     await File.WriteAllTextAsync(globalJsonPath, newContent);
@@ -426,7 +450,7 @@ internal static partial class MSBuildHelper
             // load the project even if it imports a file that doesn't exist (e.g. a file that's generated at restore
             // or build time).
             using var projectCollection = new ProjectCollection(); // do this in a one-off instance and don't pollute the global collection
-            var project = Project.FromFile(projectPath, new ProjectOptions()
+            var project = Project.FromFile(projectPath, new ProjectOptions
             {
                 LoadSettings = ProjectLoadSettings.IgnoreMissingImports,
                 ProjectCollection = projectCollection,

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

@@ -10,6 +10,7 @@ internal static class PathHelper
     {
         MatchCasing = MatchCasing.CaseInsensitive,
     };
+
     private static readonly EnumerationOptions _caseSensitiveEnumerationOptions = new()
     {
         MatchCasing = MatchCasing.CaseSensitive,
@@ -39,6 +40,11 @@ internal static class PathHelper
     /// <returns>The path of the found file or null.</returns>
     public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
     {
+        if (File.Exists(initialPath))
+        {
+            initialPath = Path.GetDirectoryName(initialPath)!;
+        }
+
         var candidatePaths = new List<string>();
         var rootDirectory = new DirectoryInfo(rootPath);
         var candidateDirectory = new DirectoryInfo(initialPath);
@@ -56,11 +62,18 @@ internal static class PathHelper
 
         foreach (var candidatePath in candidatePaths)
         {
-            var files = Directory.EnumerateFiles(candidatePath, fileName, caseSensitive ? _caseSensitiveEnumerationOptions : _caseInsensitiveEnumerationOptions);
+            try
+            {
+                var files = Directory.EnumerateFiles(candidatePath, fileName, caseSensitive ? _caseSensitiveEnumerationOptions : _caseInsensitiveEnumerationOptions);
 
-            if (files.Any())
+                if (files.Any())
+                {
+                    return files.First();
+                }
+            }
+            catch (DirectoryNotFoundException)
             {
-                return files.First();
+                // When searching for a file in a directory that doesn't exist, Directory.EnumerateFiles throws a DirectoryNotFoundException.
             }
         }
 

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

@@ -45,14 +45,14 @@ public static class ProcessEx
             // than enter right back into the Process type and start a wait which isn't guaranteed to be safe.
             Task.Run(() =>
             {
-               redirectInitiated.Wait();
-               redirectInitiated.Dispose();
-               redirectInitiated = null;
+                redirectInitiated.Wait();
+                redirectInitiated.Dispose();
+                redirectInitiated = null;
 
-               process.WaitForExit();
+                process.WaitForExit();
 
-               tcs.TrySetResult((process.ExitCode, stdout.ToString(), stderr.ToString()));
-               process.Dispose();
+                tcs.TrySetResult((process.ExitCode, stdout.ToString(), stderr.ToString()));
+                process.Dispose();
             });
         };
 

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

@@ -30,6 +30,17 @@ public static class XmlExtensions
         return element.Attributes.FirstOrDefault(a => a.Name.Equals(name, comparisonType));
     }
 
+    public static IXmlElementSyntax RemoveAttributeByName(this IXmlElementSyntax element, string attributeName, StringComparison comparisonType = StringComparison.Ordinal)
+    {
+        var attribute = element.GetAttribute(attributeName, comparisonType);
+        if (attribute is null)
+        {
+            return element;
+        }
+
+        return element.RemoveAttribute(attribute);
+    }
+
     public static string GetAttributeValue(this IXmlElementSyntax element, string name, StringComparison comparisonType)
     {
         return element.Attributes.First(a => a.Name.Equals(name, comparisonType)).Value;