fix: yaml anchor preprocessor bug for mapping and sequence objects (#628)

* too many objects has been read from the anchor if followed by sequence / mapping

Author: ChristopherHX

src/Sdk.Tests/Actions/ActionsTests.cs

@@ -0,0 +1,105 @@
+using GitHub.DistributedTask.Expressions2;
+using GitHub.DistributedTask.ObjectTemplating;
+using GitHub.DistributedTask.Pipelines.ContextData;
+using GitHub.DistributedTask.Pipelines.ObjectTemplating;
+
+namespace Runner.Server
+{
+    public class ActionsTests
+    {
+        private static TemplateContext CreateTemplateContext(GitHub.DistributedTask.ObjectTemplating.ITraceWriter traceWriter) {
+            ExpressionFlags flags = ExpressionFlags.None;
+
+            var templateContext = new TemplateContext() {
+                Flags = flags,
+                CancellationToken = CancellationToken.None,
+                Errors = new TemplateValidationErrors(10, 500),
+                Memory = new TemplateMemory(
+                    maxDepth: 100,
+                    maxEvents: 1000000,
+                    maxBytes: 10 * 1024 * 1024),
+                TraceWriter = traceWriter,
+                Schema = PipelineTemplateSchemaFactory.GetSchema()
+            };
+            return templateContext;
+        }
+
+        [Fact]
+        public void TestParseYamlAnchorsComplex()
+        {
+      using var content = new StringReader(@"
+name: 'Test Workflow'
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: &name ubuntu-latest
+    steps:
+      - &anchor
+        name: Checkout
+        uses: actions/checkout@v4
+      - name: Run Tests
+        run: echo 'Running tests...'
+  build2:
+    runs-on: ubuntu-latest
+    steps:
+      - *anchor
+      - *anchor
+      - *anchor
+      - name: Run Tests
+        run: echo 'Running tests...'
+  *name:
+    runs-on: ubuntu-latest
+    steps:
+      - *anchor
+      - *anchor
+      - *anchor
+");
+
+            YamlObjectReader reader = new YamlObjectReader(null, content, true);
+            var ctx = CreateTemplateContext(new EmptyTraceWriter());
+            var result = TemplateReader.Read(ctx, "workflow-root", reader, null, out _);
+            Assert.Equal(0, ctx.Errors.Count);
+            Assert.NotNull(result);
+            string f = result.ToContextData().ToJToken().ToString();
+            Console.WriteLine(f);
+        }
+        
+        [Fact]
+        public void TestParseYamlAnchorsSimple()
+        {
+      using var content = new StringReader(@"
+- &anchor
+  key: value
+- *anchor
+");
+
+            YamlObjectReader reader = new YamlObjectReader(null, content, true);
+            var ctx = CreateTemplateContext(new EmptyTraceWriter());
+            var result = TemplateReader.Read(ctx, "any", reader, null, out _);
+            Assert.Equal(0, ctx.Errors.Count);
+            Assert.NotNull(result);
+            string f = result.ToContextData().ToJToken().ToString();
+            Console.WriteLine(f);
+        }
+        
+        [Fact]
+        public void TestParseYamlAnchorsSimpleSplitByMapping()
+        {
+      using var content = new StringReader(@"
+a:
+- &anchor
+  key: value
+b:
+- *anchor
+");
+
+            YamlObjectReader reader = new YamlObjectReader(null, content, true);
+            var ctx = CreateTemplateContext(new EmptyTraceWriter());
+            var result = TemplateReader.Read(ctx, "any", reader, null, out _);
+            Assert.Equal(0, ctx.Errors.Count);
+            Assert.NotNull(result);
+            string f = result.ToContextData().ToJToken().ToString();
+            Console.WriteLine(f);
+        }
+    }
+}

src/Sdk/DTPipelines/Pipelines/ObjectTemplating/YamlAnchorParser.cs

@@ -70,7 +70,8 @@ private void Merge()
                 events.Add(cevent);
             }
 
-            if(yamlMerge) {
+            if (yamlMerge)
+            {
                 // Disable Merge Operator by default
                 foreach (var node in events)
                 {
@@ -95,7 +96,10 @@ private void Merge()
                     }
                 }
             }
+            // Broken here already
+            DumpState();
             events.CleanMarked();
+            DumpState();
             foreach (var node in events)
             {
                 var m_current = node.Value;
@@ -120,10 +124,20 @@ private void Merge()
                     // Verify not using achors
                     if (sequenceStart.Anchor != null)
                     {
-                        node.Value = new SequenceStart(null, sequenceStart.Tag, sequenceStart.IsImplicit, sequenceStart.Style, sequenceStart.Start, sequenceStart.End);   
+                        node.Value = new SequenceStart(null, sequenceStart.Tag, sequenceStart.IsImplicit, sequenceStart.Style, sequenceStart.Start, sequenceStart.End);
                     }
                 }
             }
+            DumpState();
+        }
+
+        private void DumpState()
+        {
+            List<string> evs = new List<string>();
+            foreach (var reference in events)
+            {
+                evs.Add(reference.Value.ToString());
+            }
         }
 
         private bool HandleMerge(LinkedListNode<ParsingEvent> node)
@@ -181,6 +195,7 @@ private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode
         private bool HandleAnchorAlias2(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, AnchorAlias anchorAlias)
         {
             var mergedEvents = GetEvents(anchorAlias.Value).ToArray();
+            // Broken here already
 
             events.AddAfter(node, mergedEvents);
             events.MarkDeleted(anchorNode);
@@ -225,17 +240,18 @@ private IEnumerable<ParsingEvent> GetEvents(AnchorName anchor)
         {
             var cloner = new ParsingEventCloner();
             var nesting = 0;
-            bool prev = true;
+            bool shouldStop = false;
 
             return events.FromAnchor(anchor)
                 .Select(e => e.Value)
                 .TakeWhile(e => {
-                    var now = (nesting += e.NestingIncrease) >= 1;
-                    if(!now && prev) {
-                        prev = false;
-                        return true;
+                    if (shouldStop)
+                    {
+                        return false;
                     }
-                    return now;
+                    // We want to stop after the closing pair
+                    shouldStop |= (nesting += e.NestingIncrease) <= 0;
+                    return true;
                 })
                 .Select(e => cloner.Clone(e));
         }