occam-verify-cli 0.0.442 → 0.0.444

package/src/axiom.js

@@ -71,43 +71,38 @@ export default class Axiom {
     return json;
   }
 
-  static fromJSON(json, callback) {
-    let axiom = null;
-
+  static fromJSON(json, releaseContext) {
     let { labels } = json;
 
-    const { statement, consequent, supposition } = json;
+    const labelsJSON = labels;  ///
 
-    labels = labels.reduce((labels, label) => {
-      if (labels !== null) {
-        const json = label; ///
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSON(json, releaseContext);
 
-        label = Label.fromJSON(json, callback); ///
+      return label;
+    });
 
-        if (label !== null) {
-          labels.push(label);
-        } else {
-          labels = null;
-        }
-      }
+    const { statement, consequent, supposition } = json;
 
-      return labels;
-    }, []);
+    let axiom;
 
-    if (statement !== null) {
+    if (false) {
+      ///
+    } else if (statement !== null) {
       const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
             content = `${statement}
 `,
-            unqualifiedStatementNode = callback(content, ruleName),
+            node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+            unqualifiedStatementNode = node,  ///
             statementNode = statementNodeQuery(unqualifiedStatementNode),
             consequentNode = null,
             suppositionNode = null;
 
       axiom = new Axiom(labels, statementNode, consequentNode, suppositionNode);
-    }
-
-    if ((consequent !== null) && (supposition !== null)) {
-      let content,
+    } else if ((consequent !== null) && (supposition !== null)) {
+      let node,
+          content,
           statementNode,
           unqualifiedStatementNode;
 
@@ -116,7 +111,9 @@ export default class Axiom {
       content = `${consequent}
 `;
 
-      unqualifiedStatementNode = callback(content, ruleName);
+      node = releaseContext.nodeFromContentAndRuleName(content, ruleName);
+
+      unqualifiedStatementNode = node;  ///
 
       statementNode = statementNodeQuery(unqualifiedStatementNode);
 
@@ -125,7 +122,9 @@ export default class Axiom {
       content = `${supposition}
 `;
 
-      unqualifiedStatementNode = callback(content, ruleName);
+      node = releaseContext.nodeFromContentAndRuleName(content, ruleName);
+
+      unqualifiedStatementNode = node;  ///
 
       statementNode = statementNodeQuery(unqualifiedStatementNode);
 

package/src/combinator.js

@@ -34,12 +34,13 @@ export default class Combinator {
     return json;
   }
 
-  static fromJSON(json, callback) {
+  static fromJSON(json, releaseContext) {
     const { statement } = json,
           ruleName = COMBINATOR_DECLARATION_RULE_NAME,
           content = `Combinator ${statement}
 `,
-          combinatorDeclarationNode = callback(content, ruleName),
+          node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+          combinatorDeclarationNode = node, ///
           statementNode = statementNodeQuery(combinatorDeclarationNode),
           combinator = new Combinator(statementNode);
 

package/src/conclusion.js

@@ -36,19 +36,15 @@ export default class Conclusion {
     return json;
   }
 
-  static fromJSON(json, callback) {
-    let conclusion = null;
-
+  static fromJSON(json, releaseContext) {
     const { metastatement } = json,
           ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
           content = `${metastatement}
 `,
-          unqualifiedMetastatementNode = callback(content, ruleName),
-          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-    if (metastatementNode !== null) {
-      conclusion = new Conclusion(metastatementNode);
-    }
+          node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+          unqualifiedMetastatementNode = node,  ///
+          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          conclusion = new Conclusion(metastatementNode);
 
     return conclusion;
   }

package/src/constructor.js

@@ -57,19 +57,31 @@ export default class Constructor {
     return json;
   }
 
-  static fromJSON(json, callback) {
-    let { type } = json;
-
+  static fromJSON(json, releaseContext) {
     const { term } = json,
           ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
           content = `Constructor ${term}
 `,
-          constructorDeclarationNode = callback(content, ruleName),
+          node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+          constructorDeclarationNode = node,  ///
           termNode = statementNodeQuery(constructorDeclarationNode);
 
-    json = type;  ///
+    let { type } = json;
+
+    const typeJSON = type;  ///
+
+    json = typeJSON;  ///
+
+    type = Type.fromJSON(json, releaseContext);
+
+    const typeName = type.getName(),
+          typePresent = releaseContext.isTypePresentByTypeName(typeName);
+
+    if (!typePresent) {
+      throw new Error(`The '${content}' constructor cannot be instantiated because its '${typeName} is not present.'`);
+    }
 
-    type = Type.fromJSON(json);
+    type = releaseContext.findTypeByTypeName(typeName); ///
 
     const constructor = new Constructor(termNode, type);
 

package/src/context/file.js

@@ -6,13 +6,13 @@ import { push } from "../utilities/array";
 import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "../utilities/tokens";
 
 export default class FileContext {
-  constructor(releaseContext, filePath, tokens, node, rules, types, axioms, variables, combinators, constructors) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, variables, combinators, constructors) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
     this.node = node;
-    this.rules = rules;
     this.types = types;
+    this.rules = rules;
     this.axioms = axioms;
     this.variables = variables;
     this.combinators = combinators;
@@ -63,32 +63,32 @@ export default class FileContext {
     return labels;
   }
 
-  getRules(includeRelease = true) {
-    const rules = []
+  getTypes(includeRelease = true) {
+    const types = [];
 
-    push(rules, this.rules);
+    push(types, this.types);
 
     if (includeRelease) {
-      const releaseContextRules = this.releaseContext.getRules();
+      const releaseContextTypes = this.releaseContext.getTypes();
 
-      push(rules, releaseContextRules);
+      push(types, releaseContextTypes);
     }
 
-    return rules;
+    return types;
   }
 
-  getTypes(includeRelease = true) {
-    const types = [];
+  getRules(includeRelease = true) {
+    const rules = []
 
-    push(types, this.types);
+    push(rules, this.rules);
 
     if (includeRelease) {
-      const releaseContextTypes = this.releaseContext.getTypes();
+      const releaseContextRules = this.releaseContext.getRules();
 
-      push(types, releaseContextTypes);
+      push(rules, releaseContextRules);
     }
 
-    return types;
+    return rules;
   }
 
   getAxioms(includeRelease = true) {
@@ -295,18 +295,18 @@ export default class FileContext {
   toJSON() {
     const json = [];
 
-    this.rules.forEach((rule) => {
-      const ruleJSON = rule.toJSON();
-
-      json.push(ruleJSON);
-    });
-
     this.types.forEach((type) => {
       const typeJSON = type.toJSON();
 
       json.push(typeJSON);
     });
 
+    this.rules.forEach((rule) => {
+      const ruleJSON = rule.toJSON();
+
+      json.push(ruleJSON);
+    });
+
     this.axioms.forEach((axiom) => {
       const axiomJSON = axiom.toJSON();
 
@@ -336,13 +336,13 @@ export default class FileContext {
 
     rewriteNodes(node);
 
-    const rules = [],
-          types = [],
+    const types = [],
+          rules = [],
           axioms = [],
           variables = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, rules, types, axioms, variables, combinators, constructors);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, variables, combinators, constructors);
 
     return fileContext;
   }

package/src/context/release/file.js

@@ -154,73 +154,65 @@ export default class FileReleaseContext extends ReleaseContext {
     return constructors;
   }
 
-  initialise(dependencyReleaseContexts) {
-    super.initialise(dependencyReleaseContexts);
+  nodeFromContentAndRuleName(content, ruleName) {
+    const ruleMap = this.florenceParser.getRuleMap(),
+          rule = ruleMap[ruleName],
+          tokens = this.florenceLexer.tokenise(content),
+          node = this.florenceParser.parse(tokens, rule);
+
+    if (node !== null) {
+      rewriteNodes(node);
+    }
 
-    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;
+  }
 
-            if (node !== null) {
-              rewriteNodes(node);
-            }
+  initialise(dependencyReleaseContexts) {
+    super.initialise(dependencyReleaseContexts);
 
-            return node;
-          };
+    const jsonArray = this.contextJSON,
+          releaseContext = this;  ///
 
     jsonArray.forEach((json) => {
       const { kind } = json;
 
       switch (kind) {
         case TYPE_KIND: {
-          const type = Type.fromJSON(json);
+          const type = Type.fromJSON(json, releaseContext);
 
-          if (type !== null) {
-            this.types.push(type);
-          }
+          this.types.push(type);
 
           break;
         }
 
         case RULE_KIND: {
-          const rule = Rule.fromJSON(json, callback);
+          const rule = Rule.fromJSON(json, releaseContext);
 
-          if (rule !== null) {
-            this.rules.push(rule);
-          }
+          this.rules.push(rule);
 
           break;
         }
 
         case AXIOM_KIND: {
-          const axiom = Axiom.fromJSON(json, callback);
+          const axiom = Axiom.fromJSON(json, releaseContext);
 
-          if (axiom !== null) {
-            this.axioms.push(axiom);
-          }
+          this.axioms.push(axiom);
 
           break;
         }
 
         case COMBINATOR_KIND: {
-          const combinator = Combinator.fromJSON(json, callback);
+          const combinator = Combinator.fromJSON(json, releaseContext);
 
-          if (combinator !== null) {
-            this.combinators.push(combinator);
-          }
+          this.combinators.push(combinator);
 
           break;
         }
 
         case CONSTRUCTOR_KIND: {
-          const constructor = Constructor.fromJSON(json, callback);
+          const constructor = Constructor.fromJSON(json, releaseContext);
 
-          if (constructor !== null) {
-            this.constructors.push(constructor);
-          }
+          this.constructors.push(constructor);
 
           break;
         }

package/src/context/release.js

@@ -56,6 +56,26 @@ export default class ReleaseContext {
     return this.dependencyReleaseContexts;
   }
 
+  findTypeByTypeName(typeName) {
+    const types = this.getTypes(),
+          type = types.find((type) => {
+            const matches = type.matchTypeName(typeName);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return type;
+  }
+
+  isTypePresentByTypeName(typeName) {
+    const type = this.findTypeByTypeName(typeName),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
   getReleaseName() {
     const name = this.getName(),
           releaseName = name; ///

package/src/label.js

@@ -34,16 +34,11 @@ export default class Label {
     return json;
   }
 
-  static fromJSON(json, callback) {
-    let label = null;
-
+  static fromJSON(json, releaseContext) {
     const content = json, ///
           ruleName = LABEL_RULE_NAME,
-          node = callback(content, ruleName);
-
-    if (node !== null) {
-      label = new Label(node);
-    }
+          node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+          label = new Label(node);
 
     return label;
   }

package/src/premise.js

@@ -71,19 +71,15 @@ export default class Premise {
     return json;
   }
 
-  static fromJSON(json, callback) {
-    let premise = null;
-
+  static fromJSON(json, releaseContext) {
     const { metastatement } = json,
           ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
           content = `${metastatement}
 `,
-          unqualifiedMetastatementNode = callback(content, ruleName),
-          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-    if (metastatementNode !== null) {
-      premise = new Premise(metastatementNode);
-    }
+          node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+          unqualifiedMetastatementNode = node,  ///
+          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          premise = new Premise(metastatementNode);
 
     return premise;
   }

package/src/rule.js

@@ -91,50 +91,40 @@ export default class Rule {
     return json;
   }
 
-  static fromJSON(json, callback) {
-    let rule = null;
+  static fromJSON(json, releaseContext) {
+    let rule;
 
-    let { labels, premises, conclusion } = json;
+    let { labels } = json;
 
-    labels = labels.reduce((labels, label) => {
-      if (labels !== null) {
-        const json = label; ///
+    const labelsJSON = labels;  ///
 
-        label = Label.fromJSON(json, callback); ///
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSON(json, releaseContext);
 
-        if (label !== null) {
-          labels.push(label);
-        } else {
-          labels = null;
-        }
-      }
+      return label;
+    });
 
-      return labels;
-    }, []);
+    let { premises } = json;
 
-    premises = premises.reduce((premises, premise) => {
-      if (premises !== null) {
-        const json = premise; ///
+    const premisesJSON = premises;  ///
 
-        premise = Premise.fromJSON(json, callback); ///
+    premises = premisesJSON.map((premiseJSON) => {
+      const json = premiseJSON, ///
+            premise = Premise.fromJSON(json, releaseContext);
 
-        if (premise !== null) {
-          premises.push(premise);
-        } else {
-          premises = null;
-        }
-      }
+      return premise;
+    });
 
-      return premises;
-    }, []);
+    let { conclusion } = json;
 
-    json = conclusion;  ///
+    const conclusionJSON = conclusion;  ///
 
-    conclusion = Conclusion.fromJSON(json, callback);
+    json = conclusionJSON;  ///
 
-    if ((labels !== null) && (premises !== null) && (conclusion !== null)) {
-      rule = new Rule(labels, premises, conclusion);
-    }
+    conclusion = Conclusion.fromJSON(json, releaseContext);
+
+    rule = new Rule(labels, premises, conclusion);
 
     return rule;
   }

package/src/type.js

@@ -119,15 +119,28 @@ export default class Type {
     return json;
   }
 
-  static fromJSON(json) {
+  static fromJSON(json, releaseContext) {
     const { name } = json;
 
     let { superType } = json;
 
     if (superType !== null) {
-      json = superType; ///
+      const superTypeJSON = superType;  ///
 
-      superType = Type.fromJSON(json);
+      json = superTypeJSON; ///
+
+      superType = Type.fromJSON(json, releaseContext);
+
+      const superTypeName = superType.getName(),
+            superTypePresent = releaseContext.isTypePresentByTypeName(superTypeName);
+
+      if (!superTypePresent) {
+        const typeName = name;  ///
+
+        throw new Error(`The '${typeName}' type cannot be instantiated because its '${superTypeName}' super type is not present.`);
+      }
+
+      superType = releaseContext.findTypeByTypeName(superTypeName); ///
     }
 
     const type = new Type(name, superType);