clarity-pattern-parser 3.0.15 → 4.0.0

package/dist/patterns/Pattern.d.ts

@@ -5,9 +5,9 @@ export default abstract class Pattern {
     protected _name: string;
     protected _children: Pattern[];
     protected _parent: Pattern | null;
-    isSequence: boolean;
-    constructor(type: string | undefined, name: string, children?: Pattern[]);
-    private _assertName;
+    protected _isOptional: boolean;
+    get isOptional(): boolean;
+    constructor(type: string, name: string, children?: Pattern[], isOptional?: boolean);
     abstract parse(cursor: Cursor): Node | null;
     exec(text: string): Node | null;
     test(text: string): boolean;
@@ -17,11 +17,10 @@ export default abstract class Pattern {
     set parent(value: Pattern | null);
     get children(): Pattern[];
     set children(value: Pattern[]);
-    protected _assertChildren(): void;
-    private _cloneChildren;
-    private _assignAsParent;
     abstract clone(name?: string): Pattern;
     abstract getTokens(): string[];
-    getNextTokens(): string[];
     getTokenValue(): string | null;
+    getNextTokens(): string[];
+    private cloneChildren;
+    private assignAsParent;
 }

package/dist/patterns/{RecursivePattern.d.ts → Recursive.d.ts}

@@ -1,13 +1,13 @@
 import Pattern from "./Pattern";
 import Cursor from "../Cursor";
-export default class RecursivePattern extends Pattern {
+export default class Recursive extends Pattern {
     isRecursing: boolean;
     pattern: Pattern | null;
-    constructor(name: string);
+    constructor(name: string, isOptional?: boolean);
     getPattern(): Pattern | null;
-    _climb(pattern: Pattern | null, isMatch: (pattern: Pattern | null) => boolean): Pattern | null;
+    private climb;
     parse(cursor: Cursor): import("..").Node | null;
-    clone(name?: string): Pattern;
+    clone(name?: string, isOptional?: boolean): Recursive;
     getTokenValue(): string | null;
     getTokens(): string[];
 }

package/dist/patterns/Reference.d.ts

@@ -0,0 +1,14 @@
+import Pattern from "./Pattern";
+import Cursor from "../Cursor";
+export default class Reference extends Pattern {
+    private isRecursing;
+    constructor(name: string, isOptional?: boolean);
+    private getRoot;
+    private findPattern;
+    private walkTheTree;
+    parse(cursor: Cursor): import("..").Node | null;
+    clone(name?: string, isOptional?: boolean): Reference;
+    getTokenValue(): string | null;
+    private safelyGetPattern;
+    getTokens(): string[];
+}

package/dist/patterns/Regex.d.ts

@@ -0,0 +1,21 @@
+import Node from "../ast/Node";
+import Pattern from "./Pattern";
+import Cursor from "../Cursor";
+export default class Regex extends Pattern {
+    private regexString;
+    private regex;
+    private node;
+    private cursor;
+    private substring;
+    constructor(name: string, regex: string, isOptional?: boolean);
+    private assertArguments;
+    parse(cursor: Cursor): Node | null;
+    private resetState;
+    private tryToParse;
+    private processResult;
+    private processError;
+    private safelyGetCursor;
+    clone(name?: string, isOptional?: boolean): Regex;
+    getTokenValue(): string;
+    getTokens(): string[];
+}

package/dist/patterns/Repeat.d.ts

@@ -0,0 +1,20 @@
+import Pattern from "./Pattern";
+import Node from "../ast/Node";
+import Cursor from "../Cursor";
+export default class Repeat extends Pattern {
+    _pattern: Pattern;
+    _divider: Pattern;
+    nodes: Node[];
+    cursor: Cursor;
+    mark: number;
+    node: Node | null;
+    constructor(name: string, pattern: Pattern, divider?: Pattern, isOptional?: boolean);
+    private assertArguments;
+    private _reset;
+    parse(cursor: Cursor): Node | null;
+    private tryToParse;
+    private processResult;
+    private safelyGetCursor;
+    clone(name?: string, isOptional?: boolean): Repeat;
+    getTokens(): string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "3.0.15",
+  "version": "4.0.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/CursorHistory.ts

@@ -139,7 +139,7 @@ export default class CursorHistory {
     return cleanedStack;
   }
 
-  getLastParseStack() {
+  getLastParseStack(): Node[] {
     const stacks = this.getAllParseStacks();
     return stacks[stacks.length - 1] || [];
   }

package/src/ast/Node.ts

@@ -1,36 +1,39 @@
-export default abstract class Node {
+export default class Node {
   public type: string;
   public name: string;
   public startIndex: number;
   public endIndex: number;
-  public isComposite: boolean;
-  public children: Node[] = [];
-  public value: string = "";
+  public children: Node[];
+  public value: string;
 
   constructor(
     type: string,
     name: string,
     startIndex: number,
     endIndex: number,
-    isComposite = false
+    children: Node[] = [],
+    value: string = ""
   ) {
     this.type = type;
     this.name = name;
     this.startIndex = startIndex;
     this.endIndex = endIndex;
-    this.isComposite = isComposite;
-
-    if (
-      typeof this.startIndex !== "number" ||
-      typeof this.endIndex !== "number"
-    ) {
-      throw new Error(
-        "Invalid Arguments: startIndex and endIndex need to be number."
-      );
-    }
+    this.children = children;
+    this.value = value;
   }
 
-  abstract clone(): Node;
+  clone(): Node {
+    return new Node(
+      this.type,
+      this.name,
+      this.startIndex,
+      this.endIndex,
+      this.children.map((c) => c.clone()),
+      this.value
+    );
+  }
 
-  abstract toString(): string;
+  toString() {
+    return this.value;
+  }
 }

package/src/ast/Visitor.ts

@@ -11,11 +11,11 @@ export default class Visitor {
 
   flatten() {
     this.selectedNodes.forEach((node) => {
-      if (node.isComposite) {
+      if (node.children.length > 0) {
         const children: Node[] = [];
 
         Visitor.walkUp(node, (descendant: Node) => {
-          if (!descendant.isComposite) {
+          if (descendant.children.length === 0) {
             children.push(descendant);
           }
         });
@@ -38,14 +38,12 @@ export default class Visitor {
 
   private recursiveRemove(node: Node) {
     const nodesToRemove = this.selectedNodes;
-    if (node.isComposite && Array.isArray(node.children)) {
-      for (let x = 0; x < node.children.length; x++) {
-        if (nodesToRemove.indexOf(node.children[x]) > -1) {
-          node.children.splice(x, 1);
-          x--;
-        } else {
-          this.recursiveRemove(node.children[x]);
-        }
+    for (let x = 0; x < node.children.length; x++) {
+      if (nodesToRemove.indexOf(node.children[x]) > -1) {
+        node.children.splice(x, 1);
+        x--;
+      } else {
+        this.recursiveRemove(node.children[x]);
       }
     }
   }
@@ -136,12 +134,10 @@ export default class Visitor {
   }
 
   private recursiveTransform(node: Node, callback: (node: Node) => Node) {
-    if (node.isComposite && Array.isArray(node.children)) {
-      const length = node.children.length;
+    const length = node.children.length;
 
-      for (let x = 0; x < length; x++) {
-        node.children[x] = this.recursiveTransform(node.children[x], callback);
-      }
+    for (let x = 0; x < length; x++) {
+      node.children[x] = this.recursiveTransform(node.children[x], callback);
     }
 
     return callback(node);
@@ -168,7 +164,7 @@ export default class Visitor {
     const node = this.root;
     const selectedNodes: Node[] = [];
 
-    if (node.isComposite) {
+    if (node.children.length > 0) {
       Visitor.walkDown(node, (descendant: Node) => {
         if (callback(descendant)) {
           selectedNodes.push(descendant);
@@ -245,7 +241,7 @@ export default class Visitor {
   ) {
     ancestors.push(node);
 
-    if (node.isComposite && Array.isArray(node.children)) {
+    if (node.children.length > 0) {
       const children = node.children.slice();
       children.forEach((c) => this.walkUp(c, callback, ancestors));
     }
@@ -264,7 +260,7 @@ export default class Visitor {
     callback(node, ancestors);
     ancestors.push(node);
 
-    if (node.isComposite && Array.isArray(node.children)) {
+    if (node.children.length > 0) {
       const children = node.children.slice();
       children.forEach((c) => this.walkDown(c, callback, ancestors));
     }

package/src/index.ts

@@ -1,49 +1,33 @@
 import Node from "./ast/Node";
-import CompositeNode from "./ast/CompositeNode";
-import ValueNode from "./ast/ValueNode";
 import Cursor from "./Cursor";
-import RegexValue from "./patterns/value/RegexValue";
-import AndValue from "./patterns/value/AndValue";
-import AnyOfThese from "./patterns/value/AnyOfThese";
-import Literal from "./patterns/value/Literal";
-import NotValue from "./patterns/value/NotValue";
-import OptionalValue from "./patterns/value/OptionalValue";
-import OrValue from "./patterns/value/OrValue";
-import RepeatValue from "./patterns/value/RepeatValue";
-import ValuePattern from "./patterns/value/ValuePattern";
-import AndComposite from "./patterns/composite/AndComposite";
-import CompositePattern from "./patterns/composite/CompositePattern";
-import OptionalComposite from "./patterns/composite/OptionalComposite";
-import OrComposite from "./patterns/composite/OrComposite";
-import RepeatComposite from "./patterns/composite/RepeatComposite";
+import Regex from "./patterns/Regex";
+import And from "./patterns/And";
+import Literal from "./patterns/Literal";
+import LookAhead from "./patterns/LookAhead";
+import Not from "./patterns/Not";
+import Or from "./patterns/Or";
+import Repeat from "./patterns/Repeat";
 import ParseError from "./patterns/ParseError";
 import Pattern from "./patterns/Pattern";
-import RecursivePattern from "./patterns/RecursivePattern";
+import Recursive from "./patterns/Recursive";
+import Reference from "./patterns/Reference";
 import TextSuggester from "./TextSuggester";
 import Visitor from "./ast/Visitor";
 
 export {
   Node,
-  CompositeNode,
-  ValueNode,
   Cursor,
-  RegexValue,
-  AndValue,
-  AnyOfThese,
+  Regex,
+  And,
   Literal,
-  NotValue,
-  OptionalValue,
-  OrValue,
-  RepeatValue,
-  ValuePattern,
-  AndComposite,
-  CompositePattern,
-  OptionalComposite,
-  OrComposite,
-  RepeatComposite,
+  Not,
+  Or,
+  Repeat,
   ParseError,
   Pattern,
-  RecursivePattern,
+  Recursive,
+  Reference,
   TextSuggester,
   Visitor,
+  LookAhead,
 };

package/src/patterns/And.ts

@@ -0,0 +1,178 @@
+import ParseError from "../patterns/ParseError";
+import Cursor from "../Cursor";
+import Pattern from "./Pattern";
+import Node from "../ast/Node";
+
+export default class And extends Pattern {
+  public onPatternIndex: number = 0;
+  public nodes: (Node | null)[] = [];
+  public node: Node | null = null;
+  public cursor: Cursor | null = null;
+  public mark: number = 0;
+
+  constructor(name: string, patterns: Pattern[], isOptional = false) {
+    super("and", name, patterns, isOptional);
+  }
+
+  parse(cursor: Cursor) {
+    this.resetState(cursor);
+    this.tryToParse();
+
+    return this.node;
+  }
+
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    if (isOptional == null){
+      isOptional = this._isOptional;
+    }
+
+    return new And(name, this._children, isOptional);
+  }
+
+  getTokens() {
+    let tokens: string[] = [];
+
+    for (let x = 0; x < this._children.length; x++) {
+      const child = this._children[x];
+
+      if (child.isOptional) {
+        tokens = tokens.concat(child.getTokens());
+      } else {
+        tokens = tokens.concat(child.getTokens());
+        break;
+      }
+    }
+
+    return tokens;
+  }
+
+  private resetState(cursor: Cursor) {
+    this.onPatternIndex = 0;
+    this.nodes = [];
+    this.node = null;
+    this.cursor = cursor;
+    this.mark = this.cursor.mark();
+  }
+
+  private tryToParse() {
+    const cursor = this.safelyGetCursor();
+
+    while (true) {
+      const pattern = this._children[this.onPatternIndex];
+      const node = pattern.parse(cursor);
+
+      if (cursor.hasUnresolvedError()) {
+        this.processError();
+        break;
+      } else {
+        this.nodes.push(node);
+      }
+
+      if (!this.shouldProceed()) {
+        this.processResult();
+        break;
+      }
+    }
+  }
+
+  private safelyGetCursor() {
+    const cursor = this.cursor;
+
+    if (cursor == null) {
+      throw new Error("Couldn't find cursor.");
+    }
+    return cursor;
+  }
+
+  private processResult() {
+    const cursor = this.safelyGetCursor();
+
+    if (cursor.hasUnresolvedError()) {
+      this.processError();
+    } else {
+      this.processSuccess();
+    }
+  }
+
+  private processError() {
+    const cursor = this.safelyGetCursor();
+
+    if (this.isOptional) {
+      cursor.moveToMark(this.mark);
+      cursor.resolveError();
+    }
+    this.node = null;
+  }
+
+  private shouldProceed() {
+    const cursor = this.safelyGetCursor();
+
+    if (this.hasMorePatterns()) {
+      const lastNode = this.nodes[this.nodes.length - 1];
+      const wasOptional = lastNode == null;
+
+      if (cursor.hasNext()) {
+        if (!wasOptional) {
+          cursor.next();
+        }
+
+        this.onPatternIndex++;
+        return true;
+      } else if (wasOptional) {
+        this.onPatternIndex++;
+        return true;
+      }
+
+      this.assertRestOfPatternsAreOptional();
+      return false;
+    } else {
+      return false;
+    }
+  }
+
+  private hasMorePatterns() {
+    return this.onPatternIndex + 1 < this._children.length;
+  }
+
+  private assertRestOfPatternsAreOptional() {
+    const cursor = this.safelyGetCursor();
+    const areTheRestOptional = this.areTheRemainingPatternsOptional();
+
+    if (!areTheRestOptional) {
+      const parseError = new ParseError(
+        `Could not match ${this.name} before string ran out.`,
+        this.onPatternIndex,
+        this
+      );
+
+      cursor.throwError(parseError);
+    }
+  }
+
+  private areTheRemainingPatternsOptional() {
+    return this.children
+      .slice(this.onPatternIndex + 1)
+      .map((p) => p.isOptional)
+      .every((r) => r);
+  }
+
+  private processSuccess() {
+    const cursor = this.safelyGetCursor();
+    const nodes = this.nodes.filter((node) => node != null) as Node[];
+    this.nodes = nodes;
+
+    const lastNode = nodes[this.nodes.length - 1];
+    const startIndex = this.mark;
+    const endIndex = lastNode.endIndex;
+    const value = nodes.map((node) => node.value).join("");
+
+    this.node = new Node("and", this.name, startIndex, endIndex, nodes, value);
+
+    cursor.index = this.node.endIndex;
+    cursor.addMatch(this, this.node);
+  }
+}

package/src/patterns/Literal.ts

@@ -0,0 +1,91 @@
+import ParseError from "./ParseError";
+import Node from "../ast/Node";
+import Pattern from "./Pattern";
+import Cursor from "../Cursor";
+
+export default class Literal extends Pattern {
+  public literal: string;
+  public node: Node | null = null;
+  public cursor!: Cursor;
+  public mark: number = 0;
+  public substring: string = "";
+
+  constructor(name: string, literal: string, isOptional = false) {
+    super("literal", name, [], isOptional);
+    this.literal = literal;
+    this.assertArguments();
+  }
+
+  parse(cursor: Cursor) {
+    this.resetState(cursor);
+    this.tryToParse();
+
+    return this.node;
+  }
+
+  clone(name?: string, isOptional?: boolean) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    if (isOptional == null) {
+      isOptional = this._isOptional;
+    }
+    
+    return new Literal(name, this.literal, isOptional);
+  }
+
+  getTokens() {
+    return [this.literal];
+  }
+
+  private assertArguments() {
+    if (this.literal.length < 1) {
+      throw new Error(
+        "Invalid Arguments: The `literal` argument needs to be at least one character long."
+      );
+    }
+  }
+
+  private resetState(cursor: Cursor) {
+    this.cursor = cursor;
+    this.mark = this.cursor.mark();
+    this.substring = this.cursor.text.substring(
+      this.mark,
+      this.mark + this.literal.length
+    );
+    this.node = null;
+  }
+
+  private tryToParse() {
+    if (this.substring === this.literal) {
+      this.processResult();
+    } else {
+      this.processError();
+    }
+  }
+
+  private processError() {
+    this.node = null;
+
+    if (!this._isOptional) {
+      const message = `ParseError: Expected '${this.literal}' but found '${this.substring}'.`;
+      const parseError = new ParseError(message, this.cursor.getIndex(), this);
+      this.cursor.throwError(parseError);
+    }
+  }
+
+  private processResult() {
+    this.node = new Node(
+      "literal",
+      this.name,
+      this.mark,
+      this.mark + this.literal.length - 1,
+      [],
+      this.substring
+    );
+
+    this.cursor.index = this.node.endIndex;
+    this.cursor.addMatch(this, this.node);
+  }
+}

package/src/patterns/LookAhead.ts

@@ -0,0 +1,32 @@
+import Cursor from "../Cursor";
+import ParseError from "./ParseError";
+import Pattern from "./Pattern";
+
+export default class LookAhead extends Pattern {
+  constructor(pattern: Pattern) {
+    super("look-ahead", "look-ahead", [pattern]);
+  }
+
+  parse(cursor: Cursor) {
+    const mark = cursor.mark();
+    const node = this.children[0].parse(cursor);
+
+    if (cursor.hasUnresolvedError() || node == null) {
+      cursor.resolveError();
+      cursor.throwError(
+        new ParseError("Couldn't find look ahead pattern.", mark, this.children[0])
+      );
+      cursor.moveToMark(mark);
+    }
+
+    return null;
+  }
+
+  clone() {
+    return new LookAhead(this.children[0].clone());
+  }
+
+  getTokens() {
+    return [];
+  }
+}

package/src/patterns/Not.ts

@@ -0,0 +1,50 @@
+import Pattern from "./Pattern";
+import ParseError from "./ParseError";
+import Cursor from "../Cursor";
+
+export default class Not extends Pattern {
+  public cursor!: Cursor;
+  public mark: number = 0;
+
+  constructor(pattern: Pattern) {
+    super("not", `not-${pattern.name}`, [pattern]);
+    this._isOptional = true;
+  }
+
+  parse(cursor: Cursor) {
+    this.cursor = cursor;
+    this.mark = cursor.mark();
+    this.tryToParse();
+    return null;
+  }
+
+  private tryToParse() {
+    const mark = this.cursor.mark();
+    this.children[0].parse(this.cursor);
+
+    if (this.cursor.hasUnresolvedError()) {
+      this.cursor.resolveError();
+      this.cursor.moveToMark(mark);
+    } else {
+      this.cursor.moveToMark(mark);
+      const parseError = new ParseError(
+        `Match invalid pattern: ${this.children[0].name}.`,
+        this.mark,
+        this
+      );
+      this.cursor.throwError(parseError);
+    }
+  }
+
+  clone(name?: string) {
+    if (name == null) {
+      name = this.name;
+    }
+
+    return new Not(this.children[0]);
+  }
+
+  getTokens() {
+    return [];
+  }
+}