occam-verify-cli 0.0.546 → 0.0.548

package/src/context/proof.js

@@ -186,6 +186,20 @@ class ProofContext {
 
     return proofContext;
   }
+
+  static fromProofContextAndAssignments(proofContext, assignments) {
+    const context = proofContext,  ///
+          variables = assignments.map((assignment) => {
+            const variable = assignment.getVariable();
+
+            return variable;
+          }),
+          proofSteps = [];
+
+    proofContext = new ProofContext(context, variables, proofSteps);
+
+    return proofContext;
+  }
 }
 
 Object.assign(ProofContext.prototype, fileMixins);

package/src/context/release.js

@@ -349,27 +349,23 @@ export default class ReleaseContext {
 
     this.parser = florenceParser; ///
 
-    if (this.json === null) {
-      this.verified = false;
+    this.dependencyReleaseContexts = dependencyReleaseContexts;
 
-      this.fileContexts = [];
-    } else {
+    if (this.json !== null) {
       const fileContextsJSON = this.json; ///
 
-      this.verified = true;
-
-      this.fileContexts = fileContextsJSON.map((fileContextJSON) => {
+      fileContextsJSON.forEach((fileContextJSON) => {
         const json = fileContextJSON, ///
               { filePath } = json,
               fileContext = FileContext.fromFilePathAndReleaseContext(filePath, releaseContext);
 
         fileContext.initialise(json);
 
-        return fileContext;
+        this.fileContexts.push(fileContext);
       });
-    }
 
-    this.dependencyReleaseContexts = dependencyReleaseContexts;
+      this.verified = true;
+    }
   }
 
   toJSON() {
@@ -386,9 +382,9 @@ export default class ReleaseContext {
   static fromLogJSONNameAndEntries(log, json, name, entries) {
     const lexer = null,
           parser = null,
-          verified = null,
+          verified = false,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          fileContexts = null,
+          fileContexts = [],
           dependencyReleaseContexts = null,
           releaseContext = new ReleaseContext(log, json, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts);
 

package/src/label.js

@@ -34,6 +34,13 @@ export default class Label {
     return json;
   }
 
+  static fromLabelNode(labelNode) {
+    const node = labelNode, ///
+          variable = new Label(node);
+
+    return variable;
+  }
+
   static fromJSONAndFileContext(json, fileContext) {
     const labelString = json, ///
           lexer  = fileContext.getLexer(),
@@ -44,11 +51,4 @@ export default class Label {
 
     return label;
   }
-
-  static fromLabelNode(labelNode) {
-    const node = labelNode, ///
-          variable = new Label(node);
-
-    return variable;
-  }
 }

package/src/supposition.js

@@ -75,6 +75,12 @@ export default class Supposition {
     return json;
   }
 
+  static fromStatementNode(statementNode) {
+    const supposition = new Supposition(statementNode);
+
+    return supposition;
+  }
+
   static fromJSONAndFileContext(json, fileContext) {
     const { statement } = json,
           statementString = statement,  ///
@@ -85,10 +91,4 @@ export default class Supposition {
 
     return supposition;
   }
-
-  static fromStatementNode(statementNode) {
-    const supposition = new Supposition(statementNode);
-
-    return supposition;
-  }
 }

package/src/type.js

@@ -186,20 +186,22 @@ class ObjectType extends Type {
 export const objectType = ObjectType.fromNothing();
 
 function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
-  let superType;
+  let superType = null;
 
-  const json = superTypeJSON, ///
-        { name } = json;
+  if (superTypeJSON !== null) {
+    const json = superTypeJSON, ///
+          { name } = json;
 
-  if (name === OBJECT_TYPE_NAME) {
-    superType = objectType; ///
-  } else {
-    const typeName = name,  ///
-          type = fileContext.findTypeByTypeName(typeName);
+    if (name === OBJECT_TYPE_NAME) {
+      superType = objectType; ///
+    } else {
+      const typeName = name,  ///
+            type = fileContext.findTypeByTypeName(typeName);
 
-    superType = (type !== null) ?
-                  type :  ///
-                    Type.fromJSONAndFileContext(json, fileContext);  ///
+      superType = (type !== null) ?
+                    type :  ///
+                      Type.fromJSONAndFileContext(json, fileContext);  ///
+    }
   }
 
   return superType;

package/src/verifier/termForVariable.js

@@ -1,13 +1,13 @@
 "use strict";
 
 import Verifier from "../verifier";
+import verifyTerm from "../verify/term";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 import { TERM_RULE_NAME } from "../ruleNames";
 import { variableNameFromVariableNode } from "../utilities/query";
-import { verifyTermAgainstConstructors } from "../verify/term";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
@@ -54,10 +54,10 @@ export default class TermForVariableVerifier extends Verifier {
     return termNodeVerified;
   }
 
-  verifyVariableNode(variableNodeB, termNodeB, substitutions, proofContextA, proofContextB) {
+  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
     let variableVerified;
 
-    const variableNameA = variableNameFromVariableNode(variableNodeB),
+    const variableNameA = variableNameFromVariableNode(variableNodeA),
           substitution = substitutions.find((substitution) => {
             const variableName = substitution.getVariableName();
 
@@ -83,7 +83,7 @@ export default class TermForVariableVerifier extends Verifier {
           const types = [],
                 context = proofContextB, ///
                 termNode = termNodeB, ///
-                termVerified = verifyTermAgainstConstructors(termNodeB, types, context);
+                termVerified = verifyTerm(termNode, types, context);
 
           if (termVerified) {
             const firstType = first(types),

package/src/verify/metastatement/unqualified.js

@@ -6,7 +6,7 @@ import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, metaproofContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
@@ -23,7 +23,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, derived, metaproofContext);
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement.js

@@ -57,7 +57,7 @@ class MetastatementVerifier extends Verifier {
 
 const metastatementVerifier = new MetastatementVerifier();
 
-export default function verifyMetastatement(metastatementNode, assignments, derived, metaproofContext) {
+export default function verifyMetastatement(metastatementNode, derived, metaproofContext) {
   let metastatementVerified = false;
 
   if (!metastatementVerified) {

package/src/verify/premise.js

@@ -17,9 +17,8 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
   metaproofContext.debug(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
-        assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, metaproofContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, metaproofContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/rule.js

@@ -51,7 +51,7 @@ export default function verifyRule(ruleNode, fileContext) {
         let ruleProofVerified = true; ///
 
         if (ruleProofNode !== null) {
-          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, metaProofContext);
+          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, assignments, metaProofContext);
         }
 
         if (ruleProofVerified) {

package/src/verify/ruleProof.js

@@ -7,7 +7,7 @@ import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 
-export default function verifyRuleProof(ruleProofNode, conclusion, metaproofContext) {
+export default function verifyRuleProof(ruleProofNode, conclusion, assignments, metaproofContext) {
   let ruleProofVerified = false;
 
   const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),

package/src/verify/supposition.js

@@ -30,7 +30,7 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
     proofContext.addProofStep(proofStep);
 
-    assignments.every((assignment) => {
+    assignments.forEach((assignment) => {
       assignment.assign(proofContext);
     });