occam-verify-cli 0.0.958 → 0.0.960

package/src/context/release.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { filePathUtilities } from "occam-entities";
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
 import FileContext from "./file";
@@ -8,18 +9,20 @@ import { objectType } from "../type";
 import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
-const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
+const { isFilePathFlorenceFilePath } = filePathUtilities,
+      { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, json, name, lexer, parser, entries, verified, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
+  constructor(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
     this.log = log;
-    this.json = json;
     this.name = name;
+    this.entries = entries;
+    this.released = released;
     this.lexer = lexer;
     this.parser = parser;
-    this.entries = entries;
     this.verified = verified;
+    this.initialised = initialised;
     this.fileContexts = fileContexts;
     this.customGrammar = customGrammar;
     this.loggingDisabled = loggingDisabled;
@@ -30,14 +33,18 @@ export default class ReleaseContext {
     return log;
   }
 
-  getJSON() {
-    return this.json;
-  }
-
   getName() {
     return this.name;
   }
 
+  getEntries() {
+    return this.entries;
+  }
+
+  isReleased() {
+    return this.released;
+  }
+
   getLexer() {
     return this.lexer;
   }
@@ -46,14 +53,14 @@ export default class ReleaseContext {
     return this.parser;
   }
 
-  getEntries() {
-    return this.entries;
-  }
-
   isVerified() {
     return this.verified;
   }
 
+  isInitialised() {
+    return this.initialised;
+  }
+
   getFileContexts() {
     return this.fileContexts;
   }
@@ -74,14 +81,18 @@ export default class ReleaseContext {
     this.log = log;
   }
 
-  setJSON(json) {
-    this.json = json;
-  }
-
   setName(name) {
     this.name = name;
   }
 
+  setEntries(entries) {
+    this.entries = entries;
+  }
+
+  setReleased(released) {
+    this.released = released;
+  }
+
   setLexer(lexer) {
     this.lexer = lexer;
   }
@@ -90,14 +101,14 @@ export default class ReleaseContext {
     this.parser = parser;
   }
 
-  setEntries(entries) {
-    this.entries = entries;
-  }
-
   setVerified(verified) {
     this.verified = verified;
   }
 
+  setInitialised(initialised) {
+    return this.initialised = initialised;
+  }
+
   setFileContexts(fileContexts) {
     this.fileContexts = fileContexts;
   }
@@ -376,12 +387,6 @@ export default class ReleaseContext {
     return type;
   }
 
-  isReleased() {
-    const released = (this.json !== null);
-
-    return released;
-  }
-
   getReleaseName() {
     const name = this.getName(),
           releaseName = name; ///
@@ -459,7 +464,9 @@ export default class ReleaseContext {
     this.log.fatal(message, node, tokens, filePath);
   }
 
-  verify(releaseContexts) {
+  initialise(releaseContexts) {
+    let initialised;
+
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
           florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar),
           florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
@@ -468,21 +475,39 @@ export default class ReleaseContext {
 
     this.parser = florenceParser; ///
 
-    this.dependencyReleaseContexts = tail(releaseContexts)
+    this.dependencyReleaseContexts = tail(releaseContexts);
 
-    if (this.json !== null) {
-      const releaseContext = this;
+    if (this.released) {
+      const verified = this.verify();
 
-      releaseContext.disableLogging();
+      initialised = verified;  ///
+    } else {
+      initialised = true;
+    }
 
-      this.fileContexts = fileContextsFromJSON(this.json, releaseContext);
+    this.initialised = initialised;
 
-      verifyFileContexts(this.fileContexts, releaseContext);
+    return initialised;
+  }
 
-      releaseContext.enableLogging();
+  verify() {
+    let verified;
 
-      this.verified = true;
-    }
+    const releaseContext = this;
+
+    releaseContext.disableLogging();
+
+    this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);
+
+    const fileContextsVerified = verifyFileContexts(this.fileContexts, releaseContext);
+
+    verified = fileContextsVerified;  ///
+
+    releaseContext.enableLogging();
+
+    this.verified = verified;
+
+    return verified;
   }
 
   toJSON() {
@@ -496,21 +521,24 @@ export default class ReleaseContext {
     return json;
   }
 
-  static fromLogJSONNameAndEntries(log, json, name, entries) {
+  static fromLogNameEntriesAndReleased(log, name, entries, released) {
     const lexer = null,
           parser = null,
           verified = false,
+          initialised = false,
           fileContexts = [],
           customGrammar = customGrammarFromNameAndEntries(name, entries),
           loggingDisabled = false,
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, json, name, lexer, parser, entries, verified, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
 
     return releaseContext;
   }
 }
 
 function verifyFileContexts(fileContexts, releaseContext) {
+  let fileContextsVerified;
+
   fileContexts = [  ///
     ...fileContexts
   ];
@@ -543,16 +571,27 @@ function verifyFileContexts(fileContexts, releaseContext) {
 
     leftDifference(fileContexts, verifiedFileContexts);
   }
+
+  const fileContextsLength = fileContexts.length;
+
+  fileContextsVerified = (fileContextsLength === 0);
+
+  return fileContextsVerified;
 }
 
-function fileContextsFromJSON(json, releaseContext) {
-  const fileContextsJSON = json, ///
-        fileContexts = fileContextsJSON.map((fileContextJSON) => {
-          const json = fileContextJSON, ///
-                fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
+function fileContextsFromEntries(entries, releaseContext) {
+  const fileContexts = [];
 
-          return fileContext;
-        });
+  entries.forEachFile((file) => {
+    const filePath = file.getPath(),
+          filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+
+    if (filePathFlorenceFilePath) {
+      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);
+
+      fileContexts.push(fileContext);
+    }
+  });
 
   return fileContexts;
 }

package/src/frame.js

@@ -38,9 +38,9 @@ export default class Frame {
 
   unifySubstitution(substitution) {
     const substitutionUnified = this.declarations.some((declaration) => {
-      const substitutionUnifiedAgainstDeclaration = declaration.unifySubstitution(substitution);
+      const substitutionUnifiedWithDeclaration = declaration.unifySubstitution(substitution);
 
-      if (substitutionUnifiedAgainstDeclaration) {
+      if (substitutionUnifiedWithDeclaration) {
         return true;
       }
     });

package/src/index.js

@@ -4,6 +4,6 @@ export { default as Log } from "./log";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
 export { default as createReleaseContext } from "./releaseContext/create";
-export { default as verifyReleaseContext } from "./releaseContext/verify";
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
+export { default as initialiseReleaseContext } from "./releaseContext/initialise";
 

package/src/label.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
 export default class Label {
   constructor(metavariableNode) {
@@ -24,26 +23,9 @@ export default class Label {
     return string;
   }
 
-  toJSON(tokens) {
-    const string = nodeAsString(this.metavariableNode, tokens),
-          json = string;  ///
-
-    return json;
-  }
-
   static fromMetavariableNode(metavariableNode) {
     const label = new Label(metavariableNode);
 
     return label;
   }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    const metavariableString = json, ///
-          lexer  = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
-          label = new Label(metavariableNode);
-
-    return label;
-  }
 }

package/src/lemma.js

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

package/src/metaLemma.js

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

package/src/metaType.js

@@ -50,15 +50,6 @@ export default class MetaType {
     return string;
   }
 
-  toJSON(tokens) {
-    const name = this.name,
-          json = {
-            name
-          };
-
-    return json;
-  }
-
   static fromMetaTypeName(metaTypeName) {
     const name = metaTypeName,  ///
           metaType = new MetaType(name);

package/src/metatheorem.js

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

package/src/metavariable.js

@@ -6,8 +6,6 @@ import { first } from "./utilities/array";
 import { nodeQuery } from "./utilities/query";
 import { nodeAsString } from "./utilities/string";
 import { nameFromMetavariableNode } from "./utilities/name";
-import { metaTypeFromJSONAndFileContext } from "./metaType";
-import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term!"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type!");
@@ -65,9 +63,9 @@ export default class Metavariable {
         } else if ((termNode === null) && (this.termType === null)) {
           matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
-          const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, this.termType, localContext);
+          const termUnifiedWithTermType = unifyTermWithTermType(termNode, this.termType, localContext);
 
-          matchesNode = termUnifiedAgainstTermType;  ///
+          matchesNode = termUnifiedWithTermType;  ///
         }
       }
     }
@@ -75,19 +73,6 @@ export default class Metavariable {
     return matchesNode;
   }
 
-  toJSON(tokens) {
-    const metaTypeJSON = this.metaType.toJSON(tokens),
-          string = nodeAsString(this.node, tokens),
-          node = string,  //
-          metaType = metaTypeJSON,  ///
-          json = {
-            node,
-            metaType
-          };
-
-    return json;
-  }
-
   asString(tokens) {
     const metaTypeName = this.metaType.getName();
 
@@ -98,29 +83,6 @@ export default class Metavariable {
     return string;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    let { node } = json;
-
-    const lexer  = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          variableString = node,  ///
-          metavariableNode = metavariableNodeFromMetavariableString(variableString, lexer, parser);
-
-    node = metavariableNode;  ///
-
-    let { metaType } = json;
-
-    json = metaType;  ///
-
-    metaType = metaTypeFromJSONAndFileContext(json, fileContext);
-
-    const name = nameFromMetavariableNode(metavariableNode),
-          termType = termTypeFromMetavariableNode(metavariableNode, fileContext),
-          metavariable = new Metavariable(node, name, termType, metaType);
-
-    return metavariable;
-  }
-
   static fromNodeNameTermTypeAndMetaType(node, name, termType, metaType) {
     const metavariable = new Metavariable(node, name, termType, metaType);
 
@@ -128,8 +90,8 @@ export default class Metavariable {
   }
 }
 
-export function unifyTermAgainstTermType(termNode, termType, localContext) {
-  let termUnifiedAgainstTermType;
+export function unifyTermWithTermType(termNode, termType, localContext) {
+  let termUnifiedWithTermType;
 
   const type = termType,  ///
         terms = [],
@@ -148,9 +110,9 @@ export function unifyTermAgainstTermType(termNode, termType, localContext) {
           return verifiedAhead;
         });
 
-  termUnifiedAgainstTermType = termVerified;  ///
+  termUnifiedWithTermType = termVerified;  ///
 
-  return termUnifiedAgainstTermType;
+  return termUnifiedWithTermType;
 }
 
 function termTypeFromMetavariableNode(metavariableNode, fileContext) {

package/src/premise.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 Premise {
     return subproofUnified;
   }
 
-  toJSON(tokens) {
-    const statementString = nodeAsString(this.statementNode, tokens),
-          statement = statementString,  ///
-          json = {
-            statement
-          };
-
-    return json;
-  }
-
   static fromStatementNode(statementNode) {
     const premise = new Premise(statementNode);
 
     return premise;
   }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    const { statement } = json,
-          statementString = statement,  ///
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          premise = new Premise(statementNode);
-
-    return premise;
-  }
 }

package/src/proofStep.js

@@ -21,23 +21,23 @@ export default class ProofStep {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
-      let statementUnifiedAgainstStatement = false;
+      let statementUnifiedWithStatement = false;
 
-      if (!statementUnifiedAgainstStatement) {
+      if (!statementUnifiedWithStatement) {
         const statementNodeA = statementNode, ///
               statementNodeB = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
-      if (!statementUnifiedAgainstStatement) {
+      if (!statementUnifiedWithStatement) {
         const statementNodeA = statementNode, ///
               statementNodeB = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
-      statementUnified = statementUnifiedAgainstStatement;  ///
+      statementUnified = statementUnifiedWithStatement;  ///
     }
 
     return statementUnified;
@@ -58,13 +58,13 @@ export default class ProofStep {
   }
 }
 
-function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
-  let statementUnifiedAgainstStatement = false;
+function unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
+  let statementUnifiedWithStatement = false;
 
   const statementStringA = localContextA.nodeAsString(statementNodeA),
         statementStringB = localContextB.nodeAsString(statementNodeB);
 
-  localContextB.trace(`Unifying the '${statementStringB}' statement against the '${statementStringA}' statement...`, statementNodeB);
+  localContextB.trace(`Unifying the '${statementStringB}' statement with the '${statementStringA}' statement...`, statementNodeB);
 
   const substitutions = Substitutions.fromNothing(),
         nodeA = statementNodeA,  ///
@@ -72,14 +72,14 @@ function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivale
         unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
   if (unified) {
-    const substitutionsUnifiedAgainstEquivalences = substitutions.unifyAgainstEquivalences(equivalences, localContextA, localContextB);
+    const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
 
-    statementUnifiedAgainstStatement = substitutionsUnifiedAgainstEquivalences;  ///
+    statementUnifiedWithStatement = substitutionsUnifiedWithEquivalences;  ///
   }
 
-  if (statementUnifiedAgainstStatement) {
-    localContextB.debug(`...unified the '${statementStringB}' statement against the '${statementStringA}' statement.`, statementNodeB);
+  if (statementUnifiedWithStatement) {
+    localContextB.debug(`...unified the '${statementStringB}' statement with the '${statementStringA}' statement.`, statementNodeB);
   }
 
-  return statementUnifiedAgainstStatement;
+  return statementUnifiedWithStatement;
 }

package/src/releaseContext/create.js

@@ -12,11 +12,9 @@ export default function createReleaseContext(dependency, dependentNames, context
   log.debug(`Creating the '${releaseName}' context given the '${dependencyString}' dependency...`);
 
   if (releaseContext !== null) {
-    const error = null,
-          version = releaseContext.getVersion(),
-          versionString = version.toString();
+    const error = null;
 
-    log.debug(`...already created the '${releaseName}:${versionString}' context.`);
+    log.debug(`...already created the '${releaseName}' context.`);
 
     callback(error);
 
@@ -52,20 +50,17 @@ export default function createReleaseContext(dependency, dependentNames, context
       return;
     }
 
-    const version = releaseContext.getVersion(),
-          versionString = version.toString();
-
     releaseContextMap[releaseName] = releaseContext;
 
-    createDependencyReleaseContexts(dependency, dependentNames, context, (error) => {
+    log.info(`...created the '${releaseName}' context.`);
+
+    createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context, (error) => {
       if (error) {
         callback(error);
 
         return;
       }
 
-      log.info(`...created the '${releaseName}@${versionString}' context.`);
-
       callback(error);
     });
   }, context);
@@ -122,7 +117,7 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
             versionString = version.toString(),
             dependencyString = dependency.asString();
 
-      log.error(`Version mismatch: '${dependentName}' requires the '${dependencyString}' dependency but a context with version '${versionString}' was created.`);
+      log.warning(`Version mismatch: The '${dependentName}' dependent requires the '${dependencyString}' dependency but a context with version '${versionString}' was provided.`);
 
       releaseMatchesDependency = false;
     }
@@ -131,11 +126,8 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
   return releaseMatchesDependency;
 }
 
-function createDependencyReleaseContexts(dependency, dependentNames, context, callback) {
-  const { releaseContextMap } = context,
-        dependencyName = dependency.getName(),
-        releaseName = dependencyName, ///
-        releaseContext = releaseContextMap[releaseName],
+function createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context, callback) {
+  const dependencyName = dependency.getName(),
         dependencies = releaseContext.getDependencies();
 
   dependentNames = [ ...dependentNames, dependencyName ];  ///