clarity-pattern-parser 11.0.21 → 11.0.23

package/src/query/selector.test.ts

@@ -0,0 +1,262 @@
+import { Node } from "../ast/Node";
+import { Selector } from "./selector";
+
+function createNodeTree() {
+    const node = Node.createNode("node", "root", [
+        Node.createNode("node", "grand-parent", [
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "1"),
+                Node.createValueNode("node", 'child', "2"),
+                Node.createValueNode("node", 'child', "3"),
+                Node.createValueNode("node", 'child', "4"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "5"),
+                Node.createValueNode("node", 'child', "6"),
+                Node.createValueNode("node", 'child', "7"),
+                Node.createValueNode("node", 'child', "8"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "9"),
+                Node.createValueNode("node", 'child', "10"),
+                Node.createValueNode("node", 'child', "11"),
+                Node.createValueNode("node", 'child', "12"),
+            ])
+        ]),
+        Node.createNode("node", "grand-parent", [
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "13"),
+                Node.createValueNode("node", 'child', "14"),
+                Node.createValueNode("node", 'child', "15"),
+                Node.createValueNode("node", 'child', "16"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "17"),
+                Node.createValueNode("node", 'child', "18"),
+                Node.createValueNode("node", 'child', "19"),
+                Node.createValueNode("node", 'child', "20"),
+            ]),
+            Node.createNode("node", "parent", [
+                Node.createValueNode("node", 'child', "21"),
+                Node.createValueNode("node", 'child', "22"),
+                Node.createValueNode("node", 'child', "23"),
+                Node.createValueNode("node", 'child', "24"),
+            ])
+        ])
+    ]);
+    node.normalize();
+    return node;
+}
+
+describe("Selector", () => {
+
+    test("Node Selector", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("child");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(24);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24");
+    });
+
+    test("Descendant Selector", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("grand-parent child");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(24);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24");
+    });
+
+    test("Descendant Selector Miss", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("grand-parent not-a-node");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(0);
+        expect(result.map(n => n.toString()).join(",")).toEqual("");
+    });
+
+    test("Direct Child", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("grand-parent > parent");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(6);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1234,5678,9101112,13141516,17181920,21222324");
+    });
+
+    test("More Than One Direct Child", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("grand-parent > parent > child");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(24);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24");
+    });
+
+    test("Direct Child With Name & Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("grand-parent > parent > child[value='4']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(1);
+        expect(result.map(n => n.toString()).join(",")).toEqual("4");
+    });
+
+    test("Direct Child With Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("grand-parent > parent > [value='4']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(1);
+        expect(result.map(n => n.toString()).join(",")).toEqual("4");
+    });
+
+    test("Adjacent", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("child + [value='4']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(1);
+        expect(result.map(n => n.toString()).join(",")).toEqual("4");
+    });
+
+    test("Adjacent Miss", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("parent + [value='4']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(0);
+        expect(result.map(n => n.toString()).join(",")).toEqual("");
+    });
+
+    test("After", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value='2'] ~ *");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(2);
+        expect(result.map(n => n.toString()).join(",")).toEqual("3,4");
+    });
+
+    test("After Miss", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value='2'] ~ not-a-node");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(0);
+        expect(result.map(n => n.toString()).join(",")).toEqual("");
+    });
+
+    test("Not Equal Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value!='4']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(32);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,2,3,1234,5,6,7,8,5678,9,10,11,12,9101112,123456789101112,13,14,15,16,13141516,17,18,19,20,17181920,21,22,23,24,21222324,131415161718192021222324,123456789101112131415161718192021222324");
+    });
+
+    test("Starts With Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value^='1']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(17);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,1234,10,11,12,123456789101112,13,14,15,16,13141516,17,18,19,17181920,131415161718192021222324,123456789101112131415161718192021222324");
+    });
+
+    test("Ends With Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value$='2']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(5);
+        expect(result.map(n => n.toString()).join(",")).toEqual("2,12,9101112,123456789101112,22");
+    });
+
+    test("Contains Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value*='2']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(14);
+        expect(result.map(n => n.toString()).join(",")).toEqual("2,1234,12,9101112,123456789101112,20,17181920,21,22,23,24,21222324,131415161718192021222324,123456789101112131415161718192021222324");
+    });
+
+    test("Greater Than Or Equal Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[endIndex>=35]");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(6);
+        expect(result.map(n => n.toString()).join(",")).toEqual("22,23,24,21222324,131415161718192021222324,123456789101112131415161718192021222324");
+    });
+
+    test("Less Than Or Equal Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[endIndex<=5]");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(6);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,2,3,4,1234,5");
+    });
+
+    test("Greater Than Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[endIndex>35]");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(5);
+        expect(result.map(n => n.toString()).join(",")).toEqual("23,24,21222324,131415161718192021222324,123456789101112131415161718192021222324");
+    });
+
+    test("Less Than Attribute", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[endIndex<5]");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(5);
+        expect(result.map(n => n.toString()).join(",")).toEqual("1,2,3,4,1234");
+    });
+
+    test("Or Selector", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("[value='5'], [value='6']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(2);
+        expect(result.map(n => n.toString()).join(",")).toEqual("5,6");
+    });
+
+    test("Nested Or Selector", () => {
+        const tree = createNodeTree();
+
+        const selector = new Selector("parent > [value='5'], [value='6']");
+        const result = selector.find([tree]);
+
+        expect(result.length).toBe(2);
+        expect(result.map(n => n.toString()).join(",")).toEqual("5,6");
+    });
+});

package/src/query/selector.ts

@@ -0,0 +1,280 @@
+import { generateErrorMessage } from "../patterns/generate_error_message";
+import { selectorParser } from "./selector_parser";
+import { Node } from "../ast/Node";
+
+const combinatorMap: Record<string, boolean> = {
+    "adjacent": true,
+    "after": true,
+    "descendant": true,
+    "direct-child": true
+};
+
+const operatorMap: Record<string, boolean> = {
+    "equal": true,
+    "not-equal": true,
+    "starts-with": true,
+    "ends-with": true,
+    "contains": true,
+    "greater-than-or-equal": true,
+    "less-than-or-equal": true,
+    "greater-than": true,
+    "less-than": true
+};
+
+export class Selector {
+    private _selectedNodes: Node[];
+    private _selectorAst: Node;
+    private _combinator: string | null;
+
+    constructor(selector: string) {
+        this._selectedNodes = [];
+        this._combinator = null;
+
+        const result = selectorParser.exec(selector);
+
+        if (result.ast == null) {
+            const message = generateErrorMessage(selectorParser, result.cursor);
+            throw new Error(`[Invalid Selector] ${message}`);
+        }
+
+        this._selectorAst = result.ast;
+    }
+
+    find(nodes: Node[]) {
+        this._selectedNodes = nodes;
+
+        const ast = this._selectorAst;
+        ast.walkUp((node) => {
+            this._process(node);
+        });
+
+        return this._selectedNodes;
+    }
+
+    filter(nodes: Node[]) {
+        if (nodes.length < 1) {
+            return [];
+        }
+
+        const nodeMap = new Map();
+        nodes.forEach(n => nodeMap.set(n, n));
+
+        this._selectedNodes = [nodes[0].findRoot()];
+
+        const ast = this._selectorAst;
+        ast.walkUp((node) => {
+            this._process(node);
+        });
+
+        return this._selectedNodes.filter(n => nodeMap.has(n));
+    }
+
+    not(nodes: Node[]) {
+        if (nodes.length < 1) {
+            return [];
+        }
+
+        this._selectedNodes = [nodes[0].findRoot()];
+
+        const ast = this._selectorAst;
+        ast.walkUp((node) => {
+            this._process(node);
+        });
+
+        const selectedNodeMap = new Map();
+        this._selectedNodes.forEach(n => selectedNodeMap.set(n, n));
+
+        return nodes.filter(n => !selectedNodeMap.has(n));
+    }
+
+    parents(nodes: Node[]) {
+        if (nodes.length < 1) {
+            return [];
+        }
+
+        this._selectedNodes = [nodes[0].findRoot()];
+
+        const ast = this._selectorAst;
+        ast.walkUp((node) => {
+            this._process(node);
+        });
+
+        const result = new Set<Node>();
+        const ancestorMap = new Map<Node, boolean>();
+        this._selectedNodes.forEach(n => ancestorMap.set(n, true));
+
+        nodes.forEach(n => {
+            const ancestor = n.findAncestor(a => ancestorMap.has(a));
+            if (ancestor != null) {
+                result.add(ancestor);
+            }
+        });
+
+        return Array.from(result);
+    }
+
+    private _process(ast: Node) {
+        const nodeName = ast.name;
+
+        if (nodeName === "wild-card") {
+            this._selectedNodes = this._processWildCard();
+        }
+        else if (nodeName === "or-selector") {
+            this._selectedNodes = this._processOrSelector(ast);
+        }
+        else if (nodeName === "name-selector" || (nodeName === "name" && (ast.parent == null || ast.parent.name === "selector-expression"))) {
+            this._selectedNodes = this._processNameSelector(ast);
+        }
+        else if (nodeName === "attribute-selector" && (ast.parent == null || ast.parent.name === "selector-expression")) {
+            this._selectedNodes = this._processAttributeSelector(ast);
+        }
+        else if (combinatorMap[nodeName]) {
+            this._combinator = nodeName;
+        }
+        else if (nodeName === "selector-expression") {
+            this._combinator = null;
+        }
+    }
+
+    private _processWildCard() {
+        return this._selectedNodes.map(n => {
+            return this._selectWithCombinator(n, () => true);
+        }).flat();
+    }
+
+    private _processOrSelector(ast: Node) {
+        const selectorNodes = ast.children.filter(n => n.name !== "comma");
+        const set: Set<Node> = new Set();
+
+        const selectors = selectorNodes.map(n => new Selector(n.toString()));
+
+        selectors.map(s => {
+            return s.find(this._selectedNodes.slice());
+        }).flat().forEach((node) => {
+            set.add(node);
+        });
+
+        return Array.from(set);
+    }
+
+
+    private _processNameSelector(ast: Node) {
+        if (ast.children.length > 1) {
+            return this._selectedNodes.map(n => {
+                const name = ast.children[0].value;
+
+                return this._selectWithCombinator(n, (node: Node) => {
+                    return node.name === name && this._isAttributeMatch(node, ast);
+                });
+
+            }).flat();
+        } else {
+            return this._selectedNodes.map(n => {
+                return this._selectWithCombinator(n, (node: Node) => node.name === ast.value);
+            }).flat();
+        }
+    }
+
+    private _processAttributeSelector(ast: Node) {
+        return this._selectedNodes.map(n => {
+            return this._selectWithCombinator(n, (node: Node) => {
+                return this._isAttributeMatch(node, ast);
+            });
+
+        }).flat();
+    }
+
+    private _selectWithCombinator(node: Node, predicate: (node: Node) => boolean) {
+        if (this._combinator === "adjacent") {
+            const sibling = node.nextSibling();
+            if (sibling == null) {
+                return [];
+            }
+
+            if (predicate(sibling)) {
+                return [sibling];
+            } else {
+                return [];
+            }
+        }
+        else if (this._combinator === "after") {
+            const parent = node.parent;
+
+            if (parent == null) {
+                return [];
+            }
+
+            const index = parent.findChildIndex(node);
+            const after = parent.children.slice(index + 1);
+            return after.filter(predicate);
+        }
+        else if (this._combinator === "direct-child") {
+            return node.children.filter(predicate);
+        }
+        else if (this._combinator === "descendant" || this._combinator == null) {
+            return node.findAll(predicate);
+        } else {
+            return [];
+        }
+    }
+
+    private _isAttributeMatch(node: Node, ast: Node) {
+        const name = this._getAttributeName(ast);
+        const operator = this._getAttributeOperator(ast);
+        const value = this._getAttributeValue(ast);
+        const anyNode = node as any;
+
+        if (anyNode[name] == null) {
+            return false;
+        }
+
+        if (operator === "equal") {
+            return anyNode[name] === value;
+        } else if (operator === "not-equal") {
+            return anyNode[name] !== value;
+        } else if (operator === "starts-with") {
+            return anyNode[name].toString().startsWith(value);
+        } else if (operator === "ends-with") {
+            return anyNode[name].toString().endsWith(value);
+        } else if (operator === "contains") {
+            return anyNode[name].toString().includes(value);
+        } else if (operator === "greater-than-or-equal") {
+            return anyNode[name] >= value;
+        } else if (operator === "less-than-or-equal") {
+            return anyNode[name] <= value;
+        } else if (operator === "greater-than") {
+            return anyNode[name] > value;
+        } else if (operator === "less-than") {
+            return anyNode[name] < value;
+        }
+
+        return false;
+    }
+
+    private _getAttributeName(ast: Node) {
+        return (ast.find(n => n.name === "attribute-name") as Node).value;
+    }
+
+    private _getAttributeValue(ast: Node) {
+        let valueNode: Node | null = ast.find(n => n.name === "single-quote-string-literal");
+
+        if (valueNode != null) {
+            return valueNode.value.slice(1, -1);
+        } else {
+            valueNode = ast.find(n => n.name === "value");
+        }
+
+        if (valueNode != null) {
+            return valueNode.value;
+        } else {
+            valueNode = ast.find(n => n.name === "number");
+        }
+
+        return (valueNode as Node).value;
+    }
+
+    private _getAttributeOperator(ast: Node) {
+        return (ast.find(n => operatorMap[n.name]) as Node).name;
+    }
+
+}

package/src/query/selector_parser.ts

@@ -1,8 +1,49 @@
 import { patterns } from "../grammar/patterns";
 
-const {selector} = patterns`
+const { expression } = patterns`
+number = /[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?/
+spaces = /\\s+/
+single-quote-string-literal = /'(?:\\\\.|[^'\\\\])*'/
+name = /[a-zA-Z_-]+[a-zA-Z0-9_-]*/
+comma = /\\s*,\\s*/
+wild-card = "*"
+equal = "="
+not-equal = "!="
+starts-with = "^="
+ends-with = "$="
+contains = "*="
+greater-than-or-equal = ">="
+less-than-or-equal = "<="
+greater-than = ">"
+less-than = "<"
+operators =      equal |
+             not-equal | 
+           starts-with | 
+             ends-with | 
+              contains | 
+ greater-than-or-equal | 
+    less-than-or-equal | 
+          greater-than | 
+             less-than
+             
+attribute-name = name
+value = name
+attribute-value = single-quote-string-literal | number | value
+attribute-selector = "[" + spaces? + attribute-name + spaces? + operators + spaces? + attribute-value + "]"
 
-    
+adjacent = spaces? + "+" + spaces?
+after = spaces? + "~" + spaces?
+direct-child = spaces? + ">" + spaces?
+descendant = spaces
 
+combinators =  adjacent | after | direct-child | descendant
+name-selector = name-selector-expression + attribute-selector
+name-selector-expression = name-selector | name
+node-selector = wild-card | attribute-selector | name-selector-expression
+or-selector = (node-selector, comma){2}
 
-`;
+selector-expression = expression + combinators + expression
+expression = selector-expression | or-selector | node-selector 
+`;
+
+export const selectorParser = expression;