highmark-yapp 0.0.1

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

@@ -0,0 +1,52 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import Textarea from "../textarea";
+
+import { DOUBLE_SPACE } from "../../constants";
+
+class LexicalEntriesTextarea extends Textarea {
+  getLexicalEntries() {
+    let lexicalEntries = {};
+
+    try {
+      const value = this.getValue(),
+            lexicalEntriesString = value; ///
+
+      lexicalEntries = JSON.parse(lexicalEntriesString);
+    } catch (error) {
+      ///
+    }
+
+    return lexicalEntries;
+  }
+
+  setLexicalEntries(lexicalEntries) {
+    const lexicalEntriesString = JSON.stringify(lexicalEntries, null, DOUBLE_SPACE),
+          value = lexicalEntriesString; ///
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const getLexicalEntries = this.getLexicalEntries.bind(this),
+          setLexicalEntries = this.setLexicalEntries.bind(this);
+
+    return ({
+      getLexicalEntries,
+      setLexicalEntries
+    });
+  }
+
+  static defaultProperties = {
+    className: "lexical-entries",
+    spellCheck: "false"
+  };
+}
+
+export default withStyle(LexicalEntriesTextarea)`
+
+  height: 12rem;
+
+`;

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

@@ -0,0 +1,50 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import Textarea from "../textarea";
+
+import { EMPTY_STRING } from "../../constants";
+
+class ParseTreeTextarea extends Textarea {
+  setParseTree(parseTree) {
+    if (parseTree !== null) {
+      parseTree.shiftLine();  //
+
+      const parseTreeString = parseTree.asString(),
+            value = parseTreeString;  ///
+
+      this.setValue(value);
+    } else {
+      this.clearParseTree();
+    }
+  }
+
+  clearParseTree() {
+    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: "tokens",
+    spellCheck: "false",
+    readOnly: true
+  };
+}
+
+export default withStyle(ParseTreeTextarea)`
+
+  height: 56rem;
+  
+`;

package/src/example/view/textarea.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Textarea } from "easy";
+
+export default withStyle(Textarea)`
+
+  border: 1px solid darkgrey;
+  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,155 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+import { rulesUtilities, parserUtilities } from "occam-parsers";
+import { RowsDiv, ColumnDiv, ColumnsDiv, VerticalSplitterDiv } from "easy-layout";
+
+import SubHeading from "./view/subHeading";
+import SizeableDiv from "./view/div/sizeable";
+import BNFTextarea from "./view/textarea/bnf";
+import MarkdownLexer from "./markdown/lexer";
+import MarkdownParser from "./markdown/parser";
+import ContentTextarea from "./view/textarea/content";
+import MarkdownSection from "./view/section/markdown";
+import ParseTreeTextarea from "./view/textarea/parseTree";
+import StartRuleNameInput from "./view/input/startRuleName";
+import LexicalEntriesTextarea from "./view/textarea/lexicalEntries";
+
+import { setNonTerminalNodes } from "../utilities/parser";
+
+const { rulesFromBNF } = parserUtilities,
+      { ruleMapFromRules, startRuleFromRulesAndStartRuleName } = rulesUtilities;
+
+class View extends Element {
+  changeHandler = (event, element) => {
+    this.update();
+  }
+
+  keyUpHandler = (event, element) => {
+    this.update();
+  }
+
+  update() {
+    const bnf = this.getBNF(),
+          rules = rulesFromBNF(bnf),
+          startRuleName = this.getStartRuleName(),
+          lexicalEntries = this.getLexicalEntries();
+
+    const markdownLexer = markdownLexerFromLexicalEntries(lexicalEntries),
+          markdownParser =  markdownParserFromRulesAndStartRuleName(rules, startRuleName);
+
+    const content = this.getContent(),
+          tokens = markdownLexer.tokenise(content),
+          node = markdownParser.parse(tokens);
+
+    let parseTree = null;
+
+    if (node !== null) {
+      parseTree = node.asParseTree(tokens);
+    }
+
+    this.updateMarkdownSection(node, tokens);
+
+    this.setParseTree(parseTree);
+  }
+
+  childElements() {
+    return (
+
+      <ColumnsDiv>
+        <SizeableDiv>
+          <RowsDiv>
+            <SubHeading>
+              Start rule name
+            </SubHeading>
+            <StartRuleNameInput onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              Lexical entries
+            </SubHeading>
+            <LexicalEntriesTextarea onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              BNF
+            </SubHeading>
+            <BNFTextarea onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              Content
+            </SubHeading>
+            <ContentTextarea onKeyUp={this.keyUpHandler} />
+          </RowsDiv>
+        </SizeableDiv>
+        <VerticalSplitterDiv/>
+        <ColumnDiv>
+          <RowsDiv>
+            <MarkdownSection/>
+            <SubHeading>
+              Parse tree
+            </SubHeading>
+            <ParseTreeTextarea />
+          </RowsDiv>
+        </ColumnDiv>
+      </ColumnsDiv>
+
+    );
+  }
+
+  initialise() {
+    this.assignContext();
+
+    const { bnf } = MarkdownParser,
+          { entries } = MarkdownLexer,
+          { initialContent, initialStartRuleName } = this.constructor,
+          content = initialContent, ///
+          startRuleName = initialStartRuleName, ///
+          lexicalEntries = entries; ///
+
+    this.setBNF(bnf);
+
+    this.setContent(content);
+
+    this.setLexicalEntries(lexicalEntries);
+
+    this.setStartRuleName(startRuleName);
+
+    this.update();
+  }
+
+  static initialContent = `===json
+{
+  "hello": "world"
+}
+===
+`;
+
+  static initialStartRuleName = "";
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "view"
+  };
+}
+
+export default withStyle(View)`
+
+  padding: 1rem;
+  
+`;
+
+function markdownLexerFromLexicalEntries(lexicalEntries) {
+  const entries = lexicalEntries, ///
+        markdownLexer = MarkdownLexer.fromEntries(entries);
+
+  return markdownLexer;
+}
+
+function markdownParserFromRulesAndStartRuleName(rules, startRuleName) {
+  const ruleMap = ruleMapFromRules(rules),
+        startRule = startRuleFromRulesAndStartRuleName(rules, startRuleName),
+        markdownParser = new MarkdownParser(startRule, ruleMap);
+
+  setNonTerminalNodes(markdownParser);
+
+  return markdownParser;
+}

package/src/example.js

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

package/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+export { default as nodeMap } from "./nodeMap";
+export { default as ruleNames } from "./ruleNames";
+export { default as tokenTypes } from "./tokenTypes";
+
+export { default as MarkdownLexer } from "./markdown/lexer";
+export { default as MarkdownParser } from "./markdown/parser";
+
+export { default as LineMarkdownNode } from "./node/markdown/line";
+export { default as ErrorMarkdownNode } from "./node/markdown/error";
+export { default as ListingMarkdownNode } from "./node/markdown/listing";
+export { default as HeadingMarkdownNode } from "./node/markdown/heading";
+export { default as LanguageMarkdownNode } from "./node/markdown/language";
+export { default as DocumentMarkdownNode } from "./node/markdown/document";
+export { default as ParagraphMarkdownNode } from "./node/markdown/paragraph";
+export { default as LineBreakMarkdownNode } from "./node/markdown/lineBreak";
+export { default as ListingEndMarkdownNode } from "./node/markdown/listingEnd";
+export { default as OrderedListMarkdownNode } from "./node/markdown/orderedList";
+export { default as ListingStartMarkdownNode } from "./node/markdown/listingStart";
+export { default as VerticalSpaceMarkdownNode } from "./node/markdown/verticalSpace";
+export { default as UnorderedListMarkdownNode } from "./node/markdown/unorderedList";
+export { default as OrderedListItemMarkdownNode } from "./node/markdown/orderedListItem";
+export { default as UnorderedListItemMarkdownNode } from "./node/markdown/unorderedListItem";

package/src/markdown/bnf.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const bnf = `
+
+    document           ::=  ( unorderedList | orderedList | listing | heading | lineBreak | paragraph | verticalSpace | error )+ ;
+
+    
+    unorderedList      ::=  unorderedListItem+ ;
+
+
+    orderedList        ::=  orderedListItem+ ;
+
+
+    listing            ::=  listingStart ( line | verticalSpace )* listingEnd ;
+
+
+    heading            ::=  [heading] line ;
+
+
+    lineBreak          ::=  [line-break] <END_OF_LINE> ;
+
+
+    paragraph          ::=  line+ ;
+    
+
+    verticalSpace      ::=  <END_OF_LINE>+ ;
+
+
+    error              ::=  . ;
+
+
+    unorderedListItem  ::=  [bullet] line ;
+
+
+    orderedListItem    ::=  [marker] line ;
+
+    
+    listingStart       ::=  [listing] language? <END_OF_LINE> ;
+
+
+    listingEnd         ::=  [listing] <END_OF_LINE> ;
+
+
+    language           ::=  <NO_WHITESPACE>[identifier] ;
+
+
+    line               ::=  ( [escaped] | [identifier] | [unassigned] )+ <END_OF_LINE> ;
+
+`;
+
+export default bnf;

package/src/markdown/entries.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const entries = [
+  {
+    "escaped": "^\\\\[^\\s]+"
+  },
+  {
+    "bullet": "^\\*"
+  },
+  {
+    "marker": "^[1-9][0-9]*\\."
+  },
+  {
+    "listing": "^```"
+  },
+  {
+    "heading": "^#{1,4}"
+  },
+  {
+    "line-break": "^-{2,3}"
+  },
+  {
+    "identifier": "^[a-z]+"
+  },
+  {
+    "unassigned": "^[^\\s]+"
+  }
+];
+
+export default entries;

package/src/markdown/lexer.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { CommonLexer, WhitespaceToken, EndOfLineSignificantToken } from "occam-lexers";
+
+import entries from "./entries";
+
+export default class MarkdownLexer 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(MarkdownLexer); }
+
+  static fromRules(rules) { return CommonLexer.fromRules(MarkdownLexer, rules); }
+
+  static fromEntries(entries) { return CommonLexer.fromEntries(MarkdownLexer, entries); }
+}

package/src/markdown/parser.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import { CommonParser } from "occam-parsers";
+
+import bnf from "./bnf";
+import nodeMap from "../nodeMap";
+
+import { setNonTerminalNodes } from "../utilities/parser";
+
+export default class MarkdownParser extends CommonParser {
+  static bnf = bnf;
+
+  static nodeMap = nodeMap;
+
+  static fromNothing() {
+    const markdownParser = CommonParser.fromNothing(MarkdownParser);
+
+    setNonTerminalNodes(markdownParser);
+
+    return markdownParser;
+  }
+
+  static fromBNF(bnf) {
+    const markdownParser = CommonParser.fromBNF(MarkdownParser, bnf);
+
+    setNonTerminalNodes(markdownParser);
+
+    return markdownParser;
+  }
+
+  static fromRules(rules) {
+    const markdownParser = CommonParser.fromRules(MarkdownParser, rules);
+
+    setNonTerminalNodes(markdownParser);
+
+    return markdownParser;
+  }
+}

package/src/mixins/element.js

@@ -0,0 +1,53 @@
+"use strict";
+
+function add(node) {
+  const domElement = this.getDOMElement(),
+        nodeDOMEElement = node.getDOMElement();
+
+  domElement.insertBefore(nodeDOMEElement, null); ///
+}
+
+function remove(node) {
+  const domElement = this.getDOMElement();
+
+  if (node) {
+    const nodeDOMEElement = node.getDOMElement();
+
+    domElement.removeChild(nodeDOMEElement);
+  } else {
+    domElement.remove();
+  }
+}
+
+function getDescendantNodes(descendantNodes = []) {
+  const domElement = this.getDOMElement();
+
+  if (domElement !== null) {
+    const childNodes = this.getChildNodes(),
+          descendantNode = this; ///
+
+    descendantNodes.push(descendantNode);
+
+    childNodes.forEach((childNode) => {
+      childNode.getDescendantNodes(descendantNodes);
+    })
+  }
+
+  return descendantNodes;
+}
+
+function getDescendantElements() {
+  const descendantNodes = this.getDescendantNodes(),
+        descendantElements = descendantNodes; ///
+
+  return descendantElements;
+}
+
+const elementMixins = {
+  add,
+  remove,
+  getDescendantNodes,
+  getDescendantElements
+};
+
+export default elementMixins;

package/src/node/markdown/document.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class DocumentMarkdownNode extends MarkdownNode {
+  static tagName = "div";
+
+  static className = "document";
+
+  static fromRuleNameAndChildNodes(ruleName, childNodes) { return MarkdownNode.fromRuleNameAndChildNodes(DocumentMarkdownNode, ruleName, childNodes); }
+
+  static fromRuleNameChildNodesAndPrecedence(ruleName, childNodes, precedence) { return MarkdownNode.fromRuleNameChildNodesAndPrecedence(DocumentMarkdownNode, ruleName, childNodes, precedence); }
+}

package/src/node/markdown/error.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class ErrorMarkdownNode extends MarkdownNode {
+  createDOMElement(tokens) {
+    const domElement = super.createDOMElement(tokens),
+          childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          terminalNode = firstChildNode,  ///
+          content = terminalNode.getContent(),
+          textContent = content;  ///
+
+    Object.assign(domElement, {
+      textContent
+    });
+
+    return domElement;
+  }
+
+  static tagName = "span";
+
+  static className = "error";
+
+  static fromRuleNameAndChildNodes(ruleName, childNodes) { return MarkdownNode.fromRuleNameAndChildNodes(ErrorMarkdownNode, ruleName, childNodes); }
+
+  static fromRuleNameChildNodesAndPrecedence(ruleName, childNodes, precedence) { return MarkdownNode.fromRuleNameChildNodesAndPrecedence(ErrorMarkdownNode, ruleName, childNodes, precedence); }
+}

package/src/node/markdown/heading.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class HeadingMarkdownNode extends MarkdownNode {
+  getTagName() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          headingTerminalNode = firstChildNode,  ///
+          headingTerminalNodeContent = headingTerminalNode.getContent(),
+          headingTerminalNodeContentLength = headingTerminalNodeContent.length,
+          tagName = `h${headingTerminalNodeContentLength}`;
+
+    return tagName;
+  }
+
+  static fromRuleNameAndChildNodes(ruleName, childNodes) { return MarkdownNode.fromRuleNameAndChildNodes(HeadingMarkdownNode, ruleName, childNodes); }
+
+  static fromRuleNameChildNodesAndPrecedence(ruleName, childNodes, precedence) { return MarkdownNode.fromRuleNameChildNodesAndPrecedence(HeadingMarkdownNode, ruleName, childNodes, precedence); }
+}

package/src/node/markdown/language.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { second } = arrayUtilities;
+
+export default class LanguageMarkdownNode extends MarkdownNode {
+  getLanguage() {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          identifierTerminalNode = secondChildNode, ///
+          identifierTerminalNodeContent = identifierTerminalNode.getContent(),
+          language = identifierTerminalNodeContent; ///
+
+    return language;
+  }
+
+  static fromRuleNameAndChildNodes(ruleName, childNodes) { return MarkdownNode.fromRuleNameAndChildNodes(LanguageMarkdownNode, ruleName, childNodes); }
+
+  static fromRuleNameChildNodesAndPrecedence(ruleName, childNodes, precedence) { return MarkdownNode.fromRuleNameChildNodesAndPrecedence(LanguageMarkdownNode, ruleName, childNodes, precedence); }
+}

package/src/node/markdown/line.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import { EMPTY_STRING } from "../../constants";
+import { tokenContentFromToken } from "../../utilities/token";
+
+export default class LineMarkdownNode extends MarkdownNode {
+  createDOMElement(tokens) {
+    const content = this.getContent(tokens),
+          domElement = document.createTextNode(content);  ///
+
+    this.setDOMElement(domElement);
+
+    return domElement;
+  }
+
+  getContent(tokens) {
+    let content = EMPTY_STRING;
+
+    const lastSignificantToken = this.getLastSignificantToken(),
+          firstSignificantToken = this.getFirstSignificantToken(),
+          lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
+          firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+          start = firstSignificantTokenIndex, ///
+          end = lastSignificantTokenIndex + 1;
+
+    tokens = tokens.slice(start, end);  ///
+
+    tokens.forEach((token) => {
+      const tokenContent = tokenContentFromToken(token);
+
+      content += tokenContent;
+    });
+
+    return content;
+  }
+
+  static fromRuleNameAndChildNodes(ruleName, childNodes) { return MarkdownNode.fromRuleNameAndChildNodes(LineMarkdownNode, ruleName, childNodes); }
+
+  static fromRuleNameChildNodesAndPrecedence(ruleName, childNodes, precedence) { return MarkdownNode.fromRuleNameChildNodesAndPrecedence(LineMarkdownNode, ruleName, childNodes, precedence); }
+}

package/src/node/markdown/lineBreak.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class LineBreakMarkdownNode extends MarkdownNode {
+  static tagName = "br";
+
+  static fromRuleNameAndChildNodes(ruleName, childNodes) { return MarkdownNode.fromRuleNameAndChildNodes(LineBreakMarkdownNode, ruleName, childNodes); }
+
+  static fromRuleNameChildNodesAndPrecedence(ruleName, childNodes, precedence) { return MarkdownNode.fromRuleNameChildNodesAndPrecedence(LineBreakMarkdownNode, ruleName, childNodes, precedence); }
+}