Fix C# parser to handle indented ID syntax - Fixes #105

csharp/Platform.Protocols.Lino.Tests/MixedIndentationModesTests.cs

@@ -0,0 +1,218 @@
+using System;
+using Xunit;
+
+namespace Platform.Protocols.Lino.Tests
+{
+    public static class MixedIndentationModesTests
+    {
+        [Fact]
+        public static void HeroExampleMixedModesTest()
+        {
+            var input = @"empInfo
+  employees:
+    (
+      name (James Kirk)
+      age 40
+    )
+    (
+      name (Jean-Luc Picard)
+      age 45
+    )
+    (
+      name (Wesley Crusher)
+      age 27
+    )";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            var formatted = result.Format();
+            Assert.Contains("empInfo", formatted);
+            Assert.Contains("employees", formatted);
+            Assert.Contains("James Kirk", formatted);
+            Assert.Contains("Jean-Luc Picard", formatted);
+            Assert.Contains("Wesley Crusher", formatted);
+        }
+
+        [Fact]
+        public static void HeroExampleAlternativeFormatTest()
+        {
+            var input = @"empInfo
+  (
+    employees:
+      (
+        name (James Kirk)
+        age 40
+      )
+      (
+        name (Jean-Luc Picard)
+        age 45
+      )
+      (
+        name (Wesley Crusher)
+        age 27
+      )
+  )";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            var formatted = result.Format();
+            Assert.Contains("empInfo", formatted);
+            Assert.Contains("employees:", formatted);
+            Assert.Contains("James Kirk", formatted);
+            Assert.Contains("Jean-Luc Picard", formatted);
+            Assert.Contains("Wesley Crusher", formatted);
+        }
+
+        [Fact]
+        public static void HeroExampleEquivalenceTest()
+        {
+            var version1 = @"empInfo
+  employees:
+    (
+      name (James Kirk)
+      age 40
+    )
+    (
+      name (Jean-Luc Picard)
+      age 45
+    )
+    (
+      name (Wesley Crusher)
+      age 27
+    )";
+
+            var version2 = @"empInfo
+  (
+    employees:
+      (
+        name (James Kirk)
+        age 40
+      )
+      (
+        name (Jean-Luc Picard)
+        age 45
+      )
+      (
+        name (Wesley Crusher)
+        age 27
+      )
+  )";
+
+            var parser = new Parser();
+            var result1 = parser.Parse(version1);
+            var result2 = parser.Parse(version2);
+
+            Assert.NotEmpty(result1);
+            Assert.NotEmpty(result2);
+
+            var formatted1 = result1.Format();
+            var formatted2 = result2.Format();
+
+            Assert.Equal(formatted1, formatted2);
+        }
+
+        [Fact]
+        public static void SetContextWithoutColonTest()
+        {
+            var input = @"empInfo
+  employees";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            var formatted = result.Format();
+            Assert.Contains("empInfo", formatted);
+            Assert.Contains("employees", formatted);
+        }
+
+        [Fact]
+        public static void SequenceContextWithColonTest()
+        {
+            var input = @"employees:
+  James Kirk
+  Jean-Luc Picard
+  Wesley Crusher";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            Assert.Single(result);
+            var formatted = result.Format();
+            Assert.Contains("employees:", formatted);
+            Assert.Contains("James Kirk", formatted);
+            Assert.Contains("Jean-Luc Picard", formatted);
+            Assert.Contains("Wesley Crusher", formatted);
+        }
+
+        [Fact]
+        public static void SequenceContextWithComplexValuesTest()
+        {
+            var input = @"employees:
+  (
+    name (James Kirk)
+    age 40
+  )
+  (
+    name (Jean-Luc Picard)
+    age 45
+  )";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            Assert.Single(result);
+            var formatted = result.Format();
+            Assert.Contains("employees:", formatted);
+            Assert.Contains("James Kirk", formatted);
+            Assert.Contains("Jean-Luc Picard", formatted);
+        }
+
+        [Fact]
+        public static void NestedSetAndSequenceContextsTest()
+        {
+            var input = @"company
+  departments:
+    engineering
+    sales
+  employees:
+    (name John)
+    (name Jane)";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            var formatted = result.Format();
+            Assert.Contains("company", formatted);
+            Assert.Contains("departments:", formatted);
+            Assert.Contains("employees:", formatted);
+        }
+
+        [Fact]
+        public static void DeeplyNestedMixedModesTest()
+        {
+            var input = @"root
+  level1
+    level2:
+      value1
+      value2
+    level2b
+      level3";
+
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.NotEmpty(result);
+            var formatted = result.Format();
+            Assert.Contains("root", formatted);
+            Assert.Contains("level2:", formatted);
+        }
+    }
+}

csharp/Platform.Protocols.Lino/ILinksGroupListExtensions.cs

@@ -33,42 +33,48 @@ private static void CollectLinksWithIndentedIdSyntaxSupport<TLinkAddress>(List<L
             if (groups != null && groups.Count > 0)
             {
                 bool isIndentedIdSyntax = link.Id != null &&
-                                          (link.Values == null || link.Values.Count == 0) &&
-                                          !parentDependency.HasValue;
+                                          (link.Values == null || link.Values.Count == 0);
 
-                if (isIndentedIdSyntax)
+                if (isIndentedIdSyntax && !parentDependency.HasValue)
                 {
                     var childValues = new List<Link<TLinkAddress>>();
                     for (int i = 0; i < groups.Count; i++)
                     {
-                        var innerGroup = groups[i];
-                        var innerLink = innerGroup.Link;
-
-                        if (innerLink.Values != null && innerLink.Values.Count == 1)
-                        {
-                            childValues.Add(innerLink.Values[0]);
-                        }
-                        else if (innerLink.Values != null && innerLink.Values.Count > 1)
-                        {
-                            childValues.Add(innerLink);
-                        }
-                        else if (innerLink.Id != null)
-                        {
-                            childValues.Add(new Link<TLinkAddress>(innerLink.Id));
-                        }
+                        var transformedLink = TransformIndentedIdLink(groups[i]);
+                        childValues.Add(transformedLink);
                     }
 
                     var linkWithChildren = new Link<TLinkAddress>(link.Id, childValues);
                     list.Add(linkWithChildren);
                 }
                 else
                 {
+                    var transformedGroups = new List<LinksGroup<TLinkAddress>>();
+                    for (int i = 0; i < groups.Count; i++)
+                    {
+                        var childGroup = groups[i];
+                        var childLink = childGroup.Link;
+                        var childGroups = childGroup.Groups;
+
+                        if (childLink.Id != null &&
+                            (childLink.Values == null || childLink.Values.Count == 0) &&
+                            childGroups != null && childGroups.Count > 0)
+                        {
+                            var transformedLink = TransformIndentedIdLink(childGroup);
+                            transformedGroups.Add(new LinksGroup<TLinkAddress>(transformedLink));
+                        }
+                        else
+                        {
+                            transformedGroups.Add(childGroup);
+                        }
+                    }
+
                     var currentDependency = parentDependency.HasValue ? parentDependency.Value.Combine(link) : link;
                     list.Add(currentDependency);
 
-                    for (int i = 0; i < groups.Count; i++)
+                    for (int i = 0; i < transformedGroups.Count; i++)
                     {
-                        CollectLinksWithIndentedIdSyntaxSupport(list, groups[i], currentDependency);
+                        CollectLinksWithIndentedIdSyntaxSupport(list, transformedGroups[i], currentDependency);
                     }
                 }
             }
@@ -78,5 +84,32 @@ private static void CollectLinksWithIndentedIdSyntaxSupport<TLinkAddress>(List<L
                 list.Add(currentLink);
             }
         }
+
+        private static Link<TLinkAddress> TransformIndentedIdLink<TLinkAddress>(LinksGroup<TLinkAddress> group)
+        {
+            var link = group.Link;
+            var groups = group.Groups;
+
+            if (groups != null && groups.Count > 0 &&
+                link.Id != null &&
+                (link.Values == null || link.Values.Count == 0))
+            {
+                var childValues = new List<Link<TLinkAddress>>();
+                for (int i = 0; i < groups.Count; i++)
+                {
+                    var transformedChild = TransformIndentedIdLink(groups[i]);
+                    childValues.Add(transformedChild);
+                }
+                return new Link<TLinkAddress>(link.Id, childValues);
+            }
+            else if (link.Values != null && link.Values.Count == 1)
+            {
+                return link.Values[0];
+            }
+            else
+            {
+                return link;
+            }
+        }
     }
 }

experiments/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "debug_rust"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "debug_equivalence"
+path = "debug_rust_equivalence.rs"
+
+[dependencies]
+platform-lino = { path = "../rust" }

experiments/Program.cs

@@ -0,0 +1,24 @@
+using System;
+using Platform.Protocols.Lino;
+
+var version1 = @"empInfo
+  employees:
+    (
+      name (James Kirk)
+      age 40
+    )
+    (
+      name (Jean-Luc Picard)
+      age 45
+    )";
+
+var parser = new Parser();
+var result1 = parser.Parse(version1);
+
+Console.WriteLine("=== BEFORE TRANSFORM ===");
+Console.WriteLine(result1.Format());
+
+var transformed = result1.TransformIndentedIdSyntax();
+
+Console.WriteLine("\n=== AFTER TRANSFORM ===");
+Console.WriteLine(transformed.Format());