occam-dom 4.0.15 → 5.0.0

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

@@ -0,0 +1,55 @@
+"use strict";
+
+import Textarea from "../textarea";
+
+import { EMPTY_STRING } from "../../../constants";
+import { tokenIndexFromTerminalNodeAndTokens, tokenIndexesFromNonTerminalNodeAndTokens } from "../../utilities/token"
+
+export default class NodesTextarea extends Textarea {
+  setNodes(nodes, tokens) { ///
+    const value = nodes.reduce((value, node) => {
+      const nodeTerminalNode = node.isTerminalNode();
+
+      if (nodeTerminalNode) {
+        const terminalNode = node,  ///
+              significantToken = terminalNode.getSignificantToken(),
+              significantTokenType = significantToken.getType(),
+              tokenIndex = tokenIndexFromTerminalNodeAndTokens(terminalNode, tokens);
+
+        value = `${value}[${significantTokenType}]${tokenIndex}\n`;
+      } else {
+        const nonTerminalNode = node, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              tokenIndexes = tokenIndexesFromNonTerminalNodeAndTokens(nonTerminalNode, tokens);
+
+        value = `${value}${ruleName}${tokenIndexes}\n`;
+      }
+
+      return value;
+    }, EMPTY_STRING);
+
+    this.setValue(value);
+  }
+
+  clearNodes() {
+    const value = EMPTY_STRING;
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const setNodes = this.setNodes.bind(this),
+          clearNodes = this.clearNodes.bind(this);
+
+    return ({
+      setNodes,
+      clearNodes
+    });
+  }
+
+  static defaultProperties = {
+    className: "nodes",
+    spellCheck: "false",
+    readOnly: true
+  };
+}

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