occam-verify-cli 0.0.1006 → 0.0.1007

package/lib/verify/release.js

@@ -14,25 +14,34 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-function verifyRelease(releaseName, releaseContextMap) {
+function verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap) {
     var releaseVerified = false;
     var releaseContext = releaseContextMap[releaseName];
     if (releaseContext !== null) {
-        var dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, releaseContextMap);
-        if (dependencyReleasesVVerified) {
-            var verified = releaseContext.isVerified();
-            if (verified) {
-                releaseVerified = true;
+        var released = releaseContext.isReleased();
+        if (released) {
+            releaseVerified = true;
+        } else {
+            if (dependentReleased) {
+                releaseContext.warning("The '".concat(releaseName, "' project cannot be verified because its '").concat(dependentName, "' dependent is a package."));
             } else {
-                releaseContext.info("Verifying the '".concat(releaseName, "' project..."));
-                var releaseFilesVerified = verifyReleaseFiles(releaseContext);
-                if (releaseFilesVerified) {
-                    var verified1 = true;
-                    releaseContext.setVerified(verified1);
-                    releaseVerified = verified1; ///
-                }
-                if (releaseVerified) {
-                    releaseContext.info("...verified the '".concat(releaseName, "' project."));
+                var _$dependentName = releaseName, _$dependentReleased = released, dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, _$dependentName, _$dependentReleased, releaseContextMap);
+                if (dependencyReleasesVVerified) {
+                    var verified = releaseContext.isVerified();
+                    if (verified) {
+                        releaseVerified = true;
+                    } else {
+                        releaseContext.info("Verifying the '".concat(releaseName, "' project..."));
+                        var releaseFilesVerified = verifyReleaseFiles(releaseContext);
+                        if (releaseFilesVerified) {
+                            var verified1 = true;
+                            releaseContext.setVerified(verified1);
+                            releaseVerified = verified1; ///
+                        }
+                        if (releaseVerified) {
+                            releaseContext.info("...verified the '".concat(releaseName, "' project."));
+                        }
+                    }
                 }
             }
         }
@@ -43,9 +52,9 @@ function verifyReleaseFiles(releaseContext) {
     var filesVerified = (0, _files.default)(releaseContext), releaseFilesVerified = filesVerified; ///
     return releaseFilesVerified;
 }
-function verifyDependencyReleases(releaseContext, releaseContextMap) {
+function verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap) {
     var dependencies = releaseContext.getDependencies(), dependencyReleasesVVerified = dependencies.everyDependency(function(dependency) {
-        var name = dependency.getName(), releaseName = name, releaseVerified = verifyRelease(releaseName, releaseContextMap);
+        var name = dependency.getName(), releaseName = name, releaseVerified = verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap);
         if (releaseVerified) {
             return true;
         }
@@ -53,4 +62,4 @@ function verifyDependencyReleases(releaseContext, releaseContextMap) {
     return dependencyReleasesVVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1006",
+  "version": "0.0.1007",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/combinator.js

@@ -1,9 +1,11 @@
 "use strict";
 
 import shim from "./shim";
+import Statement from "./statement";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
+import { statementNodeFromStatementString } from "./utilities/node";
 
 const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
@@ -43,9 +45,17 @@ export default class Combinator {
   }
 
   static fromJSON(json, fileContext) {
-    let combinator = null;
+    let { statement } = json;
 
-    debugger
+    const lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          statementString = statement,  ///
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+          localContext = LocalContext.fromFileContext(fileContext);
+
+    statement = Statement.fromStatementNode(statementNode, localContext);
+
+    const combinator = new Combinator(statement);
 
     return combinator;
   }

package/src/conclusion.js

@@ -6,6 +6,7 @@ import UnqualifiedStatement from "./statement/unqualified";
 
 import { trim } from "./utilities/string";
 import { nodeQuery } from "./utilities/query";
+import { unqualifiedStatementNodeFromUnqualifiedStatementString } from "./utilities/node";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement");
 
@@ -89,9 +90,16 @@ export default class Conclusion {
   }
 
   static fromJSON(json, fileContext) {
-    let conclusion = null;
+    let { unqualifiedStatement } = json;
 
-    debugger
+    const lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          unqualifiedStatementString = unqualifiedStatement,  ///
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, lexer, parser);
+
+    unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext);
+
+    const conclusion = new Conclusion(fileContext, unqualifiedStatement);
 
     return conclusion;
   }

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,25 +1,25 @@
 "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, json, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, 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;
@@ -45,10 +45,6 @@ export default class ReleaseContext {
     return this.entries;
   }
 
-  isReleased() {
-    return this.released;
-  }
-
   getLexer() {
     return this.lexer;
   }
@@ -89,10 +85,6 @@ export default class ReleaseContext {
     this.entries = entries;
   }
 
-  setReleased(released) {
-    this.released = released;
-  }
-
   setLexer(lexer) {
     this.lexer = lexer;
   }
@@ -121,6 +113,24 @@ export default class ReleaseContext {
     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 = [];
 
@@ -400,30 +410,32 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  trace(message, node = null, tokens = null, filePath = null) { this.log.trace(message, node, tokens, filePath); }
+  trace(message, filePath = null) { this.log.trace(message, filePath); }
 
-  debug(message, node = null, tokens = null, filePath = null) { this.log.debug(message, node, tokens, filePath); }
+  debug(message, filePath = null) { this.log.debug(message, filePath); }
 
-  info(message, node = null, tokens = null, filePath = null) { this.log.info(message, node, tokens, filePath); }
+  info(message, filePath = null) { this.log.info(message, filePath); }
 
-  warning(message, node = null, tokens = null, filePath = null) { this.log.warning(message, node, tokens, filePath); }
+  warning(message, filePath = null) { this.log.warning(message, filePath); }
 
-  error(message, node = null, tokens = null, filePath = null) { 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) {
-      debugger
-    }
+    this.fileContexts = released ?
+                          fileContextsFromJSONEntriesAndReleaseContext(this.json, this.entries, releaseContext) :
+                            fileContextsFromEntriesAndReleaseContext(this.entries, releaseContext);
 
     this.initialised = true;
   }
@@ -431,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;
@@ -457,21 +465,73 @@ export default class ReleaseContext {
     return json;
   }
 
-  static fromLogNameJSONEntriesAndReleased(log, name, json, entries, released) {
+  static fromLogNameJSONAndEntries(log, name, json, entries) {
     const lexer = null,
           parser = null,
           verified = false,
           initialised = false,
-          fileContexts = [],
+          fileContexts = null,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, name, json, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, 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 = [  ///
@@ -488,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);
@@ -498,7 +558,7 @@ function verifyFileContexts(fileContexts, releaseContext) {
     });
 
     const verifiedFileContextsLength = verifiedFileContexts.length,
-          fileVerified = (verifiedFileContextsLength > 0);
+      fileVerified = (verifiedFileContextsLength > 0);
 
     if (!fileVerified) {
       break;
@@ -514,19 +574,32 @@ function verifyFileContexts(fileContexts, releaseContext) {
   return fileContextsVerified;
 }
 
-function fileContextsFromEntries(entries, releaseContext) {
-  const fileContexts = [];
+function verifyFileContext(fileContext) {
+  let fileContextVerified = false;
 
-  entries.forEachFile((file) => {
-    const filePath = file.getPath(),
-          filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+  const tokens = fileContext.getTokens();
 
-    if (filePathFlorenceFilePath) {
-      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);
+  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);
 
-      fileContexts.push(fileContext);
-    }
-  });
+    fileContext.setTokens(tokens);
 
-  return fileContexts;
+    fileContext.setNode(node);
+  }
+
+  const node = fileContext.getNode();
+
+  if (node !== null) {
+    fileContext.reset();
+
+    fileContextVerified = topLevelVerifier.verify(node, fileContext);
+  }
+
+  return fileContextVerified;
 }