highmark-occam 1.0.1

package/src/prettyPrinter.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+import { juliaMonoFontMixin, editorScheme, prettyPrinterScheme } from "occam-styles";
+
+import LinesDiv from "./div/lines";
+
+import { padding, fontSize } from "./styles";
+
+const { borderColour } = editorScheme,
+      { backgroundColour } = prettyPrinterScheme;
+
+class PrettyPrinter extends Element {
+  constructor(selector, document) {
+    super(selector);
+
+    this.document = document;
+  }
+
+  getDocument() {
+    return this.document;
+  }
+
+  childElements() {
+    return (
+
+      <LinesDiv document={this.document} />
+
+    );
+  }
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "pretty-printer"
+  };
+}
+
+export default withStyle(PrettyPrinter)`
+
+  width: 100%;
+  border: 1px solid ${borderColour};
+  padding: ${padding};
+  font-size: ${fontSize};
+  tab-size: 2;
+  overflow: hidden;
+  user-select: none;
+  background-color: ${backgroundColour};
+
+  ${juliaMonoFontMixin}
+
+`;

package/src/styles.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export const padding = "1rem";
+export const fontSize = "13px";

package/src/token/overlay/common/content.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { contentOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ContentOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = contentOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(ContentOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/common/error.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { errorOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ErrorOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = errorOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(ErrorOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/common/labelName.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TerminalNodeOverlayToken from "../../../token/overlay/terminalNode";
+
+import { labelNameOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class LabelNameOverlayToken extends TerminalNodeOverlayToken {
+  static type = labelNameOverlayTokenType;
+
+  static fromContentAndTerminalNode(content, terminalNode) { return TerminalNodeOverlayToken.fromContentAndTerminalNode(LabelNameOverlayToken, content, terminalNode); }
+}

package/src/token/overlay/common/nonsense.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { nonsenseOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class NonsenseOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = nonsenseOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(NonsenseOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/common/procedureReferenceName.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TerminalNodeOverlayToken from "../../../token/overlay/terminalNode";
+
+import { procedureReferenceNameOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ProcedureReferenceNameOverlayToken extends TerminalNodeOverlayToken {
+  static type = procedureReferenceNameOverlayTokenType;
+
+  static fromContentAndTerminalNode(content, terminalNode) { return TerminalNodeOverlayToken.fromContentAndTerminalNode(ProcedureReferenceNameOverlayToken, content, terminalNode); }
+}

package/src/token/overlay/common/referenceName.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TerminalNodeOverlayToken from "../../../token/overlay/terminalNode";
+
+import { referenceNameOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ReferenceNameOverlayToken extends TerminalNodeOverlayToken {
+  static type = referenceNameOverlayTokenType;
+
+  static fromContentAndTerminalNode(content, terminalNode) { return TerminalNodeOverlayToken.fromContentAndTerminalNode(ReferenceNameOverlayToken, content, terminalNode); }
+}

package/src/token/overlay/common/stuff.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { stuffOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class StuffOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = stuffOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(StuffOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdown/heading.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { headingOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class HeadingOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = headingOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(HeadingOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdown/link.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { linkOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class LinkOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = linkOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(LinkOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdown/listing.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { listingOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ListingOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = listingOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(ListingOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdown/path.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { pathOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class PathOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = pathOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(PathOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdown/reference.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { referenceOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ReferenceOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = referenceOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(ReferenceOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdown/table.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { tableOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class TableOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = tableOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(TableOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdownStyle/name.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { nameOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class NameOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = nameOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(NameOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/markdownStyle/value.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import NonTerminalNodeOverlayToken from "../../../token/overlay/nonTerminalNode";
+
+import { valueOverlayTokenType } from "../../../overlayTokenTypes";
+
+export default class ValueOverlayToken extends NonTerminalNodeOverlayToken {
+  static type = valueOverlayTokenType;
+
+  static fromContentAndNonTerminalNode(content, nonTerminalNode) { return NonTerminalNodeOverlayToken.fromContentAndNonTerminalNode(ValueOverlayToken, content, nonTerminalNode); }
+}

package/src/token/overlay/nonTerminalNode.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { SignificantToken } from "occam-lexers";
+
+export default class NonTerminalNodeOverlayToken extends SignificantToken {
+  constructor(type, content, significant, nonTerminalNode) {
+    super(type, content, significant)
+
+    this.nonTerminalNode = nonTerminalNode;
+  }
+
+  getNonTerminalNode() {
+    return this.nonTerminalNode;
+  }
+
+  static fromContentAndNonTerminalNode(Class, content, nonTerminalNode) { return SignificantToken.fromContent(Class, content, nonTerminalNode); }
+}

package/src/token/overlay/terminalNode.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { SignificantToken } from "occam-lexers";
+
+export default class TerminalNodeOverlayToken extends SignificantToken {
+  constructor(type, content, significant, terminalNode) {
+    super(type, content, significant)
+
+    this.terminalNode = terminalNode;
+  }
+
+  getTerminalNode() {
+    return this.terminalNode;
+  }
+
+  static fromContentAndTerminalNode(Class, content, terminalNode) { return SignificantToken.fromContent(Class, content, terminalNode); }
+}

package/src/utilities/character.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { styles } from "occam-styles";
+
+const { juliaMonoLineHeight } = styles;
+
+export function characterHeightFromFontSize(fontSize) {
+  const characterHeight = juliaMonoLineHeight * fontSize;
+
+  return characterHeight;
+}

package/src/utilities/customGrammars.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { customGrammarUtilities } from "occam-custom-grammars";
+
+const { combinedCustomGrammarFromJSON } = customGrammarUtilities;
+
+let map = {};
+
+export function registerCustomGrammarsMap(customGrammarsJSONMap) {
+  map = customGrammarsJSONMap;  ///
+}
+
+export function registerCustomGrammarsJSON(releaseName, customGrammarsJSON) {
+  map[releaseName] = customGrammarsJSON;
+}
+
+export function combinedCustomGrammarFromReleaseName(releaseName) {
+  let combinedCustomGrammar = null;
+
+  const customGrammarsJSON = map[releaseName] || null;
+
+  if (customGrammarsJSON !== null) {
+    const json = customGrammarsJSON;  ///
+
+    combinedCustomGrammar = combinedCustomGrammarFromJSON(json);
+  }
+
+  return combinedCustomGrammar;
+}
+
+export default {
+  registerCustomGrammarsMap,
+  registerCustomGrammarsJSON
+}

package/src/utilities/document.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import BNFDcoument from "../document/bnf";
+import JSONDocument from "../document/json";
+import FurtleDocument from "../document/furtle";
+import NominalDocument from "../document/nominal";
+import MarkdownDocument from "../document/markdown";
+import PlainTextDocument from "../document/plainText";
+import MarkdownStyleDocument from "../document/markdownStyle";
+
+import { BNF_DOCUMENT_TYPE,
+         JSON_DOCUMENT_TYPE,
+         FURTLE_DOCUMENT_TYPE,
+         NOMINAL_DOCUMENT_TYPE,
+         MARKDOWN_DOCUMENT_TYPE,
+         PLAIN_TEXT_DOCUMENT_TYPE,
+         MARKDOWN_STYLE_DOCUMENT_TYPE } from "../documentTypes";
+
+export function documentFromContentLanguageNameAndReleaseName(content, languageName, releaesName) {
+  let document;
+
+  const type = languageName;  ///
+
+  if (type === NOMINAL_DOCUMENT_TYPE) {
+    const nominalDocument = NominalDocument.fromContentAndReleaseName(content, releaesName);
+
+    document = nominalDocument; ///
+  } else {
+    let Document;
+
+    switch (type) {
+      case BNF_DOCUMENT_TYPE: Document = BNFDcoument; break;
+      case JSON_DOCUMENT_TYPE: Document = JSONDocument; break;
+      case FURTLE_DOCUMENT_TYPE: Document = FurtleDocument; break;
+      case MARKDOWN_DOCUMENT_TYPE: Document = MarkdownDocument; break;
+      case PLAIN_TEXT_DOCUMENT_TYPE: Document = PlainTextDocument; break;
+      case MARKDOWN_STYLE_DOCUMENT_TYPE: Document = MarkdownStyleDocument; break;
+    }
+
+    document = Document.fromContent(content);
+  }
+
+  return document;
+}

package/src/utilities/grammar.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import { HTMLNode, TopmostHTMLNode, grammarUtilities } from "highmark-markdown";
+
+import htmlNodeMap from "../map/node/html";
+
+const { tokensFromMarkdown,
+        documentMarkdownNodeFromTokens,
+        topmostHTMLNodeFromDocumentMarkdownNode: topmostHTMLNodeFromDocumentMarkdownNodeBase } = grammarUtilities;
+
+export function HTMLClassFromMarkdownNode(markdownNode) {
+  let Class;
+
+  if (markdownNode === null) {
+    Class = TopmostHTMLNode;  ///
+  } else {
+    const nonTerminalNode = markdownNode,  ///
+          ruleName = nonTerminalNode.getRuleName();
+
+    Class = htmlNodeMap[ruleName] || HTMLNode;
+  }
+
+  return Class;
+}
+
+export function topmostHTMLNodeFromDocumentMarkdownNode(markdownNode) {
+  const ClassFromOuterNode = HTMLClassFromMarkdownNode, ///
+        topmostHTMLNode = topmostHTMLNodeFromDocumentMarkdownNodeBase(markdownNode, ClassFromOuterNode);
+
+  return topmostHTMLNode;
+}
+
+export default {
+  tokensFromMarkdown,
+  documentMarkdownNodeFromTokens,
+  HTMLClassFromMarkdownNode,
+  topmostHTMLNodeFromDocumentMarkdownNode
+};

package/src/utilities/lines.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import Line from "../line";
+
+export function linesFromContent(content, lexer) {
+  const lines = [],
+        contentsAndEndOfLines = content.split(/(\r\n|\r|\n)/),
+        contentsAndEndOfLinesLength = contentsAndEndOfLines.length,
+        length = (contentsAndEndOfLinesLength + 1) / 2;
+
+  for (let index = 0; index < length; index++) {
+    const contentIndex = index * 2,
+          endOfLineIndex = contentIndex + 1,
+          endOfLine = contentsAndEndOfLines[endOfLineIndex] || null;
+
+    let content = contentsAndEndOfLines[contentIndex];
+
+    if (endOfLine !== null) {
+      content += endOfLine;
+    }
+
+    const line = Line.fromContent(content);
+
+    line.tokenise(lexer);
+
+    lines.push(line);
+  }
+
+  return lines;
+}
+

package/src/utilities/query.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { Query } from "occam-query";
+
+export function queriesFromExpressionStrings(expressionStrings) {
+  const queries = expressionStrings.map((expressionString) => {
+    const query = Query.fromExpressionString(expressionString);
+
+    return query;
+  });
+
+  return queries;
+}

package/src/utilities/tokens.js

@@ -0,0 +1,12 @@
+"use strict";
+
+export function tokensFromLines(lines) {
+  const tokens = [];
+
+  lines.forEach((line) => {
+    line.getTokens(tokens);
+  });
+
+  return tokens;
+}
+