clarity-pattern-parser 11.1.5 → 11.2.0

package/package.json

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

package/src/grammar/Grammar.test.ts

@@ -11,6 +11,7 @@ import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
 import { createPatternsTemplate, patterns } from "./patterns";
 import { Expression } from "../patterns/Expression";
+import { Cursor } from "../patterns/Cursor";
 
 describe("Grammar", () => {
     test("Literal", () => {
@@ -768,4 +769,13 @@ describe("Grammar", () => {
         `;
     });
 
+    test("Take Until", () => {
+        const { scriptText } = patterns`
+            script-text = ?->| "</script"
+        `;
+        const result = scriptText.parse(new Cursor("function(){}</script"));
+
+        expect(result?.value).toBe("function(){}");
+    });
+
 });

package/src/grammar/Grammar.ts

@@ -11,6 +11,7 @@ import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
 import { Expression } from "../patterns/Expression";
+import { TakeUntil } from "../patterns/TakeUntil";
 import { RightAssociated } from "../patterns/RightAssociated";
 import { generateErrorMessage } from "../patterns/generate_error_message";
 import { tokens } from "./decorators/tokens";
@@ -30,6 +31,7 @@ const patternNodes: Record<string, boolean> = {
     "sequence-literal": true,
     "repeat-literal": true,
     "alias-literal": true,
+    "take-until-literal": true,
     "configurable-anonymous-pattern": true
 };
 
@@ -180,6 +182,10 @@ export class Grammar {
                     this._saveAlias(n);
                     break;
                 }
+                case "take-until-literal": {
+                    this._saveTakeUntil(n);
+                    break;
+                }
                 case "configurable-anonymous-pattern": {
                     this._saveConfigurableAnonymous(n);
                     break;
@@ -196,6 +202,7 @@ export class Grammar {
         });
     }
 
+
     private _saveLiteral(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
         const literalNode = statementNode.find(n => n.name === "literal") as Node;
@@ -322,6 +329,9 @@ export class Grammar {
             case "sequence-literal": {
                 return this._buildSequence(name, node);
             }
+            case "take-until-literal": {
+                return this._buildTakeUntil(name, node);
+            }
             case "complex-anonymous-pattern": {
                 return this._buildComplexAnonymousPattern(node);
             }
@@ -422,6 +432,24 @@ export class Grammar {
         return isOptional ? new Optional(name, new Repeat(`inner-optional-${name}`, pattern, options)) : new Repeat(name, pattern, options);
     }
 
+    private _saveTakeUntil(statementNode: Node) {
+        const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const name = nameNode.value;
+        const takeUntilNode = statementNode.find(n => n.name === "take-until-literal") as Node;
+        const takeUntil = this._buildTakeUntil(name, takeUntilNode);
+
+        this._applyDecorators(statementNode, takeUntil);
+        this._parseContext.patternsByName.set(name, takeUntil);
+    }
+
+
+    private _buildTakeUntil(name: string, takeUntilNode: Node) {
+        const patternNode = takeUntilNode.children[takeUntilNode.children.length - 1];
+        const untilPattern = this._buildPattern(patternNode);
+
+        return new TakeUntil(name, untilPattern);
+    }
+
     private _saveConfigurableAnonymous(node: Node) {
         const nameNode = node.find(n => n.name === "name") as Node;
         const name = nameNode.value;
@@ -441,7 +469,7 @@ export class Grammar {
 
     private async _resolveImports(ast: Node) {
         const importStatements = ast.findAll(n => {
-            return n.name === "import-from" || n.name === "param-name-with-default-value"
+            return n.name === "import-from" || n.name === "param-name-with-default-value";
         });
 
         for (const statement of importStatements) {

package/src/grammar/patterns/literals.ts

@@ -14,6 +14,7 @@ export const anonymousLiterals = new Options("anonymous-literals", [
 ]);
 
 export const anonymousWrappedLiterals = new Options("anonymous-wrapped-literals", [
+    new Reference("take-until-literal"),
     new Reference("options-literal"),
     new Reference("sequence-literal"),
     new Reference("complex-anonymous-pattern")

package/src/grammar/patterns/pattern.ts

@@ -5,6 +5,7 @@ import { repeatLiteral } from "./repeatLiteral";
 import { sequenceLiteral } from "./sequenceLiteral";
 import { optionsLiteral } from "./optionsLiteral";
 import { anonymousPattern } from "./anonymousPattern";
+import { takeUntilLiteral } from "./takeUtilLiteral";
 import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { name } from "./name";
@@ -20,8 +21,9 @@ export const pattern = new Options("pattern", [
     literal,
     regexLiteral,
     repeatLiteral,
+    takeUntilLiteral,
     aliasLiteral,
     optionsLiteral,
     sequenceLiteral,
     configurableAnonymousPattern,
-],  true);
+], true);

package/src/grammar/patterns/takeUtilLiteral.ts

@@ -0,0 +1,21 @@
+import { Literal } from "../../patterns/Literal"
+import { Optional } from "../../patterns/Optional";
+import { Sequence } from "../../patterns/Sequence";
+import { lineSpaces } from "./spaces";
+import { name } from "./name";
+import { Reference } from "../../patterns/Reference";
+
+const anyChar = new Literal("any-char", "?");
+const upTo = new Literal("up-to", "->");
+const wall = new Literal("wall", "|");
+const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
+
+export const takeUntilLiteral = new Sequence("take-until-literal", [
+    anyChar,
+    optionalLineSpaces,
+    upTo,
+    optionalLineSpaces,
+    wall,
+    optionalLineSpaces,
+    new Reference("pattern")
+]);

package/src/patterns/TakeUntil.test.ts

@@ -0,0 +1,62 @@
+import { Cursor } from "./Cursor";
+import { Literal } from "./Literal";
+import { Options } from "./Options";
+import { TakeUntil } from "./TakeUntil";
+
+describe("TakeUntil", () => {
+    test("Take With No End", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Literal("close-script-tag", "</script")
+        );
+
+        const result = takeUntilScript.exec("function(){}");
+
+        expect(result.ast?.value).toBe("function(){}");
+    });
+
+    test("Take Until Terminating Match", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Literal("close-script-tag", "</script")
+        );
+        const cursor = new Cursor("function(){}function(){}</script");
+        const result = takeUntilScript.parse(cursor);
+
+        expect(result?.value).toBe("function(){}function(){}");
+        expect(cursor.index).toBe(23);
+    });
+
+    test("Take Until Terminating Complex Match", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Options("end-tags", [
+                new Literal("close-script-tag", "</script"),
+                new Literal("close-style-tag", "</style")
+            ])
+        );
+        let cursor = new Cursor("function(){}function(){}</script");
+        let result = takeUntilScript.parse(cursor);
+
+        expect(result?.value).toBe("function(){}function(){}");
+        expect(cursor.index).toBe(23);
+
+        cursor = new Cursor("function(){}function(){}</style");
+        result = takeUntilScript.parse(cursor);
+
+        expect(result?.value).toBe("function(){}function(){}");
+        expect(cursor.index).toBe(23);
+    });
+
+    test("Error", () => {
+        const takeUntilScript = new TakeUntil(
+            "script-content",
+            new Literal("close-script-tag", "</script")
+        );
+        const cursor = new Cursor("</script");
+        const result = takeUntilScript.parse(cursor);
+
+        expect(result).toBeNull();
+        expect(cursor.index).toBe(0);
+    });
+});

package/src/patterns/TakeUntil.ts

@@ -0,0 +1,166 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { execPattern } from "./execPattern";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+import { testPattern } from "./testPattern";
+
+let idIndex = 0;
+
+export class TakeUntil implements Pattern {
+    private _id: string;
+    private _type: string;
+    private _name: string;
+    private _parent: Pattern | null;
+    private _children: Pattern[];
+    private _startedOnIndex: number;
+    private _terminatingPattern: Pattern;
+    private _tokens: string[];
+
+    get id(): string {
+        return this._id;
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    get children(): Pattern[] {
+        return this._children;
+    }
+
+    get parent(): Pattern | null {
+        return this._parent;
+    }
+
+    set parent(pattern: Pattern | null) {
+        this._parent = pattern;
+    }
+
+    get startedOnIndex(): number {
+        return this._startedOnIndex;
+    }
+
+    constructor(name: string, terminatingPattern: Pattern) {
+        this._id = String(idIndex++);
+        this._type = "take-until";
+        this._name = name;
+        this._parent = null;
+        this._terminatingPattern = terminatingPattern;
+        this._children = [this._terminatingPattern];
+        this._tokens = [];
+        this._startedOnIndex = 0;
+    }
+
+    parse(cursor: Cursor): Node | null {
+        let cursorIndex = cursor.index;
+        let foundMatch = false;
+        this._startedOnIndex = cursor.index;
+
+        let terminatingResult = this._terminatingPattern.parse(cursor);
+
+        if (terminatingResult == null) {
+            foundMatch = true;
+
+            cursor.moveTo(cursorIndex);
+            cursorIndex += 1;
+            cursor.hasNext() && cursor.next();
+
+            cursor.resolveError();
+        }
+
+        while (true) {
+            terminatingResult = this._terminatingPattern.parse(cursor);
+
+            if (terminatingResult == null) {
+                cursor.moveTo(cursorIndex);
+                cursorIndex += 1;
+
+                if (cursor.hasNext()) {
+                    cursor.next();
+                } else {
+                    break;
+                }
+
+                cursor.resolveError();
+            } else {
+                break;
+            }
+        }
+
+        if (foundMatch) {
+            cursor.moveTo(cursorIndex - 1);
+            const value = cursor.getChars(this.startedOnIndex, cursorIndex - 1);
+            return Node.createValueNode(this._type, this._name, value);
+        } else {
+            cursor.resolveError();
+            cursor.moveTo(this.startedOnIndex);
+            cursor.recordErrorAt(this._startedOnIndex, this._startedOnIndex, this);
+            return null;
+        }
+    }
+
+    exec(text: string, record?: boolean | undefined): ParseResult {
+        return execPattern(this, text, record);
+    }
+
+    test(text: string, record?: boolean | undefined): boolean {
+        return testPattern(this, text, record);
+    }
+
+    clone(name = this.name): Pattern {
+        const clone = new TakeUntil(name, this._terminatingPattern);
+        clone._id = this._id;
+
+        return clone;
+    }
+
+    getTokens() {
+        return this._tokens;
+    }
+
+    getTokensAfter(_childReference: Pattern): string[] {
+        return [];
+    }
+
+    getNextTokens(): string[] {
+        if (this.parent == null) {
+            return [];
+        }
+
+        return this.parent.getTokensAfter(this);
+    }
+
+    getPatterns(): Pattern[] {
+        return [this];
+    }
+
+    getPatternsAfter(_childReference: Pattern): Pattern[] {
+        return [];
+    }
+
+    getNextPatterns(): Pattern[] {
+        if (this.parent == null) {
+            return [];
+        }
+
+        return this.parent.getPatternsAfter(this);
+    }
+
+    find(_predicate: (p: Pattern) => boolean): Pattern | null {
+        return null;
+    }
+
+    setTokens(tokens: string[]) {
+        this._tokens = tokens;
+    }
+
+    isEqual(pattern: Pattern): boolean {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+
+}