occam-verify-cli 0.0.958 → 0.0.960

package/src/releaseContext/{verify.js → initialise.js}

@@ -1,7 +1,7 @@
 "use strict";
 
-export default function verifyReleaseContext(dependency, dependentName, dependentReleased, context) {
-  let releaseContextVerified = false;
+export default function initialiseReleaseContext(dependency, dependentName, dependentReleased, context) {
+  let releaseContextInitialised = false;
 
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
@@ -11,44 +11,37 @@ export default function verifyReleaseContext(dependency, dependentName, dependen
   if (releaseContext === null) {
     const { log } = context;
 
-    log.error(`Unable to verify the '${dependencyName}' dependency's context because it has not been created.`);
+    log.warning(`Unable to initialise the '${dependencyName}' ontext because it has not been created.`);
   } else {
-    const verified = releaseContext.isVerified();
+    releaseContextInitialised = releaseContext.isInitialised();
 
-    if (verified) {
-      releaseContextVerified = true;
-    } else {
+    if (!releaseContextInitialised) {
       const released = releaseContext.isReleased();
 
       if (!released && dependentReleased) {
         const { log } = context;
 
-        log.error(`Unable to verify the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
+        log.warning(`Unable to initialise the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
       } else {
-        const dependencies = releaseContext.getDependencies();
+        const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, released, context);
 
-        dependentName = dependencyName;  ///
+        if (dependencyReleaseContextsInitialised) {
+          const { log } = context,
+                releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
-        dependentReleased = released;  ///
+          log.debug(`Initialising the '${dependencyName}' context...`);
 
-        releaseContextVerified = dependencies.everyDependency((dependency) => {  ///
-          const releaseContextVerified = verifyReleaseContext(dependency, dependentName, dependentReleased, context);
+          releaseContextInitialised = releaseContext.initialise(releaseContexts);
 
-          if (releaseContextVerified) {
-            return true;
-          }
-        });
-
-        if (releaseContextVerified) {
-          const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
-
-          releaseContext.verify(releaseContexts);
+          releaseContextInitialised ?
+            log.info(`...initialised the '${dependencyName}' context.`) :
+              log.warning(`...unable to initialise the '${dependencyName}' context.`);
         }
       }
     }
   }
 
-  return releaseContextVerified;
+  return releaseContextInitialised;
 }
 
 function retrieveReleaseContexts(releaseContext, releaseContextMap) {
@@ -87,3 +80,19 @@ function retrieveReleaseContexts(releaseContext, releaseContextMap) {
 
   return releaseContexts;
 }
+
+function initialiseDependencyReleaseContexts(dependency, releaseContext, released, context) {
+  const dependencyName = dependency.getName(),
+        dependentName = dependencyName,  ///
+        dependencies = releaseContext.getDependencies(),
+        dependentReleased = released,  ///
+        dependencyReleaseContextsInitialised = dependencies.everyDependency((dependency) => {  ///
+          const releaseContextInitialised = initialiseReleaseContext(dependency, dependentName, dependentReleased, context);
+
+          if (releaseContextInitialised) {
+            return true;
+          }
+        });
+
+  return dependencyReleaseContextsInitialised;
+}

package/src/rule.js

@@ -1,11 +1,8 @@
 "use strict";
 
-import Label from "./label";
-import Premise from "./premise";
-import Conclusion from "./conclusion";
 import Substitutions from "./substitutions";
-import unifyPremisesAgainstProofSteps from "./unify/premisesAgainstProofSteps";
-import unifyConclusionAgainstStatement from "./unify/conclusionAgainstStatement";
+import unifyPremisesWithProofSteps from "./unify/premisesWithProofSteps";
+import unifyConclusionWithStatement from "./unify/conclusionWithStatement";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -40,11 +37,11 @@ export default class Rule {
           proofStepsB = proofSteps, ///
           fileContextA = this.fileContext,  ///
           localContextB = localContext, ///
-          premisesUnified = unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
+          premisesUnified = unifyPremisesWithProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (premisesUnified) {
       const conclusionA = this.conclusion,  ///
-            conclusionUnified = unifyConclusionAgainstStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
+            conclusionUnified = unifyConclusionWithStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
 
       statementUnified = conclusionUnified;  ///
     }
@@ -64,68 +61,6 @@ export default class Rule {
     return matchesMetavariableNode;
   }
 
-  toJSON(tokens) {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON(tokens);
-
-            return labelJSON;
-          }),
-          premisesJSON = this.premises.map((premise) => {
-            const premiseJSON = premise.toJSON(tokens);
-
-            return premiseJSON;
-          }),
-          conclusionJSON = this.conclusion.toJSON(tokens),
-          labels = labelsJSON,  ///
-          premises = premisesJSON,  ///
-          conclusion = conclusionJSON,  ///
-          json = {
-            labels,
-            premises,
-            conclusion
-          };
-
-    return json;
-  }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    let rule;
-
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSONAndFileContext(json, fileContext);
-
-      return label;
-    });
-
-    let { premises } = json;
-
-    const premisesJSON = premises;  ///
-
-    premises = premisesJSON.map((premiseJSON) => {
-      const json = premiseJSON, ///
-            premise = Premise.fromJSONAndFileContext(json, fileContext);
-
-      return premise;
-    });
-
-    let { conclusion } = json;
-
-    const conclusionJSON = conclusion;  ///
-
-    json = conclusionJSON;  ///
-
-    conclusion = Conclusion.fromJSONAndFileContext(json, fileContext);
-
-    rule = new Rule(labels, premises, conclusion, fileContext);
-
-    return rule;
-  }
-
   static fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext) {
     const rule = new Rule(labels, premises, conclusion, fileContext);
 

package/src/ruleNames.js

@@ -1,6 +1,4 @@
 "use strict";
 
-export const METAVARIABLE_RULE_NAME = "metavariable";
-export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/substitution/statementForMetavariable.js

@@ -3,10 +3,9 @@
 import shim from "../shim";
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "./termForVariable";
-import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
+import unifyStatementWithStatement from "../unify/statementAtainstStatement";
 
 import { nodeQuery } from "../utilities/query";
-import { statementNodeFromStatementString, metavariableNodeFromMetavariableString } from "../utilities/node";
 import { matchStatementModuloBrackets, bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
 
 const metavariableNodeQuery = nodeQuery("/statement/metavariable!");
@@ -75,8 +74,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedAgainstEquivalence = false;  ///
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence = false;  ///
 
     const metavariableNode = metavariableNodeQuery(this.statementNode);
 
@@ -90,10 +89,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
             nodeB = metavariableNode, ///
             unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-      unifiedAgainstEquivalence = unified; ///
+      unifiedWithEquivalence = unified; ///
     }
 
-    return unifiedAgainstEquivalence;
+    return unifiedWithEquivalence;
   }
 
   asString(localContextA, localContextB) {
@@ -106,19 +105,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return string;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    const { metavariable, statement } = json,
-            metavariableString = metavariable,  ///
-            statementString = statement,  ///
-            lexer = fileContext.getLexer(),
-            parser = fileContext.getParser(),
-            statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-            metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
-            statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode);
-
-    return statementForMetavariableSubstitution;
-  }
-
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
     let statementForMetavariableSubstitution;
 
@@ -170,9 +156,9 @@ function unifyStatement(statementNodeA, statementNodeB, substitution, substituti
 
     statementUnified = statementNodeAMatchesStatementNodeB; ///
   } else {
-    const statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    const statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
-    statementUnified = statementUnifiedAgainstStatement; ///
+    statementUnified = statementUnifiedWithStatement; ///
   }
 
   return statementUnified;

package/src/substitution/termForVariable.js

@@ -51,8 +51,8 @@ export default class TermForVariableSubstitution extends Substitution {
     return matchesVariableNode;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedAgainstEquivalence;
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence;
 
     const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
 
@@ -60,11 +60,11 @@ export default class TermForVariableSubstitution extends Substitution {
       const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
 
       if (equivalenceMatchesTermNode) {
-        unifiedAgainstEquivalence = true;
+        unifiedWithEquivalence = true;
       }
     }
 
-    return unifiedAgainstEquivalence;
+    return unifiedWithEquivalence;
   }
 
   asString(localContextA, localContextB) {

package/src/substitution.js

@@ -25,15 +25,15 @@ export default class Substitution {
     return matchesMetavariableNode;
   }
 
-  unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB) {
-    const unifiedAgainstEquivalences = equivalences.some((equivalence) => {
-      const substitutionUnifiedAgainstEquivalence = this.unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB);
+  unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB) {
+    const unifiedWithEquivalences = equivalences.some((equivalence) => {
+      const substitutionUnifiedWithEquivalence = this.unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB);
 
-      if (substitutionUnifiedAgainstEquivalence) {
+      if (substitutionUnifiedWithEquivalence) {
         return true;
       }
     });
 
-    return unifiedAgainstEquivalences;
+    return unifiedWithEquivalences;
   }
 }

package/src/substitutions.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
-
 import { prune, compare, rightDifference } from "./utilities/array";
 
 export default class Substitutions {
@@ -57,17 +55,17 @@ export default class Substitutions {
     localContextB.trace(`Removed the '${substitutionString}' substitution.`, substitutionNode);
   }
 
-  unifyAgainstEquivalences(equivalences, localContextA, localContextB) {
-    const unifiedAgainstEquivalences = this.everySubstitution((substitution) => {
+  unifyWithEquivalences(equivalences, localContextA, localContextB) {
+    const unifiedWithEquivalences = this.everySubstitution((substitution) => {
       const substitutions = this, ///
-            substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB);
+            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB);
 
-      if (substitutionUnifiedAgainstEquivalence) {
+      if (substitutionUnifiedWithEquivalence) {
         return true;
       }
     });
 
-    return unifiedAgainstEquivalences;
+    return unifiedWithEquivalences;
   }
 
   snapshot() {
@@ -102,16 +100,6 @@ export default class Substitutions {
     ///
   }
 
-  toJSON(tokens) {
-    const json = this.array.map((substitution) => {
-      const substitutionJSON = substitution.toJSON(tokens);
-
-      return substitutionJSON;
-    });
-
-    return json;
-  }
-
   static fromNothing() {
     const array = [],
           savedArray = null,
@@ -119,19 +107,4 @@ export default class Substitutions {
 
     return substitutions;
   }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    const substitutionsJSON = json, ///
-          array = substitutionsJSON.map((substitutionJSON) => {
-            const json = substitutionJSON,  ///
-                  statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
-                  substitution = statementForMetavariableSubstitution;  ///
-
-            return substitution;
-          }),
-          savedArray = null,
-          substitutions = new Substitutions(array, savedArray);
-
-    return substitutions;
-  }
 }

package/src/supposition.js

@@ -5,7 +5,6 @@ import metaLevelUnifier from "./unifier/metaLevel";
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString } from "./utilities/node";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
@@ -66,30 +65,9 @@ export default class Supposition {
     return subproofUnified;
   }
 
-  toJSON(tokens) {
-    const statementString = nodeAsString(this.statementNode, tokens),
-          statement = statementString, ///
-          json = {
-            statement
-          };
-
-    return json;
-  }
-
   static fromStatementNode(statementNode) {
     const supposition = new Supposition(statementNode);
 
     return supposition;
   }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    const { statement } = json,
-          statementString = statement,  ///
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          supposition = new Supposition(statementNode);
-
-    return supposition;
-  }
 }

package/src/theorem.js

@@ -3,7 +3,5 @@
 import TopLevelAssertion from "./topLevelAssertion";
 
 export default class Theorem extends TopLevelAssertion {
-  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Theorem, json, fileContext); }
-
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Theorem, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/topLevelAssertion.js

@@ -1,11 +1,8 @@
 "use strict";
 
-import Label from "./label";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import Substitutions from "./substitutions";
-import unifyConsequentAgainstStatement from "./unify/consequentAgainstStatement";
-import unifySuppositionsAgainstProofSteps from "./unify/suppositionsAgainstProofSteps";
+import unifyConsequentWithStatement from "./unify/consequentWithStatement";
+import unifySuppositionsWithProofSteps from "./unify/suppositionsWithProofSteps";
 
 export default class TopLevelAssertion {
   constructor(labels, suppositions, consequent, substitutions, fileContext) {
@@ -45,11 +42,11 @@ export default class TopLevelAssertion {
           fileContextA = this.fileContext,  ///
           suppositionsA = this.suppositions,  ///
           localContextB = localContext, ///
-          suppositionsUnified = unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
+          suppositionsUnified = unifySuppositionsWithProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (suppositionsUnified) {
       const consequentA = this.consequent,  ///
-            consequentUnified = unifyConsequentAgainstStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
+            consequentUnified = unifyConsequentWithStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
 
       statementUnified = consequentUnified;  ///
     }
@@ -69,70 +66,5 @@ export default class TopLevelAssertion {
     return matchesMetavariableNode;
   }
 
-  toJSON(tokens) {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON(tokens);
-
-            return labelJSON;
-          }),
-          suppositionsJSON = this.suppositions.map((supposition) => {
-            const suppositionJSON = supposition.toJSON(tokens);
-
-            return suppositionJSON;
-          }),
-          consequentJSON = this.consequent.toJSON(tokens),
-          substitutionsJSON = this.substitutions.toJSON(tokens),
-          labels = labelsJSON,  ///
-          suppositions = suppositionsJSON,  ///
-          consequent = consequentJSON,  ///
-          substitutions = substitutionsJSON,  ///
-          json = {
-            labels,
-            suppositions,
-            consequent,
-            substitutions
-          };
-
-    return json;
-  }
-
-  static fromJSONAndFileContext(Class, json, fileContext) {
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSONAndFileContext(json, fileContext);
-
-      return label;
-    });
-
-    let { suppositions, consequent, substitutions } = json;
-
-    const suppositionsJSON = suppositions;  ///
-
-    suppositions = suppositionsJSON.map((suppositionJSON) => {
-      const json = suppositionJSON, ///
-            supposition = Supposition.fromJSONAndFileContext(json, fileContext);
-
-      return supposition;
-    });
-
-    const consequentJSON = consequent;  ///
-
-    json = consequentJSON;  ///
-
-    consequent = Consequent.fromJSONAndFileContext(json, fileContext);
-
-    const substitutionsJSON = substitutions;  ///
-
-    json = substitutionsJSON; ///
-
-    substitutions = Substitutions.fromJSONAndFileContext(json, fileContext);
-
-    return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
-  }
-
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/type.js

@@ -125,18 +125,6 @@ export default class Type {
     return string;
   }
 
-  toJSON(tokens) {
-    const superTypeJSON = this.superType.toJSON(tokens),
-          name = this.name,
-          superType = superTypeJSON,  ///
-          json = {
-            name,
-            superType
-          };
-
-    return json;
-  }
-
   static fromTypeName(typeName) {
     const name = typeName,  ///
           superType = objectType, ///
@@ -154,17 +142,6 @@ export default class Type {
 }
 
 class ObjectType extends Type {
-  toJSON(tokens) {
-    const name = this.name,
-          superType = null,  ///
-          json = {
-            name,
-            superType
-          };
-
-    return json;
-  }
-
   static fromNothing() {
     const name = OBJECT_TYPE_NAME,
           superType = null,
@@ -175,24 +152,3 @@ class ObjectType extends Type {
 }
 
 export const objectType = ObjectType.fromNothing();
-
-export function typeFromJSONAndFileContext(json, fileContext) {
-  let type;
-
-  const { name } = json,
-        typeName = name;  ///
-
-  type = fileContext.findTypeByTypeName(typeName);
-
-  if (type === null) {
-    let { superType } = json;
-
-    const superJSON = superType;  ///
-
-    superType = typeFromJSONAndFileContext(superJSON, fileContext);
-
-    type = new Type(name, superType);
-  }
-
-  return type;
-}

package/src/unifier/equality.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstTerm from "../unify/termAgainstTerm";
+import unifyTermWithTerm from "../unify/termWithTerm";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -25,14 +25,14 @@ class EqualityUnifier extends Unifier {
       nodeQueryA: termNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termNodeA, termNodeB, localContext) => {
-        let termUnifiedAgainstTerm;
+        let termUnifiedWithTerm;
 
         const leftTermNode = termNodeA, ///
               rightTermNode = termNodeB;  ///
 
-        termUnifiedAgainstTerm = unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext);
+        termUnifiedWithTerm = unifyTermWithTerm(leftTermNode, rightTermNode, localContext);
 
-        if (!termUnifiedAgainstTerm) {
+        if (!termUnifiedWithTerm) {
           const nonTerminalNodeA = termNodeA, ///
                 nonTerminalNodeB = termNodeB, ///
                 nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
@@ -41,10 +41,10 @@ class EqualityUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext);
 
-          termUnifiedAgainstTerm = childNodesVerified; ///
+          termUnifiedWithTerm = childNodesVerified; ///
         }
 
-        return termUnifiedAgainstTerm;
+        return termUnifiedWithTerm;
       }
     }
   ];

package/src/unifier/intrinsicLevel.js

@@ -2,7 +2,7 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
+import unifyVariableWithTerm from "../unify/variableWithTerm";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -28,9 +28,9 @@ class IntrinsicLevelUnifier extends Unifier {
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedAgainstTerm = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
 
-        return variableUnifiedAgainstTerm;
+        return variableUnifiedWithTerm;
       }
     }
   ];