occam-verify-cli 0.0.1005 → 0.0.1007

package/src/context/file.js

@@ -13,16 +13,14 @@ import Combinator from "../combinator";
 import Constructor from "../constructor";
 import Metatheorem from "../metatheorem";
 import Metavariable from "../metavariable";
-import topLevelVerifier from "../verifier/topLevel";
 
 import { push } from "../utilities/array";
 import { objectType } from "../type";
 import { nodeAsString, nodesAsString } from "../utilities/string";
 
 export default class FileContext {
-  constructor(releaseContext, fileContent, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables) {
     this.releaseContext = releaseContext;
-    this.fileContent = fileContent;
     this.filePath = filePath;
     this.tokens = tokens;
     this.node = node;
@@ -44,10 +42,6 @@ export default class FileContext {
     return this.releaseContext;
   }
 
-  getFileContent() {
-    return this.fileContent;
-  }
-
   getFilePath() {
     return this.filePath;
   }
@@ -60,6 +54,8 @@ export default class FileContext {
     return this.node;
   }
 
+  getFile(filePath) { return this.releaseContext.getFile(filePath); }
+
   getLexer() { return this.releaseContext.getLexer(); }
 
   getParser() { return this.releaseContext.getParser(); }
@@ -288,6 +284,70 @@ export default class FileContext {
     return this.metavariables;
   }
 
+  setReleaseContext(releaseContext) {
+    this.releaseContext = releaseContext;
+  }
+
+  setFilePath(filePath) {
+    this.filePath = filePath;
+  }
+
+  setTokens(tokens) {
+    this.tokens = tokens;
+  }
+
+  setNode(node) {
+    this.node = node;
+  }
+
+  setTypes(types) {
+    this.types = types;
+  }
+
+  setRules(rules) {
+    this.rules = rules;
+  }
+
+  setAxioms(axioms) {
+    this.axioms = axioms;
+  }
+
+  setLemmas(lemmas) {
+    this.lemmas = lemmas;
+  }
+
+  setTheorems(theorems) {
+    this.theorems = theorems;
+  }
+
+  setVariables(variables) {
+    this.variables = variables;
+  }
+
+  setMetaLemmas(metaLemmas) {
+    this.metaLemmas = metaLemmas;
+  }
+
+  setConjectures(conjectures) {
+    this.conjectures = conjectures;
+  }
+
+  setCombinators(combinators) {
+    this.combinators = combinators;
+  }
+
+  setConstructors(constructors) {
+    this.constructors = constructors;
+  }
+
+  setMetatheorems(metatheorems) {
+    this.metatheorems = metatheorems;
+  }
+
+  setMetavariables(metavariables) {
+    this.metavariables = metavariables;
+  }
+
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
@@ -615,15 +675,15 @@ export default class FileContext {
     return metavariableAdded;
   }
 
-  trace(message, node) { this.releaseContext.trace(message, node, this.tokens, this.filePath); }
+  trace(message) { this.releaseContext.trace(message, this.filePath); }
 
-  debug(message, node) { this.releaseContext.debug(message, node, this.tokens, this.filePath); }
+  debug(message) { this.releaseContext.debug(message, this.filePath); }
 
-  info(message, node) { this.releaseContext.info(message, node, this.tokens, this.filePath); }
+  info(message) { this.releaseContext.info(message, this.filePath); }
 
-  warning(message, node) { this.releaseContext.warning(message, node, this.tokens, this.filePath); }
+  warning(message) { this.releaseContext.warning(message, this.filePath); }
 
-  error(message, node) { this.releaseContext.error(message, node, this.tokens, this.filePath); }
+  error(message) { this.releaseContext.error(message, this.filePath); }
 
   reset() {
     this.types = [];
@@ -640,30 +700,6 @@ export default class FileContext {
     this.metavariables = [];
   }
 
-  verify() {
-    let verified = false;
-
-    if (this.tokens === null) {
-      const lexer = this.getLexer(),
-            parser = this.getParser(),
-            content = this.fileContent; ///
-
-      this.tokens = lexer.tokenise(content);
-
-      this.node = parser.parse(this.tokens);
-    }
-
-    if (this.node !== null) {
-      this.reset();
-
-      const fileContext = this; ///
-
-      verified = topLevelVerifier.verify(this.node, fileContext);
-    }
-
-    return verified;
-  }
-
   toJSON() {
     const filePath =  this.filePath,
           types = this.types.map((type) => {
@@ -769,8 +805,8 @@ export default class FileContext {
     return json;
   }
 
-  static fromJSON(json) {
-    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
+  initialise(fileContextJSON) {
+    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = fileContextJSON,
           fileContext = this, ///
           typesJSON = types,  ///
           rulesJSON = rules,  ///
@@ -871,10 +907,13 @@ export default class FileContext {
   }
 
   static fromFileAndReleaseContext(file, releaseContext) {
-    const fileContent = file.getContent(),
+    const lexer = releaseContext.getLexer(),
+          parser = releaseContext.getParser(),
           filePath = file.getPath(),
-          tokens = null,
-          node = null,
+          fileContent = file.getContent(),
+          content = fileContent,  ////
+          tokens = lexer.tokenise(content),
+          node = parser.parse(tokens),
           types = [],
           rules = [],
           axioms = [],
@@ -887,7 +926,7 @@ export default class FileContext {
           constructors = [],
           metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, fileContent, filePath, tokens, node, types, rules, axioms, lemmas, metaLemmas, variables, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, metaLemmas, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     return fileContext;
   }
@@ -897,7 +936,7 @@ export default class FileContext {
           lexer = releaseContext.getLexer(),
           parser = releaseContext.getParser(),
           fileContent = file.getContent(),
-          content = fileContent,  ///
+          content = fileContent,  ////
           tokens = lexer.tokenise(content),
           node = parser.parse(tokens),
           types = [],
@@ -912,8 +951,8 @@ export default class FileContext {
           constructors = [],
           metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, fileContent, filePath, tokens, node, types, rules, axioms, lemmas, variables, metaLemmas, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, metaLemmas, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     return fileContext;
   }
-}
+}

package/src/context/release.js

@@ -1,31 +1,31 @@
 "use strict";
 
+import FileContext from "./file";
+import topLevelVerifier from "../verifier/topLevel";
+
 import { filePathUtilities } from "occam-entities";
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-import FileContext from "./file";
-
 import { objectType } from "../type";
 import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
-const { isFilePathFlorenceFilePath } = filePathUtilities,
+const { isFilePathNominalFilePath } = filePathUtilities,
       { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
+  constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
+    this.json = json;
     this.entries = entries;
-    this.released = released;
     this.lexer = lexer;
     this.parser = parser;
     this.verified = verified;
     this.initialised = initialised;
     this.fileContexts = fileContexts;
     this.customGrammar = customGrammar;
-    this.loggingDisabled = loggingDisabled;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
@@ -37,12 +37,12 @@ export default class ReleaseContext {
     return this.name;
   }
 
-  getEntries() {
-    return this.entries;
+  getJSON() {
+    return this.json;
   }
 
-  isReleased() {
-    return this.released;
+  getEntries() {
+    return this.entries;
   }
 
   getLexer() {
@@ -69,10 +69,6 @@ export default class ReleaseContext {
     return this.customGrammar;
   }
 
-  isLoggingDisabled() {
-    return this.loggingDisabled;
-  }
-
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
@@ -89,10 +85,6 @@ export default class ReleaseContext {
     this.entries = entries;
   }
 
-  setReleased(released) {
-    this.released = released;
-  }
-
   setLexer(lexer) {
     this.lexer = lexer;
   }
@@ -117,14 +109,28 @@ export default class ReleaseContext {
     this.customGrammar = customGrammar;
   }
 
-  setLoggingDisabled(loggingDisabled) {
-    this.loggingDisabled = loggingDisabled;
-  }
-
   setDependencyReleaseContexts(dependencyReleaseContexts) {
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
+  findFileContext(filePath) {
+    const fileContext = this.fileContexts.find((fileContext) => {
+      const fileContextFilePath = fileContext.getFilePath();
+
+      if (fileContextFilePath === filePath) {
+        return true;
+      }
+    });
+
+    return fileContext;
+  }
+
+  isReleased() {
+    const released = (this.json !== null);
+
+    return released;
+  }
+
   getLabels(includeDependencies = true) {
     const labels = [];
 
@@ -404,77 +410,32 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  disableLogging() {
-    const loggingDisabled = true;
-
-    this.setLoggingDisabled(loggingDisabled);
-  }
-
-  enableLogging() {
-    const loggingDisabled = false;
+  trace(message, filePath = null) { this.log.trace(message, filePath); }
 
-    this.setLoggingDisabled(loggingDisabled);
-  }
-
-  trace(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.trace(message, node, tokens, filePath);
-  }
+  debug(message, filePath = null) { this.log.debug(message, filePath); }
 
-  debug(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
+  info(message, filePath = null) { this.log.info(message, filePath); }
 
-    this.log.debug(message, node, tokens, filePath);
-  }
+  warning(message, filePath = null) { this.log.warning(message, filePath); }
 
-  info(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.info(message, node, tokens, filePath);
-  }
-
-  warning(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.warning(message, node, tokens, filePath);
-  }
-
-  error(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.error(message, node, tokens, filePath);
-  }
+  error(message, filePath = null) { this.log.error(message, filePath); }
 
   initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
+          nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar),
           nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar),
-          nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+          releaseContext = this,  ///
+          released = this.isReleased();
+
+    this.dependencyReleaseContexts = tail(releaseContexts); ///
 
     this.lexer = nominalLexer; ///
 
     this.parser = nominalParser; ///
 
-    this.dependencyReleaseContexts = tail(releaseContexts);
-
-    if (this.released) {
-      const releaseContext = this,  ///
-            fileContexts = fileContextsFromEntries(this.entries, releaseContext);
-
-      initialiseFileContexts(fileContexts, releaseContext);
-
-      this.fileContexts = fileContexts;
-    }
+    this.fileContexts = released ?
+                          fileContextsFromJSONEntriesAndReleaseContext(this.json, this.entries, releaseContext) :
+                            fileContextsFromEntriesAndReleaseContext(this.entries, releaseContext);
 
     this.initialised = true;
   }
@@ -482,13 +443,9 @@ export default class ReleaseContext {
   verify() {
     let verified = false;
 
-    const releaseContext = this,  ///
-          fileContexts = fileContextsFromEntries(this.entries, releaseContext),
-          fileContextsVerified = verifyFileContexts(fileContexts, releaseContext);
+    const fileContextsVerified = verifyFileContexts(this.fileContexts);
 
     if (fileContextsVerified) {
-      this.fileContexts = fileContexts;
-
       this.verified = true;
 
       verified = true;
@@ -508,22 +465,73 @@ export default class ReleaseContext {
     return json;
   }
 
-  static fromLogNameEntriesAndReleased(log, name, entries, released) {
+  static fromLogNameJSONAndEntries(log, name, json, entries) {
     const lexer = null,
           parser = null,
           verified = false,
           initialised = false,
-          fileContexts = [],
+          fileContexts = null,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          loggingDisabled = false,
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
 
     return releaseContext;
   }
 }
 
-function verifyFileContexts(fileContexts, releaseContext) {
+function fileContextsFromJSONEntriesAndReleaseContext(json, entries, releaseContext) {
+  const fileContexts = [];
+
+  entries.forEachFile((file) => {
+    const filePath = file.getPath(),
+          filePathNominalFilePath = isFilePathNominalFilePath(filePath);
+
+    if (filePathNominalFilePath) {
+      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext),
+            filePath = fileContext.getFilePath();
+
+      fileContexts.push(fileContext);
+
+      const fileContextJSON = findFileContextJSON(json, filePath);
+
+      fileContext.initialise(fileContextJSON);
+    }
+  });
+
+  return fileContexts;
+}
+
+function fileContextsFromEntriesAndReleaseContext(entries, releaseContext) {
+  const fileContexts = [];
+
+  entries.forEachFile((file) => {
+    const filePath = file.getPath(),
+          filePathNominalFilePath = isFilePathNominalFilePath(filePath);
+
+    if (filePathNominalFilePath) {
+      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);
+
+      fileContexts.push(fileContext);
+    }
+  });
+
+  return fileContexts;
+}
+
+function findFileContextJSON(json, filePath) {
+  const fileContextsJSON = json,  ///
+        fileContextJSON = fileContextsJSON.find((fileContextJSON) => {
+          const { filePath: fileContextFilePath } = fileContextJSON;
+
+          if (fileContextFilePath === filePath) {
+            return true;
+          }
+        });
+
+  return fileContextJSON;
+}
+
+function verifyFileContexts(fileContexts) {
   let fileContextsVerified;
 
   fileContexts = [  ///
@@ -540,9 +548,9 @@ function verifyFileContexts(fileContexts, releaseContext) {
     const verifiedFileContexts = [];
 
     fileContexts.forEach((fileContext) => {
-      const verified = fileContext.verify(releaseContext);
+      const fileContextVerified = verifyFileContext(fileContext);
 
-      if (verified) {
+      if (fileContextVerified) {
         const verifiedFileContext = fileContext;  ///
 
         verifiedFileContexts.push(verifiedFileContext);
@@ -550,7 +558,7 @@ function verifyFileContexts(fileContexts, releaseContext) {
     });
 
     const verifiedFileContextsLength = verifiedFileContexts.length,
-          fileVerified = (verifiedFileContextsLength > 0);
+      fileVerified = (verifiedFileContextsLength > 0);
 
     if (!fileVerified) {
       break;
@@ -566,54 +574,32 @@ function verifyFileContexts(fileContexts, releaseContext) {
   return fileContextsVerified;
 }
 
-function initialiseFileContexts(fileContexts, releaseContext) {
-  fileContexts = [  ///
-    ...fileContexts
-  ];
-
-  for (;;) {
-    const fileContextsLength = fileContexts.length;
-
-    if (fileContextsLength === 0) {
-      break;
-    }
+function verifyFileContext(fileContext) {
+  let fileContextVerified = false;
 
-    const initialisedFileContexts = [];
-
-    fileContexts.forEach((fileContext) => {
-      const initialised = fileContext.initialise(releaseContext);
-
-      if (initialised) {
-        const initialisedFileContext = fileContext;  ///
-
-        initialisedFileContexts.push(initialisedFileContext);
-      }
-    });
+  const tokens = fileContext.getTokens();
 
-    const initialisedFileContextsLength = initialisedFileContexts.length,
-          fileInitialised = (initialisedFileContextsLength > 0);
+  if (tokens === null) {
+    const filePath = fileContext.getFilePath(),
+          file = fileContext.getFile(filePath),
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          content = file.getContent(),
+          tokens = lexer.tokenise(content),
+          node = parser.parse(tokens);
 
-    if (!fileInitialised) {
-      break;
-    }
+    fileContext.setTokens(tokens);
 
-    leftDifference(fileContexts, initialisedFileContexts);
+    fileContext.setNode(node);
   }
-}
 
-function fileContextsFromEntries(entries, releaseContext) {
-  const fileContexts = [];
-
-  entries.forEachFile((file) => {
-    const filePath = file.getPath(),
-          filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+  const node = fileContext.getNode();
 
-    if (filePathFlorenceFilePath) {
-      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);
+  if (node !== null) {
+    fileContext.reset();
 
-      fileContexts.push(fileContext);
-    }
-  });
+    fileContextVerified = topLevelVerifier.verify(node, fileContext);
+  }
 
-  return fileContexts;
+  return fileContextVerified;
 }

package/src/log.js

@@ -25,37 +25,37 @@ export default class Log {
     return this.follow;
   }
 
-  trace(message, node, tokens, filePath) {
+  trace(message, filePath) {
     const level = TRACE_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  debug(message, node, tokens, filePath) {
+  debug(message, filePath) {
     const level = DEBUG_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  info(message, node, tokens, filePath) {
+  info(message, filePath) {
     const level = INFO_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  warning(message, node, tokens, filePath) {
+  warning(message, filePath) {
     const level = WARNING_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  error(message, node, tokens, filePath) {
+  error(message, filePath) {
     const level = ERROR_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  write(level, message, node, tokens, filePath) {
+  write(level, message, filePath) {
     const levels = [
             TRACE_LEVEL,
             DEBUG_LEVEL,
@@ -70,7 +70,7 @@ export default class Log {
       return;
     }
 
-    message = formatMessage(level, message, node, tokens, filePath);  ///
+    message = formatMessage(level, message, filePath);  ///
 
     this.follow ?
       console.log(message) :
@@ -96,27 +96,12 @@ export default class Log {
   }
 }
 
-function formatMessage(level, message, node = null, tokens = null, filePath = null) {
+function formatMessage(level, message, filePath = null) {
   const upperCaseLevel = level.toUpperCase();
 
-  if ((node === null) || (tokens === null)) {
-    message = (filePath !== null) ?
-              `${upperCaseLevel}: ${filePath} - ${message}`:
-                `${upperCaseLevel}: ${message}`;
-  } else {
-    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
-          leastLineNumber = leastLineIndex, ///
-          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, tokens),
-          greatestLineNumber = greatestLineIndex; ///
-
-    if (leastLineNumber === greatestLineNumber) {
-      const lineNumber = leastLineNumber; ///
-
-      message = `${upperCaseLevel}: ${filePath} (${lineNumber}) - ${message}`;
-    } else {
-      message = `${upperCaseLevel}: ${filePath} (${leastLineNumber}-${greatestLineNumber}) - ${message}`;
-    }
-  }
+  message = (filePath !== null) ?
+            `${upperCaseLevel}: ${filePath} - ${message}`:
+              `${upperCaseLevel}: ${message}`;
 
   return message;
 }