clarity-pattern-parser 6.0.0 → 7.0.0

package/src/grammar/patterns/repeatLiteral.ts

@@ -0,0 +1,72 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+import { name } from "./name";
+import { spaces } from "./spaces";
+
+const optionalIsOptional = new Literal("is-optional", "?", true);
+const patternName = name.clone("pattern-name");
+
+export const pattern = new And("pattern", [
+    patternName,
+    optionalIsOptional,
+]);
+
+const optionalSpaces = spaces.clone("optional-spaces", true);
+const dividerPattern = name.clone("divider-pattern");
+
+const openBracket = new Literal("open-bracket", "{");
+const closeBracket = new Literal("close-bracket", "}");
+const comma = new Literal("comma", ",");
+const integer = new Regex("integer", "([1-9][0-9]*)|0");
+integer.setTokens(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
+
+const optionalInteger = integer.clone("integer", true)
+
+const bounds = new And("bounds", [
+    openBracket,
+    optionalSpaces,
+    optionalInteger.clone("min"),
+    optionalSpaces,
+    comma,
+    optionalSpaces,
+    optionalInteger.clone("max"),
+    optionalSpaces,
+    closeBracket
+]);
+
+const exactCount = new And("exact-count", [
+    openBracket,
+    optionalSpaces,
+    integer,
+    optionalSpaces,
+    closeBracket,
+]);
+
+const quantifierShorthand = new Regex("quantifier-shorthand", "\\*|\\+");
+quantifierShorthand.setTokens(["*", "+"]);
+const quantifier = new Or("quantifier", [
+    quantifierShorthand,
+    exactCount,
+    bounds
+]);
+
+const optional = new Literal("is-optional", "?", true);
+const trimDivider = new Literal("trim-divider", "-t");
+const openParen = new Literal("open-paren", "(");
+const closeParen = new Literal("close-paren", ")");
+const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
+dividerComma.setTokens([", "]);
+
+export const repeatLiteral = new And("repeat-literal", [
+    openParen,
+    optionalSpaces,
+    pattern,
+    optional,
+    new And("optional-divider-section", [dividerComma, dividerPattern], true),
+    optionalSpaces,
+    closeParen,
+    new And("quantifier-section", [optionalSpaces, quantifier]),
+    new And("optional-trim-divider-section", [spaces, trimDivider], true)
+]);

package/src/grammar/patterns/spaces.ts

@@ -0,0 +1,4 @@
+import { Regex } from "../../patterns/Regex";
+
+export const spaces = new Regex("spaces", "[ \\t]+");
+spaces.setTokens([" "]);

package/src/grammar/patterns/statement.ts

@@ -0,0 +1,35 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { andLiteral } from "./andLiteral";
+import { name } from "./name";
+import { orLiteral } from "./orLiteral";
+import { regexLiteral } from "./regexLiteral";
+import { repeatLiteral } from "./repeatLiteral";
+import { spaces } from "./spaces";
+import { literal } from "./literal";
+import { comment } from "./comment";
+
+const optionalSpaces = spaces.clone("optional-spaces", true);
+const assignOperator = new Literal("assign-operator", "=");
+const optionalComment = comment.clone("inline-comment", true);
+
+const statements = new Or("statements", [
+    literal,
+    regexLiteral,
+    orLiteral,
+    andLiteral,
+    repeatLiteral,
+]);
+
+export const statement = new And("statement", [
+    optionalSpaces,
+    name,
+    optionalSpaces,
+    assignOperator,
+    optionalSpaces,
+    statements,
+    optionalSpaces,
+    optionalComment,
+    optionalSpaces,
+]);

package/src/grammar/spec.md

@@ -0,0 +1,142 @@
+# Grammar
+
+## Literal
+
+```
+name = "Literal"
+```
+
+## Regex
+
+```
+digits = /\d+/
+```
+
+### Regex Caveats
+
+Do not use "^" at the beginning or "$" at the end of your regular expression. If
+you are creating a regular expression that is concerned about the beginning and
+end of the text you should probably just use a regular expression.
+
+## Or
+This succeeds if it matches any of the options.
+```
+multiply = "*"
+divide = "/"
+operators = mulitply | divide
+```
+
+## And
+This succeeds if it matches all of the patterns in the order they are placed.
+```
+space = " "
+first-name = "John"
+last-name = "Doe"
+full-name = first-name & space & last-name
+```
+
+### Optional pattern
+Patterns within the and sequence can be optional.
+```
+space = " "
+first-name = /\w+/
+last-name = /\w+/
+middle-name = /\w+/
+middle-name-with-space = middle-name & space
+
+full-name = first-name & space & middle-name-with-space? & last-name
+```
+
+### Negative Look Ahead
+This will ensure that the first name isn't `Jack` before continuing to match for
+a name.
+
+```
+space = " "
+first-name = /\w+/
+last-name = /\w+/
+middle-name = /\w+/
+middle-name-with-space = m-middle-name & space
+jack = "Jack"
+
+full-name = !jack & first-name & space & middle-name-with-space? & last-name
+```
+
+## Repeat
+```
+digit = /\d/
+digits = (digit)*
+```
+
+### Zero Or More Pattern
+
+```
+digit = /\d/
+comma = ","
+digits = (digit, comma)*
+```
+
+### Zero Or More & Trim Trailing Divider
+```
+digit = /\d/
+comma = ","
+digits = (digit, comma)* -t
+```
+
+This is a useful feature if you don't want the divider to be the last pattern found. Let's look at the example below to understand.
+
+```ts
+const expression = `
+    digit = /\d/
+    comma = ","
+    digits = (digit, comma)* -t
+`;
+
+const { digits } = Gammar.parse(expression);
+
+let result = digits.exec("1,2,3");
+expect(result.ast?.value).toBe("1,2,3");
+
+result = digits.exec("1,2,");
+expect(result.ast).toBeNull();
+```
+
+### Zero Or More With Optional Repeated Pattern
+
+```
+digit = /\d/
+comma = ","
+digits = (digit?, comma)*
+```
+
+### One Or More With Optional Repeated Pattern
+
+```
+digit = /\d/
+comma = ","
+digits = (digit?, comma)+
+```
+
+### Upper Limit
+
+```
+digit = /\d/
+comma = ","
+digits = (digit, comma){,3}
+```
+
+### Bounded
+
+```
+digit = /\d/
+comma = ","
+digits = (digit, comma){1,3}
+```
+
+### Lower Limit
+
+```
+digit = /\d/
+comma = ","
+digits = (digit, comma){1,3}
+```

package/src/index.ts

@@ -1,4 +1,8 @@
 import { Node } from "./ast/Node";
+import { Grammar } from "./grammar/Grammar";
+import { Suggestion } from "./intellisense/Suggestion";
+import { SuggestionOption } from "./intellisense/SuggestionOption";
+import { AutoComplete, AutoCompleteOptions } from './intellisense/AutoComplete';
 import { Cursor } from "./patterns/Cursor";
 import { Regex } from "./patterns/Regex";
 import { And } from "./patterns/And";
@@ -9,15 +13,14 @@ import { Repeat } from "./patterns/Repeat";
 import { ParseError } from "./patterns/ParseError";
 import { Pattern } from "./patterns/Pattern";
 import { Reference } from "./patterns/Reference";
-import { AutoComplete } from './intellisense/AutoComplete';
 import { CursorHistory, Match } from "./patterns/CursorHistory";
 import { ParseResult } from "./patterns/ParseResult";
-import { Suggestion } from "./intellisense/Suggestion";
-import { SuggestionOption } from "./intellisense/SuggestionOption";
 
 export {
   Node,
+  Grammar,
   AutoComplete,
+  AutoCompleteOptions,
   Suggestion,
   SuggestionOption,
   And,

package/src/intellisense/AutoComplete.test.ts

@@ -1,5 +1,4 @@
 import { And } from "../patterns/And";
-import { findPattern } from "../patterns/findPattern";
 import { Literal } from "../patterns/Literal";
 import { Or } from "../patterns/Or";
 import { Regex } from "../patterns/Regex";
@@ -10,11 +9,11 @@ describe("AutoComplete", () => {
     test("No Text", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("");
+        let result = autoComplete.suggestFor("");
 
         expect(result.options[0].text).toBe("Name");
         expect(result.options[0].startIndex).toBe(0);
-        expect(result.nextPatterns[0]).toBe(name);
+        expect(result.errorAtIndex).toBe(0);
         expect(result.isComplete).toBeFalsy();
     });
 
@@ -26,11 +25,11 @@ describe("AutoComplete", () => {
         const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
 
         const autoComplete = new AutoComplete(name);
-        const result = autoComplete.suggest("John Doe");
+        const result = autoComplete.suggestFor("John Doe");
 
         expect(result.ast?.value).toBe("John Doe");
         expect(result.options.length).toBe(0);
-        expect(result.nextPatterns.length).toBe(0);
+        expect(result.errorAtIndex).toBeNull();
         expect(result.isComplete).toBeTruthy();
         expect(result.cursor).not.toBeNull();
     });
@@ -42,14 +41,20 @@ describe("AutoComplete", () => {
         const smith = new Literal("smith", "Smith");
         const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
 
+        const text = "John "
         const autoComplete = new AutoComplete(name);
-        const result = autoComplete.suggest("John ");
+        const result = autoComplete.suggestFor(text);
+        const expectedOptions = [{
+            text: "Doe",
+            startIndex: 5
+        }, {
+            text: "Smith",
+            startIndex: 5
+        }];
 
         expect(result.ast).toBeNull();
-        expect(result.options.length).toBe(2);
-        expect(result.nextPatterns.length).toBe(1);
-        expect(result.nextPatterns[0].type).toBe("or");
-        expect(result.nextPatterns[0].name).toBe("last-name");
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(text.length)
         expect(result.isComplete).toBeFalsy();
         expect(result.cursor).not.toBeNull();
     });
@@ -64,12 +69,17 @@ describe("AutoComplete", () => {
 
         divider.setTokens([", "])
 
-        const autoComplete = new AutoComplete(new Repeat("last-names", name, divider));
-        const result = autoComplete.suggest("John Doe");
-
-        expect(result.ast?.value).toBe("John Doe");
-        expect(result.options.length).toBe(1);
-        expect(result.nextPatterns.length).toBe(result.options.length);
+        const text = "John Doe";
+        const autoComplete = new AutoComplete(new Repeat("last-names", name, { divider }));
+        const result = autoComplete.suggestFor(text);
+        const expectedOptions = [{
+            text: ", ",
+            startIndex: 8
+        }];
+
+        expect(result.ast?.value).toBe(text);
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBeNull()
         expect(result.isComplete).toBeTruthy();
         expect(result.cursor).not.toBeNull();
     });
@@ -77,36 +87,51 @@ describe("AutoComplete", () => {
     test("Partial", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("Na");
+        // Use deprecated suggest for code coverage.
+        const result = autoComplete.suggestFor("Na");
+        const expectedOptions = [{
+            text: "me",
+            startIndex: 2
+        }];
 
-        expect(result.options[0].text).toBe("me");
-        expect(result.options[0].startIndex).toBe(2);
-        expect(result.nextPatterns[0]).toBe(name);
+        expect(result.ast).toBeNull();
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(2);
         expect(result.isComplete).toBeFalsy();
+        expect(result.cursor).not.toBeNull();
     });
 
     test("Partial Match With Bad Characters", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("Ni");
+        const result = autoComplete.suggestFor("Ni");
+
+        const expectedOptions = [{
+            text: "ame",
+            startIndex: 1
+        }];
 
-        expect(result.options[0].text).toBe("ame");
-        expect(result.options[0].startIndex).toBe(1);
-        //expect(result.nextPattern).toBe(name);
+        expect(result.ast).toBeNull();
+        expect(result.options).toEqual(expectedOptions);
+        expect(result.errorAtIndex).toBe(1);
         expect(result.isComplete).toBeFalsy();
+        expect(result.cursor).not.toBeNull();
     });
 
     test("Complete", () => {
         const name = new Literal("name", "Name");
         const autoComplete = new AutoComplete(name);
-        let result = autoComplete.suggest("Name");
+        const text = "Name"
+        const result = autoComplete.suggestFor(text);
 
-        expect(result.options.length).toBe(0);
-        expect(result.nextPatterns.length).toBe(0);
+        expect(result.ast?.value).toBe(text);
+        expect(result.options).toEqual([]);
+        expect(result.errorAtIndex).toBeNull();
         expect(result.isComplete).toBeTruthy();
+        expect(result.cursor).not.toBeNull();
     });
 
-    test("Options", ()=>{
+    test("Options AutoComplete on Composing Pattern", () => {
         const autoCompleteOptions: AutoCompleteOptions = {
             greedyPatternNames: ["space"],
             customTokens: {
@@ -123,28 +148,89 @@ describe("AutoComplete", () => {
         const lastName = new Or("last-name", [doe, smith]);
         const fullName = new And("full-name", [firstName, space, lastName]);
 
-        const text = "John";
+        const text = "Jack";
         const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
-        const { options, ast, nextPatterns } = autoComplete.suggest(text);
+        const { options, ast, errorAtIndex } = autoComplete.suggestFor(text);
+
         const expectedOptions = [
-            {text: " Doe", startIndex: 4},
-            {text: " Smith", startIndex: 4},
-            {text: " Sparrow", startIndex: 4},
+            { text: " Doe", startIndex: 4 },
+            { text: " Smith", startIndex: 4 },
+            { text: " Sparrow", startIndex: 4 },
         ];
 
-        const results = expectedOptions.map(o=>text.slice(0, o.startIndex) + o.text);
+        const results = expectedOptions.map(o => text.slice(0, o.startIndex) + o.text);
         const expectedResults = [
-            "John Doe",
-            "John Smith",
-            "John Sparrow",
+            "Jack Doe",
+            "Jack Smith",
+            "Jack Sparrow",
         ]
 
+        expect(ast).toBeNull();
+        expect(errorAtIndex).toBe(4);
         expect(options).toEqual(expectedOptions);
+        expect(results).toEqual(expectedResults);
+
+    });
+
+    test("Options AutoComplete On Leaf Pattern", () => {
+        const autoCompleteOptions: AutoCompleteOptions = {
+            greedyPatternNames: ["space"],
+            customTokens: {
+                "space": ["  "]
+            }
+        };
+
+        const jack = new Literal("jack", "Jack");
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const doe = new Literal("doe", "Doe");
+        const smith = new Literal("smith", "Smith");
+        const firstName = new Or("first-name", [jack, john]);
+        const lastName = new Or("last-name", [doe, smith]);
+        const fullName = new And("full-name", [firstName, space, lastName]);
+
+        const text = "Jack";
+        const autoComplete = new AutoComplete(fullName, autoCompleteOptions);
+        const { options, ast, errorAtIndex } = autoComplete.suggestFor(text);
+        const expectedOptions = [
+            { text: "  Doe", startIndex: 4 },
+            { text: "  Smith", startIndex: 4 },
+            { text: " Doe", startIndex: 4 },
+            { text: " Smith", startIndex: 4 },
+        ];
+
+        const results = expectedOptions.map(o => text.slice(0, o.startIndex) + o.text);
+        const expectedResults = [
+            "Jack  Doe",
+            "Jack  Smith",
+            "Jack Doe",
+            "Jack Smith",
+        ]
+
         expect(ast).toBeNull();
-        expect(nextPatterns.length).toBe(1);
-        expect(nextPatterns[0].name).toBe("space");
+        expect(errorAtIndex).toBe(4);
+        expect(options).toEqual(expectedOptions);
         expect(results).toEqual(expectedResults)
 
     });
 
+    test("Match On Different Pattern Roots", () => {
+        const start = new Literal("start", "John went to");
+        const a = new Literal("a", "a bank.");
+        const the = new Literal("the", "the store.");
+
+        const first = new And("first", [start, a]);
+        const second = new And("second", [start, the]);
+
+        const both = new Or("both", [first, second]);
+
+        const autoComplete = new AutoComplete(both);
+        const result = autoComplete.suggestFor("John went to a gas station.");
+        const expected = [
+            { text: "the store.", startIndex: 12 },
+            { text: "a bank.", startIndex: 12 }
+        ];
+        expect(result.options).toEqual(expected);
+    });
+
 });