occam-verify-cli 0.0.470 → 0.0.471

package/src/assertion.js

@@ -1,150 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "./utilities/query";
-
-const statementNodeQuery = nodeQuery("/*/statement!");
-
-export default class Assertion {
-  constructor(subproofNode, statementNode) {
-    this.subproofNode = subproofNode;
-    this.statementNode = statementNode;
-  }
-
-  getNonTerminalNode() {
-    const nonTerminalNode = (this.statementNode !== null) ?
-                               this.statementNode :
-                                 null;
-
-    return nonTerminalNode;
-  }
-
-  getSubproofNode() {
-    return this.subproofNode;
-  }
-
-  getStatementNode() {
-    return this.statementNode;
-  }
-
-  match(assertion) {
-    let matches = false;
-
-    const statementNode = assertion.getstatementNode();
-
-    if ((statementNode !== null) && (this.statementNode !== null)) {
-      const nonTerminalNode = this.statementNode, ///
-            assertionNonTerminalNode = statementNode, ///
-            assertionNonTerminalNodeMatches = matchAssertionNonTerminalNode(assertionNonTerminalNode, nonTerminalNode);
-
-      matches = assertionNonTerminalNodeMatches;  ///
-    }
-
-    return matches;
-  }
-
-  static fromSubproofNode(subproofNode) {
-    const statementNode = null,
-          assertion = new Assertion(subproofNode, statementNode);
-
-    return assertion;
-  }
-
-  static fromStatementNode(statementNode) {
-    const subproofNode = null,
-          assertion = new Assertion(subproofNode, statementNode);
-
-    return assertion;
-  }
-
-  static fromQualifiedStatementNode(qualifiedStatementNode) {
-    const subproofNode = null,
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          assertion = new Assertion(subproofNode, statementNode);
-
-    return assertion;
-  }
-
-  static fromUnqualifiedStatementNode(unqualifiedStatementNode) {
-    const subproofNode = null,
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          assertion = new Assertion(subproofNode, statementNode);
-
-    return assertion;
-  }
-}
-
-function matchAssertionNode(assertionNode, node) {
-  let assertionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = assertionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            assertionTerminalNode = assertionNode,  ///
-            assertionTerminalNodeMatches = matchAssertionTerminalNode(assertionTerminalNode, terminalNode);
-
-      assertionNodeMatches = assertionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            assertionNonTerminalNode = assertionNode,  ///
-            assertionNonTerminalNodeMatches = matchAssertionNonTerminalNode(assertionNonTerminalNode, nonTerminalNode);
-
-      assertionNodeMatches = assertionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return assertionNodeMatches;
-}
-
-function matchAssertionChildNodes(assertionChildNodes, childNodes) {
-  let assertionChildNodesMatches = false;
-
-  const childNodesLength = childNodes.length,
-        assertionChildNodesLength = assertionChildNodes.length;
-
-  if (childNodesLength === assertionChildNodesLength) {
-    assertionChildNodesMatches = childNodes.every((childNode, index) => {
-      const assertionChildNode = assertionChildNodes[index],
-            assertionNode = assertionChildNode, ///
-            node = childNode, ///
-            assertionNodeMatches = matchAssertionNode(assertionNode, node);
-
-      if (assertionNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return assertionChildNodesMatches;
-}
-
-function matchAssertionTerminalNode(assertionTerminalNode, terminalNode) {
-  let assertionTerminalNodeMatches = false;
-
-  const matches = assertionTerminalNode.match(terminalNode);
-
-  if (matches) {
-    assertionTerminalNodeMatches = true;
-  }
-
-  return assertionTerminalNodeMatches;
-}
-
-function matchAssertionNonTerminalNode(assertionNonTerminalNode, nonTerminalNode) {
-  let assertionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        assertionRuleName = assertionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === assertionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          assertionChildNodes = assertionNonTerminalNode.getChildNodes(),
-          assertionChildNodesMatches = matchAssertionChildNodes(assertionChildNodes, childNodes);
-
-    assertionNonTerminalNodeMatches = assertionChildNodesMatches; ///
-  }
-
-  return assertionNonTerminalNodeMatches;
-}

package/src/metaAssertion.js

@@ -1,245 +0,0 @@
-"use strict";
-
-import { first, second } from "./utilities/array";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-import { matchBracketedMetastatementChildNode } from "./utilities/metastatement";
-
-const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
-      metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
-      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion"),
-      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
-
-export default class MetaAssertion {
-  constructor(metaSubproofNode, metastatementNode) {
-    this.metaSubproofNode = metaSubproofNode;
-    this.metastatementNode = metastatementNode;
-  }
-
-  getMetaSubproofNode() {
-    return this.metaSubproofNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  match(metaAssertion) {
-    let matches = false;
-
-    const metastatementNode = metaAssertion.getMetastatementNode();
-
-    if (metastatementNode !== null) {
-      const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(metastatementNode);
-
-      if (metaSubproofAssertionNode === null) {
-        const metastatementNodeMatches = this.matchMetastatementNode(metastatementNode);
-
-        matches = metastatementNodeMatches;  ///
-      } else {
-        const metaSubproofAssertionNodeMatches = this.matchMetaSubproofAssertionNode(metaSubproofAssertionNode);
-
-        matches = metaSubproofAssertionNodeMatches; ///
-      }
-    }
-
-    return matches;
-  }
-
-  matchMetastatementNode(metastatementNode) {
-    let metastatementNodeMatches = false;
-
-    if (this.metastatementNode !== null) {
-      const topmostMetastatementNode = metastatementNode, ///
-            topmostMetaAssertionMetastatementNode = this.metastatementNode,  ///
-            topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
-
-      metastatementNodeMatches = topmostMetaAssertionMetastatementNodeMatches;  ///
-    }
-
-    return metastatementNodeMatches;
-  }
-
-  matchMetaSubproofAssertionNode(metaSubproofAssertionNode) {
-    let metaSubproofAssertionNodeMatches = false;
-
-    if (this.metaSubproofNode !== null) {
-      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
-            firstMetaSubproofAssertionMetastatementNode = first(metaSubproofAssertionMetastatementNodes),
-            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.metaSubproofNode),
-            firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
-
-      const topmostMetastatementNode = firstMetaSubproofAssertionMetastatementNode,  ///
-            topmostMetaAssertionMetastatementNode = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-            topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
-
-      if (topmostMetaAssertionMetastatementNodeMatches) {
-        const secondMetaSubproofAssertionMetastatementNode = second(metaSubproofAssertionMetastatementNodes),
-              secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
-
-        const topmostMetastatementNode = secondMetaSubproofAssertionMetastatementNode, ///
-              topmostMetaAssertionMetastatementNode = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-              topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
-
-        metaSubproofAssertionNodeMatches = topmostMetaAssertionMetastatementNodeMatches; ///
-      }
-    }
-
-    return metaSubproofAssertionNodeMatches;
-  }
-
-  static fromMetaSubproofNode(metaSubproofNode) {
-    const metastatementNode = null,
-          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
-
-    return metaAssertion;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const metaSubproofNode = null,
-          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
-
-    return metaAssertion;
-  }
-
-  static fromQualifiedMetastatementNode(qualifiedMetastatementNode) {
-    const metaSubproofNode = null,
-          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
-
-    return metaAssertion;
-  }
-
-  static fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode) {
-    const metaSubproofNode = null,
-          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
-
-    return metaAssertion;
-  }
-}
-
-function matchMetaAssertionNode(metaAssertionNode, node) {
-  let metaAssertionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = metaAssertionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            metaAssertionTerminalNode = metaAssertionNode,  ///
-            metaAssertionTerminalNodeMatches = matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode);
-
-      metaAssertionNodeMatches = metaAssertionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            metaAssertionNonTerminalNode = metaAssertionNode,  ///
-            metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
-
-      metaAssertionNodeMatches = metaAssertionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return metaAssertionNodeMatches;
-}
-
-function matchMetaAssertionNodes(metaAssertionNodes, nodes) {
-  let metaAssertionNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        metaAssertionNodesLength = metaAssertionNodes.length;
-
-  if (nodesLength === metaAssertionNodesLength) {
-    metaAssertionNodesMatches = nodes.every((node, index) => {
-      const metaAssertionNode = metaAssertionNodes[index],
-            metaAssertionNodeMatches = matchMetaAssertionNode(metaAssertionNode, node);
-
-      if (metaAssertionNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return metaAssertionNodesMatches;
-}
-
-function matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode) {
-  let metaAssertionTerminalNodeMatches = false;
-
-  const matches = metaAssertionTerminalNode.match(terminalNode);
-
-  if (matches) {
-    metaAssertionTerminalNodeMatches = true;
-  }
-
-  return metaAssertionTerminalNodeMatches;
-}
-
-function matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode) {
-  let metaAssertionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        metaAssertionRuleName = metaAssertionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === metaAssertionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
-          metaAssertionNodes = metaAssertionChildNodes, ///
-          metaAssertionNodesMatches = matchMetaAssertionNodes(metaAssertionNodes, nodes);
-
-    metaAssertionNonTerminalNodeMatches = metaAssertionNodesMatches;  ///
-  }
-
-  return metaAssertionNonTerminalNodeMatches;
-}
-
-function matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode) {
-  const nonTerminalNode = metastatementNode,  ///
-        metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
-        metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode),
-        metaAssertionMetastatementNodeNatches = metaAssertionNonTerminalNodeMatches;  ///
-
-  return metaAssertionMetastatementNodeNatches;
-}
-
-function matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode) {
-  let metaAssertionMetastatementNodeMatches;
-
-  const metastatementNode = topmostMetastatementNode, ///
-        metaAssertionMetastatementNode = topmostMetaAssertionMetastatementNode;  ///
-
-  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode);
-
-  if (!metaAssertionMetastatementNodeMatches) {
-    const nonTerminalNode = metastatementNode,  ///
-          childNodes = nonTerminalNode, ///
-          bracketedMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(childNodes, (bracketedMetastatementChildNode) => {
-            const metastatementNode = bracketedMetastatementChildNode,  ///
-                  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode),
-                  bracketedMetastatementChildNodeMatches = metaAssertionMetastatementNodeMatches;
-
-            return bracketedMetastatementChildNodeMatches;
-          });
-
-    metaAssertionMetastatementNodeMatches = bracketedMetastatementChildNodeMatches;  ///
-  }
-
-  if (!metaAssertionMetastatementNodeMatches) {
-    const metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
-          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
-          bracketedMetaAssertionMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(metaAssertionChildNodes, (bracketedMetaAssertionMetastatementChildNode) => {
-            const metaAssertionMetastatementNode = bracketedMetaAssertionMetastatementChildNode,  ///
-                  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode),
-                  bracketedMetaAssertionMetastatementChildNodeMatches = metaAssertionMetastatementNodeMatches;
-
-            return bracketedMetaAssertionMetastatementChildNodeMatches;
-          });
-
-    metaAssertionMetastatementNodeMatches = bracketedMetaAssertionMetastatementChildNodeMatches;  ///
-  }
-
-  const topmostMetaAssertionMetastatementNodeMatches = metaAssertionMetastatementNodeMatches;  ///
-
-  return topmostMetaAssertionMetastatementNodeMatches;
-}

package/src/utilities/metastatement.js

@@ -1,50 +0,0 @@
-"use strict";
-
-import { first, second, third } from "../utilities/array";
-import { METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH } from "../constants";
-
-export function bracketedMetastatementChildNodeFromChildNodes(childNodes) {
-  let bracketedMetastatementChildNode = null;
-
-  const childNodesLength = childNodes.length;
-
-  if (childNodesLength === BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH) {
-    const firstChildNode = first(childNodes),
-          thirdChildNode = third(childNodes),
-          secondChildNode = second(childNodes),
-          firstChildNodeTerminalNode = firstChildNode.isTerminalNode(),
-          thirdChildNodeTerminalNode = thirdChildNode.isTerminalNode(),
-          secondChildNodeNonTerminalNode = secondChildNode.isNonTerminalNode();
-
-    if (firstChildNodeTerminalNode && secondChildNodeNonTerminalNode && thirdChildNodeTerminalNode) {
-      const nonTerminalNode = secondChildNode,  ///
-            firstTerminalNode = firstChildNode, ///
-            secondTerminalNode = thirdChildNode,  ///
-            nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
-            firstTerminalNodeContent = firstTerminalNode.getContent(),
-            secondTerminalNodeContent = secondTerminalNode.getContent(),
-            firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
-            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
-            nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
-        bracketedMetastatementChildNode = nonTerminalNode;  ///
-      }
-    }
-  }
-
-  return bracketedMetastatementChildNode;
-}
-
-export function matchBracketedMetastatementChildNode(childNodes, callback) {
-  let bracketedMetastatementChildNodeMatches = false;
-
-  const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(childNodes);
-
-  if (bracketedMetastatementChildNode !== null) {
-    bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
-  }
-
-  return bracketedMetastatementChildNodeMatches;
-}