occam-verify-cli 0.0.374 → 0.0.376

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

@@ -42,27 +42,24 @@ export default class FileContext {
   getLabels(bubble = true) {
     const labels = [];
 
-    if (bubble) {
-      const releaseContextLabels = this.releaseContext.getLabels();
-
-      push(labels, releaseContextLabels);
-    }
-
-    const rules = this.getRules(),
-          axioms = this.getAxioms();
-
-    rules.forEach((rule) => {
+    this.rules.forEach((rule) => {
       const ruleLabels = rule.getLabels();
 
       push(labels, ruleLabels);
     });
 
-    axioms.forEach((axiom) => {
+    this.axioms.forEach((axiom) => {
       const axiomLabels = axiom.getLabels();
 
       push(labels, axiomLabels);
     });
 
+    if (bubble) {
+      const releaseContextLabels = this.releaseContext.getLabels();
+
+      push(labels, releaseContextLabels);
+    }
+
     return labels;
   }
 
@@ -301,31 +298,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

@@ -6,8 +6,8 @@ import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
 
 export default class DirectoryReleaseContext extends ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts) {
-    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, fileContexts) {
+    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
 
     this.fileContexts = fileContexts;
   }
@@ -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,23 +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 dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-        push(rules, releaseContextRules);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+
+        push(types, releaseContextTypes);
       });
     }
 
-    return rules;
+    return types;
   }
 
-  getTypes(releaseNames = []) {
-    const types = [],
+  getRules(releaseNames = []) {
+    const rules = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
@@ -53,19 +55,21 @@ 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 dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-        push(types, releaseContextTypes);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const releaseContextRules = releaseContext.getRules(releaseNames);
+
+        push(rules, releaseContextRules);
       });
     }
 
-    return types;
+    return rules;
   }
 
   getAxioms(releaseNames = []) {
@@ -84,7 +88,9 @@ export default class DirectoryReleaseContext extends ReleaseContext {
         push(axioms, fileContextAxioms);
       });
 
-      this.releaseContexts.forEach((releaseContext) => {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
 
         push(axioms, releaseContextAxioms);
@@ -110,7 +116,9 @@ export default class DirectoryReleaseContext extends ReleaseContext {
         push(labels, fileContextLabels);
       });
 
-      this.releaseContexts.forEach((releaseContext) => {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextLabels = releaseContext.getLabels(releaseNames);
 
         push(labels, releaseContextLabels);
@@ -136,7 +144,9 @@ export default class DirectoryReleaseContext extends ReleaseContext {
         push(combinators, fileContextCombinators);
       });
 
-      this.releaseContexts.forEach((releaseContext) => {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
 
         push(combinators, releaseContextCombinators);
@@ -162,7 +172,9 @@ export default class DirectoryReleaseContext extends ReleaseContext {
         push(constructors, fileContextConstructors);
       });
 
-      this.releaseContexts.forEach((releaseContext) => {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
 
         push(constructors, releaseContextConstructors);
@@ -193,9 +205,9 @@ export default class DirectoryReleaseContext extends ReleaseContext {
           customGrammar = customGrammarFromNameAndEntries(name, entries),
           florenceLexer = null,
           florenceParser = null,
-          releaseContexts = null,
+          dependencyReleaseContexts = null,
           fileContexts = [],
-          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
+          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, fileContexts);
 
     return directoryReleaseContext;
   }

package/src/context/release/file.js

@@ -2,17 +2,23 @@
 
 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 {combinedCustomGrammarFromReleaseContexts, customGrammarFromNameAndEntries} from "../../utilities/customGrammar";
+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, rules, types, axioms, labels, combinators, constructors) {
-    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, combinators, constructors) {
+    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
 
-    this.rules = rules;
     this.types = types;
+    this.rules = rules;
     this.axioms = axioms;
-    this.labels = labels;
     this.combinators = combinators;
     this.constructors = constructors;
     this.contextJSON = contextJSON;
@@ -22,57 +28,63 @@ export default class FileReleaseContext extends ReleaseContext {
     return this.contextJSON;
   }
 
-  getRules(releaseNames = []) {
-    const rules = [
-            ...this.rules
-          ],
+  getTypes(releaseNames = []) {
+    const types = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextRules = releaseContext.getRules(releaseNames);
+      push(types, this.types);
 
-        push(rules, releaseContextRules);
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+
+        push(types, releaseContextTypes);
       });
     }
 
-    return rules;
+    return types;
   }
 
-  getTypes(releaseNames = []) {
-    const types = [
-            ...this.types
-          ],
+  getRules(releaseNames = []) {
+    const rules = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+      push(rules, this.rules);
 
-        push(types, releaseContextTypes);
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const releaseContextRules = releaseContext.getRules(releaseNames);
+
+        push(rules, releaseContextRules);
       });
     }
 
-    return types;
+    return rules;
   }
 
   getAxioms(releaseNames = []) {
-    const axioms = [
-            ...this.axioms
-          ],
+    const axioms = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
 
-      this.releaseContexts.forEach((releaseContext) => {
+      push(axioms, this.axioms);
+
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
 
         push(axioms, releaseContextAxioms);
@@ -83,19 +95,31 @@ export default class FileReleaseContext extends ReleaseContext {
   }
 
   getLabels(releaseNames = []) {
-    const labels = [
-            ...this.labels
-          ],
+    const labels = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextLabels = releaseContext.getLabels(releaseNames);
+      this.rules.forEach((rule) => {
+        const ruleLabels = rule.getLabels();
+
+        push(labels, ruleLabels);
+      });
+
+      this.axioms.forEach((axiom) => {
+        const axiomLabels = axiom.getLabels();
 
-        push(labels, releaseContextLabels);
+        push(labels, axiomLabels);
+      });
+
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+
+        push(labels, releaseContextAxioms);
       });
     }
 
@@ -103,16 +127,18 @@ export default class FileReleaseContext extends ReleaseContext {
   }
 
   getCombinators(releaseNames = []) {
-    const combinators = [
-            ...this.combinators
-          ],
+    const combinators = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
 
-      this.releaseContexts.forEach((releaseContext) => {
+      push(combinators, this.combinators);
+
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
 
         push(combinators, releaseContextCombinators);
@@ -123,16 +149,18 @@ export default class FileReleaseContext extends ReleaseContext {
   }
 
   getConstructors(releaseNames = []) {
-    const constructors = [
-            ...this.constructors
-          ],
+    const constructors = [],
           releaseName = this.getReleaseName(),
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
 
-      this.releaseContexts.forEach((releaseContext) => {
+      push(constructors, this.constructors);
+
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
         const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
 
         push(constructors, releaseContextConstructors);
@@ -145,22 +173,75 @@ export default class FileReleaseContext extends ReleaseContext {
   initialise(dependencyReleaseContexts) {
     super.initialise(dependencyReleaseContexts);
 
-    debugger
+    const jsonArray = this.contextJSON,  ///
+          callback = (content, ruleName) => {
+            const ruleMap = this.florenceParser.getRuleMap(),
+                  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, ///
+    const verified = true,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
           florenceLexer = null,
           florenceParser = null,
-          releaseContexts = null,
-          rules = null,
-          types = null,
-          axioms = null,
-          labels = null,
-          combinators = null,
-          constructors = null,
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors);
+          dependencyReleaseContexts = null,
+          types = [],
+          rules = [],
+          axioms = [],
+          combinators = [],
+          constructors = [],
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, combinators, constructors);
 
     return releaseContext;
   }