clarity-pattern-parser 4.0.2 → 5.0.0

package/src/tests/CssPatterns.test.ts

@@ -1,90 +0,0 @@
-/** @jest-environment node */
-import cssValue from "./cssPatterns/cssValue";
-import { Cursor } from "../index";
-
-describe("Css", () => {
-  test("Css: unit", () => {
-    const cursor = new Cursor("10% 10%");
-    const result = cssValue.parse(cursor);
-
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: All known unit values spaced", () => {
-    const cursor = new Cursor(
-      "10 linear-gradient(to left, #333, #333 50%, #eee 75%, #333 75%) rgba(0,0,0,1) #333 #555555 0px 0% 0deg 1em radial-gradient(at 40% 40%, rgba(187,202,218,1) 0%, rgba(187,202,218,1) 20%, rgba(187,202,218,1) 100%)"
-    );
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-    expect(cursor.text).toBe(result?.toString());
-  });
-
-  test("Css: radial-gradient", () => {
-    const cursor = new Cursor(
-      "radial-gradient(at 40% 40%, rgba(187,202,218,1) 0%, rgba(187,202,218,1) 20%, rgba(187,202,218,1) 100%)"
-    );
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: rgba", () => {
-    const cursor = new Cursor("rgba(0,0,0,0)");
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: method mutliple values", () => {
-    const cursor = new Cursor("method-one(first 0px third, arg2)");
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: nested methods", () => {
-    const cursor = new Cursor("outer-method(inner-method(0), 0)");
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: nested methods with trailing value", () => {
-    const cursor = new Cursor("outer-method(inner-method(0,0), 0)");
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: spaced values in a method", () => {
-    const cursor = new Cursor("method(arg1 0%, arg2, 10%) 0%");
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: spaced values within method", () => {
-    const cursor = new Cursor("method(inner-method(0,0,0,0) 0%, arg2, 10%)");
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: spaced values", () => {
-    const cursor = new Cursor(
-      "inner-method(0,0,0,0) inner-method(0,0,0,0) 0px 10px 0%"
-    );
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: complex spaced values", () => {
-    const cursor = new Cursor(
-      "#222 linear-gradient(to left, #333, #333 50%, #eee 75%, #333 75%) linear-gradient(to bottom, #555, #555 50%, #eee 75%, #555 75%)"
-    );
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-  test("Css: multiple linear gradients", () => {
-    const cursor = new Cursor(
-      "linear-gradient(to left, #333, #333 50%, #eee 75%, #333 75%), linear-gradient(to bottom, #555, #555 50%, #eee 75%, #555 75%)"
-    );
-    const result = cssValue.parse(cursor);
-    expect(result?.endIndex).toBe(cursor.text.length - 1);
-  });
-
-});

package/src/tests/CursorHistory.test.ts

@@ -1,107 +0,0 @@
-/** @jest-environment node */
-import CursorHistory from "../CursorHistory";
-import { Literal, Node, Cursor, ParseError } from "../index";
-import sentence from "./patterns/sentence";
-describe("CursorHistory", () => {
-  test("addMatch", () => {
-    const cursorHistory = new CursorHistory();
-    const pattern = new Literal("T", "T");
-    const node = new Node("T", "T", 0, 1, [], "T");
-
-    cursorHistory.addMatch(pattern, node);
-    expect(cursorHistory.getFurthestMatch().pattern).toBe(pattern);
-    expect(cursorHistory.getFurthestMatch().astNode).toBe(node);
-  });
-
-  test("addMatch with Recording", () => {
-    const cursorHistory = new CursorHistory();
-    const pattern = new Literal("T", "T");
-    const node = new Node("T", "T", 0, 1, [], "T");
-
-    cursorHistory.startRecording();
-    cursorHistory.addMatch(pattern, node);
-
-    expect(cursorHistory.getFurthestMatch().pattern).toBe(pattern);
-    expect(cursorHistory.getFurthestMatch().astNode).toBe(node);
-    expect(cursorHistory.getLastMatch().pattern).toBe(pattern);
-    expect(cursorHistory.getLastMatch().astNode).toBe(node);
-  });
-
-  test("addError", () => {
-    const cursorHistory = new CursorHistory();
-    const error = new ParseError(
-      "Expected something else.",
-      0,
-      new Literal("T", "T")
-    );
-
-    cursorHistory.addError(error);
-
-    expect(cursorHistory.getFurthestError()).toBe(error);
-  });
-
-  test("addError with recording", () => {
-    const cursorHistory = new CursorHistory();
-    const error = new ParseError(
-      "Expected something else.",
-      0,
-      new Literal("T", "T")
-    );
-
-    cursorHistory.startRecording();
-    cursorHistory.addError(error);
-
-    expect(cursorHistory.getFurthestError()).toBe(error);
-    expect(cursorHistory.getLastError()).toBe(error);
-  });
-
-  test("getLastError without any.", () => {
-    const cursorHistory = new CursorHistory();
-    expect(cursorHistory.getLastError()).toBe(null);
-  });
-
-  test("getFurthestMatch without an matches.", () => {
-    const cursorHistory = new CursorHistory();
-
-    expect(cursorHistory.getLastMatch().pattern).toBe(null);
-    expect(cursorHistory.getLastMatch().astNode).toBe(null);
-    expect(cursorHistory.getFurthestMatch().pattern).toBe(null);
-    expect(cursorHistory.getFurthestMatch().astNode).toBe(null);
-  });
-
-  test("getFurthestMatch without an matches while recording.", () => {
-    const cursorHistory = new CursorHistory();
-    cursorHistory.startRecording();
-
-    expect(cursorHistory.getLastMatch().pattern).toBe(null);
-    expect(cursorHistory.getLastMatch().astNode).toBe(null);
-    expect(cursorHistory.getFurthestMatch().pattern).toBe(null);
-    expect(cursorHistory.getFurthestMatch().astNode).toBe(null);
-  });
-
-  test("getAllParseStacks.", () => {
-    const text = "Pat went to the";
-    const cursor = new Cursor(text);
-    cursor.startRecording();
-
-    sentence.parse(cursor);
-    cursor.history.getAllParseStacks();
-  });
-
-  test("getLastParseStack.", () => {
-    const text = "Pat went to the";
-    const cursor = new Cursor(text);
-    cursor.startRecording();
-
-    sentence.parse(cursor);
-
-    const stack = cursor.history.getLastParseStack();
-
-    expect(stack.length).toBe(5);
-    expect(stack[0].name).toBe("noun");
-    expect(stack[1].name).toBe("space");
-    expect(stack[2].name).toBe("verb");
-    expect(stack[3].name).toBe("space");
-    expect(stack[4].name).toBe("article");
-  });
-});

package/src/tests/Cusor.test.ts

@@ -1,174 +0,0 @@
-/** @jest-environment node */
-import { Cursor, Literal, ParseError, Node } from "../index";
-
-describe("Cursor", () => {
-  test("addMatch.", () => {
-    const cursor = new Cursor("Text");
-    const node = new Node("text-node", "Text", 0, 3, [], "Text");
-    const pattern = new Literal("text", "Text");
-
-    cursor.setIndex(3);
-    cursor.addMatch(pattern, node);
-
-    expect(cursor.history.furthestMatch.astNode).toBe(node);
-    expect(cursor.history.furthestMatch.pattern).toBe(pattern);
-  });
-
-  test("addMatch that isn't as far.", () => {
-    const cursor = new Cursor("Text");
-    const node = new Node("text-node", "Text", 0, 3, [], "Text");
-    const pattern = new Literal("text", "Text Node");
-
-    const shorterNode = new Node("tex-node", "Tex", 0, 2, [], "Tex2");
-    const shorterPattern = new Literal("tex", "Tex");
-
-    cursor.setIndex(3);
-    cursor.addMatch(pattern, node);
-
-    expect(cursor.history.furthestMatch.astNode).toBe(node);
-    expect(cursor.history.furthestMatch.pattern).toBe(pattern);
-
-    cursor.setIndex(2);
-    cursor.addMatch(shorterPattern, shorterNode);
-
-    expect(cursor.history.furthestMatch.astNode).toBe(node);
-    expect(cursor.history.furthestMatch.pattern).toBe(pattern);
-  });
-
-  test("didSuccessfullyParse.", () => {
-    const cursor = new Cursor("Text");
-    cursor.setIndex(3);
-    expect(cursor.didSuccessfullyParse()).toBe(true);
-
-    cursor.throwError(
-      new ParseError("Failed To Parse.", 0, new Literal("T", "T"))
-    );
-
-    expect(cursor.didSuccessfullyParse()).toBe(false);
-  });
-
-  test("getChar.", () => {
-    const cursor = new Cursor("Text");
-    expect(cursor.getChar()).toBe("T");
-    cursor.setIndex(3);
-    expect(cursor.getChar()).toBe("t");
-  });
-
-  test("getIndex.", () => {
-    const cursor = new Cursor("Text");
-    expect(cursor.getIndex()).toBe(0);
-    cursor.setIndex(3);
-    expect(cursor.getIndex()).toBe(3);
-  });
-
-  test("hasNext.", () => {
-    const cursor = new Cursor("Text");
-    expect(cursor.hasNext()).toBe(true);
-    cursor.setIndex(3);
-    expect(cursor.hasNext()).toBe(false);
-  });
-
-  test("hasPrevious.", () => {
-    const cursor = new Cursor("Text");
-    expect(cursor.hasPrevious()).toBe(false);
-    cursor.setIndex(3);
-    expect(cursor.hasPrevious()).toBe(true);
-  });
-
-  test("recording history.", () => {
-    const cursor = new Cursor("Text");
-    const tNode = new Node("T", "T", 0, 0, [], "T");
-    const tPattern = new Literal("T", "T");
-
-    const eNode = new Node("e", "e", 1, 1, [], "e");
-    const ePattern = new Literal("e", "e");
-
-    const xNode = new Node("x", "x", 2, 2, [], "x");
-    const xPattern = new Literal("x", "x");
-
-    cursor.startRecording();
-
-    cursor.addMatch(tPattern, tNode);
-    cursor.addMatch(ePattern, eNode);
-
-    expect(cursor.history.patterns.length).toBe(2);
-    expect(cursor.history.astNodes.length).toBe(2);
-    expect(cursor.history.getFurthestMatch().astNode).toBe(eNode);
-    expect(cursor.history.getFurthestMatch().pattern).toBe(ePattern);
-    expect(cursor.history.getLastMatch().astNode).toBe(eNode);
-    expect(cursor.history.getLastMatch().pattern).toBe(ePattern);
-
-    cursor.stopRecording();
-
-    cursor.addMatch(xPattern, xNode);
-
-    expect(cursor.history.patterns.length).toBe(0);
-    expect(cursor.history.astNodes.length).toBe(0);
-    expect(cursor.history.getFurthestMatch().astNode).toBe(xNode);
-    expect(cursor.history.getFurthestMatch().pattern).toBe(xPattern);
-    expect(cursor.history.getLastMatch().astNode).toBe(xNode);
-    expect(cursor.history.getLastMatch().pattern).toBe(xPattern);
-  });
-
-  test("moveToBeginning.", () => {
-    const cursor = new Cursor("Text");
-    cursor.setIndex(3);
-    cursor.moveToBeginning();
-
-    expect(cursor.getIndex()).toBe(0);
-  });
-
-  test("moveToEnd.", () => {
-    const cursor = new Cursor("Text");
-    cursor.moveToEnd();
-
-    expect(cursor.getIndex()).toBe(3);
-  });
-
-  test("setIndex outside of bounds.", () => {
-    const cursor = new Cursor("Text");
-    expect(() => {
-      cursor.setIndex(4);
-    }).toThrow();
-  });
-
-  test("next out of bounds.", () => {
-    const cursor = new Cursor("Text");
-    cursor.setIndex(3);
-
-    expect(() => {
-      cursor.next();
-    }).toThrow();
-  });
-
-  test("previous out of bounds.", () => {
-    const cursor = new Cursor("Text");
-
-    expect(() => {
-      cursor.previous();
-    }).toThrow();
-  });
-
-  test("previous.", () => {
-    const cursor = new Cursor("Text");
-    cursor.setIndex(1);
-    cursor.previous();
-
-    expect(cursor.getIndex()).toBe(0);
-  });
-
-  test("isAtBeginning.", () => {
-    const cursor = new Cursor("Text");
-    cursor.isAtBeginning();
-
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.isAtBeginning()).toBe(true);
-  });
-
-  test("setIndex invalid number.", () => {
-    const cursor = new Cursor("Text");
-    expect(() => {
-      cursor.setIndex(-1);
-    });
-  });
-});

package/src/tests/HtmlPatterns.test.ts

@@ -1,34 +0,0 @@
-/** @jest-environment node */
-import element, { attribute } from "./htmlPatterns/element";
-import { Cursor } from "../index";
-
-describe("HTML", () => {
-  test("Html: element", () => {
-    const cursor = new Cursor("<div></div>");
-    const result = element.parse(cursor);
-  });
-
-  test("Html: element nested", () => {
-    const cursor = new Cursor("<div><p><span></span></p></div>");
-    const result = element.parse(cursor);
-  });
-
-  test("Html: element with attributes", () => {
-    const cursor = new Cursor('<div prop="value"></div>');
-    const result = element.parse(cursor);
-  });
-
-  test("Html: multiple children", () => {
-    const cursor = new Cursor(`<div prop="value">
-          Text
-          <span>Hello</span>
-          <span>World!</span>
-      </div>`);
-    const result = element.parse(cursor);
-  });
-
-  test("Attributes: ", () => {
-    const cursor = new Cursor('prop="boo"');
-    const result = attribute.parse(cursor);
-  });
-});

package/src/tests/Literal.test.ts

@@ -1,79 +0,0 @@
-/** @jest-environment node */
-import { Literal, Cursor } from "../index";
-
-describe("Literal", () => {
-  test("Empty literal.", () => {
-    expect(() => {
-      new Literal("literal", "");
-    }).toThrow();
-  });
-
-  test("exec.", () => {
-    const john = new Literal("john", "John");
-
-    const result = john.exec("John");
-    const result2 = john.exec("Jane");
-
-    const expectedValue = {
-      type: "literal",
-      name: "john",
-      startIndex: 0,
-      endIndex: 3,
-      children: [],
-      value: "John",
-    };
-
-    expect(JSON.stringify(result)).toBe(JSON.stringify(expectedValue));
-    expect(result2).toBe(null);
-  });
-
-  test("Match.", () => {
-    const variable = new Literal("variable", "var");
-    const cursor = new Cursor("var foo = 'Hello World';");
-    const node = variable.parse(cursor);
-
-    expect(node?.name).toBe("variable");
-    expect(node?.value).toBe("var");
-    expect(cursor.getIndex()).toBe(2);
-    expect(cursor.getChar()).toBe("r");
-  });
-
-  test("Match at end.", () => {
-    const variable = new Literal("variable", "var");
-    const cursor = new Cursor("var");
-    const node = variable.parse(cursor);
-
-    expect(node?.name).toBe("variable");
-    expect(node?.value).toBe("var");
-    expect(cursor.getIndex()).toBe(2);
-    expect(cursor.getChar()).toBe("r");
-    expect(cursor.isAtEnd()).toBe(true);
-  });
-
-  test("No match.", () => {
-    const variable = new Literal("variable", "var");
-    const cursor = new Cursor("vax");
-
-    variable.parse(cursor);
-
-    expect(cursor.hasUnresolvedError()).toBe(true);
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.getChar()).toBe("v");
-  });
-
-  test("Bad cursor.", () => {
-    const variable = new Literal("variable", "var");
-
-    expect(() => {
-      (variable as any).parse();
-    }).toThrow();
-  });
-
-  test("Pattern methods.", () => {
-    const variable = new Literal("variable", "var");
-    const clone = variable.clone();
-
-    expect(variable.name).toBe(clone.name);
-    expect(variable.children.length).toBe(clone.children.length);
-  });
-});

package/src/tests/LookAhead.test.ts

@@ -1,44 +0,0 @@
-/** @jest-environment node */
-import { Literal, Cursor, LookAhead, Not } from "../index";
-
-describe("LookAheadValue", () => {
-  test("Look for pattern.", () => {
-    const john = new Literal("john", "John");
-    const lookAheadValue = new LookAhead(john);
-    const cursor = new Cursor("John");
-    const node = lookAheadValue.parse(cursor);
-
-    expect(node).toBe(null);
-    expect(cursor.hasUnresolvedError()).toBe(false);
-  });
-
-  test("Look for a not pattern.", () => {
-    const john = new Literal("john", "John");
-    const lookAheadValue = new Not(new LookAhead(john));
-    const cursor = new Cursor("Joel");
-    const node = lookAheadValue.parse(cursor);
-
-    expect(node).toBe(null);
-    expect(cursor.hasUnresolvedError()).toBe(false);
-  });
-
-  test("Fail looking for a pattern.", () => {
-    const john = new Literal("john", "John");
-    const lookAheadValue = new LookAhead(john);
-    const cursor = new Cursor("Joel");
-    const node = lookAheadValue.parse(cursor);
-
-    expect(node).toBe(null);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-  });
-
-  test("And a look ahead together.", () => {
-    const john = new Literal("john", "John");
-    const lookAheadValue = new LookAhead(john);
-    const cursor = new Cursor("Joel");
-    const node = lookAheadValue.parse(cursor);
-
-    expect(node).toBe(null);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-  });
-});

package/src/tests/Not.test.ts

@@ -1,51 +0,0 @@
-import Cursor from "../Cursor";
-import And from "../patterns/And";
-import Literal from "../patterns/Literal";
-import Not from "../patterns/Not";
-import Or from "../patterns/Or";
-import Regex from "../patterns/Regex";
-
-describe("Not", () => {
-  test("Negate pattern with literal.", () => {
-    const greaterThan = new Literal("greater-than", ">");
-    const lessThan = new Literal("less-than", "<");
-    const from = new Literal("from", "FROM");
-    const table = new Literal("table", "Table");
-    const operator = new Or("operator", [lessThan, greaterThan]);
-    const keywords = new And("keywords-with-space", [
-      new Or("keywords", [from, table]),
-      new Literal("space", " "),
-    ]);
-    const identFirstPart = new Regex(
-      "ident-first-part",
-      "[a-zA-Z_$][a-zA-Z0-9_]*"
-    );
-    const identity = new And("identity", [
-      new Not(keywords),
-      new Not(operator),
-      identFirstPart,
-    ]);
-
-    const result = identity.parse(new Cursor("_goodName"));
-
-    expect(result).not.toBeNull();
-
-    const cursor1 = new Cursor("<badName");
-    const result1 = identity.parse(cursor1);
-
-    expect(result1).toBe(null);
-    expect(cursor1.hasUnresolvedError()).toBe(true);
-
-    const cursor2 = new Cursor("FROM_IS_OKAY");
-    const result2 = identity.parse(cursor2);
-
-    expect(result2).not.toBe(null);
-    expect(cursor2.hasUnresolvedError()).toBe(false);
-
-    const cursor3 = new Cursor("FROM ISBAD");
-    const result3 = identity.parse(cursor3);
-
-    expect(result3).toBe(null);
-    expect(cursor3.hasUnresolvedError()).toBe(true);
-  });
-});

package/src/tests/Or.test.ts

@@ -1,113 +0,0 @@
-/** @jest-environment node */
-import Or from "../patterns/Or";
-import Literal from "../patterns/Literal";
-import Cursor from "../Cursor";
-
-describe("Or", () => {
-  test("Or: Empty array parser.", () => {
-    expect(() => {
-      new Or("name", []);
-    }).toThrow();
-  });
-
-  test("Or: One Pattern.", () => {
-    expect(() => {
-      new Or("name", [new Literal("some-value", "")]);
-    }).toThrow();
-  });
-
-  test("Or: Name and patterns.", () => {
-    const letter = new Literal("a", "a");
-    const number = new Literal("1", "1");
-    const alphaNumeric = new Or("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("Or: Fail.", () => {
-    const letter = new Literal("a", "a");
-    const number = new Literal("1", "1");
-    const alphaNumeric = new Or("alpha-numeric", [letter, number]);
-
-    const letterCursor = new Cursor("b");
-    const numberCursor = new Cursor("2");
-
-    const letterNode = alphaNumeric.parse(letterCursor);
-    const numberNode = alphaNumeric.parse(numberCursor);
-
-    expect(letterNode).toBe(null);
-    expect(numberNode).toBe(null);
-  });
-
-  test("Or: Clone.", () => {
-    const letter = new Literal("a", "a");
-    const number = new Literal("1", "1");
-    const alphaNumeric = new Or("alpha-numeric", [letter, number]);
-
-    const clone = alphaNumeric.clone();
-
-    expect(alphaNumeric.children.length).toBe(clone.children.length);
-    expect(alphaNumeric.name).toBe(clone.name);
-  });
-
-  test("Or: Invalid patterns.", () => {
-    expect(() => {
-      new (Or as any)("some-alpha-numeric", [{}, null]);
-    });
-  });
-
-  test("Or: Not enough patterns.", () => {
-    expect(() => {
-      new (Or as any)("some-alpha-numeric", [{}]);
-    });
-  });
-
-  test("Or: Bad name.", () => {
-    expect(() => {
-      new (Or as any)({}, [new Literal("a", "a"), new Literal("a", "a")]);
-    });
-  });
-
-  test("Or: Bad cursor.", () => {
-    expect(() => {
-      new (Or as any)("A", [
-        new Literal("a", "a"),
-        new Literal("a", "a"),
-      ]).parse();
-    });
-  });
-
-  test("Or: Furthest Parse Error.", () => {
-    const longer = new Literal("longer", "Longer");
-    const bang = new Literal("bang", "Bang");
-    const orValue = new (Or as any)("test", [longer, bang]);
-    const cursor = new Cursor("Longed");
-
-    orValue.parse(cursor);
-
-    expect(cursor.getIndex()).toBe(0);
-    expect(cursor.hasUnresolvedError()).toBe(true);
-  });
-
-  test("Or: Last pattern matches.", () => {
-    const longer = new Literal("longer", "Longer");
-    const bang = new Literal("bang", "Bang");
-    const orValue = new (Or 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");
-  });
-});