Preserve cyclic YAML removal targets

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

Author: MariusStorhaug

src/functions/private/Resolve-YamlRemovalTarget.ps1

@@ -36,7 +36,7 @@ function Resolve-YamlRemovalTarget {
             Edge          = $Document
             Node          = $Document
             Depth         = 0
-            Ancestors     = [string[]]::new(0)
+            Path          = [string[]] @($documentKey)
             Pointer       = $Pointer
             DocumentIndex = $DocumentIndex
         }
@@ -122,7 +122,7 @@ function Resolve-YamlRemovalTarget {
                     Edge          = $matchedEntry
                     Node          = $matchedEntry.Value
                     Depth         = $Tokens.Count
-                    Ancestors     = [string[]] $ancestors.ToArray()
+                    Path          = [string[]] (@($ancestors.ToArray()) + $edgeKey)
                     Pointer       = $Pointer
                     DocumentIndex = $DocumentIndex
                 }
@@ -176,7 +176,7 @@ function Resolve-YamlRemovalTarget {
                     Edge          = $sequenceItem
                     Node          = $sequenceItem
                     Depth         = $Tokens.Count
-                    Ancestors     = [string[]] $ancestors.ToArray()
+                    Path          = [string[]] (@($ancestors.ToArray()) + $edgeKey)
                     Pointer       = $Pointer
                     DocumentIndex = $DocumentIndex
                 }

src/functions/private/Select-YamlRemovalTarget.ps1

@@ -20,12 +20,12 @@ function Select-YamlRemovalTarget {
     foreach ($target in $Targets) {
         Add-YamlRemovalWork -State $State -Operation 'target coalescing' -Node $target.Node
         if ($coalesced.ContainsKey($target.Key)) {
-            $coalesced[$target.Key].AncestorSets.Add([string[]] $target.Ancestors)
+            $coalesced[$target.Key].PathSets.Add([string[]] $target.Path)
             continue
         }
 
-        $ancestorSets = [System.Collections.Generic.List[object]]::new()
-        $ancestorSets.Add([string[]] $target.Ancestors)
+        $pathSets = [System.Collections.Generic.List[object]]::new()
+        $pathSets.Add([string[]] $target.Path)
         $coalesced[$target.Key] = [pscustomobject]@{
             Key           = $target.Key
             Kind          = $target.Kind
@@ -34,28 +34,59 @@ function Select-YamlRemovalTarget {
             Edge          = $target.Edge
             Node          = $target.Node
             Depth         = $target.Depth
-            AncestorSets  = $ancestorSets
+            PathSets      = $pathSets
             Pointer       = $target.Pointer
             DocumentIndex = $target.DocumentIndex
         }
     }
 
-    $selectedKeys = [System.Collections.Generic.HashSet[string]]::new(
-        [System.StringComparer]::Ordinal
-    )
-    foreach ($key in $coalesced.Keys) {
-        [void] $selectedKeys.Add($key)
+    $pathRoot = [pscustomobject]@{
+        Children   = [System.Collections.Generic.Dictionary[string, object]]::new(
+            [System.StringComparer]::Ordinal
+        )
+        TargetKeys = [System.Collections.Generic.HashSet[string]]::new(
+            [System.StringComparer]::Ordinal
+        )
+    }
+    foreach ($target in $coalesced.Values) {
+        foreach ($path in $target.PathSets) {
+            $pathNode = $pathRoot
+            foreach ($edgeKey in $path) {
+                Add-YamlRemovalWork -State $State -Operation 'target path indexing' `
+                    -Node $target.Node
+                if (-not $pathNode.Children.ContainsKey($edgeKey)) {
+                    $pathNode.Children[$edgeKey] = [pscustomobject]@{
+                        Children   = [System.Collections.Generic.Dictionary[string, object]]::new(
+                            [System.StringComparer]::Ordinal
+                        )
+                        TargetKeys = [System.Collections.Generic.HashSet[string]]::new(
+                            [System.StringComparer]::Ordinal
+                        )
+                    }
+                }
+                $pathNode = $pathNode.Children[$edgeKey]
+            }
+            [void] $pathNode.TargetKeys.Add($target.Key)
+        }
     }
 
     $survivors = [System.Collections.Generic.List[object]]::new()
     foreach ($candidate in $coalesced.Values) {
         $allRequestsSubsumed = $true
-        foreach ($ancestorSet in $candidate.AncestorSets) {
+        foreach ($path in $candidate.PathSets) {
             $requestSubsumed = $false
-            foreach ($ancestorKey in $ancestorSet) {
-                Add-YamlRemovalWork -State $State -Operation 'ancestor coalescing' `
+            $pathNode = $pathRoot
+            for ($pathIndex = 0; $pathIndex -lt $path.Count - 1; $pathIndex++) {
+                Add-YamlRemovalWork -State $State -Operation 'target path ancestry' `
                     -Node $candidate.Node
-                if ($selectedKeys.Contains($ancestorKey)) {
+                $edgeKey = $path[$pathIndex]
+                if (-not $pathNode.Children.ContainsKey($edgeKey)) {
+                    break
+                }
+                $pathNode = $pathNode.Children[$edgeKey]
+                if ($pathNode.TargetKeys.Count -gt 1 -or
+                    ($pathNode.TargetKeys.Count -eq 1 -and
+                    -not $pathNode.TargetKeys.Contains($candidate.Key))) {
                     $requestSubsumed = $true
                     break
                 }

tests/Remove-YamlEntry.Tests.ps1

@@ -609,6 +609,76 @@ node: &node
             $result['node'].Contains('self') | Should -BeFalse
             $result['node']['keep'] | Should -BeTrue
         }
+
+        It 'removes an edge that repeats in its own direct cyclic path' {
+            $yaml = @'
+node: &node
+  self: *node
+  keep: true
+'@
+            $result = Remove-YamlEntry $yaml '/node/self/self' |
+                ConvertFrom-Yaml -AsHashtable
+
+            $result['node'].Contains('self') | Should -BeFalse
+            $result['node']['keep'] | Should -BeTrue
+        }
+
+        It 'removes an edge that repeats through a longer cycle' {
+            $yaml = @'
+first: &first
+  next: &second
+    back: *first
+    keep: true
+'@
+            $result = Remove-YamlEntry $yaml '/first/next/back/next/back' |
+                ConvertFrom-Yaml -AsHashtable
+
+            $result['first']['next'].Contains('back') | Should -BeFalse
+            $result['first']['next']['keep'] | Should -BeTrue
+        }
+
+        It 'does not mutually subsume targets reached through cyclic branches' {
+            $yaml = @'
+node: &node
+  a: *node
+  b: *node
+  keep: true
+'@
+            $result = Remove-YamlEntry $yaml @('/node/a/b', '/node/b/a') |
+                ConvertFrom-Yaml -AsHashtable
+
+            $result['node'].Contains('a') | Should -BeFalse
+            $result['node'].Contains('b') | Should -BeFalse
+            $result['node']['keep'] | Should -BeTrue
+        }
+
+        It 'coalesces one cyclic target reached through duplicate aliases' {
+            $yaml = @'
+node: &node
+  self: *node
+  keep: true
+copy: *node
+'@
+            $result = Remove-YamlEntry $yaml @('/node/self/self', '/copy/self/self') |
+                ConvertFrom-Yaml -AsHashtable
+
+            $result['node'].Contains('self') | Should -BeFalse
+            [object]::ReferenceEquals($result['node'], $result['copy']) |
+                Should -BeTrue
+        }
+
+        It 'subsumes a cyclic descendant only under a proper requested ancestor' {
+            $yaml = @'
+node: &node
+  self: *node
+  keep: true
+'@
+            $result = Remove-YamlEntry $yaml @('/node/self', '/node/self/self/keep') |
+                ConvertFrom-Yaml -AsHashtable
+
+            $result['node'].Contains('self') | Should -BeFalse
+            $result['node']['keep'] | Should -BeTrue
+        }
     }
 
     Context 'Tags and resulting graph validation' {