highmark-markdown 0.0.2 → 0.0.4

package/src/example/view/xmp.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import withStyle from "easy-with-style";
+
+import { Element } from "easy";
+
+class XMP extends Element {
+  parentContext() {
+    const xmpHTML = this.html.bind(this);  ///
+
+    return ({
+      xmpHTML
+    });
+  }
+
+  static tagName = "xmp";
+}
+
+export default withStyle(XMP)`
+
+  width: 100%;  
+  border: 1px solid darkgrey;
+  padding: 0.25rem;
+  font-size: 1.2rem;
+  line-height: 1.5rem;
+  font-family: monospace;
+  
+`;

package/src/example/view.js

@@ -3,24 +3,24 @@
 import withStyle from "easy-with-style";  ///
 
 import { Element } from "easy";
-import { parserUtilities } from "occam-parsers";
 import { RowDiv, RowsDiv, ColumnDiv, ColumnsDiv, VerticalSplitterDiv, HorizontalSplitterDiv } from "easy-layout";
 
+import XMP from "./view/xmp";
 import SubHeading from "./view/subHeading";
 import BNFTextarea from "./view/textarea/bnf";
-import PreviewPaneDiv from "./view/div/previewPane";
 import LeftSizeableDiv from "./view/div/sizeable/left";
 import RightSizeableDiv from "./view/div/sizeable/right";
 import MarkdownTextarea from "./view/textarea/markdown";
 import ParseTreeTextarea from "./view/textarea/parseTree";
 import LexicalEntriesTextarea from "./view/textarea/lexicalEntries";
 
-import { nodeMap, MarkdownLexer, MarkdownParser, nodeUtilities } from "../index";
+import { MarkdownLexer, MarkdownParser } from "../index";
 
 const { bnf } = MarkdownParser,
-      { entries } = MarkdownLexer,
-      { rulesFromBNF } = parserUtilities,
-      { setNonTerminalNodes } = nodeUtilities;
+      { entries } = MarkdownLexer;
+
+const markdownLexer = MarkdownLexer.fromNothing(),
+      markdownParser = MarkdownParser.fromNothing();
 
 class View extends Element {
   keyUpHandler = (event, element) => {
@@ -28,23 +28,23 @@ class View extends Element {
   }
 
   update() {
-    const bnf = this.getBNF(),
-          markdown = this.getMarkdown(),
-          lexicalEntries = this.getLexicalEntries();
-
-    const rules = rulesFromBNF(bnf),
-          lexer = lexerFromLexicalEntries(lexicalEntries),
-          parser =  parserFromRules(rules),
-          content = markdown; ///
-
-    const tokens = lexer.tokenise(content),
+    const markdown = this.getMarkdown(),
+          lexer = markdownLexer,  ///
+          parser =  markdownParser, ///
+          content = markdown, ///
+          tokens = lexer.tokenise(content),
           node = parser.parse(tokens);
 
-    this.updatePreviewPaneDiv(node, tokens);
-
     let parseTree = null;
 
     if (node !== null) {
+      const context = {
+              tokens
+            },
+            html = node.asHTML(context);
+
+      this.xmpHTML(html);
+
       parseTree = node.asParseTree(tokens);
     }
 
@@ -73,7 +73,7 @@ class View extends Element {
         <ColumnDiv>
           <RowsDiv>
             <RightSizeableDiv>
-              <PreviewPaneDiv/>
+              <XMP/>
             </RightSizeableDiv>
             <HorizontalSplitterDiv/>
             <RowDiv>
@@ -107,7 +107,13 @@ class View extends Element {
     this.update();
   }
 
-  static initialMarkdown = `This is a paragraph.
+  static initialMarkdown = `A paragraph...
+  
+  
+Another paragraph!
+
+And yet another'
+\`\`\`  
 `;
 
   static tagName = "div";
@@ -122,18 +128,3 @@ export default withStyle(View)`
   padding: 1rem;
   
 `;
-
-function lexerFromLexicalEntries(lexicalEntries) {
-  const entries = lexicalEntries, ///
-        lexer = MarkdownLexer.fromEntries(entries); ///
-
-  return lexer;
-}
-
-function parserFromRules(rules) {
-  const parser = MarkdownParser.fromRules(rules); ///
-
-  setNonTerminalNodes(parser, nodeMap);
-
-  return parser;
-}

package/src/mixins/content.js

@@ -2,7 +2,7 @@
 
 import { contentFromMarkdownNodes } from "../utilities/content";
 
-function getContent(context) {
+function content(context) {
   const markdownNode = this, ///
         markdownNodes = [
           markdownNode
@@ -13,7 +13,7 @@ function getContent(context) {
 }
 
 const contentMixins = {
-  getContent
+  content
 };
 
 export default contentMixins;

package/src/node/markdown/anchor.js

@@ -16,14 +16,16 @@ export default class AnchorMarkdownNode extends MarkdownNode {
     return this.identifier;
   }
 
-  createDOMElement(context) {
-    const domElement = super.createDOMElement(context),
-          name = ID_ATTRIBUTE_NAME,
-          value = this.identifier;
+  attributeName() {
+    const attributeName = ID_ATTRIBUTE_NAME;
 
-    this.setAttribute(name, value);
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const attributeValue = this.identifier; ///
 
-    return domElement;
+    return attributeValue;
   }
 
   static fromIdentifier(identifier) {

package/src/node/markdown/blockListing.js

@@ -7,20 +7,26 @@ import MarkdownNode from "../../node/markdown";
 const { first, second } = arrayUtilities;
 
 export default class BlockListingMarkdownNode extends MarkdownNode {
-  getContent() {
+  content(context) {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),
           blockTextMarkdownNode = secondChildNode,  ///
-          content = blockTextMarkdownNode;  ///
+          content = blockTextMarkdownNode.content(context);
 
     return content;
   }
 
   getClassName() {
+    let className = super.getClassName();
+
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           blockListingStartMarkdownNode = firstChildNode, ///
-          className = blockListingStartMarkdownNode.getClassName(); ///
+          blockListingStartMarkdownNodeClassName = blockListingStartMarkdownNode.getClassName();
+
+    if (blockListingStartMarkdownNodeClassName !== null) {
+      className = `${className} ${blockListingStartMarkdownNodeClassName}`;
+    }
 
     return className;
   }

package/src/node/markdown/blockText.js

@@ -5,8 +5,15 @@ import contentMixins from "../../mixins/content";
 import MarkdownNode from "../markdown";
 
 class BlockTextMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    const content = this.content(context),
+          html = content; ///
+
+    return html;
+  }
+
   createDOMElement(context) {
-    const content = this.getContent(context),
+    const content = this.content(context),
           domElement = document.createTextNode(content);
 
     this.setDOMElement(domElement);

package/src/node/markdown/document.js

@@ -3,21 +3,46 @@
 import MarkdownNode from "../../node/markdown";
 import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
 
-import { renumberLinkMarkdownNodes } from "../../utilities/link";
+import { EMPTY_STRING } from "../../constants";
+import { renumberLinkMarkdownNodes, renumberLinkMarkdownNodesHTML } from "../../utilities/link";
 
 export default class DocumentMarkdownNode extends MarkdownNode {
+  adjustIndent(indent) {
+    indent = EMPTY_STRING;
+
+    return indent;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const documentMarkdownNode = this,  ///
+          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDocumentMarkdownNode(documentMarkdownNode, context);
+
+    let childNodesHTML = super.childNodesAsHTML(indent, context);
+
+    if (footnotesListMarkdownNode !== null) {
+      const footnotesListMarkdownNodeHTML = footnotesListMarkdownNode.asHTML(indent, context);
+
+      childNodesHTML = `${childNodesHTML}${footnotesListMarkdownNodeHTML}`;
+
+      childNodesHTML = renumberLinkMarkdownNodesHTML(childNodesHTML, documentMarkdownNode, footnotesListMarkdownNode, context);
+    }
+
+    return childNodesHTML;
+  }
+
   createChildNodeDOMElements(context) {
     const documentMarkdownNode = this,  ///
-          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDocumentMarkdownNode(documentMarkdownNode);
+          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDocumentMarkdownNode(documentMarkdownNode, context);
 
     super.createChildNodeDOMElements(context);
 
     if (footnotesListMarkdownNode !== null) {
-      const domElement = footnotesListMarkdownNode.createDOMElement(context);
+      const footnotesListMarkdownNodeDOMElement = footnotesListMarkdownNode.createDOMElement(context),
+            childNodeDOMElement = footnotesListMarkdownNodeDOMElement;  ///
 
-      this.insertDOMElement(domElement);
+      this.insertDOMElement(childNodeDOMElement);
 
-      renumberLinkMarkdownNodes(documentMarkdownNode, footnotesListMarkdownNode);
+      renumberLinkMarkdownNodes(documentMarkdownNode, footnotesListMarkdownNode, context);
     }
   }
 

package/src/node/markdown/endOfLine.js

@@ -3,8 +3,15 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class EndOfLineMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    const content = this.content(context),
+          html = content; ///
+
+    return html;
+  }
+
   createDOMElement(context) {
-    const content = this.getContent(context),
+    const content = this.content(context),
           domElement = document.createTextNode(content);
 
     this.setDOMElement(domElement);
@@ -12,7 +19,7 @@ export default class EndOfLineMarkdownNode extends MarkdownNode {
     return domElement;
   }
 
-  getContent() {
+  content(context) {
     const firstSignificantToken = this.getFirstSignificantToken(),
           endOfLineToken = firstSignificantToken, ///
           content = endOfLineToken.getContent();

package/src/node/markdown/error.js

@@ -7,23 +7,24 @@ import MarkdownNode from "../../node/markdown";
 const { first } = arrayUtilities;
 
 export default class ErrorMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    const domElement = super.createDOMElement(context),
-          content = this.getContent(context),
-          textContent = content;  ///
+  childNodesAsHTML(indent, context) {
+    const content = this.content(context),
+          childNodesHTML = content;  ///
 
-    Object.assign(domElement, {
-      textContent
-    });
-
-    return domElement;
+    return childNodesHTML;
   }
 
   createChildNodeDOMElements(context) {
-    ///
+    const content = this.content(context),
+          domElement = this.getDOMElement(),
+          parentDOMElement = domElement,  ///
+          siblingDOMElement = null,
+          childNodeDOMElement = document.createTextNode(content);
+
+    parentDOMElement.insertBefore(childNodeDOMElement, siblingDOMElement);
   }
 
-  getContent() {
+  content(context) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           terminalNode = firstChildNode,  ///

package/src/node/markdown/footnote.js

@@ -7,11 +7,11 @@ import MarkdownNode from "../../node/markdown";
 const { first } = arrayUtilities;
 
 export default class FootnoteMarkdownNode extends MarkdownNode {
-  getIdentifier() {
+  identifier(context) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           referenceMarkdownNode = firstChildNode,  ///
-          referenceMarkdownNodeIdentifier = referenceMarkdownNode.getIdentifier(),
+          referenceMarkdownNodeIdentifier = referenceMarkdownNode.identifier(context),
           identifier = referenceMarkdownNodeIdentifier;  ///
 
     return identifier;

package/src/node/markdown/footnoteItem.js

@@ -10,7 +10,7 @@ import { FOOTNOTE_ITEM_RULE_NAME } from "../../ruleNames";
 const { first, second } = arrayUtilities;
 
 export default class FootnoteItemMarkdownNode extends MarkdownNode {
-  getIdentifier() {
+  identifier(context) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           anchorMarkdownNode = firstChildNode,  ///

package/src/node/markdown/footnotesList.js

@@ -8,11 +8,11 @@ import { FOOTNOTES_LIST_RULE_NAME } from "../../ruleNames";
 import { linkMarkdownNodesFromNode, footnoteMarkdownNodesFromNode } from "../../utilities/query";
 
 export default class FootnotesListMarkdownNode extends MarkdownNode {
-  getIdentifiers() {
+  identifiers(context) {
     const childNodes = this.getChildNodes(),
           footnoteItemMarkdownNodes = childNodes, ///
           identifiers = footnoteItemMarkdownNodes.map((footnoteItemMarkdownNode) => {
-            const identifier = footnoteItemMarkdownNode.getIdentifier();
+            const identifier = footnoteItemMarkdownNode.identifier(context);
 
             return identifier;
           });
@@ -20,10 +20,10 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
     return identifiers;
   }
 
-  static fromDocumentMarkdownNode(documentMarkdownNode) {
+  static fromDocumentMarkdownNode(documentMarkdownNode, context) {
     let footnotesListMarkdownNode = null;
 
-    const footnoteItemMarkdownNodes = footnoteItemMarkdownNodesFromDocumentMarkdownNode(documentMarkdownNode),
+    const footnoteItemMarkdownNodes = footnoteItemMarkdownNodesFromDocumentMarkdownNode(documentMarkdownNode, context),
           footnoteItemMarkdownNodesLength = footnoteItemMarkdownNodes.length;
 
     if (footnoteItemMarkdownNodesLength > 0) {
@@ -38,18 +38,20 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
   }
 }
 
-function footnoteItemMarkdownNodesFromDocumentMarkdownNode(documentMarkdownNode) {
+function footnoteItemMarkdownNodesFromDocumentMarkdownNode(documentMarkdownNode, context) {
   const footnoteItemMarkdownNodes = [],
-        footnoteMarkdownNodes = footnoteMarkdownNodesFromNode(documentMarkdownNode),
-        linkMarkdownNodes = linkMarkdownNodesFromNode(documentMarkdownNode),
+        node = documentMarkdownNode,  ///
+        linkMarkdownNodes = linkMarkdownNodesFromNode(node),
+        footnoteMarkdownNodes = footnoteMarkdownNodesFromNode(node),
         identifiers = footnoteMarkdownNodes.map((footnoteMarkdownNode) => {
-          const identifier = footnoteMarkdownNode.getIdentifier();
+          const identifier = footnoteMarkdownNode.identifier(context);
 
           return identifier;
         });
 
   linkMarkdownNodes.forEach((linkMarkdownNode) => {
-    const identifier = linkMarkdownNode.getIdentifier(),
+    const linkMarkdownNodeIdentifier = linkMarkdownNode.identifier(context),
+          identifier = linkMarkdownNodeIdentifier,  ///
           index = identifiers.indexOf(identifier);
 
     if (index > -1) {

package/src/node/markdown/hyperlink.js

@@ -9,38 +9,39 @@ import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 const { second, secondLast } = arrayUtilities;
 
 export default class HyperlinkMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    const domElement = super.createDOMElement(context),
-          innerHTML = this.getInnerHTML(context),
-          href = this.getHref(context),
-          name = HREF_ATTRIBUTE_NAME,
-          value = href; ///
-
-    this.setAttribute(name, value);
-
-    this.setInnerHTML(innerHTML);
+  childNodesAsHTML(indent, context) {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          inlineTextMarkdownNode = secondChildNode, ///
+          inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
+          childNodesHTML = inlineTextMarkdownNodeHTML; ///
 
-    return domElement;
+    return childNodesHTML;
   }
 
-  getInnerHTML(context) {
+  createChildNodeDOMElements(context) {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),
-          inlineTextMarkdownNode = secondChildNode,  ///
-          inlineTextMarkdownNodeContent = inlineTextMarkdownNode.getContent(context),
-          innerHTML = inlineTextMarkdownNodeContent; ///
+          inlineTextMarkdownNode = secondChildNode, ///
+          inlineTextMarkdownNodeDOMElement = inlineTextMarkdownNode.createDOMElement(context);
+
+    this.insertDOMElement(inlineTextMarkdownNodeDOMElement);
+  }
+
+  attributeName() {
+    const attributeName = HREF_ATTRIBUTE_NAME;
 
-    return innerHTML;
+    return attributeName;
   }
 
-  getHref(context) {
+  attributeValue(context) {
     const childNodes = this.getChildNodes(),
           secondLastChildNode = secondLast(childNodes),
           URLMarkdownNode = secondLastChildNode,  ///
-          URLMarkdownNodeContent = URLMarkdownNode.getContent(context),
-          href = URLMarkdownNodeContent; ///
+          URLMarkdownNodeContent = URLMarkdownNode.content(context),
+          attributeValue = URLMarkdownNodeContent; ///
 
-    return href;
+    return attributeValue;
   }
 
   static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(HyperlinkMarkdownNode, ruleName, childNodes, ambiguous); }

package/src/node/markdown/image.js

@@ -9,38 +9,46 @@ import { SRC_ATTRIBUTE_NAME } from "../../attributeNames";
 const { second, secondLast } = arrayUtilities;
 
 export default class ImageMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    const domElement = super.createDOMElement(context),
-          innerHTML = this.getInnerHTML(context),
-          src = this.getSrc(context),
-          name = SRC_ATTRIBUTE_NAME,
-          value = src; ///
+  childNodesAsHTML(indent, context) {
+    const content = this.content(context),
+          childNodesHTML = content; ///
 
-    this.setAttribute(name, value);
+    return childNodesHTML;
+  }
 
-    this.setInnerHTML(innerHTML);
+  createChildNodeDOMElements(context) {
+    const content = this.content(context),
+          domElement = this.getDOMElement(),
+          parentDOMElement = domElement,  ///
+          siblingDOMElement = null,
+          childNodeDOMElement = document.createTextNode(content);
 
-    return domElement;
+    parentDOMElement.insertBefore(childNodeDOMElement, siblingDOMElement);
   }
 
-  getInnerHTML(context) {
+  content(context) {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),
           inlineTextMarkdownNode = secondChildNode,  ///
-          inlineTextMarkdownNodeContent = inlineTextMarkdownNode.getContent(context),
-          innerHTML = inlineTextMarkdownNodeContent; ///
+          content = inlineTextMarkdownNode.content(context);
+
+    return content;
+  }
+
+  attributeName() {
+    const attributeName = SRC_ATTRIBUTE_NAME;
 
-    return innerHTML;
+    return attributeName;
   }
 
-  getSrc(context) {
+  attributeValue(context) {
     const childNodes = this.getChildNodes(),
           secondLastChildNode = secondLast(childNodes),
           URLMarkdownNode = secondLastChildNode,  ///
-          URLMarkdownNodeContent = URLMarkdownNode.getContent(context),
-          src = URLMarkdownNodeContent; ///
+          URLMarkdownNodeContent = URLMarkdownNode.content(context),
+          attributeValue = URLMarkdownNodeContent; ///
 
-    return src;
+    return attributeValue;
   }
 
   static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(ImageMarkdownNode, ruleName, childNodes, ambiguous); }

package/src/node/markdown/inlineListing.js

@@ -1,20 +1,7 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 
-const { second } = arrayUtilities;
-
 export default class InlineListingMarkdownNode extends MarkdownNode {
-  getContent() {
-    const childNodes = this.getChildNodes(),
-          secondChildNode = second(childNodes),
-          blockTextMarkdownNode = secondChildNode,  ///
-          content = blockTextMarkdownNode;  ///
-
-    return content;
-  }
-
   static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(InlineListingMarkdownNode, ruleName, childNodes, ambiguous); }
 }

package/src/node/markdown/inlineText.js

@@ -5,8 +5,15 @@ import contentMixins from "../../mixins/content";
 import MarkdownNode from "../markdown";
 
 class InlineTextMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    const content = this.content(context),
+          html = content; ///
+
+    return html;
+  }
+
   createDOMElement(context) {
-    const content = this.getContent(context),
+    const content = this.content(context),
           domElement = document.createTextNode(content);
 
     this.setDOMElement(domElement);

package/src/node/markdown/line.js

@@ -2,18 +2,26 @@
 
 import MarkdownNode from "../../node/markdown";
 
-import { domElementsFromChildNodes } from "../../utilities/childNodes";
+import { htmlFromChildNodes, domElementsFromChildNodes } from "../../utilities/childNodes";
 
 export default class LineMarkdownNode extends MarkdownNode {
+  childNodesAsHTML(indent, context) {
+    const childNodes = this.getChildNodes(),
+          childNodesHTML = htmlFromChildNodes(childNodes, context);
+
+    return childNodesHTML;
+  }
+
   createChildNodeDOMElements(context) {
-    const domElement = this.getDOMElement(),
-          childNodes = this.getChildNodes(),
+    const childNodes = this.getChildNodes(),
+          domElement = this.getDOMElement(),
           domElements = domElementsFromChildNodes(childNodes, context),
           parentDOMElement = domElement,  ///
-          siblingDOMElement = null;
+          siblingDOMElement = null,
+          childNodeDOMElements = domElements; ///
 
-    domElements.forEach((domElement) => {
-      parentDOMElement.insertBefore(domElement, siblingDOMElement);
+    childNodeDOMElements.forEach((childNodeDOMElement) => {
+      parentDOMElement.insertBefore(childNodeDOMElement, siblingDOMElement);
     });
   }