clarity-pattern-parser 6.0.2 → 7.0.1

package/src/patterns/FiniteRepeat.ts

@@ -0,0 +1,231 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { findPattern } from "./findPattern";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+
+export interface FiniteRepeatOptions {
+    divider?: Pattern;
+    min?: number;
+    trimDivider?: boolean;
+}
+
+export class FiniteRepeat implements Pattern {
+    private _type: string;
+    private _name: string;
+    private _parent: Pattern | null;
+    private _children: Pattern[];
+    private _hasDivider: boolean;
+    private _min: number;
+    private _max: number;
+    private _trimDivider: boolean;
+
+    get type() {
+        return this._type;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get parent() {
+        return this._parent;
+    }
+
+    set parent(value: Pattern | null) {
+        this._parent = value;
+    }
+
+    get children() {
+        return this._children;
+    }
+
+    get isOptional() {
+        return this._min === 0;
+    }
+
+    get min() {
+        return this._min;
+    }
+
+    get max() {
+        return this._max;
+    }
+
+    constructor(name: string, pattern: Pattern, repeatAmount: number, options: FiniteRepeatOptions = {}) {
+        this._type = "finite-repeat";
+        this._name = name;
+        this._parent = null;
+        this._children = [];
+        this._hasDivider = options.divider != null;
+        this._min = options.min != null ? options.min : 1;
+        this._max = repeatAmount;
+        this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+
+        for (let i = 0; i < repeatAmount; i++) {
+            this._children.push(pattern.clone(pattern.name));
+
+            if (options.divider != null && (i < repeatAmount - 1 || !this._trimDivider)) {
+                this._children.push(options.divider.clone(options.divider.name, false));
+            }
+        }
+    }
+
+    parse(cursor: Cursor): Node | null {
+        const startIndex = cursor.index;
+        const nodes: Node[] = [];
+        const modulo = this._hasDivider ? 2 : 1;
+        let matchCount = 0;
+
+
+        for (let i = 0; i < this._children.length; i++) {
+            const childPattern = this._children[i];
+            const node = childPattern.parse(cursor);
+
+            if (i % modulo === 0 && !cursor.hasError) {
+                matchCount++
+            }
+
+            if (cursor.hasError) {
+                cursor.resolveError();
+                break;
+            }
+
+            if (node != null) {
+                nodes.push(node);
+
+                if (cursor.hasNext()) {
+                    cursor.next();
+                } else {
+                    break;
+                }
+            }
+
+        }
+
+        if (this._trimDivider && this._hasDivider) {
+            if (cursor.leafMatch.pattern === this.children[1]) {
+                const node = nodes.pop() as Node;
+                cursor.moveTo(node.firstIndex)
+            }
+        }
+
+        if (matchCount < this._min) {
+            cursor.moveTo(startIndex);
+            cursor.recordErrorAt(startIndex, this);
+            return null;
+        } else if (nodes.length === 0) {
+            cursor.resolveError();
+            cursor.moveTo(startIndex)
+            return null;
+        }
+
+        const firstIndex = nodes[0].firstIndex;
+        const lastIndex = nodes[nodes.length - 1].lastIndex;
+
+        cursor.moveTo(lastIndex);
+
+        return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
+    }
+
+    test(text: string): boolean {
+        const cursor = new Cursor(text);
+        const ast = this.parse(cursor);
+
+        return ast?.value === text;
+    }
+
+    exec(text: string): ParseResult {
+        const cursor = new Cursor(text);
+        const ast = this.parse(cursor);
+
+        return {
+            ast: ast?.value === text ? ast : null,
+            cursor
+        };
+    }
+
+    clone(name = this._name, isOptional?: boolean): Pattern {
+        let min = this._min;
+
+        if (isOptional != null) {
+            if (isOptional) {
+                min = 0
+            } else {
+                min = Math.max(this._min, 1);
+            }
+        }
+
+        return new FiniteRepeat(
+            name,
+            this._children[0],
+            this._max,
+            {
+                divider: this._hasDivider ? this._children[1] : undefined,
+                min,
+                trimDivider: this._trimDivider
+            }
+        );
+    }
+
+    getTokens(): string[] {
+        return this._children[0].getTokens();
+    }
+
+    getTokensAfter(childReference: Pattern): string[] {
+        const patterns = this.getPatternsAfter(childReference);
+        const tokens: string[] = [];
+
+        patterns.forEach(p => tokens.push(...p.getTokens()));
+
+        return tokens;
+    }
+
+    getNextTokens(): string[] {
+        if (this._parent == null) {
+            return []
+        }
+
+        return this._parent.getTokensAfter(this);
+    }
+
+    getPatterns(): Pattern[] {
+        return this._children[0].getPatterns();
+    }
+
+    getPatternsAfter(childReference: Pattern): Pattern[] {
+        const childIndex = this._children.indexOf(childReference);
+
+        // If Reference Pattern isn't a child.
+        if (childIndex == -1) {
+            return [];
+        }
+
+        // If Reference Pattern is the last pattern. Ask for the parents next patterns 
+        if (childIndex === this._children.length - 1) {
+            if (this._parent == null) {
+                return [];
+            } else {
+                return this._parent.getPatternsAfter(this);
+            }
+        }
+
+        // Get the next childs patterns.
+        const nextChild = this._children[childIndex + 1];
+
+        return nextChild.getPatterns()
+    }
+
+    getNextPatterns(): Pattern[] {
+        if (this._parent == null) {
+            return [];
+        }
+
+        return this._parent.getPatternsAfter(this);
+    }
+
+    find(predicate: (p: Pattern) => boolean): Pattern | null {
+        return findPattern(this, predicate);
+    }
+
+}

package/src/patterns/InfiniteRepeat.test.ts

@@ -0,0 +1,296 @@
+import { Node } from "../ast/Node";
+import { And } from "./And";
+import { Cursor } from "./Cursor";
+import { findPattern } from "./findPattern";
+import { Literal } from "./Literal";
+import { Pattern } from "./Pattern";
+import { Regex } from "./Regex";
+import { InfiniteRepeat } from "./InfiniteRepeat";
+
+describe("InfiniteRepeat", () => {
+    test("Successful Parse", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit);
+        const cursor = new Cursor("337");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 2, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("regex", "digit", 1, 1, [], "3"),
+            new Node("regex", "digit", 2, 2, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Bounds", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit, { min: 2 });
+
+        let cursor = new Cursor("3");
+        let result = integer.parse(cursor);
+        let expected: Node | null = null;
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("33");
+        result = integer.parse(cursor);
+        expected = new Node("infinite-repeat", "number", 0, 1, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("regex", "digit", 1, 1, [], "3")
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Failed Parse", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit);
+        const cursor = new Cursor("John");
+        const result = integer.parse(cursor);
+
+        expect(result).toBeNull()
+        expect(cursor.hasError).toBeTruthy()
+    });
+
+    test("Successful Parse With Divider", () => {
+        const digit = new Regex("digit", "\\d");
+        const divider = new Literal("divider", ",");
+        const integer = new InfiniteRepeat("number", digit, { divider });
+        const cursor = new Cursor("3,3,7");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("literal", "divider", 1, 1, [], ","),
+            new Node("regex", "digit", 2, 2, [], "3"),
+            new Node("literal", "divider", 3, 3, [], ","),
+            new Node("regex", "digit", 4, 4, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Successful Parse Text Ends With Divider", () => {
+        const digit = new Regex("digit", "\\d");
+        const divider = new Literal("divider", ",");
+        const integer = new InfiniteRepeat("number", digit, { divider, trimDivider: true });
+        const cursor = new Cursor("3,3,7,");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("literal", "divider", 1, 1, [], ","),
+            new Node("regex", "digit", 2, 2, [], "3"),
+            new Node("literal", "divider", 3, 3, [], ","),
+            new Node("regex", "digit", 4, 4, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Successful Parse Trailing Comma", () => {
+        const digit = new Regex("digit", "\\d");
+        const divider = new Literal("divider", ",");
+        const integer = new InfiniteRepeat("number", digit, { divider, trimDivider: true });
+        const cursor = new Cursor("3,3,7,t");
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "digit", 0, 0, [], "3"),
+            new Node("literal", "divider", 1, 1, [], ","),
+            new Node("regex", "digit", 2, 2, [], "3"),
+            new Node("literal", "divider", 3, 3, [], ","),
+            new Node("regex", "digit", 4, 4, [], "7"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Optional Repeating Pattern", () => {
+        const digit = new Regex("digit", "\\d+", true);
+        const divider = new Regex("divider", "\\s");
+        const integer = new InfiniteRepeat("number", digit, { divider });
+        const cursor = new Cursor(
+            "\n" +
+            "3\n" +
+            "\n" +
+            "\n"
+        );
+        const result = integer.parse(cursor);
+        const expected = new Node("infinite-repeat", "number", 0, 4, [
+            new Node("regex", "divider", 0, 0, [], "\n"),
+            new Node("regex", "digit", 1, 1, [], "3"),
+            new Node("regex", "divider", 2, 2, [], "\n"),
+            new Node("regex", "divider", 3, 3, [], "\n"),
+            new Node("regex", "divider", 4, 4, [], "\n"),
+        ]);
+
+        expect(result).toEqual(expected)
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Failed (Optional)", () => {
+        const digit = new Regex("digit", "\\d");
+        const integer = new InfiniteRepeat("number", digit, { min: 0 });
+        const cursor = new Cursor("John");
+        const result = integer.parse(cursor);
+
+        expect(result).toBeNull()
+        expect(cursor.hasError).toBeFalsy()
+    });
+
+    test("Get Tokens", () => {
+        const a = new Literal("a", "A");
+        const manyA = new InfiniteRepeat("number", a);
+        const tokens = manyA.getTokens();
+        const expected = ["A"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Tokens After With Bogus Pattern", () => {
+        const a = new Literal("a", "A");
+        const manyA = new InfiniteRepeat("many-a", a);
+        const tokens = manyA.getTokensAfter(new Literal("bogus", "bogus"));
+        const expected: string[] = [];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Tokens After With Divider", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const divider = new Literal("divider", ",");
+        const manyA = new InfiniteRepeat("many-a", a, { divider });
+        const parent = new And("parent", [manyA, b]);
+
+        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        let tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
+        let expected = [",", "B"];
+
+        expect(tokens).toEqual(expected)
+
+        tokens = clonedManyA?.getTokensAfter(clonedManyA.children[1]);
+        expected = ["A"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Get Tokens After Without Divider", () => {
+        const a = new Literal("a", "A");
+        const b = new Literal("b", "B");
+        const manyA = new InfiniteRepeat("many-a", a);
+        const parent = new And("parent", [manyA, b]);
+
+        const clonedManyA = findPattern(parent, p => p.name == "many-a");
+        const tokens = clonedManyA?.getTokensAfter(clonedManyA.children[0]);
+        const expected = ["A", "B"];
+
+        expect(tokens).toEqual(expected)
+    });
+
+    test("Properties", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+
+        expect(integer.type).toBe("infinite-repeat");
+        expect(integer.name).toBe("integer");
+        expect(integer.min).toBe(1);
+        expect(integer.isOptional).toBeFalsy()
+        expect(integer.parent).toBeNull();
+        expect(integer.children[0].name).toBe("digit");
+    });
+
+    test("Exec", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const { ast: result } = integer.exec("B");
+        expect(result).toBeNull()
+    });
+
+    test("Test With Match", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const result = integer.test("1");
+        expect(result).toBeTruthy()
+    });
+
+    test("Test With No Match", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const result = integer.test("b");
+        expect(result).toBeFalsy()
+    });
+
+    test("Get Next Tokens", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const integerClone = parent.find(p => p.name === "integer") as Pattern;
+        const tokens = integerClone.getNextTokens();
+
+        expect(tokens).toEqual(["!"])
+    });
+
+    test("Get Next Tokens With Null Parents", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const tokens = integer.getNextTokens();
+
+        expect(tokens.length).toBe(0);
+    });
+
+    test("Find Pattern", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const digitClone = integer.find(p => p.name === "digit") as Pattern;
+
+        expect(digitClone).not.toBeNull();
+    });
+
+    test("Get Patterns", () => {
+        const a = new Literal("a", "A");
+        const manyA = new InfiniteRepeat("number", a);
+        const patterns = manyA.getPatterns();
+        const expected = [manyA.find(p => p.name === "a")];
+
+        expect(patterns).toEqual(expected)
+    });
+
+    test("Get Next Patterns", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const parent = new And("parent", [integer, new Literal("pow", "!")]);
+        const integerClone = parent.find(p => p.name === "integer") as Pattern;
+        const powClone = parent.find(p => p.name === "pow") as Pattern;
+        const patterns = integerClone.getNextPatterns();
+
+        expect(patterns.length).toBe(1);
+        expect(patterns[0]).toBe(powClone);
+    });
+
+    test("Get Next Patterns With Null Parents", () => {
+        const integer = new InfiniteRepeat("integer", new Regex("digit", "\\d"));
+        const patterns = integer.getNextPatterns();
+
+        expect(patterns.length).toBe(0);
+    });
+
+    test("Clone With Custom Overrides", () => {
+        const numbers = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0 });
+        let clone = numbers.clone();
+        let expected = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers");
+        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers", true);
+        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers", false);
+        expected = new InfiniteRepeat("cloned-numbers", new Regex("number", "\\d"), { min: 1 });
+
+        expect(clone).toEqual(expected);
+    });
+});