Make the build-output filter behave the same on every platform

CI caught this on ubuntu: the new filter used Path.GetRelativePath, which
honours only the running platform's separator. On Linux a Windows-style path is
one long segment containing no directories at all, so relativizing failed, the
whole path was examined, and a project under a directory named "bin" was skipped
again -- the exact bug the filter exists to prevent, reappearing whenever the
analysis ran anywhere but Windows.

Analyzing a Windows XAF project from a container or a CI runner is an ordinary
thing to do, so the comparison now normalizes separators and matches prefixes
itself. It requires a separator at the boundary too, so a root of "App.Module"
cannot swallow a sibling named "App.Module2".

The test now covers both separator styles rather than assuming the host's.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: peopleworks

src/XafLogicExplainer.Core/Analyzers/BuildOutputFilter.cs

@@ -58,23 +58,33 @@ public static bool IsAnalyzable(string? path, string? rootDirectory = null) =>
     /// Reduces a path to the part below the analyzed root, or leaves it alone when that cannot be
     /// established.
     /// </summary>
+    /// <remarks>
+    /// Deliberately not <see cref="Path.GetRelativePath"/>. That method honours only the running
+    /// platform's separator, so on Linux a Windows-style path is one long segment containing no
+    /// directories at all — and analyzing a Windows project from a container or a CI runner is an
+    /// ordinary thing to do. Comparing normalized prefixes gives the same answer everywhere.
+    /// </remarks>
     private static string Relativize(string path, string? rootDirectory)
     {
         if (string.IsNullOrWhiteSpace(rootDirectory))
             return path;
 
-        try
-        {
-            var relative = Path.GetRelativePath(rootDirectory, path);
+        var normalizedPath = Normalize(path);
+        var normalizedRoot = Normalize(rootDirectory);
 
-            // A path outside the root comes back with a leading "..", which tells us nothing about
-            // build output; fall back to examining the whole path in that case.
-            return relative.StartsWith("..", StringComparison.Ordinal) ? path : relative;
-        }
-        catch (ArgumentException)
-        {
-            // Different drive roots, or an unusable path. Examine what we were given.
+        if (normalizedRoot.Length == 0 || normalizedPath.Length <= normalizedRoot.Length)
             return path;
-        }
+
+        if (!normalizedPath.StartsWith(normalizedRoot, StringComparison.OrdinalIgnoreCase))
+            return path;
+
+        // Require a separator at the boundary so that a root of "App.Module" does not swallow a
+        // sibling directory named "App.Module2".
+        return normalizedPath[normalizedRoot.Length] == '/'
+            ? normalizedPath[(normalizedRoot.Length + 1)..]
+            : path;
     }
+
+    private static string Normalize(string path) =>
+        path.Replace('\\', '/').TrimEnd('/');
 }

tests/XafLogicExplainer.Tests/BuildOutputFilterTests.cs

@@ -30,15 +30,28 @@ public void SkipsBuildOutput(string path) =>
     public void KeepsSourceWhoseNameMerelyContainsThoseLetters(string path) =>
         Assert.False(BuildOutputFilter.IsBuildOutput(path));
 
-    [Fact]
-    public void KeepsProjectsThatLiveUnderADirectoryNamedBin()
+    [Theory]
+    // Both separator styles, on whichever platform the tests happen to run: analyzing a Windows
+    // project from a Linux container or CI runner is ordinary, and the answer must not change.
+    [InlineData(@"C:\bin\Sales\App.Module", @"C:\bin\Sales\App.Module\BusinessObjects\Invoice.cs", @"C:\bin\Sales\App.Module\bin\Debug\App.dll")]
+    [InlineData("/srv/bin/sales/App.Module", "/srv/bin/sales/App.Module/BusinessObjects/Invoice.cs", "/srv/bin/sales/App.Module/obj/Debug/App.g.cs")]
+    public void KeepsProjectsThatLiveUnderADirectoryNamedBin(string root, string source, string output)
     {
         // Build output is always below the project root. A "bin" above it is somebody's folder
         // name, and skipping those files would report an application with nothing in it.
-        const string root = @"C:\bin\Sales\App.Module";
+        Assert.False(BuildOutputFilter.IsBuildOutput(source, root));
+        Assert.True(BuildOutputFilter.IsBuildOutput(output, root));
+    }
+
+    [Fact]
+    public void DoesNotMistakeASiblingDirectoryForTheRoot()
+    {
+        const string root = @"C:\Solution\App.Module";
 
-        Assert.False(BuildOutputFilter.IsBuildOutput($@"{root}\BusinessObjects\Invoice.cs", root));
-        Assert.True(BuildOutputFilter.IsBuildOutput($@"{root}\bin\Debug\net10.0\App.dll", root));
+        // "App.Module2" starts with the root's text but is not inside it, so the whole path is
+        // examined rather than a bogus relative remainder.
+        Assert.False(BuildOutputFilter.IsBuildOutput(@"C:\Solution\App.Module2\Order.cs", root));
+        Assert.True(BuildOutputFilter.IsBuildOutput(@"C:\Solution\App.Module2\bin\Order.cs", root));
     }
 
     [Fact]