clarity-pattern-parser 3.0.16 → 4.0.1

package/src/tests/Pattern.test.ts

@@ -1,52 +1,10 @@
 /** @jest-environment node */
-import ValuePattern from "../patterns/value/ValuePattern";
-import AndValue from "../patterns/value/AndValue";
-import OrValue from "../patterns/value/OrValue";
-import Literal from "../patterns/value/Literal";
-import RepeatValue from "../patterns/value/RepeatValue";
-import OptionalValue from "../patterns/value/OptionalValue";
-
-describe("ValuePattern", () => {
-  test("parse.", () => {
-    const valueValuePattern = new (ValuePattern as any)(
-      "pattern-type",
-      "pattern"
-    );
-    expect(() => {
-      valueValuePattern.parse();
-    }).toThrow();
-  });
-
-  test("clone.", () => {
-    const valueValuePattern = new (ValuePattern as any)(
-      "pattern-type",
-      "pattern"
-    );
-    expect(() => {
-      valueValuePattern.clone();
-    }).toThrow();
-  });
-
-  test("getPossibilities.", () => {
-    const valueValuePattern = new (ValuePattern as any)(
-      "pattern-type",
-      "pattern"
-    );
-    expect(() => {
-      valueValuePattern.getPossibilities();
-    }).toThrow();
-  });
-
-  test("limited arguments.", () => {
-    new (ValuePattern as any)(undefined, "name");
-  });
-
-  test("no arguments.", () => {
-    expect(() => {
-      new (ValuePattern as any)();
-    }).toThrow();
-  });
+import And from "../patterns/And";
+import Or from "../patterns/Or";
+import Literal from "../patterns/Literal";
+import Repeat from "../patterns/Repeat";
 
+describe("Pattern", () => {
   test("set parent.", () => {
     const parent = new Literal("pattern-type", "pattern");
     const child = new Literal("pattern-type", "pattern");
@@ -54,17 +12,10 @@ describe("ValuePattern", () => {
     child.parent = parent;
   });
 
-  test("set invalid parent.", () => {
-    const child = new Literal("pattern-type", "pattern");
-    (child as any).parent = "";
-
-    expect(child.parent).toBe(null);
-  });
-
   test("getTokens", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
 
     let tokens = firstName.getTokens();
     expect(tokens.length).toBe(1);
@@ -82,7 +33,7 @@ describe("ValuePattern", () => {
   test("getNextToken one deep.", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [firstName, lastName]);
+    const fullName = new And("full-name", [firstName, lastName]);
 
     const tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(1);
@@ -93,8 +44,8 @@ describe("ValuePattern", () => {
     const firstName = new Literal("first-name", "John");
     const lastName = new Literal("last-name", "Doe");
     const otherLastName = new Literal("other-last-name", "Smith");
-    const lastNames = new OrValue("last-names", [lastName, otherLastName]);
-    const fullName = new AndValue("full-name", [firstName, lastNames]);
+    const lastNames = new Or("last-names", [lastName, otherLastName]);
+    const fullName = new And("full-name", [firstName, lastNames]);
 
     const tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(2);
@@ -107,17 +58,10 @@ describe("ValuePattern", () => {
     const lastName = new Literal("last-name", "Doe");
     const middleName = new Literal("middle-name", "Moses");
     const otherMiddleName = new Literal("other-middle-name", "Joshua");
-    const middleNames = new OrValue("middle-names", [
-      middleName,
-      otherMiddleName,
-    ]);
+    const middleNames = new Or("middle-names", [middleName, otherMiddleName]);
     const otherLastName = new Literal("other-last-name", "Smith");
-    const lastNames = new OrValue("last-names", [lastName, otherLastName]);
-    const fullName = new AndValue("full-name", [
-      firstName,
-      middleNames,
-      lastNames,
-    ]);
+    const lastNames = new Or("last-names", [lastName, otherLastName]);
+    const fullName = new And("full-name", [firstName, middleNames, lastNames]);
 
     const tokens = fullName.children[1].children[1].getNextTokens();
     expect(tokens.length).toBe(2);
@@ -130,17 +74,10 @@ describe("ValuePattern", () => {
     const lastName = new Literal("last-name", "Doe");
     const middleName = new Literal("middle-name", "Moses");
     const otherMiddleName = new Literal("other-middle-name", "Joshua");
-    const middleNames = new OrValue("middle-names", [
-      middleName,
-      otherMiddleName,
-    ]);
+    const middleNames = new Or("middle-names", [middleName, otherMiddleName]);
     const otherLastName = new Literal("other-last-name", "Smith");
-    const lastNames = new OrValue("last-names", [lastName, otherLastName]);
-    const fullName = new AndValue("full-name", [
-      firstName,
-      middleNames,
-      lastNames,
-    ]);
+    const lastNames = new Or("last-names", [lastName, otherLastName]);
+    const fullName = new And("full-name", [firstName, middleNames, lastNames]);
 
     const tokens = fullName.children[2].children[1].getNextTokens();
     expect(tokens.length).toBe(0);
@@ -151,14 +88,14 @@ describe("ValuePattern", () => {
     const lastName = new Literal("last-name", "Doe");
     const moses = new Literal("moses", "Moses");
     const joshua = new Literal("other-middle-name", "Joshua");
-    const moreLastNames = new OrValue("more-last-names", [moses, joshua]);
+    const moreLastNames = new Or("more-last-names", [moses, joshua]);
     const otherLastName = new Literal("other-last-name", "Smith");
-    const lastNames = new OrValue("last-names", [
+    const lastNames = new Or("last-names", [
       moreLastNames,
       lastName,
       otherLastName,
     ]);
-    const fullName = new AndValue("full-name", [firstName, lastNames]);
+    const fullName = new And("full-name", [firstName, lastNames]);
 
     const tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(4);
@@ -171,13 +108,9 @@ describe("ValuePattern", () => {
   test("getNextTokens, with repeat.", () => {
     const firstName = new Literal("first-name", "John");
     const edward = new Literal("edward", "Edward");
-    const middleName = new RepeatValue("middle-names", edward);
+    const middleName = new Repeat("middle-names", edward);
     const lastName = new Literal("lastName", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      middleName,
-      lastName,
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(1);
@@ -193,13 +126,9 @@ describe("ValuePattern", () => {
     const firstName = new Literal("first-name", "John");
     const edward = new Literal("edward", "Edward");
     const stewart = new Literal("stewart", "Stewart");
-    const middleName = new RepeatValue("middle-names", edward, stewart);
+    const middleName = new Repeat("middle-names", edward, stewart);
     const lastName = new Literal("lastName", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      middleName,
-      lastName,
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(1);
@@ -219,13 +148,9 @@ describe("ValuePattern", () => {
     const firstName = new Literal("first-name", "John");
     const edward = new Literal("edward", "Edward");
     const stewart = new Literal("stewart", "Stewart");
-    const middleName = new RepeatValue("middle-names", edward, stewart);
+    const middleName = new Repeat("middle-names", edward, stewart);
     const lastName = new Literal("lastName", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      middleName,
-      lastName,
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.getTokens();
     expect(tokens.length).toBe(1);
@@ -241,14 +166,10 @@ describe("ValuePattern", () => {
   });
 
   test("getNextTokens, and with optional start.", () => {
-    const firstName = new Literal("first-name", "John");
+    const firstName = new Literal("first-name", "John", true);
     const middleName = new Literal("middle-name", "Edward");
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
-      new OptionalValue(firstName),
-      middleName,
-      lastName,
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.getTokens();
     expect(tokens.length).toBe(2);
@@ -258,13 +179,9 @@ describe("ValuePattern", () => {
 
   test("getNextTokens, and with optional middle.", () => {
     const firstName = new Literal("first-name", "John");
-    const middleName = new Literal("middle-name", "Edward");
+    const middleName = new Literal("middle-name", "Edward", true);
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      new OptionalValue(middleName),
-      lastName,
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(2);
@@ -282,12 +199,8 @@ describe("ValuePattern", () => {
   test("getNextTokens, and with optional last.", () => {
     const firstName = new Literal("first-name", "John");
     const middleName = new Literal("middle-name", "Edward");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      middleName,
-      new OptionalValue(lastName),
-    ]);
+    const lastName = new Literal("last-name", "Doe", true);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.children[0].getNextTokens();
     expect(tokens.length).toBe(1);
@@ -302,14 +215,10 @@ describe("ValuePattern", () => {
   });
 
   test("getNextTokens, first two optional.", () => {
-    const firstName = new Literal("first-name", "John");
-    const middleName = new Literal("middle-name", "Edward");
+    const firstName = new Literal("first-name", "John", true);
+    const middleName = new Literal("middle-name", "Edward", true);
     const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
-      new OptionalValue(firstName),
-      new OptionalValue(middleName),
-      lastName,
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.getTokens();
     expect(tokens.length).toBe(3);
@@ -332,13 +241,9 @@ describe("ValuePattern", () => {
 
   test("getNextTokens, last two optional.", () => {
     const firstName = new Literal("first-name", "John");
-    const middleName = new Literal("middle-name", "Edward");
-    const lastName = new Literal("last-name", "Doe");
-    const fullName = new AndValue("full-name", [
-      firstName,
-      new OptionalValue(middleName),
-      new OptionalValue(lastName),
-    ]);
+    const middleName = new Literal("middle-name", "Edward", true);
+    const lastName = new Literal("last-name", "Doe", true);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.getTokens();
     expect(tokens.length).toBe(1);
@@ -358,15 +263,11 @@ describe("ValuePattern", () => {
   });
 
   test("getNextTokens, all three optional.", () => {
-    const firstName = new Literal("first-name", "John");
-    const middleName = new Literal("middle-name", "Edward");
-    const lastName = new Literal("last-name", "Doe");
+    const firstName = new Literal("first-name", "John", true);
+    const middleName = new Literal("middle-name", "Edward", true);
+    const lastName = new Literal("last-name", "Doe", true);
 
-    const fullName = new AndValue("full-name", [
-      new OptionalValue(firstName),
-      new OptionalValue(middleName),
-      new OptionalValue(lastName),
-    ]);
+    const fullName = new And("full-name", [firstName, middleName, lastName]);
 
     let tokens = fullName.getTokens();
     expect(tokens.length).toBe(3);

package/src/tests/{RecursivePattern.test.ts → Recursive.test.ts}

@@ -1,5 +1,5 @@
 /** @jest-environment node */
-import { RecursivePattern, Cursor } from "../index";
+import { Recursive, Cursor } from "../index";
 import literals from "./javascriptPatterns/json";
 
 describe("RecursivePattern", () => {
@@ -18,23 +18,25 @@ describe("RecursivePattern", () => {
     const cursor = new Cursor(json);
     const cursor2 = new Cursor(JSON.stringify([{ foo: "bar" }]));
 
-    const object = literals.parse(cursor);
-    const array = literals.parse(cursor2);
+    const result1 = literals.parse(cursor);
+    const result2 = literals.parse(cursor2);
 
-    expect(object.name).toBe("object-literal");
-    expect(array.name).toBe("array-literal");
-    expect(object.toString()).toBe(json);
+    expect(result1?.name).toBe("literals");
+    expect(result1?.children[0].name).toBe("object-literal");
+    expect(result2?.name).toBe("literals");
+    expect(result2?.children[0].name).toBe("array-literal");
+    expect(result1?.toString()).toBe(json);
   });
 
   test("No pattern", () => {
-    const node = new RecursivePattern("nothing");
+    const node = new Recursive("nothing");
     const result = node.exec("Some string.");
 
     expect(result).toBe(null);
   });
 
   test("clone.", () => {
-    const node = new RecursivePattern("nothing");
+    const node = new Recursive("nothing");
     const clone = node.clone();
 
     expect(node.name).toBe(clone.name);

package/src/tests/Reference.test.ts

@@ -0,0 +1,16 @@
+import { Cursor, Reference, And, Literal, Or } from "../index";
+
+describe("ReferencePattern", () => {
+  test("Reference to node in different branch.", () => {
+    const a = new Literal("a", "a");
+    const b = new Literal("b", "b");
+    const a_b_c = new And("a-and-b-and-c", [a, b, new Reference("c")]);
+    const c = new Literal("c", "c");
+    const b_c = new And("b-and-c", [b, c]);
+    const main = new Or("main", [a_b_c, b_c]);
+
+    const result = main.parse(new Cursor("abc"));
+
+    expect(result).not.toBeNull();
+  });
+});

package/src/tests/{RepeatValue.test.ts → Repeat.test.ts}

@@ -1,43 +1,11 @@
 /** @jest-environment node */
-import RepeatValue from "../patterns/value/RepeatValue";
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
-import Cursor from "../Cursor";
+import {Repeat, Cursor, Literal} from "../index";
 
-describe("RepeatValue", function () {
-  test("Empty Constructor.", () => {
-    expect(() => {
-      new (RepeatValue as any)();
-    }).toThrow();
-  });
-
-  test("Invalid name.", () => {
-    expect(() => {
-      new (RepeatValue as any)([], new Literal("blah", "Blah"));
-    }).toThrow();
-  });
-
-  test("No patterns", () => {
-    expect(() => {
-      new (RepeatValue as any)("and-value");
-    }).toThrow();
-  });
-
-  test("Empty patterns", () => {
-    expect(() => {
-      new (RepeatValue as any)("and-value", null);
-    }).toThrow();
-  });
-
-  test("Invalid patterns", () => {
-    expect(() => {
-      new (RepeatValue as any)("and-value", {});
-    }).toThrow();
-  });
+describe("Repeat", function () {
 
   test("No Match", () => {
     const john = new Literal("john", "John");
-    const johns = new RepeatValue("johns", john);
+    const johns = new Repeat("johns", john);
     const cursor = new Cursor("JaneJane");
 
     johns.parse(cursor);
@@ -46,7 +14,7 @@ describe("RepeatValue", function () {
 
   test("Success, one John", () => {
     const john = new Literal("john", "John");
-    const johns = new RepeatValue("johns", john);
+    const johns = new Repeat("johns", john);
     const cursor = new Cursor("John");
     const node = johns.parse(cursor);
 
@@ -58,7 +26,7 @@ describe("RepeatValue", function () {
 
   test("Success with a terminating match.", () => {
     const john = new Literal("john", "John");
-    const johns = new RepeatValue("johns", john);
+    const johns = new Repeat("johns", john);
     const cursor = new Cursor("JohnJohnJane");
     const node = johns.parse(cursor);
 
@@ -71,7 +39,7 @@ describe("RepeatValue", function () {
 
   test("Bad cursor.", () => {
     const john = new Literal("john", "John");
-    const johns = new RepeatValue("johns", john);
+    const johns = new Repeat("johns", john);
 
     expect(() => {
       (johns as any).parse("");
@@ -80,17 +48,17 @@ describe("RepeatValue", function () {
 
   test("Clone.", () => {
     const john = new Literal("john", "John");
-    const johns = new RepeatValue("johns", john);
+    const johns = new Repeat("johns", john);
     const clone = johns.clone();
 
     expect(johns.name).toBe(clone.name);
   });
 
   test("Try Optional.", () => {
-    const john = new Literal("john", "John");
+    const john = new Literal("john", "John", true);
 
     expect(() => {
-      new RepeatValue("johns", new OptionalValue(john));
+      new Repeat("johns", john);
     });
   });
 
@@ -99,7 +67,7 @@ describe("RepeatValue", function () {
     const john = new Literal("john", "John");
     const divider = new Literal("divider", ",");
 
-    const node = new RepeatValue("johns", john, divider).parse(cursor);
+    const node = new Repeat("johns", john, divider).parse(cursor);
 
     expect(node?.name).toBe("johns");
     expect(node?.value).toBe("John,John");

package/src/tests/TextSuggester.test.ts

@@ -1,14 +1,12 @@
 /** @jest-environment node */
 import TextSuggester from "../TextSuggester";
 import sentence from "./patterns/sentence";
-import Literal from "../patterns/value/Literal";
-import AndValue from "../patterns/value/AndValue";
-import OrValue from "../patterns/value/OrValue";
+import Literal from "../patterns/Literal";
+import And from "../patterns/And";
+import Or from "../patterns/Or";
 import json from "./javascriptPatterns/json";
-import OrComposite from "../patterns/composite/OrComposite";
-import RepeatComposite from "../patterns/composite/RepeatComposite";
-import AndComposite from "../patterns/composite/AndComposite";
-import RecursivePattern from "../patterns/RecursivePattern";
+import Repeat from "../patterns/Repeat";
+import Recursive from "../patterns/Recursive";
 
 function generateFlagFromList(flagNames: string[]) {
   return flagNames.map((flagName) => {
@@ -22,18 +20,18 @@ function generateExpression(flagNames: string[]) {
   const andLiteral = new Literal("and-literal", "AND");
   const space = new Literal("space", " ");
   const orLiteral = new Literal("or-literal", "OR");
-  const and = new AndValue("and", [space, andLiteral, space]);
-  const or = new AndValue("or", [space, orLiteral, space]);
+  const and = new And("and", [space, andLiteral, space]);
+  const or = new And("or", [space, orLiteral, space]);
 
-  const booleanOperator = new OrComposite("booleanOperator", [and, or]);
-  const flag = new OrComposite("flags", generateFlagFromList(flagNames));
-  const group = new AndComposite("group", [
+  const booleanOperator = new Or("booleanOperator", [and, or]);
+  const flag = new Or("flags", generateFlagFromList(flagNames));
+  const group = new And("group", [
     openParen,
-    new RecursivePattern("flag-expression"),
+    new Recursive("flag-expression"),
     closeParen,
   ]);
-  const flagOrGroup = new OrComposite("flag-or-group", [flag, group]);
-  const flagExpression = new RepeatComposite(
+  const flagOrGroup = new Or("flag-or-group", [flag, group]);
+  const flagExpression = new Repeat(
     "flag-expression",
     flagOrGroup,
     booleanOperator
@@ -178,15 +176,9 @@ describe("TextInspector", () => {
     const theMoney = new Literal("the-money", "the money");
     const yourLicense = new Literal("your-license", "your license");
     const space = new Literal("space", " ");
-    const first = new AndValue("first", [show, space, me, space, theMoney]);
-    const second = new AndValue("second", [
-      show,
-      space,
-      me,
-      space,
-      yourLicense,
-    ]);
-    const either = new OrValue("either", [first, second]);
+    const first = new And("first", [show, space, me, space, theMoney]);
+    const second = new And("second", [show, space, me, space, yourLicense]);
+    const either = new Or("either", [first, second]);
 
     const inspection = TextSuggester.suggest("Show me ", either);
 
@@ -255,9 +247,9 @@ describe("TextInspector", () => {
     const a = new Literal("a", "A");
     const b = new Literal("b", "B");
     const space = new Literal("space", " ");
-    const or = new OrComposite("names", [a, b]);
+    const or = new Or("names", [a, b]);
 
-    const repeat = new RepeatComposite("repeat", or, space);
+    const repeat = new Repeat("repeat", or, space);
 
     const result = TextSuggester.suggest("A B ", repeat);
 
@@ -271,9 +263,9 @@ describe("TextInspector", () => {
     const a = new Literal("a", "A");
     const b = new Literal("b", "B");
     const space = new Literal("space", " ");
-    const or = new OrComposite("names", [a, b]);
+    const or = new Or("names", [a, b]);
 
-    const repeat = new RepeatComposite("repeat", or, space);
+    const repeat = new Repeat("repeat", or, space);
 
     const result = TextSuggester.suggest("A B", repeat);
 
@@ -292,4 +284,14 @@ describe("TextInspector", () => {
     expect(result.options.values[2]).toBe("FlagZ");
     expect(result.options.values[3]).toBe("(");
   });
+
+  test("Do not match on first partial token.", () => {
+    const expression = generateExpression(["FlagX", "FlagY", "FlagZ"]);
+    const result = TextSuggester.suggest("l", expression);
+
+    expect(result.options).toBe(null);
+    expect(result.error?.startIndex).toBe(0);
+    expect(result.error?.endIndex).toBe(0);
+    expect(result.error?.text).toBe("l");
+  });
 });