occam-verify-cli 0.0.375 → 0.0.377

package/src/context/file.js

@@ -39,39 +39,36 @@ export default class FileContext {
     return this.variables;
   }
 
-  getLabels(bubble = true) {
+  getLabels(includeRelease = 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 (includeRelease) {
+      const releaseContextLabels = this.releaseContext.getLabels();
+
+      push(labels, releaseContextLabels);
+    }
+
     return labels;
   }
 
-  getRules(bubble = true) {
-    const rules = [
-      ...this.rules
-    ];
+  getRules(includeRelease = true) {
+    const rules = []
+
+    push(rules, this.rules);
 
-    if (bubble) {
+    if (includeRelease) {
       const releaseContextRules = this.releaseContext.getRules();
 
       push(rules, releaseContextRules);
@@ -80,12 +77,12 @@ export default class FileContext {
     return rules;
   }
 
-  getTypes(bubble = true) {
-    const types = [
-      ...this.types
-    ];
+  getTypes(includeRelease = true) {
+    const types = [];
 
-    if (bubble) {
+    push(types, this.types);
+
+    if (includeRelease) {
       const releaseContextTypes = this.releaseContext.getTypes();
 
       push(types, releaseContextTypes);
@@ -94,12 +91,12 @@ export default class FileContext {
     return types;
   }
 
-  getAxioms(bubble = true) {
-    const axioms = [
-      ...this.axioms
-    ];
+  getAxioms(includeRelease = true) {
+    const axioms = [];
+
+    push(axioms, this.axioms);
 
-    if (bubble) {
+    if (includeRelease) {
       const releaseContextAxioms = this.releaseContext.getAxioms();
 
       push(axioms, releaseContextAxioms);
@@ -108,12 +105,12 @@ export default class FileContext {
     return axioms;
   }
 
-  getCombinators(bubble = true) {
-    const combinators = [
-      ...this.combinators
-    ];
+  getCombinators(includeRelease = true) {
+    const combinators = [];
 
-    if (bubble) {
+    push(combinators, this.combinators);
+
+    if (includeRelease) {
       const releaseContextCombinators = this.releaseContext.getCombinators();
 
       push(combinators, releaseContextCombinators);
@@ -122,12 +119,12 @@ export default class FileContext {
     return combinators;
   }
 
-  getConstructors(bubble = true) {
-    const constructors = [
-      ...this.constructors
-    ];
+  getConstructors(includeRelease = true) {
+    const constructors = [];
+
+    push(constructors, this.constructors);
 
-    if (bubble) {
+    if (includeRelease) {
       const releaseContextConstructors = this.releaseContext.getConstructors();
 
       push(constructors, releaseContextConstructors);

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,128 +16,118 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return this.fileContexts;
   }
 
-  getTypes(releaseNames = []) {
-    const types = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getLabels(includeDependencies = true) {
+    const labels = [];
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextLabels = fileContext.getLabels(includeRelease);
 
-      const bubble = false;
+      push(labels, fileContextLabels);
+    });
 
-      this.fileContexts.forEach((fileContext) => {
-        const fileContextTypes = fileContext.getTypes(bubble);
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-        push(types, fileContextTypes);
-      });
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextLabels = releaseContext.getLabels(includeDependencies);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextTypes = releaseContext.getTypes(releaseNames);
-
-        push(types, releaseContextTypes);
+        push(labels, releaseContextLabels);
       });
     }
 
-    return types;
+    return labels;
   }
 
-  getRules(releaseNames = []) {
-    const rules = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getTypes(includeDependencies = true) {
+    const types = [];
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
-
-      const bubble = false;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTypes = fileContext.getTypes(includeRelease);
 
-      this.fileContexts.forEach((fileContext) => {
-        const fileContextRules = fileContext.getRules(bubble);
+      push(types, fileContextTypes);
+    });
 
-        push(rules, fileContextRules);
-      });
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextRules = releaseContext.getRules(releaseNames);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTypes = releaseContext.getTypes(includeDependencies);
 
-        push(rules, releaseContextRules);
+        push(types, releaseContextTypes);
       });
     }
 
-    return rules;
+    return types;
   }
 
-  getAxioms(releaseNames = []) {
-    const axioms = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
-
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+  getRules(includeDependencies = true) {
+    const rules = [];
 
-      const bubble = false;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextRules = fileContext.getRules(includeRelease);
 
-      this.fileContexts.forEach((fileContext) => {
-        const fileContextAxioms = fileContext.getAxioms(bubble);
+      push(rules, fileContextRules);
+    });
 
-        push(axioms, fileContextAxioms);
-      });
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextRules = releaseContext.getRules(includeDependencies);
 
-        push(axioms, releaseContextAxioms);
+        push(rules, releaseContextRules);
       });
     }
 
-    return axioms;
+    return rules;
   }
 
-  getLabels(releaseNames = []) {
-    const labels = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
-
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+  getAxioms(includeDependencies = true) {
+    const axioms = [];
 
-      const bubble = false;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextAxioms = fileContext.getAxioms(includeRelease);
 
-      this.fileContexts.forEach((fileContext) => {
-        const fileContextLabels = fileContext.getLabels(bubble);
+      push(axioms, fileContextAxioms);
+    });
 
-        push(labels, fileContextLabels);
-      });
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextLabels = releaseContext.getLabels(releaseNames);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
 
-        push(labels, releaseContextLabels);
+        push(axioms, releaseContextAxioms);
       });
     }
 
-    return labels;
+    return axioms;
   }
 
-  getCombinators(releaseNames = []) {
-    const combinators = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
-
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+  getCombinators(includeDependencies = true) {
+    const combinators = [];
 
-      const bubble = false;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextCombinators = fileContext.getCombinators(includeRelease);
 
-      this.fileContexts.forEach((fileContext) => {
-        const fileContextCombinators = fileContext.getCombinators(bubble);
+      push(combinators, fileContextCombinators);
+    });
 
-        push(combinators, fileContextCombinators);
-      });
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
 
         push(combinators, releaseContextCombinators);
       });
@@ -146,24 +136,22 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return combinators;
   }
 
-  getConstructors(releaseNames = []) {
-    const constructors = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
-
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+  getConstructors(includeDependencies = true) {
+    const constructors = [];
 
-      const bubble = false;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConstructors = fileContext.getConstructors(includeRelease);
 
-      this.fileContexts.forEach((fileContext) => {
-        const fileContextConstructors = fileContext.getConstructors(bubble);
+      push(constructors, fileContextConstructors);
+    });
 
-        push(constructors, fileContextConstructors);
-      });
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
 
         push(constructors, releaseContextConstructors);
       });
@@ -193,9 +181,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

@@ -13,8 +13,8 @@ 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);
+  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.types = types;
     this.rules = rules;
@@ -28,108 +28,103 @@ export default class FileReleaseContext extends ReleaseContext {
     return this.contextJSON;
   }
 
-  getTypes(releaseNames = []) {
-    const types = [
-          ...this.types
-        ],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getLabels(includeDependencies = true) {
+    const labels = [];
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+    this.rules.forEach((rule) => {
+      const ruleLabels = rule.getLabels();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+      push(labels, ruleLabels);
+    });
 
-        push(types, releaseContextTypes);
+    this.axioms.forEach((axiom) => {
+      const axiomLabels = axiom.getLabels();
+
+      push(labels, axiomLabels);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
+
+        push(labels, releaseContextAxioms);
       });
     }
 
-    return types;
+    return labels;
   }
 
-  getRules(releaseNames = []) {
-    const rules = [
-            ...this.rules
-          ],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getTypes(includeDependencies = true) {
+    const types = [];
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+    push(types, this.types);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextRules = releaseContext.getRules(releaseNames);
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-        push(rules, releaseContextRules);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTypes = releaseContext.getTypes(includeDependencies);
+
+        push(types, releaseContextTypes);
       });
     }
 
-    return rules;
+    return types;
   }
 
-  getAxioms(releaseNames = []) {
-    const axioms = [
-            ...this.axioms
-          ],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getRules(includeDependencies = true) {
+    const rules = [];
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+    push(rules, this.rules);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-        push(axioms, releaseContextAxioms);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextRules = releaseContext.getRules(includeDependencies);
+
+        push(rules, releaseContextRules);
       });
     }
 
-    return axioms;
+    return rules;
   }
 
-  getLabels(releaseNames = []) {
-    const labels = [],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getAxioms(includeDependencies = true) {
+    const axioms = [];
 
-    this.rules.forEach((rule) => {
-      const ruleLabels = rule.getLabels();
+    push(axioms, this.axioms);
 
-      push(labels, ruleLabels);
-    });
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-    this.axioms.forEach((axiom) => {
-      const axiomLabels = axiom.getLabels();
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
 
-      push(labels, axiomLabels);
-    });
-
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
-
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
-
-        push(labels, releaseContextAxioms);
+        push(axioms, releaseContextAxioms);
       });
     }
 
-    return labels;
+    return axioms;
   }
 
-  getCombinators(releaseNames = []) {
-    const combinators = [
-            ...this.combinators
-          ],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getCombinators(includeDependencies = true) {
+    const combinators = [];
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+    push(combinators, this.combinators);
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
 
         push(combinators, releaseContextCombinators);
       });
@@ -138,18 +133,17 @@ export default class FileReleaseContext extends ReleaseContext {
     return combinators;
   }
 
-  getConstructors(releaseNames = []) {
-    const constructors = [
-            ...this.constructors
-          ],
-          releaseName = this.getReleaseName(),
-          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+  getConstructors(includeDependencies = true) {
+    const constructors = [];
+
+    push(constructors, this.constructors);
 
-    if (!releaseNamesIncludesReleaseName) {
-      releaseNames.push(releaseName);
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
-      this.releaseContexts.forEach((releaseContext) => {
-        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
 
         push(constructors, releaseContextConstructors);
       });
@@ -161,10 +155,10 @@ export default class FileReleaseContext extends ReleaseContext {
   initialise(dependencyReleaseContexts) {
     super.initialise(dependencyReleaseContexts);
 
-    const ruleMap = this.florenceParser.getRuleMap(),
-          jsonArray = this.contextJSON,  ///
+    const jsonArray = this.contextJSON,  ///
           callback = (content, ruleName) => {
-            const tokens = this.florenceLexer.tokenise(content),
+            const ruleMap = this.florenceParser.getRuleMap(),
+                  tokens = this.florenceLexer.tokenise(content),
                   rule = ruleMap[ruleName],
                   node = this.florenceParser.parse(tokens, rule);
 
@@ -219,17 +213,17 @@ export default class FileReleaseContext extends ReleaseContext {
   }
 
   static fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {
-    const verified = false, ///
+    const verified = true,
           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);
+          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;
   }

package/src/context/release.js

@@ -8,7 +8,7 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts) {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
     this.entries = entries;
@@ -17,7 +17,7 @@ export default class ReleaseContext {
     this.customGrammar = customGrammar;
     this.florenceLexer = florenceLexer;
     this.florenceParser = florenceParser;
-    this.releaseContexts = releaseContexts;
+    this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
   getLog() {
@@ -52,8 +52,8 @@ export default class ReleaseContext {
     return this.florenceParser;
   }
 
-  getReleaseContexts() {
-    return this.releaseContexts;
+  getDependencyReleaseContexts() {
+    return this.dependencyReleaseContexts;
   }
 
   getReleaseName() {
@@ -64,7 +64,7 @@ export default class ReleaseContext {
   }
 
   isInitialised() {
-    const initialised = (this.releaseContexts !== null);  ///
+    const initialised = (this.dependencyReleaseContexts !== null);  ///
 
     return initialised;
   }
@@ -117,6 +117,6 @@ export default class ReleaseContext {
 
     this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-    this.releaseContexts = releaseContexts;
+    this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 }