occam-verify-cli 0.0.1190 → 0.0.1192

package/src/dom/parameter.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+
+export default domAssigned(class Parameter {
+  constructor(term, frame, statement) {
+    this.term = term;
+    this.frame = frame;
+    this.statement = statement;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getFrame() {
+    return this.frame;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  verify(assignments, stated, context) {
+    let verified = false;
+
+    const parameterString = this.string; ///
+
+    context.trace(`Verifying the '${parameterString}' parameter...`);
+
+    debugger
+
+    if (verified) {
+      context.debug(`...verified the '${parameterString}' parameter.`);
+    }
+
+    return verified;
+  }
+
+  static name = "Parameter";
+
+  static fromParameterNode(parameterNode, context) {
+    let parameter = null;
+
+    if (parameterNode !== null) {
+      const { Term, Frame, Statement } = dom,
+            term = Term.fromParameterNode(parameterNode, context),
+            frame = Frame.fromParameterNode(parameterNode, context),
+            statement = Statement.fromParameterNode(parameterNode, context);
+
+      parameter = new Parameter(term, frame, statement);
+    }
+
+    return parameter;
+  }
+});

package/src/dom/procedureCall.js

@@ -1,7 +1,9 @@
 "use strict";
 
-import {nodeQuery, nodesQuery} from "../utilities/query";
+import dom from "../dom";
+
 import { domAssigned } from "../dom";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const parameterNodesQuery = nodesQuery("/procedureCall/parameter"),
       procedureCallNodeQuery = nodeQuery("/statement/procedureCall");
@@ -44,9 +46,23 @@ export default domAssigned(class ProcedureCall {
     const procedureCallNode = procedureCallNodeQuery(statementNode);
 
     if (procedureCallNode !== null) {
-      debugger
+      const parameters = parametersFromProcedureCallNode(procedureCallNode, context);
+
+      procedureCall = new ProcedureCall(parameters);
     }
 
     return procedureCall;
   }
 });
+
+function parametersFromProcedureCallNode(procedureCallNode, context) {
+  const { Parameter } = dom,
+        parameterNodes = parameterNodesQuery(procedureCallNode),
+        parameters = parameterNodes.map((parameterNode) => {
+          const parameter = Parameter.fromParameterNode(parameterNode, context);
+
+          return parameter;
+        });
+
+  return parameters;
+}

package/src/dom/statement.js

@@ -3,6 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
+import LocalContext from "../context/local";
 import verifyMixins from "../mixins/statement/verify";
 import combinatorVerifier from "../verifier/combinator";
 import StatementPartialContext from "../context/partial/statement";
@@ -15,9 +16,15 @@ import { definedAssertionFromStatement, subproofAssertionFromStatement, containe
 
 const { match, backwardsSome } = arrayUtilities;
 
-const statementNodeQuery = nodeQuery("/*/statement"),
-      statementTermNodesQuery = nodesQuery("/statement//term"),
-      statementFrameNodesQuery = nodesQuery("/statement//frame");
+const statementTermNodesQuery = nodesQuery("/statement//term"),
+      statementFrameNodesQuery = nodesQuery("/statement//frame"),
+      premiseStatementNodeQuery = nodeQuery("/premise/statement"),
+      parameterStatementNodeQuery = nodeQuery("/parameter/statement"),
+      proofStepStatementNodeQuery = nodeQuery("/proofStep/statement"),
+      conclusionStatementNodeQuery = nodeQuery("/conclusion/statement"),
+      consequentStatementNodeQuery = nodeQuery("/consequent/statement"),
+      suppositionStatementNodeQuery = nodeQuery("/supposition/statement"),
+      containedAssertionStatementNodeQuery = nodeQuery("/containedAssertion/statement");
 
 export default domAssigned(class Statement {
   constructor(string, node, tokens) {
@@ -294,78 +301,118 @@ export default domAssigned(class Statement {
   }
 
   static fromPremiseNode(premiseNode, fileContext) {
-    const node = premiseNode, ///
-          statement = statementFromNode(node, fileContext);
+    let statement = null;
+
+    const premiseStatementNode = premiseStatementNodeQuery(premiseNode);
+
+    if (premiseStatementNode !== null) {
+      const statementNode = premiseStatementNode, ///
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext;  ///
+
+      statement = statementFromStatementNode(statementNode, context);
+    }
 
     return statement;
   }
 
   static fromProofStepNode(proofStepNode, fileContext) {
-    const node = proofStepNode, ///
-          statement = statementFromNode(node, fileContext);
+    let statement = null;
+
+    const proofStepStatementNode = proofStepStatementNodeQuery(proofStepNode);
+
+    if (proofStepStatementNode !== null) {
+      const statementNode = proofStepStatementNode; ///
+
+      statement = statementFromStatementNode(statementNode, fileContext);
+    }
 
     return statement;
   }
 
   static fromStatementNode(statementNode, context) {
+    const statement = statementFromStatementNode(statementNode, context);
+
+    return statement;
+  }
+
+  static fromParameterNode(parameterNode, context) {
     let statement = null;
 
-    if (statementNode !== null) {
-      const node = statementNode, ///
-            tokens = context.nodeAsTokens(node),
-            string = context.tokensAsString(tokens);
+    const parameterStatementNode = parameterStatementNodeQuery(parameterNode);
 
-      statement = new Statement(string, node, tokens);
+    if (parameterStatementNode !== null) {
+      const statementNode = parameterStatementNode; ///
+
+      statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
   static fromConclusionNode(conclusionNode, fileContext) {
-    const node = conclusionNode, ///
-          statement = statementFromNode(node, fileContext);
+    let statement = null;
+
+    const conclusionStatementNode = conclusionStatementNodeQuery(conclusionNode);
+
+    if (conclusionStatementNode !== null) {
+      const statementNode = conclusionStatementNode,  ///
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext;  ///
+
+      statement = statementFromStatementNode(statementNode, context);
+    }
 
     return statement;
   }
 
   static fromConsequentNode(consequentNode, fileContext) {
-    const node = consequentNode, ///
-          statement = statementFromNode(node, fileContext);
+    let statement = null;
+
+    const consequentStatementNode = consequentStatementNodeQuery(consequentNode);
+
+    if (consequentStatementNode !== null) {
+      const statementNode = consequentStatementNode,  ///
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext;  ///
+
+      statement = statementFromStatementNode(statementNode, context);
+    }
 
     return statement;
   }
 
   static fromSuppositionNode(suppositionNode, fileContext) {
-    const node = suppositionNode, ///
-          statement = statementFromNode(node, fileContext);
+    let statement = null;
+
+    const suppositionStatementNode = suppositionStatementNodeQuery(suppositionNode);
+
+    if (suppositionStatementNode !== null) {
+      const statementNode = suppositionStatementNode, ///
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext;  ///
+
+      statement = statementFromStatementNode(statementNode, context);
+    }
 
     return statement;
   }
 
   static fromContainedAssertionNode(containedAssertionNode, context) {
-    const statementNode = statementNodeQuery(containedAssertionNode),
-          node = statementNode, ///
-          tokens = context.nodeAsTokens(node),
-          string = context.tokensAsString(tokens),
-          statement = new Statement(string, node, tokens);
+    const containedAssertionStatementNode = containedAssertionStatementNodeQuery(containedAssertionNode),
+          statementNode = containedAssertionStatementNode, ///
+          statement = statementFromStatementNode(statementNode, context);
 
     return statement;
   }
 });
 
-function statementFromNode(node, fileContext) {
-  let statement = null;
-
-  const statementNode = statementNodeQuery(node);
-
-  if (statementNode !== null) {
-    const { Statement } = dom,
-          node = statementNode, ///
-          tokens = fileContext.nodeAsTokens(node),
-          string = fileContext.tokensAsString(tokens);
-
-    statement = new Statement(string, node, tokens);
-  }
+function statementFromStatementNode(statementNode, context) {
+  const { Statement } = dom,
+        node = statementNode, ///
+        tokens = context.nodeAsTokens(node),
+        string = context.tokensAsString(tokens),
+        statement = new Statement(string, node, tokens);
 
   return statement;
 }

package/src/dom/term.js

@@ -3,6 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
+import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 import constructorVerifier from "../verifier/constructor";
 
@@ -15,7 +16,8 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 const { filter, compress } = arrayUtilities;
 
 const variableNodesQuery = nodesQuery("//variable"),
-      termVariableNodeQuery = nodeQuery("/*/term[0]/variable!");
+      termVariableNodeQuery = nodeQuery("/*/term[0]/variable!"),
+      parameterTermNodeQuery = nodeQuery("/parameter/term");
 
 export default domAssigned(class Term {
   constructor(string, node, type) {
@@ -243,7 +245,8 @@ export default domAssigned(class Term {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          context = fileContext,  ///
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext,  ///
           termString = string,  ///
           termNode = termNodeFromTermString(termString, context),
           node = termNode,  ///
@@ -267,6 +270,22 @@ export default domAssigned(class Term {
     return term;
   }
 
+  static fromParameterNode(parameterNode, context) {
+    let term = null;
+
+    const parameterTermNode = parameterTermNodeQuery(parameterNode);
+
+    if (parameterTermNode !== null) {
+      const node = parameterTermNode,  ///
+            string = context.nodeAsString(node),
+            type = null;
+
+      term = new Term(string, node, type);
+    }
+
+    return term;
+  }
+
   static fromTermNodeAndType(termNode, type, context) {
     const node = termNode,  ///
           string = context.nodeAsString(node),

package/src/index.js

@@ -15,6 +15,7 @@ import Equality from "./dom/equality";
 import MetaType from "./dom/metaType";
 import Subproof from "./dom/subproof";
 import Variable from "./dom/variable";
+import Parameter from "./dom/parameter";
 import ProofStep from "./dom/proofStep";
 import Reference from "./dom/reference";
 import Statement from "./dom/statement";