highmark-markdown 0.0.1

package/src/utilities/childNodes.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import TextMarkdownNode from "../node/markdown/text";
+
+import { contentFromMarkdownNodes } from "./content";
+
+const { clear } = arrayUtilities;
+
+export function domElementsFromChildNodes(childNodes, context) {
+  const domElements = [],
+        textMarkdownNodes = [];
+
+  childNodes.forEach((childNode) => {
+    const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+    if (childNodeNonTerminalNode) {
+      const childNodeTextMarkdownNode = (childNode instanceof TextMarkdownNode);
+
+      if (childNodeTextMarkdownNode) {
+        const textMarkdownNode = childNode; ///
+
+        textMarkdownNodes.push(textMarkdownNode);
+      } else {
+        const textDOMElement = textDOMElementFromTextMarkdownNodes(textMarkdownNodes, context)
+
+        if (textDOMElement !== null) {
+          const domElement = textDOMElement;  ///
+
+          domElements.push(domElement);
+        }
+
+        const domElement = childNode.createDOMElement(context);
+
+        if (domElement !== null) {
+          domElements.push(domElement);
+        }
+      }
+    }
+  });
+
+  const textDOMElement = textDOMElementFromTextMarkdownNodes(textMarkdownNodes, context)
+
+  if (textDOMElement !== null) {
+    const domElement = textDOMElement;  ///
+
+    domElements.push(domElement);
+  }
+
+  return domElements;
+}
+
+function textDOMElementFromTextMarkdownNodes(textMarkdownNodes, context) {
+  let textDOMElement = null;
+
+  const textMarkdownNodesLength = textMarkdownNodes.length;
+
+  if (textMarkdownNodesLength > 0) {
+    const markdownNodes = textMarkdownNodes,  ///
+          content = contentFromMarkdownNodes(markdownNodes, context);
+
+    textDOMElement = document.createTextNode(content);
+
+    clear(textMarkdownNodes);
+  }
+
+  return textDOMElement;
+}
+

package/src/utilities/content.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { EMPTY_STRING } from "../constants";
+import { ESCAPED_TOKEN_TYPE } from "../tokenTypes";
+
+const { first, last } = arrayUtilities;
+
+export function contentFromMarkdownNodes(markdownNodes, context) {
+  let content = EMPTY_STRING;
+
+  let { tokens } = context;
+
+  const markdownNodesLength = markdownNodes.length,
+        firstMarkdownNode = first(markdownNodes),
+        lastMarkdownNode = (markdownNodesLength === 1) ?
+                               firstMarkdownNode : ///
+                                 last(markdownNodes),
+        firstSignificantToken = firstMarkdownNode.getFirstSignificantToken(),
+        lastSignificantToken = lastMarkdownNode.getLastSignificantToken(),
+        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken);
+
+  let firstTokenIndex = firstSignificantTokenIndex,  ///
+      lastTokenIndex = lastSignificantTokenIndex; ///
+
+  const previousTokenIndex = firstTokenIndex - 1,
+        nextTokenIndex = lastTokenIndex + 1;
+
+  if (previousTokenIndex > -1) {
+    const previousToken = tokens[previousTokenIndex],
+          previousTokenSignificant = previousToken.isSignificant();
+
+    if (!previousTokenSignificant) {
+      firstTokenIndex--;
+    }
+  }
+
+  const tokensLength = tokens.length;
+
+  if (nextTokenIndex < tokensLength) {
+    const nextToken = tokens[nextTokenIndex],
+          nextTokenSignificant = nextToken.isSignificant();
+
+    if (!nextTokenSignificant) {
+      lastTokenIndex++;
+    }
+  }
+
+  const start = firstTokenIndex,  ///
+        end = lastTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);
+
+  tokens.forEach((token) => {
+    const tokenContent = tokenContentFromToken(token);
+
+    content += tokenContent;
+  });
+
+  return content;
+}
+
+function tokenContentFromToken(token) {
+  let tokenContent = token.getContent();
+
+  const type = token.getType();
+
+  if (type === ESCAPED_TOKEN_TYPE) {
+    const start = 1;
+
+    tokenContent = tokenContent.substring(start);
+  }
+
+  return tokenContent;
+}

package/src/utilities/link.js

@@ -0,0 +1,27 @@
+"use strict";
+
+import { linkMarkdownNodesFromNode } from "../utilities/query";
+
+export function renumberLinkMarkdownNodes(documentMarkdownNode, footnotesListMarkdownNode) {
+  let number = 1;
+
+  const identifiers = footnotesListMarkdownNode.getIdentifiers(),
+        linkMarkdownNodes = linkMarkdownNodesFromNode(documentMarkdownNode);
+
+  linkMarkdownNodes.forEach((linkMarkdownNode) => {
+    const identifier = linkMarkdownNode.getIdentifier(),
+          identifiersIncludesIdentifier = identifiers.includes(identifier);
+
+    if (identifiersIncludesIdentifier) {
+      linkMarkdownNode.setNumber(number);
+
+      number++;
+    } else {
+      linkMarkdownNode.clear();
+    }
+  });
+}
+
+export default {
+  renumberLinkMarkdownNodes
+};

package/src/utilities/node.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { rulesUtilities } from "occam-parsers";
+
+const { rulesFromStartRuleAndRuleMap } = rulesUtilities;
+
+export function setNonTerminalNodes(parser, nodeMap) {
+  const startRule = parser.getStartRule(),
+        ruleMap = parser.getRuleMap(),
+        rules = rulesFromStartRuleAndRuleMap(startRule, ruleMap);
+
+  rules.forEach((rule) => {
+    const ruleName = rule.getName(),
+          MarkdownNode = nodeMap[ruleName],
+          NonTerminalNode = MarkdownNode; ///
+
+    rule.setNonTerminalNode(NonTerminalNode);
+  });
+}
+
+export default {
+  setNonTerminalNodes
+};

package/src/utilities/query.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { Query } from "occam-query";
+import { arrayUtilities } from "necessary";
+
+const { push } = arrayUtilities;
+
+const linkMarkdownNodesQuery = Query.fromExpression(`//link`),
+      footnoteMarkdownNodesQuery = Query.fromExpression(`//footnote`),
+      referenceMarkdownNodesQuery = Query.fromExpression(`//reference`);
+
+export function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);
+
+  return linkMarkdownNodes;
+}
+
+export function footnoteMarkdownNodesFromNode(node, footnoteMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, footnoteMarkdownNodesQuery, footnoteMarkdownNodes);
+
+  return footnoteMarkdownNodes;
+}
+
+export function referenceMarkdownNodesFromNode(node, referenceMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, referenceMarkdownNodesQuery, referenceMarkdownNodes);
+
+  return referenceMarkdownNodes;
+}
+
+export default {
+  linkMarkdownNodesFromNode,
+  footnoteMarkdownNodesFromNode,
+  referenceMarkdownNodesFromNode
+};
+
+function nodesFromNodeAndQuery(node, query, nodes) {
+  const queryNodes = query.execute(node);
+
+  push(nodes, queryNodes);
+
+  return nodes;
+}