occam-verify-cli 0.0.373 → 0.0.375

package/src/axiom.js

@@ -1,7 +1,10 @@
 "use strict";
 
+import Label from "./label";
+
 import { AXIOM_KIND } from "./kinds";
 import { nodeAsString } from "./utilities/string";
+import { STATEMENT_RULE_NAME } from "occam-custom-grammars/lib/ruleNames";
 
 export default class Axiom {
   constructor(labels, statementNode, suppositionStatementNode, consequentStatementNode) {
@@ -41,28 +44,74 @@ export default class Axiom {
   }
 
   toJSON() {
-    const statementString = nodeAsString(this.statementNode),
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON();
+
+            return labelJSON;
+          }),
+          statementString = nodeAsString(this.statementNode),
           consequentStatementString = nodeAsString(this.consequentStatementNode),
           suppositionStatementString = nodeAsString(this.suppositionStatementNode),
           kind = AXIOM_KIND,
+          labels = labelsJSON,  ///
           statement = statementString,  ///
           consequent = consequentStatementString, ///
           supposition = suppositionStatementString, ///
-          json = this.labels.map((label) => {
-            const labelString = label.asString();
+          json = {
+            kind,
+            labels,
+            statement,
+            consequent,
+            supposition
+          };
 
-            label = labelString;  ///
+    return json;
+  }
 
-            return ({
-              kind,
-              label,
-              statement,
-              consequent,
-              supposition
-            });
-          });
+  static fromJSON(json, callback) {
+    let { labels } = json;
 
-    return json;
+    const { statement, consequent, supposition } = json;
+
+    labels = labels.map((label) => {
+      const json = label; ///
+
+      label = Label.fromJSON(json);
+
+      return label;
+    });
+
+    let statementNode = null,
+        consequentNode = null,
+        suppositionNode = null;
+
+    if (statement !== null) {
+      const content = statement,  ///
+            ruleName = STATEMENT_RULE_NAME,
+            node = callback(content, ruleName);
+
+      statementNode = node; ///
+    }
+
+    if (consequent !== null) {
+      const content = consequent,  ///
+            ruleName = STATEMENT_RULE_NAME,
+            node = callback(content, ruleName);
+
+      consequentNode = node; ///
+    }
+
+    if (supposition !== null) {
+      const content = supposition,  ///
+            ruleName = STATEMENT_RULE_NAME,
+            node = callback(content, ruleName);
+
+      suppositionNode = node; ///
+    }
+
+    const axiom = new Axiom(labels, statementNode, consequentNode, suppositionNode);
+
+    return axiom;
   }
 
   static fromStatementNodeAndLabels(statementNode, labels) {

package/src/combinator.js

@@ -2,6 +2,7 @@
 
 import { nodeAsString } from "./utilities/string";
 import { COMBINATOR_KIND } from "./kinds";
+import { STATEMENT_RULE_NAME } from "./ruleNames";
 
 export default class Combinator {
   constructor(statementNode) {
@@ -22,14 +23,25 @@ export default class Combinator {
     const statementString = nodeAsString(this.statementNode),
           kind = COMBINATOR_KIND,
           statement = statementString,  ///
-          json = [{
+          json = {
             kind,
             statement
-          }];
+          };
 
     return json;
   }
 
+  static fromJSON(json, callback) {
+    const { statement } = json,
+          content = statement,  ///
+          ruleName = STATEMENT_RULE_NAME,
+          node = callback(content, ruleName),
+          statementNode = node, ///
+          combinator = new Combinator(statementNode);
+
+    return combinator;
+  }
+
   static fromStatementNode(statementNode) {
     const combinator = new Combinator(statementNode);
 

package/src/conclusion.js

@@ -33,6 +33,17 @@ export default class Conclusion {
     return json;
   }
 
+  static fromJSON(json, callback) {
+    const { metastatement } = json,
+          ruleName = METASTATEMENT_RULE_NAME,
+          content = metastatement,  ///
+          node = callback(content, ruleName),
+          metastatementNode = node, ///
+          conclusion = new Conclusion(metastatementNode);
+
+    return conclusion;
+  }
+
   static fromMetastatementNode(metastatementNode) {
     const conclusion = new Conclusion(metastatementNode);
 

package/src/constructor.js

@@ -1,6 +1,9 @@
 "use strict";
 
+import Type from "./type";
+
 import { nodeAsString } from "./utilities/string";
+import { TERM_RULE_NAME } from "./ruleNames";
 import { CONSTRUCTOR_KIND } from "./kinds";
 
 export default class Constructor {
@@ -42,15 +45,33 @@ export default class Constructor {
           kind = CONSTRUCTOR_KIND,
           term = termString,  ///
           type = typeJSON,  ///
-          json = [{
+          json = {
             kind,
             term,
             type
-          }];
+          };
 
     return json;
   }
 
+  static fromJSON(json, callback) {
+    let { type } = json;
+
+    const { term } = json,
+          content = term,  ///
+          ruleName = TERM_RULE_NAME,
+          node = callback(content, ruleName),
+          termNode = node; ///
+
+    json = type;  ///
+
+    type = Type.fromJSON(json);
+
+    const constructor = new Constructor(termNode, type);
+
+    return constructor;
+  }
+
   static fromTermNodeAndType(termNode, type) {
     const constructor = new Constructor(termNode, type);
 

package/src/context/file.js

@@ -301,31 +301,31 @@ export default class FileContext {
     this.rules.forEach((rule) => {
       const ruleJSON = rule.toJSON();
 
-      push(json, ruleJSON);
+      json.push(ruleJSON);
     });
 
     this.types.forEach((type) => {
       const typeJSON = type.toJSON();
 
-      push(json, typeJSON);
+      json.push(typeJSON);
     });
 
     this.axioms.forEach((axiom) => {
       const axiomJSON = axiom.toJSON();
 
-      push(json, axiomJSON);
+      json.push(axiomJSON);
     });
 
     this.combinators.forEach((combinator) => {
       const combinatorJSON = combinator.toJSON();
 
-      push(json, combinatorJSON);
+      json.push(combinatorJSON);
     });
 
     this.constructors.forEach((constructor) => {
       const constructorJSON = constructor.toJSON();
 
-      push(json, constructorJSON)
+      json.push(constructorJSON)
     });
 
     return json;

package/src/context/release/directory.js

@@ -16,8 +16,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return this.fileContexts;
   }
 
-  getRules(releaseNames = []) {
-    const rules = [],
+  getTypes(releaseNames = []) {
+    const types = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
@@ -27,25 +27,25 @@ export default class DirectoryReleaseContext extends ReleaseContext {
       const bubble = false;
 
       this.fileContexts.forEach((fileContext) => {
-        const fileContextRules = fileContext.getRules(bubble);
+        const fileContextTypes = fileContext.getTypes(bubble);
 
-        push(rules, fileContextRules);
+        push(types, fileContextTypes);
       });
 
       this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextRules = releaseContext.getRules(releaseNames);
+        const releaseContextTypes = releaseContext.getTypes(releaseNames);
 
-        push(rules, releaseContextRules);
+        push(types, releaseContextTypes);
       });
     }
 
-    return rules;
+    return types;
   }
 
-  getTypes(releaseNames = []) {
-    const types = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getRules(releaseNames = []) {
+    const rules = [],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -53,25 +53,25 @@ export default class DirectoryReleaseContext extends ReleaseContext {
       const bubble = false;
 
       this.fileContexts.forEach((fileContext) => {
-        const fileContextTypes = fileContext.getTypes(bubble);
+        const fileContextRules = fileContext.getRules(bubble);
 
-        push(types, fileContextTypes);
+        push(rules, fileContextRules);
       });
 
       this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+        const releaseContextRules = releaseContext.getRules(releaseNames);
 
-        push(types, releaseContextTypes);
+        push(rules, releaseContextRules);
       });
     }
 
-    return types;
+    return rules;
   }
 
   getAxioms(releaseNames = []) {
     const axioms = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -96,8 +96,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getLabels(releaseNames = []) {
     const labels = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -122,8 +122,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getCombinators(releaseNames = []) {
     const combinators = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -148,8 +148,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getConstructors(releaseNames = []) {
     const constructors = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -195,8 +195,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
           florenceParser = null,
           releaseContexts = null,
           fileContexts = [],
-          releaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
+          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
 
-    return releaseContext;
+    return directoryReleaseContext;
   }
 }

package/src/context/release/file.js

@@ -0,0 +1,236 @@
+"use strict";
+
+import ReleaseContext from "../../context/release";
+
+import Rule from "../../rule";
+import Type from "../../type";
+import Axiom from "../../axiom";
+import Combinator from "../../combinator";
+import Constructor from "../../constructor";
+
+import { push } from "../../utilities/array";
+import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
+import { RULE_KIND, TYPE_KIND, AXIOM_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
+
+export default class FileReleaseContext extends ReleaseContext {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, types, rules, axioms, combinators, constructors) {
+    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);
+
+    this.types = types;
+    this.rules = rules;
+    this.axioms = axioms;
+    this.combinators = combinators;
+    this.constructors = constructors;
+    this.contextJSON = contextJSON;
+  }
+
+  getContextJSON() {
+    return this.contextJSON;
+  }
+
+  getTypes(releaseNames = []) {
+    const types = [
+          ...this.types
+        ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+
+        push(types, releaseContextTypes);
+      });
+    }
+
+    return types;
+  }
+
+  getRules(releaseNames = []) {
+    const rules = [
+            ...this.rules
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextRules = releaseContext.getRules(releaseNames);
+
+        push(rules, releaseContextRules);
+      });
+    }
+
+    return rules;
+  }
+
+  getAxioms(releaseNames = []) {
+    const axioms = [
+            ...this.axioms
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+
+        push(axioms, releaseContextAxioms);
+      });
+    }
+
+    return axioms;
+  }
+
+  getLabels(releaseNames = []) {
+    const labels = [],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    this.rules.forEach((rule) => {
+      const ruleLabels = rule.getLabels();
+
+      push(labels, ruleLabels);
+    });
+
+    this.axioms.forEach((axiom) => {
+      const axiomLabels = axiom.getLabels();
+
+      push(labels, axiomLabels);
+    });
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+
+        push(labels, releaseContextAxioms);
+      });
+    }
+
+    return labels;
+  }
+
+  getCombinators(releaseNames = []) {
+    const combinators = [
+            ...this.combinators
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+
+        push(combinators, releaseContextCombinators);
+      });
+    }
+
+    return combinators;
+  }
+
+  getConstructors(releaseNames = []) {
+    const constructors = [
+            ...this.constructors
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+
+        push(constructors, releaseContextConstructors);
+      });
+    }
+
+    return constructors;
+  }
+
+  initialise(dependencyReleaseContexts) {
+    super.initialise(dependencyReleaseContexts);
+
+    const ruleMap = this.florenceParser.getRuleMap(),
+          jsonArray = this.contextJSON,  ///
+          callback = (content, ruleName) => {
+            const tokens = this.florenceLexer.tokenise(content),
+                  rule = ruleMap[ruleName],
+                  node = this.florenceParser.parse(tokens, rule);
+
+            return node;
+          };
+
+    jsonArray.forEach((json) => {
+      const { kind } = json;
+
+      switch (kind) {
+        case TYPE_KIND: {
+          const type = Type.fromJSON(json);
+
+          this.types.push(type);
+
+          break;
+        }
+
+        case RULE_KIND: {
+          const rule = Rule.fromJSON(json, callback);
+
+          this.rules.push(rule);
+
+          break;
+        }
+
+        case AXIOM_KIND: {
+          const axiom = Axiom.fromJSON(json, callback);
+
+          this.axioms.push(axiom);
+
+          break;
+        }
+
+        case COMBINATOR_KIND: {
+          const combinator = Combinator.fromJSON(json, callback);
+
+          this.combinators.push(combinator);
+
+          break;
+        }
+
+        case CONSTRUCTOR_KIND: {
+          const constructor = Constructor.fromJSON(json, callback);
+
+          this.constructors.push(constructor);
+
+          break;
+        }
+      }
+    });
+  }
+
+  static fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {
+    const verified = false, ///
+          customGrammar = customGrammarFromNameAndEntries(name, entries),
+          florenceLexer = null,
+          florenceParser = null,
+          releaseContexts = null,
+          types = null,
+          rules = null,
+          axioms = null,
+          combinators = null,
+          constructors = null,
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, types, rules, axioms, combinators, constructors);
+
+    return releaseContext;
+  }
+}

package/src/context/release.js

@@ -58,11 +58,17 @@ export default class ReleaseContext {
 
   getReleaseName() {
     const name = this.getName(),
-        releaseName = name; ///
+         releaseName = name; ///
 
     return releaseName;
   }
 
+  isInitialised() {
+    const initialised = (this.releaseContexts !== null);  ///
+
+    return initialised;
+  }
+
   getFile(filePath) { return this.entries.getFile(filePath); }
 
   getVersion() { return this.entries.getVersion(); }
@@ -99,12 +105,13 @@ export default class ReleaseContext {
 
   complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
 
-  initialise(releaseContexts, dependencyReleaseContexts) {
-    const releaseContext = this;  ///
-
-    releaseContexts = [ releaseContext, ...dependencyReleaseContexts ]; ///
-
-    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
+  initialise(dependencyReleaseContexts) {
+    const releaseContext = this,  ///
+          releaseContexts = [
+            releaseContext,
+            ...dependencyReleaseContexts
+          ],
+          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
 
     this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 

package/src/index.js

@@ -4,6 +4,7 @@ export { default as Callbacks } from "./callbacks";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
 export { default as versionChanges } from "./versionChanges";
+export { default as FileReleaseContext } from "./context/release/file";
 export { default as DirectoryReleaseContext } from "./context/release/directory";
 
 export { default as jsonUtilities } from "./utilities/json";

package/src/kinds.js

@@ -1,7 +1,7 @@
 "use strict";
 
-export const RULE_KIND = "rule";
 export const TYPE_KIND = "type";
+export const RULE_KIND = "rule";
 export const AXIOM_KIND = "axiom";
 export const COMBINATOR_KIND = "combinator";
 export const CONSTRUCTOR_KIND = "constructor";

package/src/label.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
+import { TERM_RULE_NAME } from "./ruleNames";
 import { labelNameFromLabelNode } from "./utilities/query";
 
 export default class Label {
@@ -26,6 +27,22 @@ export default class Label {
     return string;
   }
 
+  toJSON() {
+    const string = nodeAsString(this.node),
+          json = string;  ///
+
+    return json;
+  }
+
+  static fromJSON(json, callback) {
+    const content = json, ///
+          ruleName = TERM_RULE_NAME,
+          node = callback(content, ruleName),
+          label = new Label(node);
+
+    return label;
+  }
+
   static fromLabelNode(labelNode) {
     const node = labelNode, ///
           variable = new Label(node);