clarity-pattern-parser 4.0.3 → 5.0.0

package/dist/patterns/Pattern.d.ts

@@ -1,26 +1,17 @@
-import Cursor from "../Cursor";
-import Node from "../ast/Node";
-export default abstract class Pattern {
-    protected _type: string;
-    protected _name: string;
-    protected _children: Pattern[];
-    protected _parent: Pattern | null;
-    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;
-    get name(): string;
-    get type(): string;
-    get parent(): Pattern | null;
-    set parent(value: Pattern | null);
-    get children(): Pattern[];
-    set children(value: Pattern[]);
-    abstract clone(name?: string): Pattern;
-    abstract getTokens(): string[];
-    getTokenValue(): string | null;
-    getNextTokens(): string[];
-    private cloneChildren;
-    private assignAsParent;
-}
+import { Cursor } from "./Cursor";
+import { Node } from "../ast/Node";
+import { ParseResult } from "./ParseResult";
+export interface Pattern {
+    type: string;
+    name: string;
+    parent: Pattern | null;
+    children: Pattern[];
+    isOptional: boolean;
+    parse(cursor: Cursor): Node | null;
+    parseText(text: string): ParseResult;
+    clone(name?: string, isOptional?: boolean): Pattern;
+    getTokens(): string[];
+    getNextTokens(lastMatched: Pattern): string[];
+    getNextPattern(): Pattern | null;
+    findPattern(isMatch: (p: Pattern) => boolean): Pattern | null;
+}

package/dist/patterns/Reference.d.ts

@@ -1,12 +1,31 @@
-import Pattern from "./Pattern";
-import Cursor from "../Cursor";
-export default class Reference extends Pattern {
-    constructor(name: string, isOptional?: boolean);
-    private getRoot;
-    private findPattern;
-    private walkTheTree;
-    parse(cursor: Cursor): import("..").Node | null;
-    clone(name?: string, isOptional?: boolean): Reference;
-    private safelyGetPattern;
-    getTokens(): string[];
-}
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+export declare class Reference implements Pattern {
+    private _type;
+    private _name;
+    private _parent;
+    private _isOptional;
+    private _pattern;
+    private _children;
+    get type(): string;
+    get name(): string;
+    get isOptional(): boolean;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    constructor(name: string, isOptional?: boolean);
+    parseText(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    clone(name?: string, isOptional?: boolean): Pattern;
+    getTokens(): string[];
+    getNextTokens(_lastMatched: Pattern): string[];
+    getNextPattern(): Pattern | null;
+    findPattern(_isMatch: (p: Pattern) => boolean): Pattern | null;
+    private _getPatternSafely;
+    private _findPattern;
+    private _getRoot;
+}

package/dist/patterns/Regex.d.ts

@@ -1,21 +1,42 @@
-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[];
-}
+import { Node } from "../ast/Node";
+import { Pattern } from "./Pattern";
+import { Cursor } from "./Cursor";
+export declare class Regex implements Pattern {
+    private _type;
+    private _name;
+    private _isOptional;
+    private _parent;
+    private _originalRegexString;
+    private _regex;
+    private _node;
+    private _cursor;
+    private _substring;
+    private _tokens;
+    private _hasContextualTokenAggregation;
+    private _isRetrievingContextualTokens;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get isOptional(): boolean;
+    constructor(name: string, regex: string, isOptional?: boolean);
+    private assertArguments;
+    parseText(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    private resetState;
+    private tryToParse;
+    private processResult;
+    private processError;
+    clone(name?: string, isOptional?: boolean): Regex;
+    getTokens(): string[];
+    getNextTokens(_reference: Pattern): string[];
+    getNextPattern(): Pattern | null;
+    findPattern(_isMatch: (p: Pattern) => boolean): Pattern | null;
+    setTokens(tokens: string[]): void;
+    enableContextualTokenAggregation(): void;
+    disableContextualTokenAggregation(): void;
+}

package/dist/patterns/Repeat.d.ts

@@ -1,20 +1,38 @@
-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[];
-}
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+export declare class Repeat implements Pattern {
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    private _pattern;
+    private _divider;
+    private _isOptional;
+    private _nodes;
+    private _firstIndex;
+    private _shouldReduceAst;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get isOptional(): boolean;
+    constructor(name: string, pattern: Pattern, divider?: Pattern, isOptional?: boolean);
+    private _assignChildrenToParent;
+    parseText(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    private tryToParse;
+    private createNode;
+    private getLastValidNode;
+    enableAstReduction(): void;
+    disableAstReduction(): void;
+    getTokens(): string[];
+    getNextTokens(lastMatched: Pattern): string[];
+    getNextPattern(): Pattern | null;
+    findPattern(isMatch: (p: Pattern) => boolean): Pattern | null;
+    clone(name?: string, isOptional?: boolean): Pattern;
+}

package/dist/patterns/clonePatterns.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function clonePatterns(patterns: Pattern[], isOptional?: boolean): Pattern[];

package/dist/patterns/filterOutNull.d.ts

@@ -0,0 +1,2 @@
+import { Node } from "../ast/Node";
+export declare function filterOutNull(nodes: (Node | null)[]): Node[];

package/dist/patterns/findPattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function findPattern(pattern: Pattern, predicate: (pattern: Pattern) => boolean): Pattern | null;

package/dist/patterns/getNextPattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function getNextPattern(pattern: Pattern): Pattern | null;

package/jest.config.js

@@ -9,4 +9,5 @@ module.exports = {
   "transform": {
     "^.+\\.(ts|tsx)$": "ts-jest"
   },
-}
+  coverageReporters: ["lcov", "text-summary"],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "4.0.3",
+  "version": "5.0.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",
@@ -8,17 +8,16 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "rollup -c -m",
-    "test": "jest"
+    "test": "jest --coverage"
   },
   "keywords": [],
   "devDependencies": {
     "@types/jest": "^26.0.23",
     "jest": "^26.6.3",
     "rollup": "^2.41.2",
-    "rollup-plugin-typescript2": "^0.30.0",
+    "@rollup/plugin-typescript": "^11.1.6",
     "ts-jest": "^26.5.3",
     "tslib": "^2.1.0",
     "typescript": "^4.2.3"
-  },
-  "dependencies": {}
+  }
 }

package/rollup.config.js

@@ -1,4 +1,4 @@
-import typescript from "rollup-plugin-typescript2";
+import typescript from "@rollup/plugin-typescript";
 import pkg from "./package.json";
 
 export default {

package/src/ast/Node.test.ts

@@ -0,0 +1,254 @@
+import { Node } from "./Node";
+
+describe("Node", () => {
+    test("Create", () => {
+        const node = new Node("type", "name", 0, 0, [], "value");
+
+        expect(node.type).toBe("type");
+        expect(node.name).toBe("name");
+        expect(node.value).toBe("value");
+        expect(node.firstIndex).toBe(0);
+        expect(node.lastIndex).toBe(0);
+        expect(node.startIndex).toBe(0);
+        expect(node.endIndex).toBe(1);
+        expect(node.parent).toBeNull();
+        expect(node.children.length).toBe(0);
+    });
+
+    test("Create Tree", () => {
+        const child = new Node("child", "child", 0, 0, [], "Child");
+        const parent = new Node("parent", "parent", 0, 0, [child]);
+
+        expect(parent.value).toBe(child.value);
+    });
+
+    test("Remove Child", () => {
+        const child = new Node("child", "child", 0, 0, [], "Child");
+        const parent = new Node("parent", "parent", 0, 0, [child]);
+
+        parent.removeChild(child);
+
+        expect(parent.children.length).toBe(0);
+        expect(child.parent).toBeNull();
+        expect(parent.value).toBe("");
+        expect(child.value).toBe("Child");
+    });
+
+    test("Remove all Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b], "Fallback Value");
+
+        expect(parent.children.length).toBe(2);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(parent.value).toBe("AB");
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+
+        parent.removeAllChildren();
+
+        expect(parent.children.length).toBe(0);
+        expect(a.parent).toBeNull();
+        expect(b.parent).toBeNull();
+        expect(parent.value).toBe("Fallback Value");
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Replace Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        parent.replaceChild(b, a);
+
+        expect(parent.children.length).toBe(1);
+        expect(a.parent).toBeNull();
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Insert Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.insertBefore(b, a);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("BA")
+        expect(parent.children[0]).toBe(b);
+        expect(parent.children[1]).toBe(a);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Insert Child With Null Reference", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.insertBefore(b, null);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("AB")
+        expect(parent.children[0]).toBe(a);
+        expect(parent.children[1]).toBe(b);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Append Child", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.appendChild(b);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("AB")
+        expect(parent.children[0]).toBe(a);
+        expect(parent.children[1]).toBe(b);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Splice Children", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.spliceChildren(0, 0, b);
+
+        expect(parent.children.length).toBe(2);
+        expect(parent.value).toBe("BA")
+        expect(parent.children[0]).toBe(b);
+        expect(parent.children[1]).toBe(a);
+        expect(a.parent).toBe(parent);
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+    test("Splice Children (Replace)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a]);
+
+        expect(parent.value).toBe("A");
+
+        parent.spliceChildren(0, 1, b);
+
+        expect(parent.children.length).toBe(1);
+        expect(parent.value).toBe("B")
+        expect(parent.children[0]).toBe(b);
+        expect(a.parent).toBeNull();
+        expect(b.parent).toBe(parent);
+        expect(a.value).toBe("A");
+        expect(b.value).toBe("B");
+    });
+
+
+    test("Find", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+
+        const result = parent.find(n => n.name === "a");
+
+        expect(result).toBe(a)
+    });
+
+    test("Walk Down", () => {
+        const result: Node[] = [];
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+
+        parent.walkDown((n) => {
+            result.push(n)
+        });
+
+        const expected = [parent, a, b];
+
+        expect(result).toEqual(expected);
+    });
+
+    test("Walk Up", () => {
+        const result: Node[] = [];
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+
+        parent.walkUp((n) => {
+            result.push(n)
+        });
+
+        const expected = [a, b, parent];
+
+        expect(result).toEqual(expected);
+    });
+
+    test("Clone", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+        const clone = parent.clone();
+
+        expect(clone).toEqual(parent)
+    });
+
+    test("Turn Into JSON", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const parent = new Node("parent", "parent", 0, 0, [a, b]);
+        const result = parent.toJson();
+        const expected = JSON.stringify({
+            type: "parent",
+            name: "parent",
+            value: "AB",
+            firstIndex: 0,
+            lastIndex: 0,
+            startIndex: 0,
+            endIndex: 1,
+            children: [{
+                type: "a",
+                name: "a",
+                value: "A",
+                firstIndex: 0,
+                lastIndex: 0,
+                startIndex: 0,
+                endIndex: 1,
+                children: [],
+            }, {
+                type: "b",
+                name: "b",
+                value: "B",
+                firstIndex: 0,
+                lastIndex: 0,
+                startIndex: 0,
+                endIndex: 1,
+                children: [],
+            }],
+        });
+
+        expect(result).toEqual(expected)
+    });
+
+});