Handle cross-platform YAML path aliases

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: MariusStorhaug

src/functions/public/Import-Yaml.ps1

@@ -457,12 +457,18 @@ function Import-Yaml {
                                 [System.IO.Directory]::EnumerateFileSystemEntries($directoryPath)
                             )) {
                             $entryName = [System.IO.Path]::GetFileName($directoryEntry)
+                            $entryIdentityName = $entryName.Normalize(
+                                [System.Text.NormalizationForm]::FormC
+                            )
                             $nameGroup = $null
-                            if ($nameGroups.TryGetValue($entryName, [ref]$nameGroup)) {
+                            if ($nameGroups.TryGetValue(
+                                    $entryIdentityName,
+                                    [ref]$nameGroup
+                                )) {
                                 $nameGroup.Count++
                             } else {
                                 $nameGroups.Add(
-                                    $entryName,
+                                    $entryIdentityName,
                                     [pscustomobject]@{
                                         Count         = 1
                                         CanonicalName = $entryName
@@ -474,7 +480,13 @@ function Import-Yaml {
                     }
 
                     $nameGroup = $null
-                    if (-not $nameGroups.TryGetValue($leafName, [ref]$nameGroup)) {
+                    $leafIdentityName = $leafName.Normalize(
+                        [System.Text.NormalizationForm]::FormC
+                    )
+                    if (-not $nameGroups.TryGetValue(
+                            $leafIdentityName,
+                            [ref]$nameGroup
+                        )) {
                         $identityFailed = $true
                         break
                     }
@@ -503,7 +515,13 @@ function Import-Yaml {
                 }
                 $identityComponents.Add($rootPath)
                 $identityComponents.Reverse()
-                $identityKey = $identityComponents -join [char]0x1F
+                $identityKeyBuilder = [System.Text.StringBuilder]::new()
+                foreach ($identityComponent in $identityComponents) {
+                    $null = $identityKeyBuilder.Append($identityComponent.Length)
+                    $null = $identityKeyBuilder.Append(':')
+                    $null = $identityKeyBuilder.Append($identityComponent)
+                }
+                $identityKey = $identityKeyBuilder.ToString()
             }
 
             $null = $pathsByIdentity.TryAdd($identityKey, $resolvedPath)

tests/Import-Yaml.Tests.ps1

@@ -85,27 +85,74 @@ Describe 'Import-Yaml' {
             @($result.value) | Should -Be @('first', 'second')
         }
 
-        It 'keeps case-distinct files separate on case-sensitive filesystems' -Skip:$IsWindows {
+        It 'keeps case-distinct files separate on case-sensitive filesystems' {
             $upperPath = Join-Path $TestDrive 'Case.yaml'
             $lowerPath = Join-Path $TestDrive 'case.yaml'
             [System.IO.File]::WriteAllText($upperPath, 'value: upper')
             [System.IO.File]::WriteAllText($lowerPath, 'value: lower')
+            if ([System.IO.File]::ReadAllText($upperPath) -eq
+                [System.IO.File]::ReadAllText($lowerPath)) {
+                Set-ItResult -Skipped -Because 'the test filesystem is case-insensitive'
+                return
+            }
 
             $result = @(Import-Yaml -Path @($upperPath, $lowerPath))
 
             @($result.value) | Should -Be @('upper', 'lower')
         }
 
-        It 'suppresses path case variants on case-insensitive filesystems' -Skip:(-not $IsWindows) {
+        It 'suppresses path case variants on case-insensitive filesystems' {
             $path = Join-Path $TestDrive 'CaseVariant.yaml'
             [System.IO.File]::WriteAllText($path, 'value: once')
+            $caseVariantPath = $path.ToLowerInvariant()
+            try {
+                $null = [System.IO.File]::GetAttributes($caseVariantPath)
+            } catch [System.IO.FileNotFoundException] {
+                Set-ItResult -Skipped -Because 'the test filesystem is case-sensitive'
+                return
+            }
+
+            $result = @(Import-Yaml -Path @($path, $caseVariantPath))
+
+            $result.Count | Should -Be 1
+            $result[0].value | Should -Be 'once'
+        }
+
+        It 'suppresses Unicode normalization aliases on matching filesystems' {
+            $composedPath = Join-Path $TestDrive "caf$([char] 0x00E9).yaml"
+            $decomposedPath = Join-Path $TestDrive "cafe$([char] 0x0301).yaml"
+            [System.IO.File]::WriteAllText($composedPath, 'value: once')
+            try {
+                $null = [System.IO.File]::GetAttributes($decomposedPath)
+            } catch [System.IO.FileNotFoundException] {
+                Set-ItResult -Skipped -Because (
+                    'the test filesystem distinguishes Unicode normalization forms'
+                )
+                return
+            }
 
-            $result = @(Import-Yaml -Path @($path, $path.ToLowerInvariant()))
+            $result = @(Import-Yaml -LiteralPath @($composedPath, $decomposedPath))
 
             $result.Count | Should -Be 1
             $result[0].value | Should -Be 'once'
         }
 
+        It 'keeps delimiter-bearing Unix paths distinct' -Skip:$IsWindows {
+            $separator = [char] 0x001F
+            $firstDirectory = Join-Path $TestDrive 'identity-a'
+            $secondDirectory = Join-Path $TestDrive "identity-a${separator}identity-b"
+            $null = [System.IO.Directory]::CreateDirectory($firstDirectory)
+            $null = [System.IO.Directory]::CreateDirectory($secondDirectory)
+            $firstPath = Join-Path $firstDirectory "identity-b${separator}value.yaml"
+            $secondPath = Join-Path $secondDirectory 'value.yaml'
+            [System.IO.File]::WriteAllText($firstPath, 'value: first')
+            [System.IO.File]::WriteAllText($secondPath, 'value: second')
+
+            $result = @(Import-Yaml -LiteralPath @($firstPath, $secondPath))
+
+            @($result.value | Sort-Object) | Should -Be @('first', 'second')
+        }
+
         It 'sorts by canonical identity regardless of duplicate path spelling' {
             $firstPath = Join-Path $TestDrive 'canonical-a.yaml'
             $secondPath = Join-Path $TestDrive 'canonical-b.yaml'