clarity-pattern-parser 6.0.2 → 7.0.0

package/src/patterns/FiniteRepeat.test.ts

@@ -0,0 +1,481 @@
+import { FiniteRepeat } from "./FiniteRepeat";
+import { Cursor } from "./Cursor";
+import { Regex } from "./Regex";
+import { Node } from "../ast/Node";
+import { Literal } from "./Literal";
+import { And } from "./And";
+
+describe("BoundedRepeat", () => {
+    test("Bounds Without Divider", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, {
+            min: 2
+        });
+
+        let cursor = new Cursor("1");
+        let result = numbers.parse(cursor);
+        let expected: Node | null = null;
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("12");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 1, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+
+        cursor = new Cursor("123");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 2, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2"),
+            new Node("regex", "number", 2, 2, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+
+        cursor = new Cursor("1234");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 2, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2"),
+            new Node("regex", "number", 2, 2, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+        expect(cursor.index).toBe(2);
+
+        cursor = new Cursor("12f");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 1, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Bounds Are Equal Without Divider", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 3});
+
+        let cursor = new Cursor("1");
+        let result = numbers.parse(cursor);
+        let expected: Node | null = null;
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("12");
+        result = numbers.parse(cursor);
+        expected = null;
+
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("123");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 2, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2"),
+            new Node("regex", "number", 2, 2, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+
+        cursor = new Cursor("1234");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 2, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("regex", "number", 1, 1, [], "2"),
+            new Node("regex", "number", 2, 2, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+        expect(cursor.index).toBe(2);
+
+    });
+
+    test("Bounds With Divider", () => {
+        const divider = new Literal("comma", ",");
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { divider, min: 2, trimDivider: true });
+
+        let cursor = new Cursor("1,");
+        let result = numbers.parse(cursor);
+        let expected: Node | null = null;
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("1,2");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 2, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("literal", "comma", 1, 1, [], ","),
+            new Node("regex", "number", 2, 2, [], "2"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+
+        cursor = new Cursor("1,2,3,");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 4, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("literal", "comma", 1, 1, [], ","),
+            new Node("regex", "number", 2, 2, [], "2"),
+            new Node("literal", "comma", 3, 3, [], ","),
+            new Node("regex", "number", 4, 4, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+
+        cursor = new Cursor("1,2,3,4");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 4, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("literal", "comma", 1, 1, [], ","),
+            new Node("regex", "number", 2, 2, [], "2"),
+            new Node("literal", "comma", 3, 3, [], ","),
+            new Node("regex", "number", 4, 4, [], "3"),
+        ]);
+
+        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 FiniteRepeat("number", digit, 4, { divider });
+        const cursor = new Cursor(
+            "\n" +
+            "3\n" +
+            "\n" +
+            "\n"
+        );
+        const result = integer.parse(cursor);
+        const expected = new Node("finite-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("Bounds Are Equal With Divider", () => {
+        const divider = new Literal("comma", ",");
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { divider, min: 3, trimDivider: true });
+
+        let cursor = new Cursor("1,");
+        let result = numbers.parse(cursor);
+        let expected: Node | null = null;
+        expect(result).toBeNull();
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("1,2");
+        result = numbers.parse(cursor);
+        expected = null;
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeTruthy();
+
+        cursor = new Cursor("1,2,3,");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 4, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("literal", "comma", 1, 1, [], ","),
+            new Node("regex", "number", 2, 2, [], "2"),
+            new Node("literal", "comma", 3, 3, [], ","),
+            new Node("regex", "number", 4, 4, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+
+        cursor = new Cursor("1,2,3,4");
+        result = numbers.parse(cursor);
+        expected = new Node("finite-repeat", "numbers", 0, 4, [
+            new Node("regex", "number", 0, 0, [], "1"),
+            new Node("literal", "comma", 1, 1, [], ","),
+            new Node("regex", "number", 2, 2, [], "2"),
+            new Node("literal", "comma", 3, 3, [], ","),
+            new Node("regex", "number", 4, 4, [], "3"),
+        ]);
+
+        expect(result).toEqual(expected);
+        expect(cursor.hasError).toBeFalsy();
+    });
+
+    test("Test", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3);
+        const result = numbers.test("1");
+
+        expect(result).toBeTruthy();
+    });
+
+    test("Exec", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3);
+        const result = numbers.exec("1");
+
+        expect(result.ast).not.toBeNull();
+        expect(result.cursor.hasError).toBeFalsy();
+    });
+
+    test("Fail", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3);
+        const result = numbers.exec("f");
+
+        expect(result.ast).toBeNull();
+        expect(result.cursor.hasError).toBeTruthy();
+    });
+
+    test("Optional", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const result = numbers.exec("f");
+
+        expect(result.ast).toBeNull();
+        expect(result.cursor.hasError).toBeFalsy();
+    });
+
+    test("Optional With Multiple Matches But Still Below Min", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const result = numbers.exec("12f");
+
+        expect(result.ast).toBeNull();
+        expect(result.cursor.hasError).toBeFalsy();
+    });
+
+    test("Properties", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+
+        expect(numbers.type).toBe("finite-repeat");
+        expect(numbers.name).toBe("numbers");
+        expect(numbers.parent).toBeNull();
+        expect(numbers.children.length).toBe(3);
+        expect(numbers.min).toBe(0);
+        expect(numbers.max).toBe(3);
+        expect(numbers.isOptional).toBeTruthy();
+    });
+
+    test("Clone", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        const clone = numbers.clone() as FiniteRepeat;
+
+        expect(clone.type).toBe(numbers.type);
+        expect(clone.name).toBe(numbers.name);
+        expect(clone.parent).toBeNull();
+        expect(clone.children.length).toBe(numbers.children.length);
+        expect(clone.min).toBe(numbers.min);
+        expect(clone.max).toBe(numbers.max);
+        expect(clone.isOptional).toBe(numbers.isOptional);
+    });
+
+    test("Clone With Custom Overrides", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+        let clone = numbers.clone();
+        let expected = new FiniteRepeat("numbers", new Regex("number", "\\d"), 3, { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers");
+        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), 3, { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers", true);
+        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), 3, { min: 0 });
+
+        expect(clone).toEqual(expected);
+
+        clone = numbers.clone("cloned-numbers", false);
+        expected = new FiniteRepeat("cloned-numbers", new Regex("number", "\\d"), 3, { min: 1 });
+
+        expect(clone).toEqual(expected);
+    });
+
+    test("Get Tokens", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            3,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            });
+
+        const tokens = numbers.getTokens();
+
+        expect(tokens).toEqual(["1"]);
+    });
+
+    test("Get Tokens After Without Parent", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0,
+                trimDivider: true
+            });
+
+        let child = numbers.children[0];
+        let tokens = numbers.getTokensAfter(child);
+
+        expect(tokens).toEqual([","]);
+
+        child = numbers.children[2];
+        tokens = numbers.getTokensAfter(child);
+
+        expect(tokens).toEqual([]);
+
+        child = numbers.children[3];
+        tokens = numbers.getTokensAfter(child);
+
+        expect(tokens).toEqual([]);
+    });
+
+    test("Get Tokens After With Parent", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                trimDivider: true,
+                min: 0
+            });
+
+        const parent = new And("parent", [numbers, new Literal("b", "B")]);
+        const numbersClone = parent.children[0];
+        let child = numbersClone.children[0];
+        let tokens = numbersClone.getTokensAfter(child);
+
+        expect(tokens).toEqual([","]);
+
+        child = numbersClone.children[2];
+        tokens = numbersClone.getTokensAfter(child);
+
+        expect(tokens).toEqual(["B"]);
+
+        child = numbersClone.children[3];
+        tokens = numbersClone.getTokensAfter(child);
+
+        expect(tokens).toEqual([]);
+
+    });
+
+    test("Get Next Tokens", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            }
+        );
+
+        const parent = new And("parent", [numbers, new Literal("b", "B")]);
+        const numbersClone = parent.children[0];
+        const tokens = numbersClone.getNextTokens();
+
+
+        expect(tokens).toEqual(["B"]);
+    });
+
+    test("Get Next Tokens Without Parent", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            }
+        );
+
+        const tokens = numbers.getNextTokens();
+
+
+        expect(tokens).toEqual([]);
+    });
+
+    test("Get Patterns", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            }
+        );
+
+        const patterns = numbers.getPatterns();
+
+        expect(patterns).toEqual([numbers.children[0]]);
+    });
+
+    test("Get Next Patterns Without Parent", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            }
+        );
+
+        const patterns = numbers.getNextPatterns();
+
+        expect(patterns).toEqual([]);
+    });
+
+    test("Get Next Patterns With Parent", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            }
+        );
+
+        const parent = new And("parent", [numbers, new Literal("b", "B")]);
+        const numbersClone = parent.children[0];
+
+        const patterns = numbersClone.getNextPatterns();
+
+        expect(patterns).toEqual([parent.children[1]]);
+    });
+
+    test("Find Pattern", () => {
+        const numbers = new FiniteRepeat(
+            "numbers",
+            new Literal("one", "1"),
+            2,
+            {
+                divider: new Literal("comma", ","),
+                min: 0
+            }
+        );
+
+        const comma = numbers.find(p => p.name === "comma");
+        expect(comma).toBe(numbers.children[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);
+    }
+
+}