occam-dom 4.0.16 → 5.0.0

package/src/example/view/textarea/parseTree.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import Textarea from "../textarea";
+
+import { EMPTY_STRING } from "../../../constants";
+
+class ParseTreeTextarea extends Textarea {
+  setParseTree(parseTree) {
+    parseTree.shiftLine();  //
+
+    const parseTreeString = parseTree.asString(),
+          value = parseTreeString;  ///
+
+    this.setValue(value);
+  }
+
+  clearParseTree(parseTree) {
+    const value = EMPTY_STRING;
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const setParseTree = this.setParseTree.bind(this), ///
+          clearParseTree = this.clearParseTree.bind(this); ///
+
+    return ({
+      setParseTree,
+      clearParseTree
+    });
+  }
+
+  static defaultProperties = {
+    className: "parse-tree",
+    spellCheck: "false",
+    readOnly: true
+  };
+}
+
+export default withStyle(ParseTreeTextarea)`
+  
+  height: 32rem;
+  
+`;

package/src/example/view/textarea.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Textarea } from "easy";
+
+export default withStyle(Textarea)`
+
+  border: 1px solid darkgrey;
+  height: 12rem;
+  resize: vertical;
+  padding: 0.25rem;
+  font-size: 1.2rem;
+  line-height: 1.5rem;
+  white-space: pre;
+  font-family: monospace;
+
+`;

package/src/example/view.js

@@ -0,0 +1,125 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+import { queryUtilities } from "../index";  ///
+import { CSSLexer, CSSParser } from "with-style";
+import { RowsDiv, ColumnDiv, ColumnsDiv, VerticalSplitterDiv } from "easy-layout";
+
+import SubHeading from "./view/subHeading";
+import SizeableDiv from "./view/div/sizeable";
+import NodesTextarea from "./view/textarea/nodes";
+import ContentTextarea from "./view/textarea/content";
+import MaximumDepthInput from "./view/input/maximumDepth";
+import ExpressionStringInput from "./view/input/expressionString";
+import ParseTreeTextarea from "./view/textarea/parseTree";
+
+const cssLexer = CSSLexer.fromNothing(),
+      cssParser = CSSParser.fromNothing();
+
+const { queryByExpressionString } = queryUtilities;
+
+class View extends Element {
+  keyUpHandler = (event, element) => {
+    this.clearNodes();
+
+    this.clearParseTree();
+
+    const content = this.getContent(),
+          tokens = cssLexer.tokenise(content),
+          node = cssParser.parse(tokens);
+
+    if (node === null) {
+      return;
+    }
+
+    const abridged = true,
+          parseTree = node.asParseTree(tokens, abridged),
+          expressionString = this.getExpressionString(),
+          maximumDepth = this.getMaximumDepth(),
+          nodes = queryByExpressionString(node, expressionString, maximumDepth);
+
+    if (nodes !== null) {
+      this.setNodes(nodes, tokens); ///
+
+      this.setParseTree(parseTree);
+    }
+  }
+
+  childElements() {
+    return ([
+
+      <ColumnsDiv>
+        <SizeableDiv>
+          <RowsDiv>
+            <SubHeading>
+              Expression
+            </SubHeading>
+            <ExpressionStringInput onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              Maximum depth
+            </SubHeading>
+            <MaximumDepthInput onKeyUp={this.keyUpHandler} />
+          </RowsDiv>
+        </SizeableDiv>
+        <VerticalSplitterDiv />
+        <ColumnDiv>
+          <RowsDiv>
+            <SubHeading>
+              Content
+            </SubHeading>
+            <ContentTextarea onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              Parse tree
+            </SubHeading>
+            <ParseTreeTextarea />
+            <SubHeading>
+              Nodes
+            </SubHeading>
+            <NodesTextarea />
+          </RowsDiv>
+        </ColumnDiv>
+      </ColumnsDiv>
+
+    ]);
+  }
+
+  initialise() {
+    this.assignContext();
+
+    const { initialContent, initialExpressionString, initialMaximumDepth } = this.constructor,
+          content = initialContent,  ///
+          maximumDepth = initialMaximumDepth,  ///
+          expressionString = initialExpressionString;  ///
+
+    this.setContent(content);
+
+    this.setMaximumDepth(maximumDepth);
+
+    this.setExpressionString(expressionString);
+
+    this.keyUpHandler();  ///
+  }
+
+  static initialContent = `.view {
+  background: red;
+}
+`;
+
+  static initialExpressionString = "/*//@special[2...4]";
+
+  static initialMaximumDepth = 5;
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "view"
+  };
+}
+
+export default withStyle(View)`
+
+  padding: 1rem;
+  
+`;

package/src/example.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import "juxtapose";
+
+import withStyle from "easy-with-style";  ///
+
+import { Body } from "easy";
+
+import View from "./example/view";
+
+const { renderStyles } = withStyle;
+
+const body = new Body();
+
+renderStyles();
+
+body.mount(
+
+  <View/>
+
+);

package/src/expression/bnf.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const bnf = `
+
+    expression       ::=  path spread? subExpression?   
+    
+                       |  error+ 
+                                 
+                       ;
+  
+    path             ::=  "/" infiniteDescent? selectors ;
+    
+    subExpression    ::=  path spread? subExpression?;
+
+    infiniteDescent  ::=  "/" ;
+    
+    selectors        ::=  selector ( "|" selector )* ;
+
+    spread           ::=  unique
+    
+                       |  "[" 
+
+                          ( 
+                            
+                            ( startIndex "..." endIndex ) 
+                            
+                            | 
+                            
+                            ( startIndex "..." ) 
+                            
+                            | 
+                            
+                            ( "..." endIndex )
+                             
+                            | 
+                            
+                            index 
+                            
+                          )  
+                          
+                          "]" ;
+
+    selector         ::=  ruleName | tokenType ;
+                       
+    ruleName         ::=  [name] | "*" ;
+                       
+    tokenType        ::=  "@"<NO_WHITESPACE>( [name] | "*" ) ;
+                       
+    startIndex       ::=  [number] ;
+                       
+    endIndex         ::=  [number] ;
+                       
+    index            ::=  [number] ;
+                       
+    unique           ::=  "!" ;
+                       
+
+
+    error.           ::=  . ;
+    
+`;
+
+export default bnf;

package/src/expression/entries.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const entries = [
+  {
+    "special": "^(?:@|!|\\*|\\||\\/|\\[|\\]|\\.\\.\\.)"
+  },
+  {
+    "name": "^[a-zA-Z\-]+"
+  },
+  {
+    "number": "^[0-9]+"
+  },
+  {
+    "unassigned": "^."
+  }
+];
+
+export default entries;

package/src/expression/lexer.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { CommonLexer, WhitespaceToken, EndOfLineSignificantToken } from "occam-lexers";
+
+import entries from "./entries";
+
+export default class ExpressionLexer extends CommonLexer {
+  static entries = entries;
+
+  static EndOfLineToken = EndOfLineSignificantToken; ///
+
+  static WhitespaceToken = WhitespaceToken;
+
+  static EndOfLineCommentToken = null;
+
+  static SingleLineCommentToken = null;
+
+  static RegularExpressionToken = null;
+
+  static EndOfMultiLineCommentToken = null;
+
+  static StartOfMultiLineCommentToken = null;
+
+  static MiddleOfMultiLineCommentToken = null;
+
+  static SinglyQuotedStringLiteralToken = null;
+
+  static DoublyQuotedStringLiteralToken = null;
+
+  static fromNothing() { return CommonLexer.fromNothing(ExpressionLexer); }
+
+  static fromRules(rules) { return CommonLexer.fromRules(ExpressionLexer, rules); }
+
+  static fromEntries(entries) { return CommonLexer.fromEntries(ExpressionLexer, entries); }
+}

package/src/expression/parser.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { CommonParser } from "occam-parsers";
+
+import bnf from "./bnf";
+
+export default class ExpressionParser extends CommonParser {
+  static bnf = bnf;
+
+  static fromNothing() { return CommonParser.fromNothing(ExpressionParser); }
+
+  static fromBNF(bnf) { return CommonParser.fromBNF(ExpressionParser, bnf); }
+
+  static fromRules(rules) { return CommonParser.fromRules(ExpressionParser, rules); }
+}

package/src/expression.js

@@ -0,0 +1,82 @@
+"use strict";
+
+import Path from "./path";
+import Spread from "./spread";
+import SubExpression from "./subExpression";
+import ExpressionLexer from "./expression/lexer";
+import ExpressionParser from "./expression/parser";
+
+import { pathNodeFromExpressionNode,
+         spreadNodeFromExpressionNode,
+         errorNodesFromExpressionNode,
+         subExpressionNodeFromExpressionNode } from "./utilities/node";
+
+const expressionLexer = ExpressionLexer.fromNothing(),
+      expressionParser = ExpressionParser.fromNothing();
+
+export default class Expression {
+  constructor(path, spread, subExpression) {
+    this.path = path;
+    this.spread = spread;
+    this.subExpression = subExpression;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  getSpread() {
+    return this.spread;
+  }
+
+  getSubExpression() {
+    return this.subExpression;
+  }
+
+  getRuleNames() { return this.path.getRuleNames(); }
+
+  getTokenTypes() { return this.path.getTokenTypes(); }
+
+  isInfiniteDescent() { return this.path.isInfiniteDescent(); }
+
+  static fromExpressionNode(expressionNode) {
+    const pathNode = pathNodeFromExpressionNode(expressionNode),
+          spreadNode = spreadNodeFromExpressionNode(expressionNode),
+          subExpressionNode = subExpressionNodeFromExpressionNode(expressionNode),
+          path = Path.fromPathNode(pathNode),
+          spread = Spread.fromSpreadNode(spreadNode),
+          subExpression = SubExpression.fromSubExpressionNode(subExpressionNode),
+          expression = new Expression(path, spread, subExpression);
+
+    return expression;
+  }
+
+  static fromExpressionString(expressionString) {
+    let expression = null;
+
+    const lexer = expressionLexer,  ///
+          parser = expressionParser,  ///
+          content = expressionString, ///
+          tokens = lexer.tokenise(content),
+          node = parser.parse(tokens);
+
+    if (node !== null) {
+      const expressionNode = node, ///
+            errorNodes = errorNodesFromExpressionNode(expressionNode),
+            errorNodesLength = errorNodes.length;
+
+      if (errorNodesLength === 0) {
+        const pathNode = pathNodeFromExpressionNode(expressionNode),
+              spreadNode = spreadNodeFromExpressionNode(expressionNode),
+              subExpressionNode = subExpressionNodeFromExpressionNode(expressionNode),
+              path = Path.fromPathNode(pathNode),
+              spread = Spread.fromSpreadNode(spreadNode),
+              subExpression = SubExpression.fromSubExpressionNode(subExpressionNode);
+
+        expression = new Expression(path, spread, subExpression);
+      }
+    }
+
+    return expression;
+  }
+}

package/src/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export { default as Query } from "./query";
+export { default as Expression } from "./expression";
+export { default as queryUtilities } from "./utilities/query";
+export { default as ExpressionLexer } from "./expression/lexer";
+export { default as ExpressionParser } from "./expression/parser";

package/src/path.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import { ruleNamesFromPathNode, tokenTypesFromPathNode, infiniteDescentFromPathNode } from "./utilities/node";
+
+export default class Path {
+  constructor(ruleNames, tokenTypes, infiniteDescent) {
+    this.ruleNames = ruleNames;
+    this.tokenTypes = tokenTypes;
+    this.infiniteDescent = infiniteDescent;
+  }
+
+  getRuleNames() {
+    return this.ruleNames;
+  }
+
+  getTokenTypes() {
+    return this.tokenTypes;
+  }
+
+  isInfiniteDescent() {
+    return this.infiniteDescent;
+  }
+
+  static fromPathNode(pathNode) {
+    const ruleNames = ruleNamesFromPathNode(pathNode),
+          tokenTypes = tokenTypesFromPathNode(pathNode),
+          infiniteDescent = infiniteDescentFromPathNode(pathNode),
+          path = new Path(ruleNames, tokenTypes, infiniteDescent);
+
+    return path;
+  }
+}

package/src/query.js

@@ -0,0 +1,207 @@
+"use strict";
+
+import { characters } from "necessary";
+
+import Expression from "./expression";
+
+import { push, clear, includes } from "./utilities/array";
+
+const { WILDCARD_CHARACTER } = characters;
+
+export default class Query {
+  constructor(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes) {
+    this.spread = spread;
+    this.subQuery = subQuery;
+    this.ruleNames = ruleNames;
+    this.tokenTypes = tokenTypes;
+    this.maximumDepth = maximumDepth;
+    this.infiniteDescent = infiniteDescent;
+    this.intermediateNodes = intermediateNodes;
+  }
+
+  getSpread() {
+    return this.sprea;
+  }
+
+  getSubQuery() {
+    return this.subQuery;
+  }
+
+  getRuleNames() {
+    return this.ruleNames;
+  }
+
+  getTokenTypes() {
+    return this.tokenTypes;
+  }
+
+  getMaximumDepth() {
+    return this.maximumDepth;
+  }
+
+  isInfiniteDescent() {
+    return this.infiniteDescent;
+  }
+
+  getIntermediateNodes() {
+    return this.intermediateNodes;
+  }
+
+  execute(node, depth = 0, maximumDepth = this.maximumDepth) {
+    const nodes = [];
+
+    this.clear();
+
+    this.find(node, depth, maximumDepth);
+
+    this.apply(nodes, depth, maximumDepth);
+
+    return nodes;
+  }
+
+  clear() {
+    clear(this.intermediateNodes);
+  }
+
+  find(node, depth, maximumDepth) {
+    if (depth > maximumDepth) {
+      return;
+    }
+
+    const nodeTerminalNode = node.isTerminalNode(),
+          nodeNonTerminalNode = !nodeTerminalNode;
+
+    let found;
+
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            types = this.tokenTypes,  ///
+            type = terminalNode.getType();
+
+      found = includes(types, type, WILDCARD_CHARACTER);
+    }
+
+    if (nodeNonTerminalNode) {
+      const nonTerminalNode = node, ///
+            ruleName = nonTerminalNode.getRuleName();
+
+      found = includes(this.ruleNames, ruleName, WILDCARD_CHARACTER);
+    }
+
+    if (found) {
+      const intermediateNode = node; ///
+
+      this.intermediateNodes.push(intermediateNode);
+    }
+
+    if (this.infiniteDescent) {
+      if (nodeNonTerminalNode) {
+        depth++;
+
+        const nonTerminalNode = node; ///
+
+        nonTerminalNode.forEachChildNode((childNode) => {
+          this.find(childNode, depth, maximumDepth);
+        });
+      }
+    }
+  }
+
+  apply(nodes, depth, maximumDepth) {
+    this.spread.adjustNodes(this.intermediateNodes);
+
+    if (this.subQuery === null) {
+      push(nodes, this.intermediateNodes);
+    } else {
+      this.intermediateNodes.forEach((intermediateNode) => {
+        const intermediateNodeNonTerminalNode = intermediateNode.isNonTerminalNode();
+
+        if (intermediateNodeNonTerminalNode) {
+          depth++;
+
+          const nonTerminalNode = intermediateNode; ///
+
+          this.subQuery.clear();
+
+          nonTerminalNode.forEachChildNode((childNode) => {
+            this.subQuery.find(childNode, depth, maximumDepth);
+          });
+
+          this.subQuery.apply(nodes, depth, maximumDepth);
+        }
+      });
+    }
+  }
+
+  static fromExpression(expression, maximumDepth = Infinity) {
+    const spread = expression.getSpread(),
+          subQuery = subQueryFromExpression(expression),
+          ruleNames = expression.getRuleNames(),
+          tokenTypes = expression.getTokenTypes(),
+          infiniteDescent = expression.isInfiniteDescent(),
+          intermediateNodes = [],
+          query = new Query(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes);
+
+    return query;
+  }
+
+  static fromSubExpression(subExpression) {
+    const spread = subExpression.getSpread(),
+          subQuery = subQueryFromSubExpression(subExpression),
+          ruleNames = subExpression.getRuleNames(),
+          tokenTypes = subExpression.getTokenTypes(),
+          maximumDepth = Infinity,
+          infiniteDescent = subExpression.isInfiniteDescent(),
+          intermediateNodes = [],
+          query = new Query(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes);
+
+    return query;
+  }
+
+  static fromExpressionString(expressionString, maximumDepth = Infinity) {
+    let query = null;
+
+    const expression = Expression.fromExpressionString(expressionString);
+
+    if (expression !== null) {
+      const spread = expression.getSpread(),
+            subQuery = subQueryFromExpression(expression),
+            ruleNames = expression.getRuleNames(),
+            tokenTypes = expression.getTokenTypes(),
+            infiniteDescent = expression.isInfiniteDescent(),
+            intermediateNodes = [];
+
+      query = new Query(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes);
+    }
+
+    return query;
+  }
+}
+
+function subQueryFromExpression(expression) {
+  let subQuery = null;
+
+  const subExpression = expression.getSubExpression();
+
+  if (subExpression !== null) {
+    const query = Query.fromSubExpression(subExpression);
+
+    subQuery = query; ///
+  }
+
+  return subQuery;
+}
+
+function subQueryFromSubExpression(subExpression) {
+  let subQuery = null;
+
+  subExpression = subExpression.getSubExpression(); ///
+
+  if (subExpression !== null) {
+    const query = Query.fromSubExpression(subExpression);
+
+    subQuery = query; ///
+  }
+
+  return subQuery;
+}

package/src/ruleNames.js

@@ -0,0 +1,12 @@
+"use strict";
+
+export const ERROR_RULE_NAME = "error";
+export const INDEX_RULE_NAME = "index";
+export const UNIQUE_RULE_NAME = "unique";
+export const SPREAD_RULE_NAME = "spread";
+export const END_INDEX_RULE_NAME = "endIndex";
+export const RULE_NAME_RULE_NAME = "ruleName";
+export const TOKEN_TYPE_RULE_NAME = "tokenType";
+export const START_INDEX_RULE_NAME = "startIndex";
+export const SUB_EXPRESSION_RULE_NAME = "subExpression";
+export const INFINITE_DESCENT_RULE_NAME = "infiniteDescent";