occam-verify-cli 0.0.915 → 0.0.917

package/src/verify/metastatement.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import verifyFrameAssertion from "../verify/frameAssertion";
+import verifyJudgement from "../verify/judgement";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
-const frameAssertionNodeQuery = nodeQuery("/metastatement/frameAssertion!");
+const judgementNodeQuery = nodeQuery("/metastatement/judgement!");
 
 function verifyMetastatement(metastatementNode, assignments, derived, localContext) {
   let metastatementVerified;
@@ -15,7 +15,7 @@ function verifyMetastatement(metastatementNode, assignments, derived, localConte
   localContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
   const verifyMetaStatementFunctions = [
-    verifyMetastatementAsFrameAssertion,
+    verifyMetastatementAsJudgement,
     verifyMetastatementAsIs
   ];
 
@@ -40,34 +40,35 @@ Object.assign(metaLevelNodeVerifier, {
 
 export default verifyMetastatement;
 
-function verifyMetastatementAsFrameAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsFrameAssertion = false;
+function verifyMetastatementAsJudgement(metastatementNode, assignments, derived, localContext) {
+  let metastatementVerifiedAsJudgement = false;
 
-  const frameAssertionNode = frameAssertionNodeQuery(metastatementNode);
+  const metastatementJudgement = isMetastatementJudgement(metastatementNode);
 
-  if (frameAssertionNode !== null) {
+  if (metastatementJudgement) {
     const metastatementString = localContext.nodeAsString(metastatementNode);
 
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as a frame assertion...`, metastatementNode);
+    localContext.trace(`Verifying the '${metastatementString}' metastatement as a judgement...`, metastatementNode);
 
-    const frameAssertionVerified = verifyFrameAssertion(frameAssertionNode, assignments, derived, localContext);
+    const judgementNode = judgementNodeQuery(metastatementNode),
+          judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
 
-    metastatementVerifiedAsFrameAssertion = frameAssertionVerified;  ///
+    metastatementVerifiedAsJudgement = judgementVerified;  ///
 
-    if (metastatementVerifiedAsFrameAssertion) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as a frame assertion.`, metastatementNode);
+    if (metastatementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${metastatementString}' metastatement as a judgement.`, metastatementNode);
     }
   }
 
-  return metastatementVerifiedAsFrameAssertion;
+  return metastatementVerifiedAsJudgement;
 }
 
 function verifyMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
   let metastatementVerifiedAsIs;
 
-  const frameAssertionNode = frameAssertionNodeQuery(metastatementNode);
+  const metastatementJudgement = isMetastatementJudgement(metastatementNode);
 
-  if (frameAssertionNode === null) {
+  if (!metastatementJudgement) {
     const metastatementString = localContext.nodeAsString(metastatementNode);
 
     localContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
@@ -129,3 +130,10 @@ function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived,
 
   return statedMetastatementVerifiedAsIs;
 }
+
+function isMetastatementJudgement(metastatementNode) {
+  const judgementNode = judgementNodeQuery(metastatementNode),
+        metastatementJudgement = (judgementNode !== null);
+
+  return metastatementJudgement;
+}

package/src/verify/statement.js

@@ -3,16 +3,16 @@
 import verifyEquality from "../verify/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/typeAssertion";
-import verifyDefinedAssertion from "../verify/definedAssertion";
-import verifyContainedAssertion from "../verify/containedAssertion";
+import verifyStatementAsDefinedAssertion from "../verify/statementAsDefinedAssertion";
+import verifyStatementAsContainedAssertion from "../verify/statementAsContainedAssertion";
 import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
 
-import { nodeQuery } from "../utilities/query";
+import { DEFINED, CONTAINED } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -77,23 +77,24 @@ export default verifyStatement;
 export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
-  const equalityNode = equalityNodeQuery(statementNode);
+  const statementEquality = isStatementEquality(statementNode);
 
-  if (equalityNode !== null) {
+  if (statementEquality) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as an equality...`, equalityNode);
+    localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
+    const equalityNode = equalityNodeQuery(statementNode),
+          equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-      return verifiedAhead;
-    });
+            return verifiedAhead;
+          });
 
     statementVerifiedAsEquality = equalityVerified; ///
 
     if (statementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${statementString}' statement as an equality.`, equalityNode);
+      localContext.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
     }
   }
 
@@ -103,82 +104,39 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
 export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const statementTypeAssertion = isStatementTypeAssertion(statementNode);
 
-  if (typeAssertionNode !== null) {
+  if (statementTypeAssertion) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, typeAssertionNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
+    const typeAssertionNode = typeAssertionNodeQuery(statementNode),
+          typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-      return verifiedAhead;
-    });
+            return verifiedAhead;
+          });
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
     if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, typeAssertionNode);
+      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
     }
   }
 
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsDefinedAssertion = false;
-
-  const definedAssertionNode = definedAssertionNodeQuery(statementNode);
-
-  if (definedAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, definedAssertionNode);
-
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext);
-
-    statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
-
-    if (statementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, definedAssertionNode);
-    }
-  }
-
-  return statementVerifiedAsDefinedAssertion;
-}
-
-function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsContainedAssertion = false;
-
-  const containedAssertionNode = containedAssertionNodeQuery(statementNode);
-
-  if (containedAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, containedAssertionNode);
-
-    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
-
-    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
-
-    if (statementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, containedAssertionNode);
-    }
-  }
-
-  return statementVerifiedAsContainedAssertion;
-}
-
 function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
   let statementVerifiedAgainstCombinators = false;
 
-  const equalityNode = equalityNodeQuery(statementNode),
-        typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        definedAssertionNode = definedAssertionNodeQuery(statementNode),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+  const statementEquality = isStatementEquality(statementNode),
+        statementTypeAssertion = isStatementTypeAssertion(statementNode),
+        statementDefinedAssertion = isStatementDefinedAssertion(statementNode),
+        statementContainedAssertion = isStatementContainedAssertion(statementNode);
 
-  if ((equalityNode === null) && (typeAssertionNode === null) && (definedAssertionNode === null) && (containedAssertionNode === null)) {
+  if (!statementEquality && !statementTypeAssertion && !statementDefinedAssertion && !statementContainedAssertion) {
     let combinators = localContext.getCombinators();
 
     combinators = [ ///
@@ -223,3 +181,45 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
 
   return statementVerifiedAgainstCombinator;
 }
+
+function isStatementEquality(statementNode) {
+  const equalityNode = equalityNodeQuery(statementNode),
+        statementEquality = (equalityNode !== null);
+
+  return statementEquality;
+}
+
+function isStatementTypeAssertion(statementNode) {
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        statementTypeAssertion = (typeAssertionNode === null);
+
+  return statementTypeAssertion;
+}
+
+function isStatementDefinedAssertion(statementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
+        statementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentDefined = (content === DEFINED);
+
+          if (contentDefined) {
+            return true;
+          }
+        });
+
+  return statementDefinedAssertion;
+}
+
+function isStatementContainedAssertion(statementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
+        statementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentContained = (content === CONTAINED);
+
+          if (contentContained) {
+            return true;
+          }
+        });
+
+  return statementContainedAssertion;
+}

package/src/verify/statementAsContainedAssertion.js

@@ -0,0 +1,112 @@
+"use strict";
+
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { isAssertionNegated } from "../utilities/verify";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/statement/term/variable!"),
+      metastatementVariableNodesQuery = nodesQuery("/statement/statement//variable");
+
+export default function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsContainedAssertion;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
+
+  const statementFunctions = [
+    verifyStatementAsDerivedContainedAssertion,
+    verifyStatementAsStatedContainedAssertion
+  ];
+
+  statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
+    const statementVerifiedAsContainedAssertion = statementFunction(statementNode, assignments, derived, localContext);
+
+    if (statementVerifiedAsContainedAssertion) {
+      return true;
+    }
+  });
+
+  if (statementVerifiedAsContainedAssertion) {
+    localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
+  }
+
+  return statementVerifiedAsContainedAssertion;
+}
+
+function verifyStatementAsDerivedContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedContainedAssertion = false;
+
+  if (derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the derived '${statementString}' statement as a contained assertion...`, statementNode);
+
+    const statementNegated = isAssertionNegated(statementNode),
+          variableNode = variableNodeQuery(statementNode),
+          negated = statementNegated;  ///
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const metastatementVariableNodes = metastatementVariableNodesQuery(statementNode),
+            variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
+              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
+
+              if (variableNodeMatchesMetaArgumentVariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (variableNodeMatchesMetaArgumentVariableNode) {
+          statementVerifiedAsDefinedContainedAssertion = true;
+        }
+      }
+
+      if (negated) {
+        if (!variableNodeMatchesMetaArgumentVariableNode) {
+          statementVerifiedAsDefinedContainedAssertion = true;
+        }
+      }
+    }
+
+    if (statementVerifiedAsDefinedContainedAssertion) {
+      localContext.debug(`...verified the derived '${statementString}' statement as a contained assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsDefinedContainedAssertion;
+}
+
+function verifyStatementAsStatedContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsStatedContainedAssertion = false;
+
+  if (!derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the stated '${statementString}' statement as a contained assertion...`, statementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${statementString}' statement as a contained assertion cannot be verified at intrinsic level.`, statementNode);
+    } else {
+      const nonTerminalNode = statementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statementVerifiedAsStatedContainedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statementVerifiedAsStatedContainedAssertion) {
+      localContext.debug(`...verified the stated '${statementString}' statement as a contained assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsStatedContainedAssertion;
+}

package/src/verify/statementAsDefinedAssertion.js

@@ -0,0 +1,136 @@
+"use strict";
+
+import verifyTerm from "./term";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+import { isStatementNegated } from "../utilities/verify";
+
+const termNodeQuery = nodeQuery("/statement/term!"),
+      variableNodeQuery = nodeQuery("/statement/term/variable!");
+
+export default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedAssertion;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+  const definedAssertionFunctions = [
+    verifyDerivedStatementAsDefinedAssertion,
+    verifyStatedStatementAsDefinedAssertion
+  ];
+
+  statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
+    const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+
+    if (statementVerifiedAsDefinedAssertion) {
+      return true;
+    }
+  });
+
+  if (statementVerifiedAsDefinedAssertion) {
+    localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+  }
+
+  return statementVerifiedAsDefinedAssertion;
+}
+
+function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsDefeindAssertion = false;
+
+  if (derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the derived '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const statementNegated = isStatementNegated(statementNode),
+          variableNode = variableNodeQuery(statementNode),
+          termNode = termNodeQuery(statementNode);
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode);
+
+      if (variable !== null) {
+        const variableDefined = localContext.isVariableDefined(variable);
+
+        if (!statementNegated) {
+          if (variableDefined) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (statementNegated) {
+          if (!variableDefined) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    } else if (termNode !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      if (termVerified) {
+        const firstTerm = first(terms),
+              term = firstTerm, ///
+              termGrounded = localContext.isTermGrounded(term);
+
+        if (!statementNegated) {
+          if (termGrounded) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (statementNegated) {
+          if (!termGrounded) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    }
+
+    if (derivedStatementVerifiedAsDefeindAssertion) {
+      localContext.debug(`...verified the derived '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return derivedStatementVerifiedAsDefeindAssertion;
+}
+
+function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsDefinedAssertion = false;
+
+  if (!derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the stated '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${statementString}' statement as a defined assertion cannot be verified at intrinsic level.`, statementNode);
+    } else {
+      const nonTerminalNode = statementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statedStatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statedStatementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the stated '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statedStatementVerifiedAsDefinedAssertion;
+}

package/lib/assignment/frameAssertion.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return FrameAssertionAssignment;
-    }
-});
-function _class_call_check(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 _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var FrameAssertionAssignment = /*#__PURE__*/ function() {
-    function FrameAssertionAssignment(frameAssertion) {
-        _class_call_check(this, FrameAssertionAssignment);
-        this.frameAssertion = frameAssertion;
-    }
-    _create_class(FrameAssertionAssignment, [
-        {
-            key: "getFrameAssertion",
-            value: function getFrameAssertion() {
-                return this.frameAssertion;
-            }
-        },
-        {
-            key: "assign",
-            value: function assign(localContext) {
-                var frameAssertionAdded = localContext.addFrameAssertion(this.frameAssertion), frameAssertionNode = this.frameAssertion.getNode(), frameAssertionString = localContext.nodeAsString(frameAssertionNode), frameAssertionAssigned = frameAssertionAdded; ///
-                frameAssertionAssigned ? localContext.trace("Assigned the '".concat(frameAssertionString, "' frame assertion."), frameAssertionNode) : localContext.debug("Unable to assign the '".concat(frameAssertionString, "' frame assertion."), frameAssertionNode);
-                return frameAssertionAssigned;
-            }
-        }
-    ], [
-        {
-            key: "fromFrameAssertion",
-            value: function fromFrameAssertion(frameAssertion) {
-                var frameAssertionAssignment = new FrameAssertionAssignment(frameAssertion);
-                return frameAssertionAssignment;
-            }
-        }
-    ]);
-    return FrameAssertionAssignment;
-}();
-
-//# sourceMappingURL=data:application/json;base64,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