occam-verify-cli 0.0.533 → 0.0.535

package/src/verify/statement.js

@@ -1,31 +1,24 @@
 "use strict";
 
+import Equality from "../equality";
 import Variable from "../variable";
-import Assertion from "../assertion";
+import Assignment from "../assignment";
 import verifyTerm from "../verify/term";
+import statementVerifier from "../verifier/statement";
 import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
 import { first } from "../utilities/array";
-import { objectType } from "../type";
+import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
-import { OBJECT_TYPE_NAME } from "../typeNames";
-import { STATEMENT_META_TYPE } from "../metaTypes";
 import { verifyTermAsVariable } from "../verify/term";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
-import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
-const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!"),
-      leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
-      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyStatement(statementNode, assertions, derived, context) {
+export default function verifyStatement(statementNode, assignments, derived, context) {
   let statementVerified = false;
 
   if (!statementVerified) {
@@ -35,13 +28,13 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, derived, context);
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
 
     statementVerified = statementVerifiedAsTypeAssertion; ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assertions, derived, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assignments, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
@@ -76,21 +69,22 @@ function verifyStatementAgainstCombinators(statementNode, context) {
 
 function verifyStatementAgainstCombinator(statementNode, combinator, context) {
   const combinatorStatementNode = combinator.getStatementNode(),
-      node = statementNode,  ///
-      combinatorNode = combinatorStatementNode, ///
-      nodeVerified = verifyNode(node, combinatorNode, context),
-      statementVerifiedAgainstCombinator = nodeVerified;  ///
+        nonTerminalNodeA = statementNode,  ///
+        nonTerminalNodeB = combinatorStatementNode, ///
+        substitutions = null,
+        nodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context),
+        statementVerifiedAgainstCombinator = nodeVerified;  ///
 
   return statementVerifiedAgainstCombinator;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assertions, derived, context) {
+function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, derived, context);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
   }
@@ -98,7 +92,7 @@ function verifyStatementAsTypeAssertion(statementNode, assertions, derived, cont
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, assertions, derived, context) {
+function verifyStatementAsEquality(statementNode, assignments, derived, context) {
   let statementVerifiedAsEquality = false;
 
   const statementString = context.nodeAsString(statementNode);
@@ -107,13 +101,17 @@ function verifyStatementAsEquality(statementNode, assertions, derived, context)
         statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
   if (statementVerifiedAgainstCombinator) {
+    const leftTermNode = leftTermNodeQuery(statementNode),
+          rightTermNode = rightTermNodeQuery(statementNode);
+
     if (derived) {
-      debugger
+      const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+            equalityEquates = equality.equate(context);
+
+      statementVerifiedAsEquality = equalityEquates;  ///
     } else {
       const types = [],
             variables = [],
-            leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode),
             leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context);
 
       if (leftTermVerifiedAsVariable) {
@@ -138,9 +136,9 @@ function verifyStatementAsEquality(statementNode, assertions, derived, context)
                 name = leftVariableName,  ///
                 termNode = rightTermNode, ///
                 variable = Variable.fromTypeNameAndTermNode(type, name, termNode),
-                assertion = Assertion.fromVariable(variable);
+                assignment = Assignment.fromVariable(variable);
 
-          assertions.push(assertion);
+          assignments.push(assignment);
 
           statementVerifiedAsEquality = true;
         }
@@ -167,168 +165,3 @@ function verifyStatementAsEquality(statementNode, assertions, derived, context)
 
   return statementVerifiedAsEquality;
 }
-
-function verifyNode(node, combinatorNode, context) {
-  let nodeVerified;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        combinatorNodeTerminalNode = combinatorNode.isTerminalNode();
-
-  if (nodeTerminalNode === combinatorNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            combinatorTerminalNode = combinatorNode,  ///
-            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, context);
-
-      nodeVerified = terminalNodeVerified;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            combinatorNonTerminalNode = combinatorNode,  ///
-            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context);
-
-      nodeVerified = nonTerminalNodeVerified; ///
-    }
-  }
-
-  return nodeVerified;
-}
-
-function verifyNodes(nodes, combinatorNodes, context) {
-  let nodesVerified = false;
-
-  const nodesLength = nodes.length,
-        combinatorNodesLength = combinatorNodes.length;
-
-  if (nodesLength === combinatorNodesLength) {
-    nodesVerified = nodes.every((node, index) => {
-      const combinatorNode = combinatorNodes[index],
-            nodeVerified = verifyNode(node, combinatorNode, context);
-
-      if (nodeVerified) {
-        return true;
-      }
-    });
-  }
-
-  return nodesVerified;
-}
-
-function verifyTerminalNode(terminalNode, combinatorTerminalNode, context) {
-  let terminalNodeVerified = false;
-
-  const matches = terminalNode.match(combinatorTerminalNode);
-
-  if (matches) {
-    terminalNodeVerified = true;
-  }
-
-  return terminalNodeVerified;
-}
-
-function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context) {
-  let nonTerminalNodeVerified = false;
-
-  const ruleName = nonTerminalNode.getRuleName(), ///
-        combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === combinatorRuleName) {
-    switch (ruleName) {
-      case ARGUMENT_RULE_NAME: {
-        const argumentNode = nonTerminalNode, ///
-              combinatorArgumentNode = combinatorNonTerminalNode, ///
-              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
-
-        nonTerminalNodeVerified = argumentNodeVerified; ///
-
-        break;
-      }
-
-      case META_ARGUMENT_RULE_NAME: {
-        const metaArgumentNode = nonTerminalNode, ///
-              combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-              metaArgumentNodeVerified = verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context);
-
-        nonTerminalNodeVerified = metaArgumentNodeVerified; ///
-
-        break;
-      }
-
-      default: {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              combinatorNodes = combinatorChildNodes, ///
-              nodesVerified = verifyNodes(nodes, combinatorNodes, context);
-
-        nonTerminalNodeVerified = nodesVerified; ///
-
-        break;
-      }
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
-  let argumentNodeVerified = false;
-
-  const termNode = termNodeQuery(argumentNode);
-
-  if (termNode === null) {
-    const argumentString = context.nodeAsString(argumentNode);
-
-    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
-  } else {
-    const types = [],
-          termVerified = verifyTerm(termNode, types, context);
-
-    if (termVerified) {
-      const firstType = first(types),
-            termType = firstType, ///
-            typeNode = typeNodeQuery(combinatorArgumentNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            type = (typeName === OBJECT_TYPE_NAME) ?
-                     objectType :  ///
-                       context.findTypeByTypeName(typeName),
-            statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-
-      if (statementTypeEqualToOrSubTypeOfType) {
-        argumentNodeVerified = true;
-      }
-    }
-  }
-
-  return argumentNodeVerified;
-}
-
-function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
-  let metaArgumentNodeVerified = false;
-
-  const statementNode = statementNodeQuery(metaArgumentNode),
-        combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
-
-  if (statementNode === null) {
-    const metaArgumentString = context.nodeAsString(metaArgumentNode);
-
-    context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
-  } else {
-    if (combinatorMetaTYpeNode === null) {
-      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-
-      context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
-    } else {
-      const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
-            content = combinatorMetaTypeTerminalNode.getContent(),
-            contentStatementMetaType = (content === STATEMENT_META_TYPE);
-
-      if (!contentStatementMetaType) {
-        context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
-      } else {
-        metaArgumentNodeVerified = true;
-      }
-    }
-  }
-
-  return metaArgumentNodeVerified;
-}

package/src/verify/statementAsCombinator.js

@@ -145,8 +145,8 @@ function verifyTermNode(termNode, fileContext) {
 function verifyStatementNode(statementNode, fileContext) {
   const context = fileContext,  ///
         derived = false,
-        assertions = [],
-        statementVerified = verifyStatement(statementNode, assertions, derived, context),
+        assignments = [],
+        statementVerified = verifyStatement(statementNode, assignments, derived, context),
         statementNodeVerified = statementVerified;  ///
 
   return statementNodeVerified;

package/src/verify/supposition.js

@@ -17,9 +17,9 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
   proofContext.debug(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
-        assertions = [],
+        assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
-        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
 
   if (unqualifiedStatementVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
@@ -30,8 +30,8 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
     proofContext.addProofStep(proofStep);
 
-    assertions.every((assertion) => {
-      assertion.assert(proofContext);
+    assignments.every((assignment) => {
+      assignment.assign(proofContext);
     });
 
     suppositionVerified = true;

package/lib/assertion.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return Assertion;
-    }
-});
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var Assertion = /*#__PURE__*/ function() {
-    function Assertion(variable) {
-        _classCallCheck(this, Assertion);
-        this.variable = variable;
-    }
-    _createClass(Assertion, [
-        {
-            key: "getVariable",
-            value: function getVariable() {
-                return this.variable;
-            }
-        },
-        {
-            key: "assert",
-            value: function assert(proofContext) {
-                proofContext.addVariable(this.variable);
-            }
-        }
-    ], [
-        {
-            key: "fromVariable",
-            value: function fromVariable(variable) {
-                var assertion = new Assertion(variable);
-                return assertion;
-            }
-        }
-    ]);
-    return Assertion;
-}();
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9hc3NlcnRpb24uanMiLCI8PGpzeC1jb25maWctcHJhZ21hLmpzPj4iXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFzc2VydGlvbiB7XG4gIGNvbnN0cnVjdG9yKHZhcmlhYmxlKSB7XG4gICAgdGhpcy52YXJpYWJsZSA9IHZhcmlhYmxlO1xuICB9XG5cbiAgZ2V0VmFyaWFibGUoKSB7XG4gICAgcmV0dXJuIHRoaXMudmFyaWFibGU7XG4gIH1cblxuICBhc3NlcnQocHJvb2ZDb250ZXh0KSB7XG4gICAgcHJvb2ZDb250ZXh0LmFkZFZhcmlhYmxlKHRoaXMudmFyaWFibGUpO1xuICB9XG5cbiAgc3RhdGljIGZyb21WYXJpYWJsZSh2YXJpYWJsZSkge1xuICAgIGNvbnN0IGFzc2VydGlvbiA9IG5ldyBBc3NlcnRpb24odmFyaWFibGUpO1xuXG4gICAgcmV0dXJuIGFzc2VydGlvbjtcbiAgfVxufVxuIiwiUmVhY3QuY3JlYXRlRWxlbWVudCJdLCJuYW1lcyI6WyJBc3NlcnRpb24iLCJ2YXJpYWJsZSIsImdldFZhcmlhYmxlIiwiYXNzZXJ0IiwicHJvb2ZDb250ZXh0IiwiYWRkVmFyaWFibGUiLCJmcm9tVmFyaWFibGUiLCJhc3NlcnRpb24iXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O2VBRXFCQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFOLElBQUEsQUFBTUEsMEJBQU47YUFBTUEsVUFDUEMsUUFBUTs4QkFEREQ7UUFFakIsSUFBSSxDQUFDQyxRQUFRLEdBQUdBOztpQkFGQ0Q7O1lBS25CRSxLQUFBQTttQkFBQUEsU0FBQUEsY0FBYztnQkFDWixPQUFPLElBQUksQ0FBQ0QsUUFBUTtZQUN0Qjs7O1lBRUFFLEtBQUFBO21CQUFBQSxTQUFBQSxPQUFPQyxZQUFZLEVBQUU7Z0JBQ25CQSxhQUFhQyxXQUFXLENBQUMsSUFBSSxDQUFDSixRQUFRO1lBQ3hDOzs7O1lBRU9LLEtBQUFBO21CQUFQLFNBQU9BLGFBQWFMLFFBQVEsRUFBRTtnQkFDNUIsSUFBTU0sWUFBWSxJQWREUCxVQWNlQztnQkFFaEMsT0FBT007WUFDVDs7O1dBakJtQlAifQ==