clarity-pattern-parser 3.0.16 → 4.0.1

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);
-  });
-});

package/src/tests/readmeDemo.test.ts

@@ -1,124 +0,0 @@
-/** @jest-environment node */
-import {
-  Cursor,
-  Literal,
-  AndValue,
-  OrValue,
-  RepeatValue,
-  NotValue,
-  AndComposite,
-} from "../index";
-
-describe("Readme.md", () => {
-  test("value", () => {
-    const forwardSlashes = new Literal("forward-slashes", "//");
-    const newLine = new Literal("new-line", "\n");
-    const returnCarriage = new Literal("return-carriage", "\r");
-    const windowsNewLine = new AndValue("windows-new-line", [
-      returnCarriage,
-      newLine,
-    ]);
-    const lineEnd = new OrValue("line-end", [newLine, windowsNewLine]);
-    const character = new NotValue("character", lineEnd);
-    const comment = new RepeatValue("comment", character);
-
-    const lineEndingComment = new AndValue("line-ending-comment", [
-      forwardSlashes,
-      comment,
-      lineEnd,
-    ]);
-
-    const string = "// This is a comment\n";
-    const cursor = new Cursor(string);
-    const node = lineEndingComment.parse(cursor);
-
-    expect(node?.name).toBe("line-ending-comment"); // --> true
-    expect(node?.value).toBe(string); // --> true
-
-    const expectedValue = {
-      children: [],
-      value: "// This is a comment\n",
-      type: "and-value",
-      name: "line-ending-comment",
-      startIndex: 0,
-      endIndex: 20,
-      isComposite: false,
-    };
-
-    expect(JSON.stringify(node)).toBe(JSON.stringify(expectedValue)); // --> true
-  });
-
-  test("composite", () => {
-    const forwardSlashes = new Literal("forward-slashes", "//");
-    const newLine = new Literal("new-line", "\n");
-    const returnCarriage = new Literal("return-carriage", "\r");
-    const windowsNewLine = new AndValue("windows-new-line", [
-      returnCarriage,
-      newLine,
-    ]);
-    const lineEnd = new OrValue("line-end", [newLine, windowsNewLine]);
-    const character = new NotValue("character", lineEnd);
-    const comment = new RepeatValue("comment", character);
-
-    const lineEndingComment = new AndComposite("line-ending-comment", [
-      forwardSlashes,
-      comment,
-      lineEnd,
-    ]);
-
-    const string = "// This is a comment\n";
-    const cursor = new Cursor(string);
-    const node = lineEndingComment.parse(cursor);
-
-    expect(node?.name).toBe("line-ending-comment");
-
-    expect(node?.children[0].name).toBe("forward-slashes");
-    expect(node?.children[0].value).toBe("//");
-
-    expect(node?.children[1].name).toBe("comment");
-    expect(node?.children[1].value).toBe(" This is a comment");
-
-    expect(node?.children[2].name).toBe("line-end");
-    expect(node?.children[2].value).toBe("\n");
-
-    const expectedValue = {
-      children: [
-        {
-          children: [],
-          value: "//",
-          type: "literal",
-          name: "forward-slashes",
-          startIndex: 0,
-          endIndex: 1,
-          isComposite: false,
-        },
-        {
-          children: [],
-          value: " This is a comment",
-          type: "repeat-value",
-          name: "comment",
-          startIndex: 2,
-          endIndex: 19,
-          isComposite: false,
-        },
-        {
-          children: [],
-          value: "\n",
-          type: "or-value",
-          name: "line-end",
-          startIndex: 20,
-          endIndex: 20,
-          isComposite: false,
-        },
-      ],
-      value: "",
-      type: "and-composite",
-      name: "line-ending-comment",
-      startIndex: 0,
-      endIndex: 20,
-      isComposite: true,
-    };
-
-    expect(JSON.stringify(node)).toBe(JSON.stringify(expectedValue)); // --> true
-  });
-});