clarity-pattern-parser 3.0.16 → 4.0.0

package/src/tests/AnyOfThese.test.ts

@@ -1,74 +0,0 @@
-/** @jest-environment node */
-import AnyOfThese from "../patterns/value/AnyOfThese";
-import Cursor from "../Cursor";
-
-describe("AnyOfThese", () => {
-  test("Empty string provided as characters.", () => {
-    expect(() => {
-      new AnyOfThese("no-characters", "");
-    }).toThrow();
-  });
-
-  test("Single character.", () => {
-    const lowerCaseA = new AnyOfThese("lower-case-a", "a");
-    const cursor = new Cursor("a");
-    const node = lowerCaseA.parse(cursor);
-
-    expect(node?.name).toBe("lower-case-a");
-    expect(node?.value).toBe("a");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(0);
-    expect(cursor.isAtEnd()).toBe(true);
-    expect(cursor.getChar()).toBe("a");
-  });
-
-  test("Uppercase A and lowercase A.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-    const lowerCaseCursor = new Cursor("a");
-    const upperCaseCursor = new Cursor("A");
-    const lowerCaseNode = letterA.parse(lowerCaseCursor);
-    const upperCaseNode = letterA.parse(upperCaseCursor);
-
-    expect(lowerCaseNode?.name).toBe("letter-a");
-    expect(lowerCaseNode?.value).toBe("a");
-    expect(lowerCaseNode?.startIndex).toBe(0);
-    expect(lowerCaseNode?.endIndex).toBe(0);
-
-    expect(upperCaseNode?.name).toBe("letter-a");
-    expect(upperCaseNode?.value).toBe("A");
-    expect(upperCaseNode?.startIndex).toBe(0);
-    expect(upperCaseNode?.endIndex).toBe(0);
-
-    expect(upperCaseCursor.getChar()).toBe("A");
-    expect(upperCaseCursor.isAtEnd()).toBe(true);
-
-    expect(lowerCaseCursor.getChar()).toBe("a");
-    expect(lowerCaseCursor.isAtEnd()).toBe(true);
-  });
-
-  test("Match with long cursor.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-    const cursor = new Cursor("a12345");
-    const node = letterA.parse(cursor);
-
-    expect(node?.name).toBe("letter-a");
-    expect(node?.value).toBe("a");
-    expect(cursor.getChar()).toBe("a");
-    expect(cursor.getIndex()).toBe(0);
-  });
-
-  test("No match.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-    const cursor = new Cursor("12345");
-    const node = letterA.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("Pattern Methods.", () => {
-    const letterA = new AnyOfThese("letter-a", "Aa");
-
-    expect(letterA.name).toBe("letter-a");
-    expect(letterA.children.length).toBe(0);
-  });
-});

package/src/tests/CompositeNode.test.ts

@@ -1,33 +0,0 @@
-/** @jest-environment node */
-import CompositeNode from "../ast/CompositeNode";
-import { ValueNode } from "../index";
-
-describe("CompositeNode", () => {
-  test("CompositeNode: clone", () => {
-    const node = new CompositeNode("type", "name", 0, 0);
-    const valueNode = new ValueNode("value-type", "value-name", "t", 0, 0);
-
-    node.children.push(valueNode);
-
-    const clone = node.clone();
-
-    expect(clone.type).toBe("type");
-    expect(clone.name).toBe("name");
-    expect(clone.children.length).toBe(1);
-    expect(clone.children[0].type).toBe("value-type");
-    expect(clone.children[0].name).toBe("value-name");
-  });
-
-  test("CompositeNode: constructor without default indexes.", () => {
-    const node = new CompositeNode("type", "name");
-    const valueNode = new ValueNode("value-type", "value-name", "t", 0, 0);
-
-    node.children.push(valueNode);
-
-    expect(node.type).toBe("type");
-    expect(node.name).toBe("name");
-    expect(node.children.length).toBe(1);
-    expect(node.children[0].type).toBe("value-type");
-    expect(node.children[0].name).toBe("value-name");
-  });
-});

package/src/tests/NotValue.test.ts

@@ -1,76 +0,0 @@
-/** @jest-environment node */
-import NotValue from "../patterns/value/NotValue";
-import Literal from "../patterns/value/Literal";
-import Cursor from "../Cursor";
-import OrValue from "../patterns/value/OrValue";
-import AndValue from "../patterns/value/AndValue";
-import RepeatValue from "../patterns/value/RepeatValue";
-import RegexValue from "../patterns/value/RegexValue";
-
-describe("NotValue", () => {
-  test("Empty Constructor.", () => {
-    expect(() => {
-      new (NotValue as any)();
-    }).toThrow();
-  });
-
-  test("Invalid name.", () => {
-    expect(() => {
-      new (NotValue as any)([], new Literal("blah", "Blah"));
-    }).toThrow();
-  });
-
-  test("No patterns", () => {
-    expect(() => {
-      new (NotValue as any)("and-value");
-    }).toThrow();
-  });
-
-  test("Empty patterns", () => {
-    expect(() => {
-      new (NotValue as any)("and-value", null);
-    }).toThrow();
-  });
-
-  test("Invalid patterns", () => {
-    expect(() => {
-      new (NotValue as any)("and-value", {});
-    }).toThrow();
-  });
-
-  test("No Match", () => {
-    const john = new Literal("john", "John");
-    const notJohn = new NotValue("not-john", john);
-    const cursor = new Cursor("John");
-
-    notJohn.parse(cursor);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-    expect(cursor.parseError?.message).toBe(
-      "Didn't find any characters that didn't match the john pattern."
-    );
-  });
-
-  test("Success", () => {
-    const john = new Literal("john", "John");
-    const notJohn = new NotValue("not-john", john);
-    const cursor = new Cursor("Jane");
-    const node = notJohn.parse(cursor);
-
-    expect(node?.name).toBe("not-john");
-    expect(node?.value).toBe("J");
-    expect(node?.startIndex).toBe(0);
-    expect(node?.endIndex).toBe(0);
-    expect(cursor.getIndex()).toBe(0);
-  });
-
-  test("Clone.", () => {
-    const john = new Literal("john", "John");
-    const notJohn = new NotValue("not-john", john);
-    const clone = notJohn.clone();
-
-    expect(notJohn.name).toBe(clone.name);
-  });
-
-  
-
-});

package/src/tests/OptionalValue.test.ts

@@ -1,50 +0,0 @@
-/** @jest-environment node */
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
-import Cursor from "../Cursor";
-
-describe("OptionalValue", () => {
-  test("Empty constructor.", () => {
-    expect(() => {
-      new (OptionalValue as any)();
-    }).toThrow();
-  });
-
-  test("Empty pattern.", () => {
-    expect(() => {
-      new (OptionalValue as any)();
-    }).toThrow();
-  });
-
-  test("Invalid pattern.", () => {
-    expect(() => {
-      new (OptionalValue as any)({});
-    }).toThrow();
-  });
-
-  test("Match pattern.", () => {
-    const john = new Literal("john", "John");
-    const optionalValue = new OptionalValue(john);
-    const cursor = new Cursor("John");
-    const node = optionalValue.parse(cursor);
-
-    expect(node?.name).toBe("john");
-    expect(node?.value).toBe("John");
-  });
-
-  test("No Match pattern.", () => {
-    const john = new Literal("john", "John");
-    const optionalValue = new OptionalValue(john);
-    const cursor = new Cursor("Jane");
-    const node = optionalValue.parse(cursor);
-
-    expect(node).toBe(null);
-  });
-
-  test("Name", () => {
-    const john = new Literal("john", "John");
-    const optionalValue = new OptionalValue(john);
-
-    expect(optionalValue.name).toBe("optional-value");
-  });
-});

package/src/tests/OrComposite.test.ts

@@ -1,75 +0,0 @@
-/** @jest-environment node */
-import OrComposite from "../patterns/composite/OrComposite";
-import Literal from "../patterns/value/Literal";
-import OptionalValue from "../patterns/value/OptionalValue";
-import { Cursor } from "../index";
-
-describe("OrComposite", ()=>{
-  test("Match.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-    const cursor = new Cursor("John");
-    const name = new OrComposite("name", [john, jane]);
-  
-    const node = name.parse(cursor);
-  
-    expect(node.name).toBe("john");
-    expect(node.value).toBe("John");
-  });
-  
-  test("No Match", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-    const cursor = new Cursor("Jeffrey");
-    const name = new OrComposite("name", [john, jane]);
-  
-    const node = name.parse(cursor);
-  
-    expect(node).toBe(null);
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-  });
-  
-  test("Supplied only one option.", () => {
-    const john = new Literal("john", "John");
-  
-    expect(() => {
-      new OrComposite("name", [john]);
-    }).toThrow();
-  });
-  
-  test("Optional Children.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-  
-    expect(() => {
-      new OrComposite("name", [new OptionalValue(john), new OptionalValue(jane)]);
-    }).toThrow();
-  });
-  
-  test("parse with null cursor.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-    const cursor = new Cursor("John");
-    const name = new OrComposite("name", [john, jane]);
-  
-    const node = name.parse(cursor);
-  
-    expect(node.name).toBe("john");
-    expect(node.value).toBe("John");
-  });
-  
-  test("clone.", () => {
-    const john = new Literal("john", "John");
-    const jane = new Literal("jane", "Jane");
-  
-    const name = new OrComposite("name", [john, jane]);
-    const clone = name.clone("name2");
-  
-    expect(clone.name).toBe("name2");
-    expect(clone.children.length).toBe(2);
-    expect(clone.children[0].name).toBe("john");
-    expect(clone.children[1].name).toBe("jane");
-  });
-  
-});

package/src/tests/OrValue.test.ts

@@ -1,171 +0,0 @@
-/** @jest-environment node */
-import OrValue from "../patterns/value/OrValue";
-import AnyOfThese from "../patterns/value/AnyOfThese";
-import Literal from "../patterns/value/Literal";
-import Cursor from "../Cursor";
-
-describe("OrValue", () => {
-  test("OrValue: Empty constructor.", () => {
-    expect(() => {
-      new (OrValue as any)();
-    }).toThrow();
-  });
-
-  test("OrValue: Undefined parser.", () => {
-    expect(() => {
-      new (OrValue as any)("name");
-    }).toThrow();
-  });
-
-  test("OrValue: Null patterns.", () => {
-    expect(() => {
-      new (OrValue as any)("name", null);
-    }).toThrow();
-  });
-
-  test("OrValue: Empty array parser.", () => {
-    expect(() => {
-      new (OrValue as any)("name", []);
-    }).toThrow();
-  });
-
-  test("OrValue: One parser.", () => {
-    expect(() => {
-      new (OrValue as any)("name", [new Literal("some-value", "")]);
-    }).toThrow();
-  });
-
-  test("OrValue: Name and patterns.", () => {
-    const letter = new AnyOfThese(
-      "letter",
-      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    );
-    const number = new AnyOfThese("number", "0987654321");
-    const alphaNumeric = new (OrValue as any)("alpha-numeric", [
-      letter,
-      number,
-    ]);
-
-    const letterCursor = new Cursor("a");
-    const numberCursor = new Cursor("1");
-
-    const letterNode = alphaNumeric.parse(letterCursor);
-    const numberNode = alphaNumeric.parse(numberCursor);
-
-    expect(letterNode.name).toBe("alpha-numeric");
-    expect(letterNode.value).toBe("a");
-
-    expect(numberNode.name).toBe("alpha-numeric");
-    expect(numberNode.value).toBe("1");
-  });
-
-  test("OrValue: Optional Pattern as one of the patterns.", () => {
-    const letter = new AnyOfThese(
-      "letter",
-      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    );
-    const number = new AnyOfThese("number", "0987654321");
-    const alphaNumeric = new (OrValue as any)("alpha-numeric", [
-      letter,
-      number,
-    ]);
-
-    const letterCursor = new Cursor("a");
-    const numberCursor = new Cursor("1");
-
-    const letterNode = alphaNumeric.parse(letterCursor);
-    const numberNode = alphaNumeric.parse(numberCursor);
-
-    expect(letterNode.name).toBe("alpha-numeric");
-    expect(letterNode.value).toBe("a");
-
-    expect(numberNode.name).toBe("alpha-numeric");
-    expect(numberNode.value).toBe("1");
-  });
-
-  test("OrValue: Fail.", () => {
-    const letter = new AnyOfThese("some-letter", "abc");
-    const number = new AnyOfThese("some-number", "123");
-    const alphaNumeric = new (OrValue as any)("some-alpha-numeric", [
-      letter,
-      number,
-    ]);
-
-    const letterCursor = new Cursor("d");
-    const numberCursor = new Cursor("4");
-
-    const letterNode = alphaNumeric.parse(letterCursor);
-    const numberNode = alphaNumeric.parse(numberCursor);
-
-    expect(letterCursor.getIndex()).toBe(0);
-    expect(letterCursor.hasUnresolvedError()).toBe(true);
-
-    expect(numberCursor.getIndex()).toBe(0);
-    expect(numberCursor.hasUnresolvedError()).toBe(true);
-  });
-
-  test("OrValue: Clone.", () => {
-    const letter = new AnyOfThese("some-letter", "abc");
-    const number = new AnyOfThese("some-number", "123");
-    const alphaNumeric = new (OrValue as any)("some-alpha-numeric", [
-      letter,
-      number,
-    ]);
-
-    const clone = alphaNumeric.clone();
-
-    expect(alphaNumeric.children.length).toBe(clone.children.length);
-    expect(alphaNumeric.name).toBe(clone.name);
-  });
-
-  test("OrValue: Invalid patterns.", () => {
-    expect(() => {
-      new (OrValue as any)("some-alpha-numeric", [{}, null]);
-    });
-  });
-
-  test("OrValue: Not enough patterns.", () => {
-    expect(() => {
-      new (OrValue as any)("some-alpha-numeric", [{}]);
-    });
-  });
-
-  test("OrValue: Bad name.", () => {
-    expect(() => {
-      new (OrValue as any)({}, [new Literal("a", "a"), new Literal("a", "a")]);
-    });
-  });
-
-  test("OrValue: Bad cursor.", () => {
-    expect(() => {
-      new (OrValue as any)("A", [
-        new Literal("a", "a"),
-        new Literal("a", "a"),
-      ]).parse();
-    });
-  });
-
-  test("OrValue: Furthest Parse Error.", () => {
-    const longer = new Literal("longer", "Longer");
-    const bang = new Literal("bang", "Bang");
-    const orValue = new (OrValue as any)("test", [longer, bang]);
-    const cursor = new Cursor("Longed");
-
-    orValue.parse(cursor);
-
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-  });
-
-  test("OrValue: Last pattern matches.", () => {
-    const longer = new Literal("longer", "Longer");
-    const bang = new Literal("bang", "Bang");
-    const orValue = new (OrValue as any)("test", [longer, bang]);
-    const cursor = new Cursor("Bang");
-
-    const node = orValue.parse(cursor);
-
-    expect(node.name).toBe("test");
-    expect(node.value).toBe("Bang");
-  });
-});

package/src/tests/Permutor.test.ts

@@ -1,30 +0,0 @@
-/** @jest-environment node */
-import Permutor from "../Permutor";
-
-describe("Permutor", () => {
-  test("Permutor: simple.", () => {
-    const permutor = new Permutor();
-    const array = [
-      [0, 1],
-      [0, 1],
-      [0, 1],
-    ];
-
-    const result = permutor.permute(array);
-    expect(result.join(",")).toBe("000,001,010,011,100,101,110,111");
-  });
-
-  test("Permutor: larger.", () => {
-    const permutor = new Permutor();
-    const array = [
-      [0, 1, 2],
-      [0, 1],
-      [0, 1, 2, 3],
-    ];
-
-    const result = permutor.permute(array);
-    expect(result.join(",")).toBe(
-      "000,001,002,003,010,011,012,013,100,101,102,103,110,111,112,113,200,201,202,203,210,211,212,213"
-    );
-  });
-});

package/src/tests/ReferencePattern.test.ts

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

package/src/tests/RegexValue.test.ts

@@ -1,22 +0,0 @@
-/** @jest-environment node */
-import { RegexValue } from "../index";
-
-test("RegexValue: exec.", () => {
-  const notA = new RegexValue("not-a", "[^a]+");
-
-  const result = notA.exec("John");
-  const result2 = notA.exec("a");
-
-  const expectedValue = {
-    children: [],
-    value: "John",
-    type: "regex-value",
-    name: "not-a",
-    startIndex: 0,
-    endIndex: 3,
-    isComposite: false,
-  };
-
-  expect(JSON.stringify(result)).toBe(JSON.stringify(expectedValue));
-  expect(result2).toBe(null);
-});

package/src/tests/RepeatComposite.test.ts

@@ -1,58 +0,0 @@
-/** @jest-environment node */
-import RepeatComposite from "../patterns/composite/RepeatComposite";
-import AndComposite from "../patterns/composite/AndComposite";
-import OptionalComposite from "../patterns/composite/OptionalComposite";
-import Literal from "../patterns/value/Literal";
-import Cursor from "../Cursor";
-import OrComposite from "../patterns/composite/OrComposite";
-
-describe("RepeatComposite", () => {
-  test("Cannot use optional patterns.", () => {
-    const firstName = new Literal("John", "John");
-    const lastName = new Literal("Doe", "Doe");
-    const andComposite = new AndComposite("full-name", [firstName, lastName]);
-
-    expect(() => {
-      new RepeatComposite("full-names", new OptionalComposite(andComposite));
-    }).toThrow();
-  });
-
-  test("clone with custom name.", () => {
-    const firstName = new Literal("John", "John");
-    const lastName = new Literal("Doe", "Doe");
-    const andComposite = new AndComposite("full-name", [firstName, lastName]);
-    const fullnames = new RepeatComposite("full-names", andComposite);
-    const clone = fullnames.clone("full-names-2");
-
-    expect(clone.name).toBe("full-names-2");
-  });
-
-  test("parse.", () => {
-    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 repeat = new RepeatComposite("repeat", or, space);
-    const result = repeat.parse(new Cursor("A B"));
-
-    expect(result?.children[0].value).toBe("A");
-    expect(result?.children[0].name).toBe("a");
-    expect(result?.children[1].value).toBe(" ");
-    expect(result?.children[1].name).toBe("space");
-    expect(result?.children[2].value).toBe("B");
-    expect(result?.children[2].name).toBe("b");
-  });
-
-  test("Cannot end on a divider.", () => {
-    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 repeat = new RepeatComposite("repeat", or, space);
-    const result = repeat.parse(new Cursor("A B "));
-
-    expect(result).toBe(null);
-  });
-});

package/src/tests/ValueNode.test.ts

@@ -1,24 +0,0 @@
-/** @jest-environment node */
-import ValueNode from "../ast/ValueNode";
-import assert from "assert";
-
-describe("ValueNode", () => {
-  test("clone.", () => {
-    const node = new ValueNode("type", "name", "value", 0, 1);
-    const clone = node.clone();
-
-    assert.equal(node.name, clone.name);
-    assert.equal(node.value, clone.value);
-    assert.equal(node.startIndex, clone.startIndex);
-    assert.equal(node.endIndex, clone.endIndex);
-  });
-
-  test("Without indexes.", () => {
-    const node = new ValueNode("type", "name", "value");
-
-    assert.equal(node.name, "name");
-    assert.equal(node.value, "value");
-    assert.equal(node.startIndex, 0);
-    assert.equal(node.endIndex, 0);
-  });
-});