Add support for alternative bracket delimiters { } and [ ] (closes #143)

csharp/Link.Foundation.Links.Notation.Tests/SingleLineParserTests.cs

@@ -431,5 +431,169 @@ public static void QuotedReferencesWithSpacesInLinkTest()
             Assert.Single(result[0].Values);
             Assert.Equal("value with spaces", result[0].Values?[0].Id);
         }
+
+        // Tests for alternative bracket delimiters (issue #143)
+
+        [Fact]
+        public static void CurlyBracesAsDelimitersLinkWithIdTest()
+        {
+            var input = "{id: source target}";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Equal("id", result[0].Id);
+            Assert.NotNull(result[0].Values);
+            Assert.Equal(2, result[0].Values!.Count);
+            Assert.Equal("source", result[0].Values![0].Id);
+            Assert.Equal("target", result[0].Values![1].Id);
+        }
+
+        [Fact]
+        public static void SquareBracketsAsDelimitersLinkWithIdTest()
+        {
+            var input = "[id: source target]";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Equal("id", result[0].Id);
+            Assert.NotNull(result[0].Values);
+            Assert.Equal(2, result[0].Values!.Count);
+            Assert.Equal("source", result[0].Values![0].Id);
+            Assert.Equal("target", result[0].Values![1].Id);
+        }
+
+        [Fact]
+        public static void CurlyBracesAsDelimitersValueLinkTest()
+        {
+            var input = "{a b c}";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Null(result[0].Id);
+            Assert.Equal(3, result[0].Values?.Count);
+        }
+
+        [Fact]
+        public static void SquareBracketsAsDelimitersValueLinkTest()
+        {
+            var input = "[a b c]";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Null(result[0].Id);
+            Assert.Equal(3, result[0].Values?.Count);
+        }
+
+        [Fact]
+        public static void CurlyBracesSingletTest()
+        {
+            var input = "{singlet}";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Null(result[0].Id);
+            Assert.Single(result[0].Values);
+            Assert.Equal("singlet", result[0].Values?[0].Id);
+        }
+
+        [Fact]
+        public static void SquareBracketsSingletTest()
+        {
+            var input = "[singlet]";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Null(result[0].Id);
+            Assert.Single(result[0].Values);
+            Assert.Equal("singlet", result[0].Values?[0].Id);
+        }
+
+        [Fact]
+        public static void NestedCurlyBracesTest()
+        {
+            var input = "{outer: {inner: value}}";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Equal("outer", result[0].Id);
+            Assert.Single(result[0].Values);
+            Assert.Equal("inner", result[0].Values?[0].Id);
+        }
+
+        [Fact]
+        public static void NestedSquareBracketsTest()
+        {
+            var input = "[outer: [inner: value]]";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Equal("outer", result[0].Id);
+            Assert.Single(result[0].Values);
+            Assert.Equal("inner", result[0].Values?[0].Id);
+        }
+
+        [Fact]
+        public static void MixedDelimitersParenthesesWithCurlyBracesTest()
+        {
+            var input = "(outer: {inner: value})";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Equal("outer", result[0].Id);
+            Assert.Single(result[0].Values);
+            Assert.Equal("inner", result[0].Values?[0].Id);
+        }
+
+        [Fact]
+        public static void MixedDelimitersSquareBracketsWithParenthesesTest()
+        {
+            var input = "[outer: (inner: value)]";
+            var parser = new Parser();
+            var result = parser.Parse(input);
+
+            Assert.Single(result);
+            Assert.Equal("outer", result[0].Id);
+            Assert.Single(result[0].Values);
+            Assert.Equal("inner", result[0].Values?[0].Id);
+        }
+
+        [Fact]
+        public static void CurlyBracesEquivalentToParenthesesTest()
+        {
+            var parenInput = "(id: source target)";
+            var curlyInput = "{id: source target}";
+            var parser = new Parser();
+
+            var parenResult = parser.Parse(parenInput);
+            var curlyResult = parser.Parse(curlyInput);
+
+            Assert.Equal(parenResult.Count, curlyResult.Count);
+            Assert.Equal(parenResult[0].Id, curlyResult[0].Id);
+            Assert.Equal(parenResult[0].Values?.Count, curlyResult[0].Values?.Count);
+        }
+
+        [Fact]
+        public static void SquareBracketsEquivalentToParenthesesTest()
+        {
+            var parenInput = "(id: source target)";
+            var bracketInput = "[id: source target]";
+            var parser = new Parser();
+
+            var parenResult = parser.Parse(parenInput);
+            var bracketResult = parser.Parse(bracketInput);
+
+            Assert.Equal(parenResult.Count, bracketResult.Count);
+            Assert.Equal(parenResult[0].Id, bracketResult[0].Id);
+            Assert.Equal(parenResult[0].Values?.Count, bracketResult[0].Values?.Count);
+        }
     }
 }

csharp/Link.Foundation.Links.Notation/Link.Foundation.Links.Notation.csproj

@@ -4,7 +4,7 @@
     <Description>Link.Foundation's Platform.Protocols.Lino Class Library</Description>
     <Copyright>Konstantin Diachenko</Copyright>
     <AssemblyTitle>Link.Foundation.Links.Notation</AssemblyTitle>
-    <VersionPrefix>0.12.0</VersionPrefix>
+    <VersionPrefix>0.13.0</VersionPrefix>
     <Authors>Konstantin Diachenko</Authors>
     <TargetFramework>net8</TargetFramework>
     <PackageId>Link.Foundation.Links.Notation</PackageId>
@@ -23,8 +23,7 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <LangVersion>latest</LangVersion>
-    <PackageReleaseNotes>Bug fixes.
-Test cases suite is updated.</PackageReleaseNotes>
+    <PackageReleaseNotes>Added support for alternative bracket delimiters { } and [ ] as equivalent to ( ).</PackageReleaseNotes>
     <Nullable>enable</Nullable>
     <RootNamespace>Link.Foundation.Links.Notation</RootNamespace>
     <NoWarn>$(NoWarn);CS8981;CS1591;CS1584;CS1658</NoWarn>

csharp/Link.Foundation.Links.Notation/Link.cs

@@ -146,6 +146,10 @@ public static string EscapeReference(string? reference)
                     reference.Contains(":") ||
                     reference.Contains("(") ||
                     reference.Contains(")") ||
+                    reference.Contains("{") ||
+                    reference.Contains("}") ||
+                    reference.Contains("[") ||
+                    reference.Contains("]") ||
                     reference.Contains(" ") ||
                     reference.Contains("\t") ||
                     reference.Contains("\n") ||

csharp/Link.Foundation.Links.Notation/Parser.peg

@@ -16,9 +16,11 @@ multiLineValues <IList<Link<string>>> = _ list:multiLineValueAndWhitespace* { li
 singleLineValueAndWhitespace <Link<string>> = __ value:referenceOrLink { value }
 singleLineValues <IList<Link<string>>> = list:singleLineValueAndWhitespace+ { list }
 singleLineLink <Link<string>> = __ id:(reference) __ ":" v:singleLineValues { new Link<string>(id, v) }
-multiLineLink <Link<string>> = "(" _ id:(reference) _ ":" v:multiLineValues _ ")" { new Link<string>(id, v) }
+multiLineLink <Link<string>> = openBracket _ id:(reference) _ ":" v:multiLineValues _ closeBracket { new Link<string>(id, v) }
 singleLineValueLink <Link<string>> = v:singleLineValues { new Link<string>(v) }
-multiLineValueLink <Link<string>> = "(" v:multiLineValues _ ")" { new Link<string>(v) }
+multiLineValueLink <Link<string>> = openBracket v:multiLineValues _ closeBracket { new Link<string>(v) }
+openBracket = "(" / "{" / "["
+closeBracket = ")" / "}" / "]"
 indentedIdLink <Link<string>> = id:(reference) __ ":" eol { new Link<string>(id) }
 
 reference <string> = doubleQuotedReference / singleQuotedReference / simpleReference
@@ -34,4 +36,4 @@ eof = !.
 __ = [ \t]*
 _ = whiteSpaceSymbol*
 whiteSpaceSymbol = [ \t\n\r]
-referenceSymbol = [^ \t\n\r(:)]
+referenceSymbol = [^ \t\n\r(:)\[\]{}]

js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "type": "module",

js/src/grammar.pegjs

@@ -71,11 +71,14 @@ singleLineValues = list:singleLineValueAndWhitespace+ { return list; }
 
 singleLineLink = __ id:reference __ ":" v:singleLineValues { return { id: id, values: v }; }
 
-multiLineLink = "(" _ id:reference _ ":" v:multiLineValues _ ")" { return { id: id, values: v }; }
+multiLineLink = openBracket _ id:reference _ ":" v:multiLineValues _ closeBracket { return { id: id, values: v }; }
 
 singleLineValueLink = v:singleLineValues { return { values: v }; }
 
-multiLineValueLink = "(" v:multiLineValues _ ")" { return { values: v }; }
+multiLineValueLink = openBracket v:multiLineValues _ closeBracket { return { values: v }; }
+
+openBracket = "(" / "{" / "["
+closeBracket = ")" / "}" / "]"
 
 indentedIdLink = id:reference __ ":" eol { return { id: id, values: [] }; }
 
@@ -103,4 +106,4 @@ _ = whiteSpaceSymbol*
 
 whiteSpaceSymbol = [ \t\n\r]
 
-referenceSymbol = [^ \t\n\r(:)]
+referenceSymbol = [^ \t\n\r(:)\[\]{}]