occam-verify-cli 0.0.1003 → 0.0.1005

package/src/context/local.js

@@ -88,8 +88,6 @@ class LocalContext {
     return lastProofStep;
   }
 
-  getTokens() { return this.context.getTokens(); }
-
   getAxioms() { return this.context.getAxioms(); }
 
   getLemmas() { return this.context.getLemmas(); }
@@ -377,29 +375,29 @@ class LocalContext {
     return metavariable;
   }
 
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
+  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
 
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+
+  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-  findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
+  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
 
-  findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
+  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
 
-  findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
+  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
 
-  findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
+  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
 
-  findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
+  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
 
-  findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
+  findMetaLemmaByReference(reference) { return this.context.findMetaLemmaByReference(reference); }
 
-  findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
+  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
 
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+  findMetatheoremByReference(reference) { return this.context.findMetatheoremByReference(reference); }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -415,8 +413,6 @@ class LocalContext {
 
   error(message, node) { this.context.error(message, node); }
 
-  fatal(message, node) { this.context.fatal(node, message); }
-
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],

package/src/context/release.js

@@ -10,8 +10,8 @@ import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { isFilePathFlorenceFilePath } = filePathUtilities,
-      { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
-      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
   constructor(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
@@ -456,61 +456,44 @@ export default class ReleaseContext {
     this.log.error(message, node, tokens, filePath);
   }
 
-  fatal(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.fatal(message, node, tokens, filePath);
-  }
-
-  initialise(releaseContexts, verbose) {
-    let initialised;
-
+  initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
-          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar),
-          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+          nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar),
+          nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-    this.lexer = florenceLexer; ///
+    this.lexer = nominalLexer; ///
 
-    this.parser = florenceParser; ///
+    this.parser = nominalParser; ///
 
     this.dependencyReleaseContexts = tail(releaseContexts);
 
     if (this.released) {
-      const verified = this.verify(verbose);
+      const releaseContext = this,  ///
+            fileContexts = fileContextsFromEntries(this.entries, releaseContext);
 
-      initialised = verified;  ///
-    } else {
-      initialised = true;
-    }
+      initialiseFileContexts(fileContexts, releaseContext);
 
-    this.initialised = initialised;
+      this.fileContexts = fileContexts;
+    }
 
-    return initialised;
+    this.initialised = true;
   }
 
-  verify(verbose = true) {
-    let verified;
+  verify() {
+    let verified = false;
 
-    const releaseContext = this;
+    const releaseContext = this,  ///
+          fileContexts = fileContextsFromEntries(this.entries, releaseContext),
+          fileContextsVerified = verifyFileContexts(fileContexts, releaseContext);
 
-    if (!verbose) {
-      releaseContext.disableLogging();
-    }
-
-    this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);
-
-    const fileContextsVerified = verifyFileContexts(this.fileContexts, releaseContext);
+    if (fileContextsVerified) {
+      this.fileContexts = fileContexts;
 
-    verified = fileContextsVerified;  ///
+      this.verified = true;
 
-    if (!verbose) {
-      releaseContext.enableLogging();
+      verified = true;
     }
 
-    this.verified = verified;
-
     return verified;
   }
 
@@ -583,6 +566,41 @@ function verifyFileContexts(fileContexts, releaseContext) {
   return fileContextsVerified;
 }
 
+function initialiseFileContexts(fileContexts, releaseContext) {
+  fileContexts = [  ///
+    ...fileContexts
+  ];
+
+  for (;;) {
+    const fileContextsLength = fileContexts.length;
+
+    if (fileContextsLength === 0) {
+      break;
+    }
+
+    const initialisedFileContexts = [];
+
+    fileContexts.forEach((fileContext) => {
+      const initialised = fileContext.initialise(releaseContext);
+
+      if (initialised) {
+        const initialisedFileContext = fileContext;  ///
+
+        initialisedFileContexts.push(initialisedFileContext);
+      }
+    });
+
+    const initialisedFileContextsLength = initialisedFileContexts.length,
+          fileInitialised = (initialisedFileContextsLength > 0);
+
+    if (!fileInitialised) {
+      break;
+    }
+
+    leftDifference(fileContexts, initialisedFileContexts);
+  }
+}
+
 function fileContextsFromEntries(entries, releaseContext) {
   const fileContexts = [];