links-notation 0.13.0 → 0.15.0

package/src/grammar.pegjs

@@ -1,6 +1,37 @@
 {
   let indentationStack = [0];
   let baseIndentation = null;
+  // Saved indentation contexts of the enclosing scopes. Every parenthesised
+  // group opens a nested context that starts fresh at indentation level zero,
+  // so line breaks and indentation mean the same thing at every depth.
+  let contextStack = [];
+
+  function resetState() {
+    indentationStack = [0];
+    baseIndentation = null;
+    contextStack = [];
+    return true;
+  }
+
+  function enterNestedContext() {
+    contextStack.push({ indentationStack, baseIndentation });
+    indentationStack = [0];
+    baseIndentation = null;
+    return true;
+  }
+
+  function exitNestedContext() {
+    const saved = contextStack.pop();
+    if (saved) {
+      indentationStack = saved.indentationStack;
+      baseIndentation = saved.baseIndentation;
+    }
+    return true;
+  }
+
+  function isInsideNestedContext() {
+    return contextStack.length > 0;
+  }
 
   function setBaseIndentation(spaces) {
     if (baseIndentation === null) {
@@ -35,8 +66,36 @@
     return indentationStack[indentationStack.length - 1];
   }
 
+  // A body written between an even run of delimiters is substantive when it
+  // holds at least one visible character and does not straddle a parenthesis.
+  // An even run can always be read as delimiter pairs enclosing nothing, so the
+  // n-quote reading is only taken when it carries something the pairs cannot.
+  function isSubstantiveBody(content) {
+    let depth = 0;
+    let hasVisible = false;
+
+    for (const c of content) {
+      if (c === '(') {
+        depth++;
+      } else if (c === ')') {
+        depth--;
+        if (depth < 0) {
+          return false;
+        }
+      }
+      if (!/\s/.test(c)) {
+        hasVisible = true;
+      }
+    }
+
+    return hasVisible && depth === 0;
+  }
+
   // Universal procedural parser for N-quote strings (any N >= 1)
   // Parses from the given position in the input string
+  // A run of an even number of delimiters that does not open a reference with a
+  // substantive body is the empty reference: the shortest reading, a bare
+  // delimiter pair enclosing nothing, wins over a longer n-quote delimiter.
   // Returns { value, length } or null
   function parseQuotedStringAt(inputStr, startPos, quoteChar) {
     if (startPos >= inputStr.length || inputStr[startPos] !== quoteChar) {
@@ -51,6 +110,9 @@
       pos++;
     }
 
+    const isEvenRun = quoteCount % 2 === 0;
+    const emptyReference = isEvenRun ? { value: '', length: quoteCount } : null;
+
     const closeSeq = quoteChar.repeat(quoteCount);
     const escapeSeq = quoteChar.repeat(quoteCount * 2);
 
@@ -69,6 +131,9 @@
         const afterClose = pos + quoteCount;
         if (afterClose >= inputStr.length || inputStr[afterClose] !== quoteChar) {
           // Found valid closing
+          if (isEvenRun && !isSubstantiveBody(content)) {
+            return emptyReference;
+          }
           return {
             value: content,
             length: afterClose - startPos
@@ -81,7 +146,7 @@
       pos++;
     }
 
-    return null; // No valid closing found
+    return emptyReference; // No valid closing found
   }
 
   // Global state for passing parsed values between predicate and action
@@ -89,8 +154,8 @@
   let parsedLength = 0;
 }
 
-document = &{ indentationStack = [0]; baseIndentation = null; return true; } skipEmptyLines links:links _ eof { return links; }
-  / &{ indentationStack = [0]; baseIndentation = null; return true; } _ eof { return []; }
+document = &{ return resetState(); } skipEmptyLines links:links _ eof { return links; }
+  / &{ return resetState(); } _ eof { return []; }
 
 skipEmptyLines = ([ \t]* [\r\n])*
 
@@ -101,7 +166,7 @@ firstLine = SET_BASE_INDENTATION l:element { return l; }
 line = CHECK_INDENTATION l:element { return l; }
 
 element = e:anyLink PUSH_INDENTATION l:links {
-    return { id: e.id, values: e.values, children: l };
+    return Object.assign({}, e, { children: l });
   }
   / e:anyLink { return e; }
 
@@ -109,14 +174,23 @@ referenceOrLink = l:multiLineAnyLink { return l; } / i:reference { return { id:
 
 anyLink = ml:multiLineAnyLink eol { return ml; } / il:indentedIdLink { return il; } / sl:singleLineAnyLink { return sl; }
 
-multiLineAnyLink = multiLineValueLink / multiLineLink
+multiLineAnyLink = nestedGroup
 
 singleLineAnyLink = fl:singleLineLink eol { return fl; }
   / vl:singleLineValueLink eol { return vl; }
 
-multiLineValueAndWhitespace = value:referenceOrLink _ { return value; }
+// A parenthesised group opens a nested context that follows exactly the same
+// rules as the root of the document: line breaks separate links and
+// indentation nests them, starting fresh at indentation level zero.
+nestedGroup = "(" ENTER_NESTED_CONTEXT body:nestedGroupBody {
+    exitNestedContext();
+    return body;
+  }
+
+nestedGroupBody = skipEmptyLines l:links _ ")" { return { nested: l }; }
+  / _ ")" { return { nested: [] }; }
 
-multiLineValues = _ list:multiLineValueAndWhitespace* { return list; }
+ENTER_NESTED_CONTEXT = &{ return enterNestedContext(); }
 
 singleLineValueAndWhitespace = __ value:referenceOrLink { return value; }
 
@@ -124,12 +198,8 @@ 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 }; }
-
 singleLineValueLink = v:singleLineValues { return { values: v }; }
 
-multiLineValueLink = "(" v:multiLineValues _ ")" { return { values: v }; }
-
 indentedIdLink = id:reference __ ":" eol { return { id: id, values: [] }; }
 
 // Reference can be quoted (with any number of quotes N >= 1) or simple unquoted
@@ -194,7 +264,11 @@ PUSH_INDENTATION = spaces:" "* &{ return normalizeIndentation(spaces) > getCurre
 
 CHECK_INDENTATION = spaces:" "* &{ return checkIndentation(spaces); }
 
-eol = __ ([\r\n]+ / eof)
+eol = __ ([\r\n]+ / eof / nestedGroupEnd)
+
+// Inside a parenthesised group the closing parenthesis terminates a line the
+// same way the end of the input does at the root.
+nestedGroupEnd = &{ return isInsideNestedContext(); } &")"
 
 eof = !.