Add StringComparison to file/directory extensions, with hearistic for default for IsSubPathOf

Author: Mpdreamz

src/Elastic.Documentation/Extensions/IFileInfoExtensions.cs

@@ -2,7 +2,9 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
+using System.Globalization;
 using System.IO.Abstractions;
+using static System.StringComparison;
 
 namespace Elastic.Documentation.Extensions;
 
@@ -26,7 +28,7 @@ public static bool IsSubPathOf(this IFileInfo file, IDirectoryInfo parentDirecto
 		return parent is not null && parent.IsSubPathOf(parentDirectory);
 	}
 
-	/// Checks if <paramref name="file"/> has parent directory <paramref name="parentName"/>
+	/// Checks if <paramref name="file"/> has parent directory <paramref name="parentName"/>, defaults to OrdinalIgnoreCase comparison
 	public static bool HasParent(this IFileInfo file, string parentName)
 	{
 		var parent = file.Directory;
@@ -36,29 +38,57 @@ public static bool HasParent(this IFileInfo file, string parentName)
 
 public static class IDirectoryInfoExtensions
 {
+	private static bool? CaseSensitiveOsCheck;
+	public static bool IsCaseSensitiveFileSystem
+	{
+
+		get
+		{
+			// heuristic to determine if the OS is case-sensitive
+			try
+			{
+				var tmp = Path.GetTempPath();
+				if (CaseSensitiveOsCheck.HasValue)
+					return CaseSensitiveOsCheck.Value;
+				var culture = CultureInfo.CurrentCulture;
+				CaseSensitiveOsCheck = !Directory.Exists(tmp.ToUpper(culture)) || !Directory.Exists(tmp.ToLower(culture));
+				return CaseSensitiveOsCheck ?? false;
+
+			}
+			catch
+			{
+				// fallback to case-insensitive unless it's linux
+				CaseSensitiveOsCheck = Environment.OSVersion.Platform == PlatformID.Unix;
+				return false;
+			}
+		}
+	}
+
+
 	/// Validates <paramref name="directory"/> is subdirectory of <paramref name="parentDirectory"/>
 	public static bool IsSubPathOf(this IDirectoryInfo directory, IDirectoryInfo parentDirectory)
 	{
+		var cmp = IsCaseSensitiveFileSystem ? Ordinal : OrdinalIgnoreCase;
 		var parent = directory;
 		do
 		{
-			if (parent.FullName == parentDirectory.FullName)
+			if (string.Equals(parent.FullName, parentDirectory.FullName, cmp))
 				return true;
 			parent = parent.Parent;
 		} while (parent != null);
 
 		return false;
 	}
 
-	/// Checks if <paramref name="directory"/> has parent directory <paramref name="parentName"/>
-	public static bool HasParent(this IDirectoryInfo directory, string parentName)
+	/// Checks if <paramref name="directory"/> has parent directory <paramref name="parentName"/>, defaults to OrdinalIgnoreCase comparison
+	public static bool HasParent(this IDirectoryInfo directory, string parentName, StringComparison comparison = OrdinalIgnoreCase)
 	{
-		if (directory.Name == parentName)
+		if (string.Equals(directory.Name, parentName, comparison))
 			return true;
 		var parent = directory;
 		do
 		{
-			if (parent.Name == parentName)
+			if (string.Equals(parent.Name, parentName, comparison))
 				return true;
 			parent = parent.Parent;
 		} while (parent != null);

tests/Elastic.Markdown.Tests/FileSystemExtensionsTests.cs

@@ -0,0 +1,55 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.IO.Abstractions.TestingHelpers;
+using Elastic.Documentation;
+using Elastic.Documentation.Configuration;
+using Elastic.Documentation.Configuration.Versions;
+using Elastic.Documentation.Diagnostics;
+using Elastic.Documentation.Extensions;
+using Elastic.Markdown.IO;
+using FluentAssertions;
+
+namespace Elastic.Markdown.Tests;
+
+public class FileSystemExtensionsTest(ITestOutputHelper output)
+{
+	[Fact]
+	public void IsSubPathOfTests()
+	{
+		var fs = new MockFileSystem();
+
+		fs.DirectoryInfo.New("/a/b/c/d").IsSubPathOf(fs.DirectoryInfo.New("/a/b/c/d/e/f")).Should().BeFalse();
+		fs.DirectoryInfo.New("/a/b/c/d/e/f").IsSubPathOf(fs.DirectoryInfo.New("/a/b/c/d")).Should().BeTrue();
+
+		var caseSensitive = IDirectoryInfoExtensions.IsCaseSensitiveFileSystem;
+
+		if (caseSensitive)
+		{
+			fs.DirectoryInfo.New("/a/b/C/d/e/f").IsSubPathOf(fs.DirectoryInfo.New("/a/b/c/d")).Should().BeFalse();
+			fs.DirectoryInfo.New("/a/b/c/d/e/f").IsSubPathOf(fs.DirectoryInfo.New("/a/b/C/d")).Should().BeFalse();
+		}
+		else
+		{
+			fs.DirectoryInfo.New("/a/b/C/d/e/f").IsSubPathOf(fs.DirectoryInfo.New("/a/b/c/d")).Should().BeTrue();
+			fs.DirectoryInfo.New("/a/b/c/d/e/f").IsSubPathOf(fs.DirectoryInfo.New("/a/b/C/d")).Should().BeTrue();
+		}
+	}
+
+	[Fact]
+	public void HasParentTests()
+	{
+		var fs = new MockFileSystem();
+
+		fs.DirectoryInfo.New("/a/b/c/d").HasParent("c").Should().BeTrue();
+		fs.DirectoryInfo.New("/a/b/c/d/e").HasParent("e").Should().BeTrue();
+
+		var caseSensitive = IDirectoryInfoExtensions.IsCaseSensitiveFileSystem;
+
+		if (caseSensitive)
+			fs.DirectoryInfo.New("/a/b/C/d").HasParent("c").Should().BeFalse();
+		else
+			fs.DirectoryInfo.New("/a/b/C/d").HasParent("c").Should().BeTrue();
+	}
+}