clarity-pattern-parser 11.3.11 → 11.3.13

package/src/generator/delete.ts

@@ -1,88 +0,0 @@
-import { Context } from "../patterns/Context";
-import { Expression } from "../patterns/Expression";
-import { Literal } from "../patterns/Literal";
-import { Reference } from "../patterns/Reference";
-import { Repeat } from "../patterns/Repeat";
-import { Sequence } from "../patterns/Sequence";
-import { Options } from "../patterns/Options";
-import { Optional } from "../patterns/Optional";
-import { TakeUntil } from "../patterns/TakeUntil";
-
-new Context("expression",
-    new Expression("expression", [
-        new Sequence("prefix-expression", [
-            new Literal("pre", "pre"),
-            new Reference("expression")
-        ]),
-        new Sequence("postfix-expression", [
-            new Reference("expression"),
-            new Literal("post", "post")
-        ]),
-        new Sequence("infix-expression", [
-            new Reference("expression"),
-            new Literal(" and ", " and "),
-            new Reference("expression")
-        ]),
-        new Expression("item", [
-            new Options("names", [
-                new Literal("john", "John"),
-                new Literal("Jane", "Jane")
-            ]),
-            new Reference("array")
-        ])
-    ]), [
-    new Literal("john", "John"),
-    new Options("names", [
-        new Literal("john", "John"),
-        new Literal("Jane", "Jane")
-    ]),
-    new Literal("space", "\\s+"),
-    new Literal("comma", "\\s*,\\s*"),
-    new Expression("item", [
-        new Options("names", [
-            new Literal("john", "John"),
-            new Literal("Jane", "Jane")
-        ]),
-        new Reference("array")
-    ]),
-    new Repeat("items",
-        new Expression("item", [
-            new Options("names", [
-                new Literal("john", "John"),
-                new Literal("Jane", "Jane")
-            ]),
-            new Reference("array")
-        ]), { min: 1, divider: new Literal("comma", "\\s*,\\s*") }),
-    new Sequence("array", [
-        new Literal("[", "["),
-        new Optional("optional-space",
-            new Literal("space", "\\s+")),
-        new Optional("optional-items",
-            new Repeat("items",
-                new Expression("item", [
-                    new Options("names", [
-                        new Literal("john", "John"),
-                        new Literal("Jane", "Jane")
-                    ]),
-                    new Reference("array")
-                ]), { min: 1, divider: new Literal("comma", "\\s*,\\s*") })),
-        new Optional("optional-space",
-            new Literal("space", "\\s+")),
-        new Literal("]", "]")
-    ]),
-    new Sequence("prefix-expression", [
-        new Literal("pre", "pre"),
-        new Reference("expression")
-    ]),
-    new Sequence("postfix-expression", [
-        new Reference("expression"),
-        new Literal("post", "post")
-    ]),
-    new Sequence("infix-expression", [
-        new Reference("expression"),
-        new Literal(" and ", " and "),
-        new Reference("expression")
-    ]),
-    new TakeUntil("take-until",
-        new Literal("</script", "</script"))
-])

package/src/generator/generator.test.ts

@@ -1,28 +0,0 @@
-import { patterns } from "../grammar/patterns";
-import { Generator } from "./generator";
-import { TypescriptVisitor } from "./typescriptVisitor";
-
-describe("generator", () => {
-    test("Every Pattern", () => {
-        const { expression } = patterns`
-            john = "John"
-            names = john | "Jane"
-            space = /\\s+/
-            comma = /\\s*,\\s*/
-            item = names | array
-            items = (item, comma)+
-            array = "[" + space? + items? + space? + "]"
-            prefix-expression = "pre" + expression
-            postfix-expression = expression + "post"
-            infix-expression = expression + " and " + expression
-            expression = prefix-expression | postfix-expression | infix-expression | item
-            take-until = ? -> | "</script"
-        `;
-
-        const visitor = new TypescriptVisitor();
-        const result = new Generator(visitor).generate(expression);
-        expect(result).toBe(result);
-
-    });
-});
-

package/src/generator/generator.ts

@@ -1,106 +0,0 @@
-import { Pattern } from "../patterns/Pattern";
-import { IVisitor } from "./ivisitor";
-
-export class Generator {
-    private _visitor: IVisitor;
-    private _depth = 1;
-    private _usedPatterns: Set<string>;
-    private _terminalPatterns = [
-        "literal",
-        "regex",
-        "repeat",
-        "finite-repeat",
-        "infinite-repeat",
-        "reference",
-        "context",
-        "expression"
-    ];
-
-    constructor(visitor: IVisitor, depth = 0) {
-        this._usedPatterns = new Set();
-        this._visitor = visitor;
-        this._depth = depth;
-    }
-
-    setDepth(depth: number) {
-        this._depth = depth;
-    }
-
-    generate(pattern: Pattern): string {
-        this._visitor.begin(this);
-
-        const body = this._walkUp(pattern, (pattern: Pattern, args: string[]) => {
-            const type = pattern.type;
-            this._usedPatterns.add(type);
-
-            switch (type) {
-                case "context": {
-                    return this._visitor.context(pattern, this._depth);
-                }
-                case "expression": {
-                    return this._visitor.expression(pattern, this._depth);
-                }
-                case "literal": {
-                    return this._visitor.literal(pattern, this._depth);
-                }
-                case "not": {
-                    return this._visitor.not(pattern, args, this._depth);
-                }
-                case "optional": {
-                    return this._visitor.optional(pattern, args, this._depth);
-                }
-                case "options": {
-                    return this._visitor.options(pattern, args, this._depth);
-                }
-                case "reference": {
-                    return this._visitor.reference(pattern, this._depth);
-                }
-                case "regex": {
-                    return this._visitor.regex(pattern, this._depth);
-                }
-                case "infinite-repeat": {
-                    return this._visitor.infiniteRepeat(pattern, this._depth);
-                }
-                case "finite-repeat": {
-                    return this._visitor.finiteRepeat(pattern, this._depth);
-                }
-                case "right-associated": {
-                    return this._visitor.rightAssociated(pattern, args, this._depth);
-                }
-                case "sequence": {
-                    return this._visitor.sequence(pattern, args, this._depth);
-                }
-                case "take-until": {
-                    return this._visitor.takeUntil(pattern, args, this._depth);
-                }
-            }
-            throw Error("Cannot find pattern.");
-        });
-
-
-        const header = this._visitor.header(Array.from(this._usedPatterns));
-        const footer = this._visitor.footer();
-
-        this._visitor.end();
-
-        return `${header}${body}${footer}`;
-    }
-
-    private _walkUp(pattern: Pattern, callback: (pattern: Pattern, args: string[]) => string): string {
-        const results: string[] = [];
-
-        if (this._terminalPatterns.includes(pattern.type)) {
-            return callback(pattern, []);
-        }
-
-        pattern.children.forEach(p => {
-            this._depth++;
-            results.push(this._walkUp(p, callback));
-            this._depth--;
-        });
-
-        const filteredResults = results.filter(s => s.length > 0);
-
-        return callback(pattern, filteredResults);
-    }
-}

package/src/generator/igenerator.ts

@@ -1,6 +0,0 @@
-import { Pattern } from "../patterns/Pattern";
-
-export interface IGenerator {
-    generate(pattern: Pattern): string;
-    setDepth(depth: number): void;
-}

package/src/generator/ivisitor.ts

@@ -1,24 +0,0 @@
-import { Pattern } from "../patterns/Pattern";
-import { IGenerator } from "./igenerator";
-
-export interface IVisitor {
-    begin(generator: IGenerator): void;
-    end(): void;
-    header(usedPatterns: string[]): string;
-    footer(): string;
-
-    context(pattern: Pattern, depth: number): string;
-    expression(pattern: Pattern, depth: number): string;
-    literal(pattern: Pattern, depth: number): string;
-    not(pattern: Pattern, args: string[], depth: number): string;
-    optional(pattern: Pattern, args: string[], depth: number): string;
-    options(pattern: Pattern, args: string[], depth: number): string;
-    reference(pattern: Pattern, depth: number): string;
-
-    regex(pattern: Pattern, depth: number): string;
-    infiniteRepeat(pattern: Pattern, depth: number): string;
-    finiteRepeat(pattern: Pattern, depth: number): string
-    rightAssociated(pattern: Pattern, args: string[], depth: number): string;
-    sequence(pattern: Pattern, args: string[], depth: number): string;
-    takeUntil(pattern: Pattern, args: string[], depth: number): string;
-}

package/src/generator/typescriptVisitor.ts

@@ -1,179 +0,0 @@
-import { Context } from "../patterns/Context";
-import { Expression } from "../patterns/Expression";
-import { Literal } from "../patterns/Literal";
-import { Pattern } from "../patterns/Pattern";
-import { Regex } from "../patterns/Regex";
-import { Repeat } from "../patterns/Repeat";
-import { IGenerator } from "./igenerator";
-import { IVisitor } from "./ivisitor";
-
-const importMap: any = {
-    "literal": "Literal",
-    "optional": "Optional",
-    "options": "Options",
-    "reference": "Reference",
-    "regex": "Regex",
-    "repeat": "Repeat",
-    "right-associated": "RightAssociation",
-    "sequence": "Sequence",
-    "take-until": "TakeUntil",
-    "context": "Context",
-    "expression": "Expression"
-};
-
-export class TypescriptVisitor implements IVisitor {
-    private _generator: IGenerator | null = null;
-
-    get generator() {
-        if (this._generator == null) {
-            throw new Error("No Generator Found");
-        }
-
-        return this._generator;
-    }
-
-    begin(generator: IGenerator) {
-        this._generator = generator;
-    }
-
-    end() { }
-
-    header( patterns: string[]): string {
-        console.log(patterns);
-        return `import { ${patterns.map(p => importMap[p]).join(", ")} } from "../index.ts";`;
-    }
-
-    footer(): string {
-        return "";
-    }
-
-    context(pattern: Pattern, depth: number): string {
-        const name = pattern.name;
-        const context = pattern as Context;
-        const contextPatterns = context.getPatternsWithinContext();
-
-        this.generator.setDepth(depth);
-
-        const contextPatternString = this.generator.generate(context.children[0]);
-
-        const contextPatternsString = this._indent(Object.values(contextPatterns).map(p => {
-            this.generator.setDepth(depth + 2);
-            return this.generator.generate(p);
-        }), depth + 2);
-
-        return `new Context("${name}",${this._generateTabs(depth + 1)}${contextPatternString}, [${contextPatternsString.join(", ")}${this._generateTabs(depth + 1)}])`;
-
-    }
-
-    expression(pattern: Pattern, depth: number): string {
-        const name = pattern.name;
-        const expression = pattern as Expression;
-        const patterns = expression.originalPatterns;
-
-        const patternsString = this._indent(patterns.map(p => {
-            this.generator.setDepth(depth + 2);
-            return this.generator.generate(p);
-        }), depth + 2);
-
-        return `new Expression("${name}", [${patternsString.join(", ")}${this._generateTabs(depth)}])`;
-
-    }
-
-    literal(pattern: Pattern): string {
-        const name = pattern.name;
-        const literal = pattern as Literal;
-        return `new Literal("${name}", "${this._escapeString(literal.token)}")`;
-    }
-
-    not(pattern: Pattern, args: string[], depth: number): string {
-        args = this._indent(args, depth + 1);
-
-        const name = pattern.name;
-        return `new Not("${name}", ${args.join("")})`;
-    }
-
-    optional(pattern: Pattern, args: string[], depth: number): string {
-        args = this._indent(args, depth + 1);
-        const name = pattern.name;
-        return `new Optional("${name}", ${args.join("")})`;
-    }
-
-    options(pattern: Pattern, args: string[], depth: number): string {
-        args = this._indent(args, depth + 1);
-        const name = pattern.name;
-        return `new Options("${name}", [${args.join(", ")}${this._generateTabs(depth)}])`;
-    }
-
-    reference(pattern: Pattern): string {
-        const name = pattern.name;
-        return `new Reference("${name}")`;
-    }
-
-    regex(pattern: Pattern): string {
-        const name = pattern.name;
-        const regex = pattern as Regex;
-        return `new Literal("${name}", "${this._escapeString(regex.regex)}")`;
-    }
-
-    infiniteRepeat(pattern: Pattern, depth: number): string {
-        const name = pattern.name;
-        const repeat = pattern as Repeat;
-        this.generator.setDepth(depth);
-        const repeatPattern = repeat.pattern;
-        const options = repeat.options;
-        const repeatPatternString = this.generator.generate(repeatPattern);
-        let dividerString = "null";
-
-        if (options.divider != null) {
-            dividerString = this.generator.generate(options.divider);
-        }
-
-        return `new Repeat("${name}", ${this._generateTabs(depth + 1)}${repeatPatternString}, {min: ${repeat.min}, divider: ${dividerString}})`;
-    }
-    
-    finiteRepeat(pattern: Pattern, depth: number): string {
-        const name = pattern.name;
-        const repeat = pattern as Repeat;
-        this.generator.setDepth(depth);
-
-        const repeatPattern = repeat.pattern;
-        const options = repeat.options;
-        const repeatPatternString = this.generator.generate(repeatPattern);
-        let dividerString = "null";
-
-        if (options.divider != null) {
-            dividerString = this.generator.generate(options.divider);
-        }
-        return `new Repeat("${name}", ${this._generateTabs(depth + 1)}${repeatPatternString}, {min: ${repeat.min}, max: ${repeat.max} divider: ${dividerString}})`;
-    }
-
-    rightAssociated(_: Pattern, args: string[], depth: number) {
-        args = this._indent(args, depth + 1);
-        return `new RightAssociation(${args.join("")})`;
-    }
-
-    sequence(pattern: Pattern, args: string[], depth: number): string {
-        args = this._indent(args, depth + 1);
-        const name = pattern.name;
-        return `new Sequence("${name}", [${args.join(", ")}${this._generateTabs(depth)}])`;
-    }
-
-    takeUntil(pattern: Pattern, args: string[], depth: number): string {
-        args = this._indent(args, depth + 1);
-        const name = pattern.name;
-        return `new TakeUntil("${name}", ${args.join("")})`;
-    }
-
-    private _escapeString(value: string) {
-        return value.replaceAll('"', '\\"');
-    }
-
-    private _generateTabs(depth: number) {
-        return "\n" + new Array(depth).fill("  ").join("");
-    }
-
-    private _indent(args: string[], depth: number) {
-        return args.map(s => this._generateTabs(depth) + s);
-    }
-
-}