highmark-occam 1.0.1

package/src/example/customGrammarsJSON/firstOrderLogic.js

@@ -0,0 +1,18 @@
+"use strict";
+
+export default [
+  {
+    "name": "Default",
+    "termBNF": "term                                 ::=  \"(\" argument \")\"\n\n                                       |  variable \n                                       \n                                       ;",
+    "statementBNF": "statement                            ::=  \"(\" metaArgument \")\" \n                                                  \n                                       |  equality\n\n                                       |  judgement\n\n                                       |  typeAssertion \n                                                  \n                                       |  definedAssertion  \n\n                                       |  containedAssertion  \n                                       \n                                       |  signatureAssertion\n\n                                       |  subproofAssertion         \n\n                                       |  propertyAssertion  \n\n                                       |  metavariable ( frameSubstitution | termSubstitution )?\n\n                                       ;\n\nequality                             ::=  term \"=\" term ;\n\ntypeAssertion                        ::=  term \":\" type ;\n\ndefinedAssertion                     ::=  ( frame | term ) \"is\" ( \"defined\" | \"undefined\" ) ;\n\ncontainedAssertion                   ::=  ( frame | term ) \"is\" ( \"present\" | \"missing\" ) \"in\" statement ;\n\nsignatureAssertion                   ::=  signature \"satisfies\" metavariable ;  \n\nsubproofAssertion                    ::=  \"[\" statement ( \",\" statement )* \"]\" \"...\" statement ;\n\npropertyAssertion                    ::=  term \"is\" ( \"a\" | \"an\" ) propertyRelation ;\n\npropertyRelation                     ::=  property \"of\" term ;\n\njudgement                            ::=  frame \"|\"<NO_WHITESPACE>\"-\" assumption ;\n\nframe                                ::=  \"[\" ( ( metavariable | assumption ) ( \",\" assumption )* ) \"]\" ;\n \nassumption                           ::=  metavariable \"::\" statement ;\n\nmetaLevelAssumption                  ::=  reference \"::\" statement ;\n\ntermSubstitution                     ::=  \"[\" term \"for\" term \"]\" ;\n\nframeSubstitution                    ::=  \"[\" frame \"for\" frame \"]\" ;\n\nstatementSubstitution                ::=  \"[\" statement \"for\" statement \"]\" ;\n\nreferenceSubstitution                ::=  \"[\" reference \"for\" reference \"]\" ;",
+    "typeVocabulary": "",
+    "symbolVocabulary": ""
+  },
+  {
+    "name": "first-order-logic",
+    "termBNF": "",
+    "statementBNF": "\n\n                              statement  ::=  ( \"∀\" | \"∃\" )<NO_WHITESPACE>( frameArgument | argument ) metaArgument \n\n                                           |  ( frameArgument | argument ) \"is\" ( \"𝘣𝘰𝘶𝘯𝘥\" | \"𝘧𝘳𝘦𝘦\" ) \"in\" metaArgument\n\n                                           ;\n\n",
+    "typeVocabulary": "",
+    "symbolVocabulary": "𝘣𝘰𝘶𝘯𝘥\n𝘧𝘳𝘦𝘦\n∀\n∃\n"
+  }
+];

package/src/example/preamble.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { customGrammarsUtilities } from "../index"; ///
+
+import firstOrderLogicCustomGrammarsJSON from "./customGrammarsJSON/firstOrderLogic";
+
+const { registerCustomGrammarsMap } = customGrammarsUtilities;
+
+const customGrammarsJSONMap = {
+  "first-order-logic": firstOrderLogicCustomGrammarsJSON
+}
+
+registerCustomGrammarsMap(customGrammarsJSONMap);

package/src/example/view/div/column.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { ColumnDiv } from "easy-layout";
+
+export default withStyle(ColumnDiv)`
+
+  position: relative;
+  
+`;

package/src/example/view/div/markdown.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import withStyle from "easy-with-style";
+
+import { Element } from "easy";
+import { grammarUtilities } from "../../../index";  ///
+
+const { topmostHTMLNodeFromDocumentMarkdownNode } = grammarUtilities;
+
+class MarkdownDiv extends Element {
+  clear() {
+    const topmostHTMLNode = this.getTopmostHTMLNode();
+
+    if (topmostHTMLNode !== null) {
+      const domElement = this.getDOMElement(),
+            parentDOMElement = domElement,  ///
+            context = null;
+
+      topmostHTMLNode.unmount(parentDOMElement, context);
+
+      this.clearTopmostHTMLNode();
+    }
+  }
+
+  update(documentMarkdownNode, tokens) {
+    if (documentMarkdownNode === null) {
+      return;
+    }
+
+    const domElement = this.getDOMElement(),
+          parentDOMElement = domElement,  ///
+          siblingDOMElement = null,
+          context = {
+            tokens
+          },
+          topmostHTMLNode = topmostHTMLNodeFromDocumentMarkdownNode(documentMarkdownNode);
+
+    topmostHTMLNode.mount(parentDOMElement, siblingDOMElement, context);
+
+    this.setTopmostHTMLNode(topmostHTMLNode);
+  }
+
+  clearTopmostHTMLNode() {
+    const topmostHTMLNode = null;
+
+    this.setTopmostHTMLNode(topmostHTMLNode);
+  }
+
+  getTopmostHTMLNode() {
+    const { topmostHTMLNode } = this.getState();
+
+    return topmostHTMLNode;
+  }
+
+  setTopmostHTMLNode(topmostHTMLNode) {
+    this.updateState({
+      topmostHTMLNode
+    });
+  }
+
+  setInitialState() {
+    const topmostHTMLNode = null;
+
+    this.setState({
+      topmostHTMLNode
+    });
+  }
+
+  parentContext() {
+    const clearMarkdownDiv = this.clear.bind(this),
+          updateMarkdownDiv = this.update.bind(this);
+
+    return ({
+      clearMarkdownDiv,
+      updateMarkdownDiv
+    });
+  }
+
+  initialise() {
+    this.setInitialState();
+  }
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "markdown"
+  };
+}
+
+export default withStyle(MarkdownDiv)`
+
+  width: 100%;
+  height: 100%;
+  border: 1px solid darkgrey;
+  padding: 0.25rem;
+  position: absolute;
+  
+  
+`;

package/src/example/view/div/sizeable.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { SizeableDiv } from "easy-layout";
+
+export default withStyle(SizeableDiv)`
+
+  width: 64rem;
+  min-width: 12rem;
+  
+`;

package/src/example/view/heading.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+const Heading = withStyle.h1`
+
+  font-size: 3rem;
+  text-align: center;
+  margin-top: 1rem;
+  margin-bottom: 1rem;
+
+`;
+
+export default Heading;

package/src/example/view/input.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Input } from "easy";
+
+export default withStyle(Input)`
+
+  border: 1px solid darkgrey;
+  padding: 0.25rem;
+  font-size: 1.2rem;
+  line-height: 1.5rem;
+  font-family: monospace;
+
+`;

package/src/example/view/listing.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import withStyle from "easy-with-style";
+
+import Listing from "../../listing";
+
+import { listingPadding } from "../styles";
+
+export default withStyle(Listing)`
+
+  border: 0;
+  padding: ${listingPadding};
+  
+`;

package/src/example/view/subHeading.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+const SubHeading = withStyle.h2`
+
+  margin: 1rem 0 0.5rem 0;
+  font-size: 2rem;
+  
+  :first-of-type {
+    margin-top: 0;
+  }
+
+`;
+
+export default SubHeading;

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

@@ -0,0 +1,43 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import Textarea from "../textarea";
+
+class ContentTextarea extends Textarea {
+  getContent() {
+    const value = this.getValue(),
+          content = value; ///
+
+    return content;
+  }
+
+  setContent(content) {
+    const value = content;
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const getContent = this.getContent.bind(this),
+          setContent = this.setContent.bind(this),
+          focusContentTextarea = this.focus.bind(this);
+
+    return ({
+      getContent,
+      setContent,
+      focusContentTextarea
+    });
+  }
+
+  static defaultProperties = {
+    className: "content",
+    spellCheck: "false"
+  };
+}
+
+export default withStyle(ContentTextarea)`
+
+  height: 64rem;
+  
+`;

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,93 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Element } from "easy";
+import { grammarUtilities } from "../index"; ///
+import { RowsDiv, ColumnsDiv, VerticalSplitterDiv } from "easy-layout";
+
+import ColumnDiv from "./view/div/column";
+import SubHeading from "./view/subHeading";
+import SizeableDiv from "./view/div/sizeable";
+import MarkdownDiv from "./view/div/markdown";
+import ContentTextarea from "./view/textarea/content";
+
+const { tokensFromMarkdown, documentMarkdownNodeFromTokens } = grammarUtilities;
+
+class View extends Element {
+  keyUpHandler = (event, element) => {
+    this.update();
+  }
+
+  update() {
+    const content = this.getContent(),
+          markdown = content, ///
+          tokens = tokensFromMarkdown(markdown),
+          documentMarkdownNode = documentMarkdownNodeFromTokens(tokens);
+
+    this.clearMarkdownDiv();
+
+    this.updateMarkdownDiv(documentMarkdownNode, tokens);
+
+    this.focusContentTextarea();
+  }
+
+  didMount() {
+    this.update();
+  }
+
+  willUnmount() {
+    ///
+  }
+
+  childElements() {
+    return (
+
+      <ColumnsDiv>
+        <SizeableDiv>
+          <RowsDiv>
+            <SubHeading>
+              Content
+            </SubHeading>
+            <ContentTextarea onKeyUp={this.keyUpHandler} />
+          </RowsDiv>
+        </SizeableDiv>
+        <VerticalSplitterDiv/>
+        <ColumnDiv>
+          <MarkdownDiv/>
+        </ColumnDiv>
+      </ColumnsDiv>
+
+    );
+  }
+
+  initialise() {
+    this.assignContext();
+
+    const content = `\`\`\`nominal:first-order-logic
+Lemma
+  Suppose
+    [F] |- R :: S
+  Then
+    ∃[G] [G] |- R :: S
+  Proof
+    [G] is 𝘧𝘳𝘦𝘦 in [G] |- R :: S by FreeMetavariable
+  Therefore
+    ∃[G] [G] |- R :: S by MetaExistentialIntroduction
+\`\`\``;
+
+    this.setContent(content);
+  }
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "view"
+  };
+}
+
+export default withStyle(View)`
+
+  padding: 1rem;
+  
+`;

package/src/example.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import "juxtapose";
+
+import withStyle from "easy-with-style";  ///
+
+import { Body } from "easy";
+import { juliaMonoStyle, prettyPrinterStyle } from "occam-styles";
+
+import "./example/preamble";
+
+import View from "./example/view";
+
+const { renderStyle, renderStyles } = withStyle;
+
+const body = new Body();
+
+renderStyles();
+
+renderStyle(prettyPrinterStyle);
+
+renderStyle(juliaMonoStyle);
+
+body.mount(
+
+  <View/>
+
+);

package/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { default as BlockListing } from "./blockListing";
+export { default as grammarUtilities } from "./utilities/grammar";
+export { default as customGrammarsUtilities } from "./utilities/customGrammars";

package/src/line.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { push } = arrayUtilities;
+
+export default class Line {
+  constructor(tokens, content) {
+    this.tokens = tokens;
+    this.content = content;
+  }
+
+  getTokens(tokens = []) {
+    push(tokens, this.tokens);
+
+    return tokens;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  tokenise(lexer) {
+    this.tokens = lexer.tokenise(this.content);
+  }
+
+  asHTML() {
+    const html = this.tokens.reduce((html, token) => {
+      const tokenHTML = token.asHTML();
+
+      html = (html !== null) ?
+               `${html}${tokenHTML}` :
+                 tokenHTML;  ///
+
+      return html;
+    }, null);
+
+    return html;
+  }
+
+  static fromContent(content) {
+    const tokens = null,
+          line = new Line(tokens, content);
+
+    return line;
+  }
+}

package/src/map/node/html.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { htmlNodeMap as htmlNodeMapBase, markdownRuleNames } from "highmark-markdown";
+
+import BlockListingHTMLNode from "../../node/html/listing/block";
+
+const { BLOCK_LISTING_MARKDOWN_RULE_NAME } = markdownRuleNames;
+
+const htmlNodeMap = Object.assign({}, htmlNodeMapBase, {
+  [BLOCK_LISTING_MARKDOWN_RULE_NAME]: BlockListingHTMLNode
+});
+
+export default htmlNodeMap;

package/src/node/html/listing/block.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import { BlockListingHTMLNode as BlockListingHTMLNodeBase } from "highmark-markdown";
+
+import BlockListing from "../../../blockListing";
+
+import { documentFromContentLanguageNameAndReleaseName } from "../../../utilities/document";
+
+export default class BlockListingHTMLNode extends BlockListingHTMLNodeBase {
+  constructor(outerNode, parentNode, childNodes, domElement, blockListing) {
+    super(outerNode, parentNode, childNodes, domElement);
+
+    this.blockListing = blockListing;
+  }
+
+  getBlockListing() {
+    return this.blockListing;
+  }
+
+  content(context) {
+    let content = super.content(context);
+
+    content = `${content}
+`;
+
+    return content;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.blockListing = this.createBlockListing(context);
+
+    siblingDOMElement = this.blockListing.mount(parentDOMElement, siblingDOMElement, context);
+
+    return siblingDOMElement;
+  }
+
+  unmount(parentDOMElement, context) {
+    this.blockListing.unmount(parentDOMElement, context);
+
+    this.blockListing = null;
+  }
+
+  createBlockListing(context) {
+    const content = this.content(context),
+          markdownNode = this.getMarkdownNode(),
+          languageName = markdownNode.languageName(context),
+          releaseName = markdownNode.releaseName(context),
+          document = documentFromContentLanguageNameAndReleaseName(content, languageName, releaseName),
+          properties = {},
+          blockListing = BlockListing.fromClass(properties, document);
+
+    return blockListing;
+  }
+
+  static fromNothing() {
+    const blockListing = null,
+          blockListingHTMLNode = BlockListingHTMLNodeBase.fromNothing(BlockListingHTMLNode, blockListing);
+
+    return blockListingHTMLNode;
+  }
+
+  static fromOuterNode(outerNode) {
+    const blockListing = null,
+          blockListingHTMLNode = BlockListingHTMLNodeBase.fromOuterNode(BlockListingHTMLNode, outerNode, blockListing);
+
+    return blockListingHTMLNode;
+  }
+}

package/src/overlay.js

@@ -0,0 +1,87 @@
+"use strict";
+
+import { EMPTY_STRING } from "./constants";
+import { queriesFromExpressionStrings } from "./utilities/query";
+
+export default class Overlay {
+  constructor(weakMap) {
+    this.weakMap = weakMap;
+  }
+
+  getWeakMap() {
+    return this.weakMap;
+  }
+
+  lineAsHTML(line) {
+    let html = EMPTY_STRING;
+
+    const tokens = line.getTokens();
+
+    tokens.forEach((token) => { ///
+      const overlayToken = this.weakMap.get(token) || null;
+
+      if (overlayToken !== null) {
+        const overlayTokenHTML = overlayToken.asHTML();
+
+        html += overlayTokenHTML;
+      } else {
+        const tokenHTML = token.asHTML();
+
+        html += tokenHTML;
+      }
+
+      return html;
+    });
+
+    return html;
+  }
+
+  static fromNodeAndOverlayTokenMap(node, overlayTokenMap) {
+    const weakMap = weakMapFromNodeAndOverlayTokenMap(node, overlayTokenMap),
+          overlay = new Overlay(weakMap);
+
+    return overlay;
+  }
+}
+
+function weakMapFromNodeAndOverlayTokenMap(node, overlayTokenMap) {
+  const weakMap = new WeakMap();
+
+  if (node !== null) {
+    const expressionStrings = Object.keys(overlayTokenMap),
+          OverlayTokens = Object.values(overlayTokenMap),
+          queries = queriesFromExpressionStrings(expressionStrings);
+
+    OverlayTokens.forEach((OverlayToken, index) => {
+      const query = queries[index],
+            nodes = query.execute(node);
+
+      nodes.forEach((node) => {
+        const nodeTerminalNode = node.isTerminalNode();
+
+        if (nodeTerminalNode) {
+          const terminalNode = node,  ///
+                significantToken = terminalNode.getSignificantToken(),
+                content = significantToken.getContent(),
+                overlayToken = OverlayToken.fromContentAndTerminalNode(content, terminalNode),
+                overlaidToken = significantToken; ///
+
+          weakMap.set(overlaidToken, overlayToken);
+        } else {
+          const nonTerminalNode = node,
+                significantTokens = nonTerminalNode.getSignificantTokens();
+
+          significantTokens.forEach((significantToken) => {
+            const content = significantToken.getContent(),
+                  overlayToken = OverlayToken.fromContentAndNonTerminalNode(content, nonTerminalNode),
+                  overlaidToken = significantToken; ///
+
+            weakMap.set(overlaidToken, overlayToken);
+          });
+        }
+      });
+    });
+  }
+
+  return weakMap;
+}

package/src/overlayTokenTypes.js

@@ -0,0 +1,33 @@
+"use strict";
+
+export const pathOverlayTokenType = "path overlay";
+export const nameOverlayTokenType = "name overlay";
+export const linkOverlayTokenType = "link overlay";
+export const valueOverlayTokenType = "value overlay";
+export const errorOverlayTokenType = "error overlay";
+export const tableOverlayTokenType = "table overlay";
+export const contextOverlayTokenType = "context overlay";
+export const listingOverlayTokenType = "listing overlay";
+export const headingOverlayTokenType = "heading overlay";
+export const contentOverlayTokenType = "content overlay";
+export const nonsenseOverlayTokenType = "nonsense overlay";
+export const labelNameOverlayTokenType = "label-name overlay";
+export const referenceNameOverlayTokenType = "reference-name overlay";
+export const procedureReferenceNameOverlayTokenType = "procedure-reference-name overlay";
+
+export default {
+  pathOverlayTokenType,
+  nameOverlayTokenType,
+  linkOverlayTokenType,
+  valueOverlayTokenType,
+  errorOverlayTokenType,
+  tableOverlayTokenType,
+  contextOverlayTokenType,
+  listingOverlayTokenType,
+  headingOverlayTokenType,
+  contentOverlayTokenType,
+  nonsenseOverlayTokenType,
+  labelNameOverlayTokenType,
+  referenceNameOverlayTokenType,
+  procedureReferenceNameOverlayTokenType
+};