Rename SlnxFileRefs→SlnxFile, remove try-catch, add #regions/AAA, split integration tests

Co-authored-by: 304NotModified <5808377+304NotModified@users.noreply.github.com>
Agent-Logs-Url: https://github.com/304NotModified/SLNX-validator/sessions/ceaf8ba9-6628-42a8-b534-1dfec61aafc3

Author: Copilot

src/SLNX-validator.Core/Validation/IRequiredFilesChecker.cs

@@ -12,11 +12,11 @@ public interface IRequiredFilesChecker
 
     /// <summary>
     /// Checks which of the <paramref name="requiredAbsolutePaths"/> are NOT present in
-    /// <paramref name="slnxFileRefs"/>.
+    /// <paramref name="slnxFile"/>.
     /// Returns a <see cref="ValidationError"/> for each missing file.
     /// </summary>
     IReadOnlyList<ValidationError> CheckInSlnx(
         IReadOnlyList<string> requiredAbsolutePaths,
-        SlnxFileRefs slnxFileRefs);
+        SlnxFile slnxFile);
 }
 

src/SLNX-validator.Core/Validation/RequiredFilesChecker.cs

@@ -32,14 +32,14 @@ public IReadOnlyList<string> ResolveMatchedPaths(string patternsRaw, string root
     /// <inheritdoc />
     public IReadOnlyList<ValidationError> CheckInSlnx(
         IReadOnlyList<string> requiredAbsolutePaths,
-        SlnxFileRefs slnxFileRefs)
+        SlnxFile slnxFile)
     {
         var errors = new List<ValidationError>();
         foreach (var requiredPath in requiredAbsolutePaths)
         {
-            if (!slnxFileRefs.AbsoluteFilePaths.Contains(requiredPath, StringComparer.OrdinalIgnoreCase))
+            if (!slnxFile.Files.Contains(requiredPath, StringComparer.OrdinalIgnoreCase))
             {
-                var relativePath = Path.GetRelativePath(slnxFileRefs.SlnxDirectory, requiredPath).Replace('\\', '/');
+                var relativePath = Path.GetRelativePath(slnxFile.SlnxDirectory, requiredPath).Replace('\\', '/');
                 errors.Add(new ValidationError(
                     ValidationErrorCode.RequiredFileNotReferencedInSolution,
                     $"Required file is not referenced in the solution: {requiredPath}" +

src/SLNX-validator.Core/Validation/SlnxFile.cs

@@ -0,0 +1,57 @@
+using System.Xml.Linq;
+
+namespace JulianVerdurmen.SlnxValidator.Core.Validation;
+
+/// <summary>
+/// Represents the set of absolute file paths that are referenced as
+/// <c>&lt;File Path="..."&gt;</c> elements inside a .slnx solution file.
+/// </summary>
+public sealed class SlnxFile
+{
+    /// <summary>The directory that contains the .slnx file.</summary>
+    public string SlnxDirectory { get; }
+
+    /// <summary>Absolute, normalised paths for every <c>&lt;File&gt;</c> entry in the solution.</summary>
+    public IReadOnlyList<string> Files { get; }
+
+    private SlnxFile(string slnxDirectory, IReadOnlyList<string> files)
+    {
+        SlnxDirectory = slnxDirectory;
+        Files = files;
+    }
+
+    /// <summary>
+    /// Parses <paramref name="slnxContent"/> and returns the resolved absolute paths of all
+    /// <c>&lt;File Path="..."&gt;</c> elements.  Relative paths are resolved against
+    /// <paramref name="slnxDirectory"/>.
+    /// </summary>
+    /// <returns>The parsed <see cref="SlnxFile"/>, or <see langword="null"/> when the XML is malformed.</returns>
+    public static SlnxFile? Parse(string slnxContent, string slnxDirectory)
+    {
+        XDocument doc;
+        try
+        {
+            doc = XDocument.Parse(slnxContent);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+
+        var refs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var fileElement in doc.Descendants("File"))
+        {
+            var path = fileElement.Attribute("Path")?.Value;
+            if (path is null)
+                continue;
+
+            var fullPath = Path.IsPathRooted(path)
+                ? Path.GetFullPath(path)
+                : Path.GetFullPath(Path.Combine(slnxDirectory, path));
+
+            refs.Add(fullPath);
+        }
+
+        return new SlnxFile(slnxDirectory, [.. refs]);
+    }
+}

src/SLNX-validator.Core/Validation/SlnxFileRefs.cs

@@ -52,8 +52,9 @@ public async Task<IReadOnlyList<FileValidationResult>> CollectAsync(
                 }
                 else
                 {
-                    var slnxFileRefs = SlnxFileRefs.Parse(content, directory);
-                    allErrors.AddRange(requiredFilesChecker.CheckInSlnx(matched, slnxFileRefs));
+                    var slnxFile = SlnxFile.Parse(content, directory);
+                    if (slnxFile is not null)
+                        allErrors.AddRange(requiredFilesChecker.CheckInSlnx(matched, slnxFile));
                 }
             }
 

src/SLNX-validator/ValidationCollector.cs

@@ -0,0 +1,69 @@
+using AwesomeAssertions;
+using JulianVerdurmen.SlnxValidator.Core.Validation;
+
+namespace JulianVerdurmen.SlnxValidator.Core.Tests;
+
+public class RequiredFilesCheckerIntegrationTests
+{
+    private static string CreateTempDir()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+        Directory.CreateDirectory(tempDir);
+        return tempDir;
+    }
+
+    private static RequiredFilesChecker CreateChecker() => new();
+
+    #region ResolveMatchedPaths
+
+    [Test]
+    public void ResolveMatchedPaths_SingleInclude_MatchesFiles_ReturnsNonEmpty()
+    {
+        // Arrange
+        var tempDir = CreateTempDir();
+        try
+        {
+            var docDir = Path.Combine(tempDir, "doc");
+            Directory.CreateDirectory(docDir);
+            File.WriteAllText(Path.Combine(docDir, "readme.md"), "# Readme");
+            File.WriteAllText(Path.Combine(docDir, "contributing.md"), "# Contributing");
+
+            // Act
+            var matched = CreateChecker().ResolveMatchedPaths("doc/*.md", tempDir);
+
+            // Assert
+            matched.Should().HaveCount(2);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, recursive: true);
+        }
+    }
+
+    [Test]
+    public void ResolveMatchedPaths_IncludeFollowedByExclude_ExcludesFile()
+    {
+        // Arrange
+        var tempDir = CreateTempDir();
+        try
+        {
+            var docDir = Path.Combine(tempDir, "doc");
+            Directory.CreateDirectory(docDir);
+            File.WriteAllText(Path.Combine(docDir, "readme.md"), "# Readme");
+            File.WriteAllText(Path.Combine(docDir, "contributing.md"), "# Contributing");
+
+            // Act
+            var matched = CreateChecker().ResolveMatchedPaths("doc/*.md;!doc/contributing.md", tempDir);
+
+            // Assert
+            matched.Should().HaveCount(1);
+            matched[0].Should().EndWith("readme.md");
+        }
+        finally
+        {
+            Directory.Delete(tempDir, recursive: true);
+        }
+    }
+
+    #endregion
+}