highmark-markdown 0.0.2 → 0.0.3

package/src/node/markdown/link.js

@@ -4,50 +4,49 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 
-import { EMPTY_STRING } from "../../constants";
 import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 
 const { second } = arrayUtilities;
 
 export default class LinkMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    const domElement = super.createDOMElement(context),
-          href = this.getHRef(),
-          name = HREF_ATTRIBUTE_NAME,
-          value = href; ///
+  asHTML(indent, context, number = null) {
+    let html;
 
-    this.setAttribute(name, value);
+    if (number === null) {
+      const selfClosingTag = this.selfClosingTag(context);
 
-    return domElement;
+      html = selfClosingTag;  ///
+    } else {
+      const startingTag = this.startingTag(context),
+            closingTag = this.closingTag(context);
+
+      html = `${startingTag}${number}${closingTag}`;
+    }
+
+    return html;
   }
 
-  getIdentifier() {
+  identifier(context) {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),
-          textMarkdownNode = secondChildNode,  ///
-          textMarkdownNodeContent = textMarkdownNode.getContent(),
-          identifier = textMarkdownNodeContent; ///
+          identifierTerminalNode = secondChildNode,  ///
+          identifierTerminalNodeContent = identifierTerminalNode.getContent(),
+          identifier = identifierTerminalNodeContent; ///
 
     return identifier;
   }
 
-  getHRef() {
-    const identifier = this.getIdentifier(),
-          href = `#${identifier}`;
-
-    return href;
-  }
-
-  clear() {
-    const innerHTML = EMPTY_STRING;
+  attributeName() {
+    const attributeName = HREF_ATTRIBUTE_NAME;
 
-    this.setInnerHTML(innerHTML);
+    return attributeName;
   }
 
-  setNumber(number) {
-    const innerHTML = `${number}`;
+  attributeValue(context) {
+    const identifier = this.identifier(context),
+          attributeValue = `#${identifier}`; ///
 
-    this.setInnerHTML(innerHTML);
+    return attributeValue;
   }
 
   static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(LinkMarkdownNode, ruleName, childNodes, ambiguous); }

package/src/node/markdown/orderedList.js

@@ -9,24 +9,20 @@ import { START_ATTRIBUTE_NAME } from "../../attributeNames";
 const { first } = arrayUtilities;
 
 export default class OrderedListMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    const domElement = super.createDOMElement(context),
-          start = this.getStart(),
-          name = START_ATTRIBUTE_NAME,  ///
-          value = start; ///
+  attributeName() {
+    const attributeName = START_ATTRIBUTE_NAME;
 
-    this.setAttribute(name, value);
-
-    return domElement;
+    return attributeName;
   }
 
-  getStart() {
+  attributeValue(context) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           firstOrderedListItemMarkdownNode = firstChildNode,  ///
-          start = firstOrderedListItemMarkdownNode.getStart();
+          start = firstOrderedListItemMarkdownNode.start(),
+          attributeValue = start; ///
 
-    return start;
+    return attributeValue;
   }
 
   static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(OrderedListMarkdownNode, ruleName, childNodes, ambiguous); }

package/src/node/markdown/orderedListItem.js

@@ -7,7 +7,7 @@ import MarkdownNode from "../../node/markdown";
 const { first } = arrayUtilities;
 
 export default class OrderedListItemMarkdownNode extends MarkdownNode {
-  getStart() {
+  start() {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           markerTerminalNode = firstChildNode,  ///

package/src/node/markdown/reference.js

@@ -7,12 +7,12 @@ import MarkdownNode from "../../node/markdown";
 const { second } = arrayUtilities;
 
 export default class ReferenceMarkdownNode extends MarkdownNode {
-  getIdentifier() {
+  identifier(context) {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),
-          textMarkdownNode = secondChildNode,  ///
-          textMarkdownNodeContent = textMarkdownNode.getContent(),
-          identifier = textMarkdownNodeContent; ///
+          identiierTerminalNode = secondChildNode,  ///
+          identiierTerminalNodeContent = identiierTerminalNode.getContent(),
+          identifier = identiierTerminalNodeContent; ///
 
     return identifier;
   }

package/src/node/markdown/stronglyEmphasisedText.js

@@ -7,15 +7,25 @@ import ruleNameToHTMLMap from "../../ruleNameToHTMLMap";
 
 import { STRONG_TEXT_RULE_NAME } from "../../ruleNames";
 
-const strongTextHTML = ruleNameToHTMLMap[STRONG_TEXT_RULE_NAME],
-      { tagName: strongTextTagName } = strongTextHTML;
+const { tagName } = ruleNameToHTMLMap[STRONG_TEXT_RULE_NAME];
 
 class StronglyEmphasisedTextMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    let html = super.asHTML(indent, context);
+
+    const childNodesHTML = html,  ///
+          startingTag = `<${tagName}>`,
+          closingTag = `<\\${tagName}>`;
+
+    html = `${startingTag}${childNodesHTML}${closingTag}`;
+
+    return html;
+  }
+
   createDOMElement(context) {
     let domElement = super.createDOMElement(context);
 
-    const childDOMElement = domElement, ///
-          tagName = strongTextTagName; ///
+    const childDOMElement = domElement; ///
 
     domElement = document.createElement(tagName);
 

package/src/node/markdown/tableBodyCell.js

@@ -7,6 +7,15 @@ import MarkdownNode from "../../node/markdown";
 const { first } = arrayUtilities;
 
 export default class TableBodyCellMarkdownNode extends MarkdownNode {
+  childNodesAsHTML(indent, context) {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          tableCellMarkdownNode = firstChildNode, ///
+          childNodesHTML = tableCellMarkdownNode.childNodesAsHTML(indent, context);
+
+    return childNodesHTML;
+  }
+
   createChildNodeDOMElements(context) {
     const domElement = this.getDOMElement(),
           childNodes = this.getChildNodes(),

package/src/node/markdown/tableCell.js

@@ -6,12 +6,14 @@ import MarkdownNode from "../../node/markdown";
 import TextMarkdownNode from "./text";
 
 import { PERIOD } from "../../constants";
-import { domElementsFromChildNodes } from "../../utilities/childNodes";
+import { htmlFromChildNodes, domElementsFromChildNodes } from "../../utilities/childNodes";
 
 const { first } = arrayUtilities;
 
 export default class TableCellMarkdownNode extends MarkdownNode {
-  createChildNodeDOMElements(domElement, context) {
+  isEmpty(context) {
+    let empty = false;
+
     const childNodes = this.getChildNodes(),
           childNodesLength = childNodes.length;
 
@@ -21,20 +23,47 @@ export default class TableCellMarkdownNode extends MarkdownNode {
 
       if (firstChildNodeTextMarkdownNode) {
         const textMarkdownNode = firstChildNode,  ///
-              content = textMarkdownNode.getContent();
+              content = textMarkdownNode.content(context);
 
         if (content === PERIOD) {
-          return;
+          empty = true;
         }
       }
     }
 
-    const domElements = domElementsFromChildNodes(childNodes, context),
+    return empty;
+  }
+
+  childNodesAsHTML(indent, context) {
+    let childNodesHTML = null;
+
+    const empty = this.isEmpty(context);
+
+    if (!empty) {
+      const childNodes = this.getChildNodes(),
+            html = htmlFromChildNodes(childNodes, context);
+
+      childNodesHTML = html;  ///
+    }
+
+    return childNodesHTML;
+  }
+
+  createChildNodeDOMElements(domElement, context) {
+    const empty = this.isEmpty(context);
+
+    if (empty) {
+      return;
+    }
+
+    const childNodes = this.getChildNodes(),
+          domElements = domElementsFromChildNodes(childNodes, context),
           parentDOMElement = domElement,  ///
+          childDOMElements = domElements,  ///
           siblingDOMElement = null;
 
-    domElements.forEach((domElement) => {
-      parentDOMElement.insertBefore(domElement, siblingDOMElement);
+    childDOMElements.forEach((childDOMElement) => {
+      parentDOMElement.insertBefore(childDOMElement, siblingDOMElement);
     });
   }
 

package/src/node/markdown/tableHeadCell.js

@@ -7,6 +7,15 @@ import MarkdownNode from "../../node/markdown";
 const { first } = arrayUtilities;
 
 export default class TableHeadCellMarkdownNode extends MarkdownNode {
+  childNodesAsHTML(indent, context) {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          tableCellMarkdownNode = firstChildNode, ///
+          childNodesHTML = tableCellMarkdownNode.childNodesAsHTML(indent, context);
+
+    return childNodesHTML;
+  }
+
   createChildNodeDOMElements(context) {
     const domElement = this.getDOMElement(),
           childNodes = this.getChildNodes(),

package/src/node/markdown/text.js

@@ -7,7 +7,7 @@ import MarkdownNode from "../../node/markdown";
 const { first } = arrayUtilities;
 
 export default class TextMarkdownNode extends MarkdownNode {
-  getContent() {
+  content(context) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           terminalNode = firstChildNode,  ///

package/src/node/markdown/verticalSpace.js

@@ -1,15 +1,16 @@
 "use strict";
 
-import contentMixins from "../../mixins/content";
-
 import MarkdownNode from "../../node/markdown";
 
 class VerticalSpaceMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    const content = this.getContent(context),
-          domElement = document.createTextNode(content);
+  asHTML(index, context) {
+    const html = null;
+
+    return html;
+  }
 
-    this.setDOMElement(domElement);
+  createDOMElement(context) {
+    const domElement = null;
 
     return domElement;
   }
@@ -17,6 +18,4 @@ class VerticalSpaceMarkdownNode extends MarkdownNode {
   static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(VerticalSpaceMarkdownNode, ruleName, childNodes, ambiguous); }
 }
 
-Object.assign(VerticalSpaceMarkdownNode.prototype, contentMixins);
-
 export default VerticalSpaceMarkdownNode;

package/src/node/markdown.js

@@ -6,6 +6,9 @@ import nodeMixins from "../mixins/node";
 import elementMixins from "../mixins/element";
 import ruleNameToHTMLMap from "../ruleNameToHTMLMap";
 
+import { trim } from "../utilities/string";
+import { EMPTY_STRING } from "../constants";
+
 class MarkdownNode extends NonTerminalNode {
   constructor(ruleName, childNodes, precedence, ambiguous, domElement) {
     super(ruleName, childNodes, precedence, ambiguous);
@@ -22,22 +25,149 @@ class MarkdownNode extends NonTerminalNode {
   }
 
   getTagName() {
-    const html = ruleNameToHTMLMap[this.ruleName],
-          { tagName } = html;
+    const { tagName } = ruleNameToHTMLMap[this.ruleName];
 
     return tagName;
   }
 
   getClassName() {
-    const html = ruleNameToHTMLMap[this.ruleName],
-          { className } = html;
+    const { className } = ruleNameToHTMLMap[this.ruleName];
 
     return className;
   }
 
-  setInnerHTML(innerHTML) { this.domElement.innerHTML = innerHTML; }
+  attributeName() {
+    const attributeName = null;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const attributeValue = null;
+
+    return attributeValue;
+  }
+
+  asHTML(indent, context) {
+    if (context === undefined) {
+      context = indent; ///
+
+      indent = EMPTY_STRING;
+    }
+
+    const tagName = this.getTagName();
+
+    let html = null;
+
+    if (tagName !== null) {
+      indent = this.adjustIndent(indent);
+
+      const childNodesHTML = this.childNodesAsHTML(indent, context);
+
+      if (childNodesHTML !== null) {
+        const startingTag = this.startingTag(context),
+              closingTag = this.closingTag(context);
+
+        html = (indent === null) ?
+                `${startingTag}${trim(childNodesHTML)}${closingTag}` :
+                  `${indent}${startingTag}
+${trim(childNodesHTML)}
+${indent}${closingTag}
+`;
+      } else {
+        const selfClosingTag = this.selfClosingTag(context);
+
+        html = (indent === null) ?
+                selfClosingTag :  ///
+                 `${indent}${selfClosingTag}
+`;
+      }
+    }
+
+    return html;
+  }
+
+  closingTag(context) {
+    const tagName = this.getTagName(),
+          closingTag = `<\\${tagName}>`;
+
+    return closingTag;
+  }
+
+  startingTag(context) {
+    const tagName = this.getTagName(),
+          className = this.getClassName(),
+          attributeName = this.attributeName();
+
+    let classHTML = EMPTY_STRING,
+        attributeHTML = EMPTY_STRING;
+
+    if (className !== null) {
+      classHTML = ` class="${className}"`;
+    }
+
+    if (attributeName !== null) {
+      const attributeValue = this.attributeValue(context);
+
+      attributeHTML = ` ${attributeName}="${attributeValue}"`;
+    }
 
-  setAttribute(name, value) { this.domElement.setAttribute(name, value); }
+    const startingTag = `<${tagName}${classHTML}${attributeHTML}>`;
+
+    return startingTag;
+  }
+
+  selfClosingTag(context) {
+    const tagName = this.getTagName(),
+          className = this.getClassName(),
+          attributeName = this.attributeName();
+
+    let classHTML = EMPTY_STRING,
+        attributeHTML = EMPTY_STRING;
+
+    if (className !== null) {
+      classHTML = ` class="${className}"`;
+    }
+
+    if (attributeName !== null) {
+      const attributeValue = this.attributeValue(context);
+
+      attributeHTML = ` ${attributeName}="${attributeValue}"`;
+    }
+
+    const selfClosingTag = `<${tagName}${classHTML}${attributeHTML}/>`;
+
+    return selfClosingTag;
+  }
+
+  adjustIndent(indent) {
+    if (indent !== null) {
+      indent = `  ${indent}`;
+    }
+
+    return indent;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const childNodes = this.getChildNodes(),
+          childNodesHTML = childNodes.reduce((childNodesHTML, childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const childNodeHTML = childNode.asHTML(indent, context);
+
+              if (childNodeHTML !== null) {
+                childNodesHTML = (childNodesHTML === null) ?
+                                   childNodeHTML :  ///
+                                    `${childNodesHTML}${childNodeHTML}`;
+              }
+            }
+
+            return childNodesHTML;
+          }, null);
+
+    return childNodesHTML;
+  }
 
   createDOMElement(context) {
     let domElement = null;
@@ -47,7 +177,10 @@ class MarkdownNode extends NonTerminalNode {
     if (tagName !== null) {
       domElement = document.createElement(tagName);
 
-      const className = this.getClassName();
+      this.setDOMElement(domElement);
+
+      const className = this.getClassName(),
+            attributeName = this.attributeName();
 
       if (className !== null) {
         Object.assign(domElement, {
@@ -55,7 +188,11 @@ class MarkdownNode extends NonTerminalNode {
         });
       }
 
-      this.setDOMElement(domElement);
+      if (attributeName !== null) {
+        const attributeValue = this.attributeValue(context);
+
+        domElement.setAttribute(attributeName, attributeValue);
+      }
 
       this.createChildNodeDOMElements(context);
     }
@@ -70,10 +207,10 @@ class MarkdownNode extends NonTerminalNode {
       const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
       if (childNodeNonTerminalNode) {
-        const domElement = childNode.createDOMElement(context);
+        const childNodeDOMElement = childNode.createDOMElement(context);
 
-        if (domElement !== null) {
-          this.insertDOMElement(domElement);
+        if (childNodeDOMElement !== null) {
+          this.insertDOMElement(childNodeDOMElement);
         }
       }
     });

package/src/ruleNameToHTMLMap.js

@@ -75,7 +75,7 @@ const ruleNameToHTMLMap = {
     className: "error"
   },
   [ANCHOR_RULE_NAME]: {
-    tagName: "A",
+    tagName: "a",
     className: "anchor"
   },
   [DOCUMENT_RULE_NAME]: {

package/src/utilities/childNodes.js

@@ -4,6 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import TextMarkdownNode from "../node/markdown/text";
 
+import { EMPTY_STRING } from "../constants";
 import { contentFromMarkdownNodes } from "./content";
 
 const { clear } = arrayUtilities;
@@ -51,6 +52,51 @@ export function domElementsFromChildNodes(childNodes, context) {
   return domElements;
 }
 
+export function htmlFromChildNodes(childNodes, context) {
+  let html;
+
+  const htmls = [],
+        textMarkdownNodes = [];
+
+  childNodes.forEach((childNode) => {
+    const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+    if (childNodeNonTerminalNode) {
+      const childNodeTextMarkdownNode = (childNode instanceof TextMarkdownNode);
+
+      if (childNodeTextMarkdownNode) {
+        const textMarkdownNode = childNode; ///
+
+        textMarkdownNodes.push(textMarkdownNode);
+      } else {
+        html = htmlFromTextMarkdownNodes(textMarkdownNodes, context)
+
+        if (html !== null) {
+          htmls.push(html);
+        }
+
+        const indent = null;
+
+        html = childNode.asHTML(indent, context);
+
+        if (html !== null) {
+          htmls.push(html);
+        }
+      }
+    }
+  });
+
+  html = htmlFromTextMarkdownNodes(textMarkdownNodes, context)
+
+  if (html !== null) {
+    htmls.push(html);
+  }
+
+  html = htmls.join(EMPTY_STRING);
+
+  return html;
+}
+
 function textDOMElementFromTextMarkdownNodes(textMarkdownNodes, context) {
   let textDOMElement = null;
 
@@ -68,3 +114,19 @@ function textDOMElementFromTextMarkdownNodes(textMarkdownNodes, context) {
   return textDOMElement;
 }
 
+function htmlFromTextMarkdownNodes(textMarkdownNodes, context) {
+  let html = null;
+
+  const textMarkdownNodesLength = textMarkdownNodes.length;
+
+  if (textMarkdownNodesLength > 0) {
+    const markdownNodes = textMarkdownNodes,  ///
+          content = contentFromMarkdownNodes(markdownNodes, context);
+
+    html = content;
+
+    clear(textMarkdownNodes);
+  }
+
+  return html;
+}

package/src/utilities/link.js

@@ -1,24 +1,67 @@
 "use strict";
 
+import { stringUtilities } from "necessary";
+
+import { EMPTY_STRING } from "../constants";
+import { chop, splice } from "../utilities/string";
 import { linkMarkdownNodesFromNode } from "../utilities/query";
 
-export function renumberLinkMarkdownNodes(documentMarkdownNode, footnotesListMarkdownNode) {
+const { strlen, indexOf } = stringUtilities;
+
+export function renumberLinkMarkdownNodesHTML(childNodesHTML, documentMarkdownNode, footnotesListMarkdownNode, context) {
+  let number = 1;
+
+  const identifiers = footnotesListMarkdownNode.identifiers(),
+        linkMarkdownNodes = linkMarkdownNodesFromNode(documentMarkdownNode);
+
+  linkMarkdownNodes.forEach((linkMarkdownNode) => {
+    const indent = null,
+          identifier = linkMarkdownNode.identifier(context),
+          identifiersIncludesIdentifier = identifiers.includes(identifier),
+          linkMarkdownNodeHTML = linkMarkdownNode.asHTML(indent, context),
+          index = indexOf(childNodesHTML, linkMarkdownNodeHTML),
+          length = strlen(linkMarkdownNodeHTML),
+          start = index,  ///
+          deleteCount = length; ///
+
+    if (identifiersIncludesIdentifier) {
+      const linkMarkdownNodeHTML = linkMarkdownNode.asHTML(indent, context, number);
+
+      childNodesHTML = splice(childNodesHTML, start, deleteCount, linkMarkdownNodeHTML);
+
+      number++;
+    } else {
+      childNodesHTML = chop(childNodesHTML, start, deleteCount);
+    }
+  });
+
+  return childNodesHTML;
+}
+
+export function renumberLinkMarkdownNodes(documentMarkdownNode, footnotesListMarkdownNode, context) {
   let number = 1;
 
-  const identifiers = footnotesListMarkdownNode.getIdentifiers(),
+  const identifiers = footnotesListMarkdownNode.identifiers(),
         linkMarkdownNodes = linkMarkdownNodesFromNode(documentMarkdownNode);
 
   linkMarkdownNodes.forEach((linkMarkdownNode) => {
-    const identifier = linkMarkdownNode.getIdentifier(),
+    const identifier = linkMarkdownNode.identifier(context),
+          linkMarkdownNodeDOMElement = linkMarkdownNode.getDOMElement(),
           identifiersIncludesIdentifier = identifiers.includes(identifier);
 
+    let innerHTML;
+
     if (identifiersIncludesIdentifier) {
-      linkMarkdownNode.setNumber(number);
+      innerHTML = `${number}`;
 
       number++;
     } else {
-      linkMarkdownNode.clear();
+      innerHTML = EMPTY_STRING;
     }
+
+    Object.assign(linkMarkdownNodeDOMElement, {
+      innerHTML
+    });
   });
 }