links-notation 0.21.1 → 0.21.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.21.1",
+  "version": "0.21.3",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/StreamParser.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { Parser } from './Parser.js';
-import { quotedReferenceEnd } from './comments.js';
+import { DelimitedReferences } from './quotes.js';
 
 const DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 
@@ -249,6 +249,7 @@ function structurallyComplete(document, comments) {
   const quotes = ['"', "'", '`'];
   const beforeReference = [' ', '\t', '\n', '\r', '(', ':'];
   const beforeComment = [' ', '\t', '\n', '\r'];
+  const references = new DelimitedReferences(document);
   let depth = 0;
 
   for (let position = 0; position < document.length; position++) {
@@ -259,7 +260,7 @@ function structurallyComplete(document, comments) {
       quotes.includes(character) &&
       (previous === null || beforeReference.includes(previous))
     ) {
-      const end = quotedReferenceEnd(document, position);
+      const end = references.endAt(position);
       if (end === null) return false;
       position = end - 1;
       continue;

package/src/comments.js

@@ -12,12 +12,11 @@
  * the reader can see.
  */
 
+import { DelimitedReferences, QUOTES, readReference } from './quotes.js';
+
 /** The character that starts a comment. */
 export const COMMENT = '#';
 
-/** The delimiters a reference can be written between. */
-const QUOTES = ['"', "'", '`'];
-
 /** What a delimited reference may start after. */
 const BEFORE_REFERENCE = [' ', '\t', '\n', '\r', '(', ':'];
 
@@ -38,6 +37,7 @@ export function stripComments(document) {
   // parse error reports are both counted in.
   let blanked = null;
   let position = 0;
+  const references = new DelimitedReferences(document);
 
   while (position < document.length) {
     const character = document[position];
@@ -46,7 +46,7 @@ export function stripComments(document) {
       QUOTES.includes(character) &&
       follows(document, position, BEFORE_REFERENCE)
     ) {
-      const end = quotedReferenceEnd(document, position);
+      const end = references.endAt(position);
       position = end === null ? position + 1 : end;
       continue;
     }
@@ -95,70 +95,6 @@ function follows(document, position, allowed) {
  * @returns {number|null} The position just past the reference
  */
 export function quotedReferenceEnd(document, start) {
-  const quote = document[start];
-  if (!QUOTES.includes(quote)) {
-    return null;
-  }
-
-  let position = start;
-  while (position < document.length && document[position] === quote) {
-    position++;
-  }
-  const count = position - start;
-  const isEvenRun = count % 2 === 0;
-  const emptyReference = isEvenRun ? start + count : null;
-
-  const closing = quote.repeat(count);
-  const escape = quote.repeat(count * 2);
-  let content = '';
-
-  while (position < document.length) {
-    if (document.startsWith(escape, position)) {
-      content += closing;
-      position += escape.length;
-      continue;
-    }
-
-    if (document.startsWith(closing, position)) {
-      const afterClosing = position + count;
-      if (afterClosing >= document.length || document[afterClosing] !== quote) {
-        if (isEvenRun && !isSubstantiveBody(content)) {
-          return emptyReference;
-        }
-        return afterClosing;
-      }
-    }
-
-    content += document[position];
-    position++;
-  }
-
-  return emptyReference;
-}
-
-/**
- * Whether a body written between an even run of delimiters carries something a
- * pair of delimiters enclosing nothing cannot.
- * @param {string} content - The body between the delimiters
- * @returns {boolean} True when the n-quote reading is the one to take
- */
-function isSubstantiveBody(content) {
-  let depth = 0;
-  let hasVisible = false;
-
-  for (const character of content) {
-    if (character === '(') {
-      depth++;
-    } else if (character === ')') {
-      depth--;
-      if (depth < 0) {
-        return false;
-      }
-    }
-    if (!/[ \t\n\r]/.test(character)) {
-      hasVisible = true;
-    }
-  }
-
-  return hasVisible && depth === 0;
+  const reading = readReference(document, start);
+  return reading === null ? null : start + reading.length;
 }

package/src/grammar.pegjs

@@ -1,3 +1,7 @@
+{{
+  import { DelimitedReferences } from './quotes.js';
+}}
+
 {
   let indentationStack = [0];
   let baseIndentation = null;
@@ -5,14 +9,27 @@
   // 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 = [];
+  // Lines already found unreadable, keyed by where they start and whether they
+  // are inside a parenthesised group. Reading a line depends on nothing else: a
+  // group starts a fresh indentation context, and indentation only decides
+  // which lines become children, so a line that could not be read once never
+  // can be. A line that does not parse as the first child of the line above it
+  // is tried again as a sibling at every enclosing indentation level, and
+  // without this each of those attempts would read the whole line again.
+  let unreadableLines = new Set();
 
   function resetState() {
     indentationStack = [0];
     baseIndentation = null;
     contextStack = [];
+    unreadableLines = new Set();
     return true;
   }
 
+  function lineKey(position) {
+    return contextStack.length > 0 ? -1 - position : position;
+  }
+
   function enterNestedContext() {
     contextStack.push({ indentationStack, baseIndentation });
     indentationStack = [0];
@@ -66,87 +83,18 @@
     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 (!/[ \t\n\r]/.test(c)) {
-        hasVisible = true;
-      }
-    }
-
-    return hasVisible && depth === 0;
-  }
+  // Delimited references of this document, each read once however many
+  // alternatives ask for it (see quotes.js for how a reference is read)
+  const delimitedReferences = new DelimitedReferences(input);
 
   // 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) {
       return null;
     }
-
-    // Count opening quotes
-    let quoteCount = 0;
-    let pos = startPos;
-    while (pos < inputStr.length && inputStr[pos] === quoteChar) {
-      quoteCount++;
-      pos++;
-    }
-
-    const isEvenRun = quoteCount % 2 === 0;
-    const emptyReference = isEvenRun ? { value: '', length: quoteCount } : null;
-
-    const closeSeq = quoteChar.repeat(quoteCount);
-    const escapeSeq = quoteChar.repeat(quoteCount * 2);
-
-    let content = '';
-    while (pos < inputStr.length) {
-      // Check for escape sequence (2*N quotes)
-      if (inputStr.substr(pos, escapeSeq.length) === escapeSeq) {
-        content += closeSeq; // 2*N quotes become N quotes
-        pos += escapeSeq.length;
-        continue;
-      }
-
-      // Check for closing sequence (exactly N quotes)
-      if (inputStr.substr(pos, quoteCount) === closeSeq) {
-        // Verify it's exactly N quotes (not followed by more of same char)
-        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
-          };
-        }
-      }
-
-      // Add character to content
-      content += inputStr[pos];
-      pos++;
-    }
-
-    return emptyReference; // No valid closing found
+    return delimitedReferences.readAt(startPos);
   }
 
   // Global state for passing parsed values between predicate and action
@@ -165,14 +113,39 @@ firstLine = SET_BASE_INDENTATION l:element { return l; }
 
 line = CHECK_INDENTATION l:element { return l; }
 
-element = e:anyLink PUSH_INDENTATION l:links {
+// A line is read once, whether or not indented children follow it: reading it
+// again after looking for children doubled the work at every level of nesting.
+element = &{ return !unreadableLines.has(lineKey(offset())); }
+    e:anyLink saved:SAVE_INDENTATION l:(PUSH_INDENTATION @links)? {
+    if (l === null) {
+      // No child line followed the indentation. Forget what looking for one
+      // pushed, so the next line is compared with this line's indentation.
+      indentationStack = saved;
+      return e;
+    }
     return Object.assign({}, e, { children: l });
   }
-  / e:anyLink { return e; }
+  // Remember that this line could not be read. The predicate always fails, so
+  // the "." is never reached; it only tells Peggy that this alternative cannot
+  // succeed without consuming input.
+  / &{ unreadableLines.add(lineKey(offset())); return false; } .
 
 referenceOrLink = l:multiLineAnyLink { return l; } / i:reference { return { id: i }; }
 
-anyLink = ml:multiLineAnyLink eol { return ml; } / il:indentedIdLink { return il; } / sl:singleLineAnyLink { return sl; }
+// A line that starts with a parenthesised group reads that group once and then
+// branches on what follows it: the end of the line makes the group the whole
+// link, and more values make it the first value of a value link. Neither an
+// indented ID nor a single-line link can start with a parenthesis, so nothing
+// else is tried for such a line; trying them read the group again, doubling
+// the work at every level of nesting.
+anyLink = &"(" @groupLink / !"(" @(indentedIdLink / singleLineAnyLink)
+
+groupLink = g:multiLineAnyLink rest:groupLinkRest {
+    return rest === null ? g : { values: [g].concat(rest) };
+  }
+
+groupLinkRest = eol { return null; }
+  / @singleLineValueAndWhitespace* eol
 
 multiLineAnyLink = nestedGroup
 
@@ -186,6 +159,9 @@ nestedGroup = "(" ENTER_NESTED_CONTEXT body:nestedGroupBody {
     exitNestedContext();
     return body;
   }
+  // The group was opened but its body did not parse: restore the context it
+  // was opened in before failing, just as a parsed group does.
+  / "(" &{ exitNestedContext(); return false; }
 
 nestedGroupBody = skipEmptyLines l:links _ ")" { return { nested: l }; }
   / _ ")" { return { nested: [] }; }
@@ -258,6 +234,8 @@ backtickQuotedUniversal = &'`' &{
 consumeBacktick = c:. cs:consumeBacktickMore* { return [c].concat(cs).join(''); }
 consumeBacktickMore = &{ return parsedLength > 1 && (parsedLength--, true); } c:. { return c; }
 
+SAVE_INDENTATION = "" { return indentationStack.slice(); }
+
 SET_BASE_INDENTATION = spaces:" "* { setBaseIndentation(spaces); }
 
 PUSH_INDENTATION = spaces:" "* &{ return normalizeIndentation(spaces) > getCurrentIndentation(); } { pushIndentation(spaces); }