clarity-pattern-parser 8.4.14 → 9.0.0

package/src/intellisense/javascript/fraction.ts

@@ -1,11 +1,11 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { Regex } from "../../patterns/Regex";
 
 const period = new Literal("period", ".");
 const digit = new Regex("digit", "\\d+");
-const fraction = new And("fraction", [period, digit]);
+const fraction = new Sequence("fraction", [period, digit]);
 
 export {
     fraction
-}
+};

package/src/intellisense/javascript/infixOperator.ts

@@ -1,40 +1,40 @@
-import { Literal } from "../../patterns/Literal"
-import { Or } from "../../patterns/Or";
+import { Literal } from "../../patterns/Literal";
+import { Options } from "../../patterns/Options";
 
 const multiply = new Literal("multiply", "*");
 const divide = new Literal("divide", "/");
 const remainder = new Literal("remainder", "%");
 const add = new Literal("add", "+");
 const subtract = new Literal("subtract", "-");
-const greaterOrEqual = new Literal("greater-or-equal", ">=");
-const lessOrEqual = new Literal("less-or-equal", "<=");
+const greaterOptionsEqual = new Literal("greater-or-equal", ">=");
+const lessOptionsEqual = new Literal("less-or-equal", "<=");
 const greater = new Literal("greater", ">");
 const less = new Literal("less", "<");
 const equal = new Literal("equal", "==");
 const notEqual = new Literal("not-equal", "!=");
 const strictEqual = new Literal("strict-equal", "===");
 const strictNotEqual = new Literal("strict-not-equal", "!==");
-const logicalOr = new Literal("logical-or", "||");
+const logicalOptions = new Literal("logical-or", "||");
 const logicalAnd = new Literal("logical-and", "&&");
 
-const infixOperator = new Or("infix-operator", [
+const infixOperator = new Options("infix-operator", [
     multiply,
     divide,
     remainder,
     add,
     subtract,
-    greaterOrEqual,
-    lessOrEqual,
+    greaterOptionsEqual,
+    lessOptionsEqual,
     greater,
     less,
     strictEqual,
     strictNotEqual,
     equal,
     notEqual,
-    logicalOr,
+    logicalOptions,
     logicalAnd
 ]);
 
-export { infixOperator }
+export { infixOperator };
 
 

package/src/intellisense/javascript/integer.ts

@@ -4,4 +4,4 @@ const integer = new Regex("integer", "([1-9][0-9]*)|0");
 
 export {
     integer
-}
+};

package/src/intellisense/javascript/invocation.ts

@@ -1,28 +1,29 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Reference } from "../../patterns/Reference";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { optionalSpaces } from "./optionalSpaces";
+import { Optional } from "../../patterns/Optional";
 
 const divider = new Regex("invocation-divider", "\\s*,\\s*");
 
-const invocationWithArguments = new And("invocation-with-arguments", [
+const invocationWithArguments = new Sequence("invocation-with-arguments", [
     new Literal("open-paren", "("),
     optionalSpaces,
-    new Repeat("expressions", new Reference("expression"), { divider, min: 0 }),
+    new Optional("optional-expression", new Repeat("expressions", new Reference("expression"), { divider })),
     optionalSpaces,
     new Literal("close-paren", ")"),
 ]);
 
-const emptyInvocation = new And("empty-invocation", [
+const emptyInvocation = new Sequence("empty-invocation", [
     new Literal("open-paren", "("),
     optionalSpaces,
     new Literal("close-paren", ")"),
 ]);
 
-export const invocation = new Or("invocation", [
+export const invocation = new Options("invocation", [
     emptyInvocation,
     invocationWithArguments
-])
+]);

package/src/intellisense/javascript/literal.ts

@@ -1,14 +1,14 @@
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { arrayLiteral } from "./arrayLiteral";
 import { numberLiteral } from "./numberLiteral";
 import { objectLiteral } from "./objectLiteral";
 import { stringLiteral } from "./stringLiteral";
 
-const literal = new Or("literal", [
+const literal = new Options("literal", [
     numberLiteral,
     stringLiteral,
     arrayLiteral,
     objectLiteral,
 ]);
 
-export { literal }
+export { literal };

package/src/intellisense/javascript/numberLiteral.ts

@@ -1,10 +1,11 @@
-import { And } from "../../patterns/And";
+import { Optional } from "../../patterns/Optional";
+import { Sequence } from "../../patterns/Sequence";
 import { exponent } from "./exponent";
 import { fraction } from "./fraction";
 import { integer } from "./integer";
 
-export const numberLiteral = new And("number-literal", [
+export const numberLiteral = new Sequence("number-literal", [
     integer,
-    fraction.clone("number-fraction", true),
-    exponent.clone("number-exponent", true)
+    new Optional("number-fraction", fraction),
+    new Optional("number-exponent", exponent)
 ]);

package/src/intellisense/javascript/objectAccess.ts

@@ -1,9 +1,8 @@
-import { And } from "../../patterns/And";
-import { Reference } from "../../patterns/Reference";
+import { Sequence } from "../../patterns/Sequence";
 import { name } from "./name";
 import { propertyAccess } from "./propertyAccess";
 
-export const objectAccess = new And("object-access", [
+export const objectAccess = new Sequence("object-access", [
     name.clone("variable-name"),
     propertyAccess,
 ]);

package/src/intellisense/javascript/objectLiteral.ts

@@ -1,15 +1,16 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Reference } from "../../patterns/Reference";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { name } from "./name";
 import { optionalSpaces } from "./optionalSpaces";
 import { stringLiteral } from "./stringLiteral";
+import { Optional } from "../../patterns/Optional";
 
-const propertyName = new Or("property-name", [stringLiteral.clone("object-property"), name.clone("object-property")]);
-const property = new And("property", [
+const propertyName = new Options("property-name", [stringLiteral.clone("object-property"), name.clone("object-property")]);
+const property = new Sequence("property", [
     propertyName,
     optionalSpaces,
     new Literal("colon", ":"),
@@ -17,9 +18,9 @@ const property = new And("property", [
     new Reference("expression"),
 ]);
 const divider = new Regex("property-divider", "\\s*,\\s*");
-const optionalProperties = new Repeat("properties", property, { divider, min: 0 });
+const optionalProperties = new Optional("optional-properties", new Repeat("properties", property, { divider}));
 
-const objectLiteral = new And("object-literal", [
+const objectLiteral = new Sequence("object-literal", [
     new Literal("open-curly-bracket", "{"),
     optionalSpaces,
     optionalProperties,
@@ -27,4 +28,4 @@ const objectLiteral = new And("object-literal", [
     new Literal("close-curly-bracket", "}"),
 ]);
 
-export { objectLiteral }
+export { objectLiteral };

package/src/intellisense/javascript/optionalSpaces.ts

@@ -1,3 +1,4 @@
+import { Optional } from "../../patterns/Optional";
 import { Regex } from "../../patterns/Regex";
 
-export const optionalSpaces = new Regex("optional-spaces", "\\s+", true);
+export const optionalSpaces = new Optional("optional-spaces", new Regex("optional-spaces", "\\s+"));

package/src/intellisense/javascript/parameters.ts

@@ -1,19 +1,19 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { name } from "./name";
+import { optionalSpaces } from "./optionalSpaces";
 
 const divider = new Regex(",", "\\s*[,]\\s*");
 divider.setTokens([", "]);
 
-const optionalSpace = new Regex("optional-space", "\\s", true)
 
-const parameters = new And("parameters", [
+const parameters = new Sequence("parameters", [
     new Literal("open-paren", "("),
-    optionalSpace,
+    optionalSpaces,
     new Repeat("arguments", name, { divider, trimDivider: true }),
-    optionalSpace,
+    optionalSpaces,
     new Literal("close-paren", ")"),
 ]);
 

package/src/intellisense/javascript/prefixOperator.ts

@@ -1,13 +1,12 @@
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
-import { Regex } from "../../patterns/Regex";
+import { Options } from "../../patterns/Options";
 
-const prefixOperator = new Or("prefix-operator", [
+const prefixOperator = new Options("prefix-operator", [
     new Literal("typeof", "typeof "),
     new Literal("to-number", "+"),
     new Literal("negate", "-"),
     new Literal("logical-not", "!"),
 ]);
 
-export { prefixOperator }
+export { prefixOperator };
 

package/src/intellisense/javascript/propertyAccess.ts

@@ -1,28 +1,29 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Reference } from "../../patterns/Reference";
 import { name } from "./name";
+import { Optional } from "../../patterns/Optional";
 
-const dotPropertyAccess = new And("dot-property-access", [
+const dotPropertyAccess = new Sequence("dot-property-access", [
     new Literal("period", "."),
     name.clone("property-name")
 ]);
 
-const bracketPropertyAccess = new And("bracket-property-access", [
+const bracketPropertyAccess = new Sequence("bracket-property-access", [
     new Literal("open-square-bracket", "["),
     new Reference("expression"),
     new Literal("close-square-bracket", "]"),
 ]);
 
-const propertyAccessTypes = new Or("property-access-types", [
+const propertyAccessTypes = new Options("property-access-types", [
     dotPropertyAccess,
     bracketPropertyAccess
 ]);
 
-const propertyAccess = new And("property-access", [
+const propertyAccess = new Sequence("property-access", [
     propertyAccessTypes,
-    new Reference("property-access", true)
+    new Optional("optional-property-access", new Reference("property-access"))
 ]);
 
-export { propertyAccess }
+export { propertyAccess };

package/src/intellisense/javascript/stringLiteral.ts

@@ -1,34 +1,33 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { escapedCharacter } from "./escapedCharacter";
+import { Optional } from "../../patterns/Optional";
 
-const doubleQuoteStringLiteral = new And("double-string-literal", [
+const doubleQuoteStringLiteral = new Sequence("double-string-literal", [
     new Literal("double-quote", "\""),
-    new Repeat("characters",
-        new Or("characters", [
+    new Optional("optional-characters", new Repeat("characters",
+        new Options("characters", [
             new Regex("normal-characters", "[^\\\"]+"),
             escapedCharacter
-        ]),
-        { min: 0 }
-    ),
+        ])
+    )),
     new Literal("double-quote", "\""),
 ]);
 
-const singleQuoteStringLiteral = new And("single-string-literal", [
+const singleQuoteStringLiteral = new Sequence("single-string-literal", [
     new Literal("single-quote", "'"),
-    new Repeat("characters",
-        new Or("characters", [
+    new Optional("optional-characters", new Repeat("characters",
+        new Options("characters", [
             new Regex("normal-characters", "[^\\']+"),
             escapedCharacter
         ]),
-        { min: 0 }
-    ),
+    )),
     new Literal("single-quote", "'"),
 ]);
 
-const stringLiteral = new Or("string-literal", [doubleQuoteStringLiteral, singleQuoteStringLiteral]);
+const stringLiteral = new Options("string-literal", [doubleQuoteStringLiteral, singleQuoteStringLiteral]);
 
-export { stringLiteral }
+export { stringLiteral };

package/src/patterns/Cursor.ts

@@ -1,5 +1,5 @@
 import { Node } from "../ast/Node";
-import { CursorHistory, Match } from "./CursorHistory";
+import { CursorHistory, Match, Trace } from "./CursorHistory";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
 
@@ -8,6 +8,7 @@ export class Cursor {
   private _index: number;
   private _length: number;
   private _history: CursorHistory;
+  private _stackTrace: Trace[];
 
   get text(): string {
     return this._text;
@@ -66,11 +67,11 @@ export class Cursor {
   }
 
   get hasError(): boolean {
-    return this._history.error != null
+    return this._history.error != null;
   }
 
   get currentChar(): string {
-    return this._text[this._index]
+    return this._text[this._index];
   }
 
   constructor(text: string) {
@@ -78,6 +79,7 @@ export class Cursor {
     this._index = 0;
     this._length = text.length;
     this._history = new CursorHistory();
+    this._stackTrace = [];
   }
 
   hasNext(): boolean {
@@ -131,7 +133,7 @@ export class Cursor {
   }
 
   resolveError(): void {
-    this._history.resolveError()
+    this._history.resolveError();
   }
 
   startRecording(): void {
@@ -142,4 +144,40 @@ export class Cursor {
     this._history.stopRecording();
   }
 
+  startParseWith(pattern: Pattern) {
+    const patternName = pattern.name;
+
+    const trace = {
+      pattern,
+      cursorIndex: this.index
+    };
+
+    if (this._stackTrace.find(t => t.pattern.id === pattern.id && this.index === t.cursorIndex)) {
+      throw new Error(`Cyclical Pattern: ${this._stackTrace.map(t => `${t.pattern.name}#${t.pattern.id}{${t.cursorIndex}}`).join(" -> ")} -> ${patternName}#${pattern.id}{${this.index}}.`);
+    }
+
+    this._history.pushStackTrace(trace);
+    this._stackTrace.push(trace);
+  }
+
+  endParse() {
+    this._stackTrace.pop();
+  }
+
+  audit() {
+    return this._history.trace.map(t => {
+      const onChar = this.getChars(t.cursorIndex, t.cursorIndex);
+      const restChars = this.getChars(t.cursorIndex + 1, t.cursorIndex + 5);
+      const context = `{${t.cursorIndex}}[${onChar}]${restChars}`;
+      return `${this._buildPatternContext(t.pattern)}-->${context}`;
+    });
+  }
+
+  private _buildPatternContext(pattern: Pattern) {
+    if (pattern.parent != null) {
+      return `${pattern.parent.name}.${pattern.name}`;
+    }
+    return pattern.name;
+  }
+
 }

package/src/patterns/CursorHistory.ts

@@ -2,6 +2,11 @@ import { Node } from "../ast/Node";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
 
+export interface Trace {
+  pattern: Pattern;
+  cursorIndex: number;
+}
+
 export interface Match {
   pattern: Pattern | null;
   node: Node | null;
@@ -16,6 +21,7 @@ export class CursorHistory {
   private _patterns: Pattern[] = [];
   private _nodes: Node[] = [];
   private _errors: ParseError[] = [];
+  private _trace: Trace[] = [];
 
   get isRecording(): boolean {
     return this._isRecording;
@@ -42,7 +48,7 @@ export class CursorHistory {
   }
 
   get error(): ParseError | null {
-    return this._currentError
+    return this._currentError;
   }
 
   get nodes(): Node[] {
@@ -53,6 +59,10 @@ export class CursorHistory {
     return this._patterns;
   }
 
+  get trace(): Trace[] {
+    return this._trace;
+  }
+
   recordMatch(pattern: Pattern, node: Node): void {
     if (this._isRecording) {
       this._patterns.push(pattern);
@@ -67,7 +77,7 @@ export class CursorHistory {
       leafMatch.node === null || node.lastIndex > leafMatch.node.lastIndex;
 
     const isSameIndexMatch =
-      leafMatch.node === null || node.lastIndex === leafMatch.node.lastIndex
+      leafMatch.node === null || node.lastIndex === leafMatch.node.lastIndex;
 
     if (isFurthestMatch) {
       // This is to save on GC churn.
@@ -85,10 +95,10 @@ export class CursorHistory {
           if (parent === pattern.parent) {
             return true;
           }
-          parent = parent.parent
+          parent = parent.parent;
         }
         return false;
-      })
+      });
 
       if (!isAncestor) {
         this._leafMatches.unshift({ pattern, node });
@@ -121,4 +131,10 @@ export class CursorHistory {
     this._currentError = null;
   }
 
+  pushStackTrace(trace: Trace) {
+    if (this._isRecording) {
+      this._trace.push(trace);
+    }
+  }
+
 }