occam-verify-cli 1.0.230 → 1.0.233

package/src/dom/rule.js

@@ -3,7 +3,6 @@
 import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
@@ -14,12 +13,13 @@ import { labelsFromJSON,
          labelsToLabelsJSON,
          premisesToPremisesJSON,
          conclusionToConclusionJSON } from "../utilities/json";
+import LocalContext from "../context/local";
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
 export default domAssigned(class Rule {
-  constructor(fileContext, string, labels, premises, conclusion, proof) {
-    this.fileContext = fileContext;
+  constructor(context, string, labels, premises, conclusion, proof) {
+    this.context = context;
     this.string = string;
     this.labels = labels;
     this.premises = premises;
@@ -27,8 +27,8 @@ export default domAssigned(class Rule {
     this.proof = proof;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -66,8 +66,7 @@ export default domAssigned(class Rule {
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
     let statementAndStepsOrSubproofsUnify = false;
 
-    const localContext = LocalContext.fromFileContext(this.fileContext),
-          generalContext = localContext, ///
+    const generalContext = this.context, ///
           specificContext = context; ///
 
     const substitutions = Substitutions.fromNothing(),
@@ -148,12 +147,13 @@ export default domAssigned(class Rule {
 
     const ruleString = this.string; ///
 
-    this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
+    this.context.trace(`Verifying the '${ruleString}' rule...`);
 
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const context = LocalContext.fromFileContext(this.fileContext),
+      const localContext = LocalContext.fromContext(this.context),
+            context = localContext, ///
             premisesVerify = this.verifyPremises(context);
 
       if (premisesVerify) {
@@ -165,7 +165,7 @@ export default domAssigned(class Rule {
           if (proofVerifies) {
             const rule = this;  ///
 
-            this.fileContext.addRule(rule);
+            this.context.addRule(rule);
 
             verifies = true;
           }
@@ -174,7 +174,7 @@ export default domAssigned(class Rule {
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${ruleString}' rule.`);
+      this.context.debug(`...verified the '${ruleString}' rule.`);
     }
 
     return verifies;
@@ -249,45 +249,45 @@ export default domAssigned(class Rule {
 
   static name = "Rule";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     let rule;
 
     const proof = null,
-          labels = labelsFromJSON(json, fileContext),
-          premises = premisesFromJSON(json, fileContext),
-          conclusion = conclusionFromJSON(json, fileContext),
+          labels = labelsFromJSON(json, context),
+          premises = premisesFromJSON(json, context),
+          conclusion = conclusionFromJSON(json, context),
           string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion);
 
-    rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
+    rule = new Rule(context, string, labels, premises, conclusion, proof);
 
     return rule;
   }
 
-  static fromRuleNode(ruleNode, fileContext) {
-    const proof = proofFromRuleNode(ruleNode, fileContext),
-          labels = labelsFromRuleNode(ruleNode, fileContext),
-          premises = premisesFromRuleNode(ruleNode, fileContext),
-          conclusion = conclusionFromRuleNode(ruleNode, fileContext),
+  static fromRuleNode(ruleNode, context) {
+    const proof = proofFromRuleNode(ruleNode, context),
+          labels = labelsFromRuleNode(ruleNode, context),
+          premises = premisesFromRuleNode(ruleNode, context),
+          conclusion = conclusionFromRuleNode(ruleNode, context),
           string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
-          rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
+          rule = new Rule(context, string, labels, premises, conclusion, proof);
 
     return rule;
   }
 });
 
-function proofFromRuleNode(ruleNode, fileContext) {
+function proofFromRuleNode(ruleNode, context) {
   const { Proof } = dom,
         proofNode = ruleNode.getProofNode(),
-        proof = Proof.fromProofNode(proofNode, fileContext);
+        proof = Proof.fromProofNode(proofNode, context);
 
   return proof;
 }
 
-function labelsFromRuleNode(ruleNode, fileContext) {
+function labelsFromRuleNode(ruleNode, context) {
   const { Label } = dom,
         labelNodes = ruleNode.getLabelNodes(),
         labels = labelNodes.map((labelNode) => {
-          const label = Label.fromLabelNode(labelNode, fileContext);
+          const label = Label.fromLabelNode(labelNode, context);
 
           return label;
         });
@@ -295,11 +295,11 @@ function labelsFromRuleNode(ruleNode, fileContext) {
   return labels;
 }
 
-function premisesFromRuleNode(ruleNode, fileContext) {
+function premisesFromRuleNode(ruleNode, context) {
   const { Premise } = dom,
         premiseNodes = ruleNode.getPremiseNodes(),
         premises = premiseNodes.map((premiseNode) => {
-          const premise = Premise.fromPremiseNode(premiseNode, fileContext);
+          const premise = Premise.fromPremiseNode(premiseNode, context);
 
           return premise;
         });
@@ -307,10 +307,10 @@ function premisesFromRuleNode(ruleNode, fileContext) {
   return premises;
 }
 
-function conclusionFromRuleNode(ruleNode, fileContext) {
+function conclusionFromRuleNode(ruleNode, context) {
   const { Conclusion } = dom,
         conclusionNode = ruleNode.getConclusionNode(),
-        conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext);
+        conclusion = Conclusion.fromConclusionNode(conclusionNode, context);
 
   return conclusion;
 }

package/src/dom/section.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+
+const { first } = arrayUtilities;
+
+export default domAssigned(class Section {
+  constructor(context, string, hypotheses) {
+    this.context = context;
+    this.string = string;
+    this.hypotheses = hypotheses;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getHypotheses() {
+    return this.hypotheses;
+  }
+
+  verify() {
+    let verifies = false;
+
+    const sectionString = this.string;  ///
+
+    debugger
+
+    return verifies;
+  }
+
+  static name = "Section";
+
+  static fromSectionNode(sectionNode, context) {
+    const hypothesisNodes = sectionNode.getHypothesisNodes(),
+          hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),
+          string = stringFromHypotheses(hypotheses, context),
+          section = new Section(context, string, hypotheses);
+
+    return section;
+  }
+});
+
+function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
+  const hypotheses = hypothesisNodes.map((hypothesisNode) => {
+    const { Hypothesis } = dom,
+          hypothesis = Hypothesis.fromHypothesisNode(hypothesisNode, context);
+
+    return hypothesis;
+  });
+
+  return hypotheses;
+}
+
+function stringFromHypotheses(hypotheses, context) {
+  const firstHypothesis = first(hypotheses),
+        hypothesis = firstHypothesis, ///
+        hypothesisString = hypothesis.getString(),
+        string = `'${hypothesisString}'...`;
+
+  return string;
+}

package/src/dom/signature.js

@@ -157,17 +157,17 @@ export default domAssigned(class Signature {
 
   static name = "Signature";
 
-  static fromJSON(json, fileContext) {
-    const terms = termsFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const terms = termsFromJSON(json, context),
           string = stringFromTerms(terms),
           signature = new Signature(string, terms);
 
     return signature;
   }
 
-  static fromSignatureNode(signatureNode, fileContext) {
+  static fromSignatureNode(signatureNode, context) {
     const termNodes = signatureNode.getTermNodes(),
-          terms = termsFromTermNodes(termNodes, fileContext),
+          terms = termsFromTermNodes(termNodes, context),
           string = stringFromTerms(terms),
           signature = new Signature(string, terms);
 

package/src/dom/statement.js

@@ -2,7 +2,6 @@
 
 import { arrayUtilities } from "necessary";
 
-import LocalContext from "../context/local";
 import verifyMixins from "../mixins/statement/verify";
 import StatementPartialContext from "../context/partial/statement";
 
@@ -250,10 +249,10 @@ export default domAssigned(class Statement {
 
   static name = "Statement";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           statementPartialContext = StatementPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = statementPartialContext.getNode(),
           tokens = statementPartialContext.getTokens(),
@@ -262,27 +261,24 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromStepNode(stepNode, fileContext) {
+  static fromStepNode(stepNode, context) {
     let statement = null;
 
     const statementNode = stepNode.getStatementNode();
 
     if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, fileContext);
+      statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
+  static fromPremiseNode(premiseNode, context) {
     let statement = null;
 
     const statementNode = premiseNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
@@ -295,84 +291,80 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromDeductionNode(deductionNode, fileContext) {
+  static fromDeductionNode(deductionNode, context) {
     let statement = null;
 
     const statementNode = deductionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
+      statement = statementFromStatementNode(statementNode, context);
+    }
+
+    return statement;
+  }
+
+  static fromHypothesisNode(hypothesisNode, context) {
+    let statement = null;
+
+    const statementNode = hypothesisNode.getStatementNode();
 
+    if (statementNode !== null) {
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromConclusionNode(conclusionNode, fileContext) {
+  static fromConclusionNode(conclusionNode, context) {
     let statement = null;
 
     const statementNode = conclusionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromSuppositionNode(suppositionNode, fileContext) {
+  static fromSuppositionNode(suppositionNode, context) {
     let statement = null;
 
     const statementNode = suppositionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromDeclarationNode(declarationNode, fileContext) {
+  static fromDeclarationNode(declarationNode, context) {
     let statementNode;
 
     statementNode = declarationNode.getStatementNode(); ///
 
     statementNode = stripBracketsFromStatementNode(statementNode);  ///
 
-    const localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          statement = statementFromStatementNode(statementNode, context);
+    const statement = statementFromStatementNode(statementNode, context);
 
     return statement;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, fileContext) {
+  static fromContainedAssertionNode(containedAssertionNode, context) {
     let statement = null;
 
     const statementNode = containedAssertionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
     const statementNode = combinatorDeclarationNode.getStatementNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           statement = statementFromStatementNode(statementNode, context);
 
     return statement;

package/src/dom/step.js

@@ -164,7 +164,7 @@ export default domAssigned(class Step {
     return step;
   }
 
-  static fromStepOrSubproofNode(stepOrSubproofNode, fileContext) {
+  static fromStepOrSubproofNode(stepOrSubproofNode, context) {
     let step = null;
 
     const stepNode = stepOrSubproofNode.isStepNode();
@@ -173,9 +173,9 @@ export default domAssigned(class Step {
       const { Statement, Reference } = dom,
             stepNode = stepOrSubproofNode,  ///
             node = stepNode, ///
-            string = fileContext.nodeAsString(node),
-            statement = Statement.fromStepNode(stepNode, fileContext),
-            reference = Reference.fromStepNode(stepNode, fileContext);
+            string = context.nodeAsString(node),
+            statement = Statement.fromStepNode(stepNode, context),
+            reference = Reference.fromStepNode(stepNode, context);
 
       step = new Step(string, statement, reference);
     }

package/src/dom/subDerivation.js

@@ -52,20 +52,20 @@ export default domAssigned(class SubDerivation {
 
   static name = "SubDerivation";
 
-  static fromSubDerivationNode(subDerivationNode, fileContext) {
-    const stepsOrSubproofs = stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext),
+  static fromSubDerivationNode(subDerivationNode, context) {
+    const stepsOrSubproofs = stepOrSubproofFromSubDerivationNode(subDerivationNode, context),
           subDerivation = new SubDerivation(stepsOrSubproofs);
 
     return subDerivation;
   }
 });
 
-function stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext) {
+function stepOrSubproofFromSubDerivationNode(subDerivationNode, context) {
   const { Step, Subproof } = dom,
         stepOrSubproofNodes = subDerivationNode.getStepOrSubproofNodes(),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
-          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
-                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
+          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, context),
+                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, context),
                 stepOrSubproof = (step || subproof);
 
           return stepOrSubproof;

package/src/dom/subproof.js

@@ -134,16 +134,16 @@ export default domAssigned(class Subproof {
 
   static name = "Subproof";
 
-  static fromStepOrSubproofNode(sStepOrSubproofNode, fileContext) {
+  static fromStepOrSubproofNode(sStepOrSubproofNode, context) {
     let subproof = null;
 
     const subproofNode = sStepOrSubproofNode.isSubproofNode();
 
     if (subproofNode) {
       const subproofNode = sStepOrSubproofNode, ///
-            suppositions = suppositionsFromSubproofNode(subproofNode, fileContext),
-            subDerivation = subDerivationFromSubproofNode(subproofNode, fileContext),
-            subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+            suppositions = suppositionsFromSubproofNode(subproofNode, context),
+            subDerivation = subDerivationFromSubproofNode(subproofNode, context),
+            subproofString = subproofStringFromSubproofNode(subproofNode, context),
             string = subproofString;  ///
 
       subproof = new Subproof(string, suppositions, subDerivation);
@@ -153,11 +153,11 @@ export default domAssigned(class Subproof {
   }
 });
 
-function suppositionsFromSubproofNode(subproofNode, fileContext) {
+function suppositionsFromSubproofNode(subproofNode, context) {
   const { Supposition } = dom,
         suppositionNodes = subproofNode.getSuppositionNodes(),
         suppositions = suppositionNodes.map((suppositionNode) => {
-          const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+          const supposition = Supposition.fromSuppositionNode(suppositionNode, context);
 
           return supposition;
         });
@@ -165,10 +165,10 @@ function suppositionsFromSubproofNode(subproofNode, fileContext) {
   return suppositions;
 }
 
-function subDerivationFromSubproofNode(subproofNode, fileContext) {
+function subDerivationFromSubproofNode(subproofNode, context) {
   const { SubDerivation } = dom,
         subDerivationNode = subproofNode.getSubDerivationNode(),
-        subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
+        subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, context);
 
   return subDerivation;
 }

package/src/dom/substitution/statement.js

@@ -171,16 +171,16 @@ export default domAssigned(class StatementSubstitution extends Substitution {
     return json;
   }
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           statementSubstitutionPartialContext = StatementSubstitutionPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = statementSubstitutionPartialContext.getNode(),
           tokens = statementSubstitutionPartialContext.getTokens(),
           resolved = true,
-          statement = statementFromJSON(json, fileContext),
-          metavariable = metavariableFromJSON(json, fileContext),
+          statement = statementFromJSON(json, context),
+          metavariable = metavariableFromJSON(json, context),
           substitution = null,  ///
           statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
 

package/src/dom/supposition.js

@@ -220,9 +220,9 @@ export default domAssigned(class Supposition {
 
   static name = "Supposition";
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
-          procedureCall = procedureCallFromJSON(json, fileContext);
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          procedureCall = procedureCallFromJSON(json, context);
 
     let string;
 
@@ -239,12 +239,12 @@ export default domAssigned(class Supposition {
     return supposition;
   }
 
-  static fromSuppositionNode(suppositionNode, fileContext) {
+  static fromSuppositionNode(suppositionNode, context) {
     const { Statement, ProcedureCall } = dom,
           node = suppositionNode, ///
-          string = fileContext.nodeAsString(node),
-          statement = Statement.fromSuppositionNode(suppositionNode, fileContext),
-          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, fileContext),
+          string = context.nodeAsString(node),
+          statement = Statement.fromSuppositionNode(suppositionNode, context),
+          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, context),
           supposition = new Supposition(string, statement, procedureCall);
 
     return supposition

package/src/dom/term.js

@@ -3,7 +3,6 @@
 import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 
 import { domAssigned } from "../dom";
@@ -188,14 +187,12 @@ export default domAssigned(class Term {
 
   static name = "Term";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext,  ///
           termString = string,  ///
           termNode = termNodeFromTermString(termString, context),
           node = termNode,  ///
-          type = typeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
           term = new Term(string, node, type);
 
     return term;
@@ -265,11 +262,9 @@ export default domAssigned(class Term {
     return term;
   }
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
     const { Type } = dom,
           termNode = constructorDeclarationNode.getTermNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           term = termFromTermNode(termNode, context),
           type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
 

package/src/dom/theorem.js

@@ -8,19 +8,19 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
   verify() {
     let verifies;
 
-    const fileContext = this.getFileContext(),
+    const context = this.getContext(),
           theoremString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${theoremString}' theorem...`);
+    context.trace(`Verifying the '${theoremString}' theorem...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const theorem = this; ///
 
-      fileContext.addTheorem(theorem);
+      context.addTheorem(theorem);
 
-      fileContext.debug(`...verified the '${theoremString}' theorem.`);
+      context.debug(`...verified the '${theoremString}' theorem.`);
     }
 
     return verifies;
@@ -28,11 +28,11 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
 
   static name = "Theorem";
 
-  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
 
-  static fromTheoremNode(theoremNode, fileContext) {
+  static fromTheoremNode(theoremNode, context) {
     const node = theoremNode, ///
-          theorem = TopLevelAssertion.fromNode(Theorem, node, fileContext);
+          theorem = TopLevelAssertion.fromNode(Theorem, node, context);
 
     return theorem;
   }