occam-verify-cli 0.0.539 → 0.0.541

package/src/context/release.js

@@ -2,20 +2,25 @@
 
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-import { combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
+import FileContext from "./file";
+
+import { push } from "../utilities/array";
+import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts) {
+  constructor(log, json, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts) {
     this.log = log;
+    this.json = json;
     this.name = name;
     this.entries = entries;
     this.lexer = lexer;
     this.parser = parser;
     this.verified = verified;
     this.customGrammar = customGrammar;
+    this.fileContexts = fileContexts;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
@@ -23,6 +28,10 @@ export default class ReleaseContext {
     return log;
   }
 
+  getJSON() {
+    return this.json;
+  }
+
   getName() {
     return this.name;
   }
@@ -47,10 +56,223 @@ export default class ReleaseContext {
     return this.customGrammar;
   }
 
+  getFileContexts() {
+    return this.fileContexts;
+  }
+
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
 
+  getLabels(includeDependencies = true) {
+    const labels = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextLabels = fileContext.getLabels(includeRelease);
+
+      push(labels, fileContextLabels);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+          releaseContextLabels = releaseContext.getLabels(includeDependencies);
+
+        push(labels, releaseContextLabels);
+      });
+    }
+
+    return labels;
+  }
+
+  getTypes(includeDependencies = true) {
+    const types = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTypes = fileContext.getTypes(includeRelease);
+
+      push(types, fileContextTypes);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTypes = releaseContext.getTypes(includeDependencies);
+
+        push(types, releaseContextTypes);
+      });
+    }
+
+    return types;
+  }
+
+  getRules(includeDependencies = true) {
+    const rules = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextRules = fileContext.getRules(includeRelease);
+
+      push(rules, fileContextRules);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextRules = releaseContext.getRules(includeDependencies);
+
+        push(rules, releaseContextRules);
+      });
+    }
+
+    return rules;
+  }
+
+  getAxioms(includeDependencies = true) {
+    const axioms = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextAxioms = fileContext.getAxioms(includeRelease);
+
+      push(axioms, fileContextAxioms);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
+
+        push(axioms, releaseContextAxioms);
+      });
+    }
+
+    return axioms;
+  }
+
+  getLemmas(includeDependencies = true) {
+    const lemmas = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextLemmas = fileContext.getLemmas(includeRelease);
+
+      push(lemmas, fileContextLemmas);
+    });
+
+    return lemmas;
+  }
+
+  getTheorems(includeDependencies = true) {
+    const theorems = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTheorems = fileContext.getTheorems(includeRelease);
+
+      push(theorems, fileContextTheorems);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTheorems = releaseContext.getTheorems(includeDependencies);
+
+        push(theorems, releaseContextTheorems);
+      });
+    }
+
+    return theorems;
+  }
+
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConjectures = fileContext.getConjectures(includeRelease);
+
+      push(conjectures, fileContextConjectures);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
+  }
+
+  getCombinators(includeDependencies = true) {
+    const combinators = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextCombinators = fileContext.getCombinators(includeRelease);
+
+      push(combinators, fileContextCombinators);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
+
+        push(combinators, releaseContextCombinators);
+      });
+    }
+
+    return combinators;
+  }
+
+  getConstructors(includeDependencies = true) {
+    const constructors = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConstructors = fileContext.getConstructors(includeRelease);
+
+      push(constructors, fileContextConstructors);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
+
+        push(constructors, releaseContextConstructors);
+      });
+    }
+
+    return constructors;
+  }
+
+  addFileContext(fileContext) {
+    this.fileContexts.push(fileContext);
+  }
+
   findTypeByTypeName(typeName) {
     const types = this.getTypes(),
           type = types.find((type) => {
@@ -108,7 +330,8 @@ export default class ReleaseContext {
   fatal(message, node = null, tokens = null, filePath = null) { this.log.fatal(message, node, tokens, filePath); }
 
   initialise(dependencyReleaseContexts) {
-    const releaseContext = this,  ///
+    const fileContexts = [],
+          releaseContext = this,  ///
           releaseContexts = [
             releaseContext,
             ...dependencyReleaseContexts
@@ -117,10 +340,50 @@ export default class ReleaseContext {
           florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
           florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
+    if (this.json !== null) {
+      const fileContextsJSON = this.json; ///
+
+      fileContextsJSON.forEach((fileContextJSON) => {
+        const json = fileContextJSON, ///
+              { filePath } = json,
+              fileContext = FileContext.fromFilePathAndReleaseContext(filePath, releaseContext);
+
+        fileContext.initialise(json);
+
+        fileContexts.push(fileContext);
+      });
+    }
+
     this.lexer = florenceLexer; ///
 
     this.parser = florenceParser; ///
 
+    this.fileContexts = fileContexts;
+
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
+
+  toJSON() {
+    const json = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const fileContextJSON = fileContext.toJSON();
+
+      push(json, fileContextJSON);
+    });
+
+    return json;
+  }
+
+  static fromLogJSONNameAndEntries(log, json, name, entries) {
+    const lexer = null,
+          parser = null,
+          verified = false,
+          customGrammar = customGrammarFromNameAndEntries(name, entries),
+          fileContexts = null,
+          dependencyReleaseContexts = null,
+          releaseContext = new ReleaseContext(log, json, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts);
+
+    return releaseContext;
+  }
 }

package/src/index.js

@@ -4,8 +4,6 @@ export { default as Log } from "./log";
 
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
-export { default as FileReleaseContext } from "./context/release/file";
-export { default as DirectoryReleaseContext } from "./context/release/directory";
 
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
 export { default as releaseContextUtilities } from "./utilities/releaseContext";

package/src/kinds.js

@@ -5,7 +5,9 @@ export const RULE_KIND = "rule";
 export const AXIOM_KIND = "axiom";
 export const LEMMA_KIND = "lemma";
 export const THEOREM_KIND = "theorem";
+export const VARIABLE_KIND = "variable";
 export const META_TYPE_KIND = "meta-type";
 export const CONJECTURE_KIND = "conjecture";
 export const COMBINATOR_KIND = "combinator";
 export const CONSTRUCTOR_KIND = "constructor";
+export const METAVARIABLE_KIND = "metavariable";

package/src/label.js

@@ -34,10 +34,10 @@ export default class Label {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     const labelString = json, ///
-          lexer  = context.getLexer(),
-          parser = context.getParser(),
+          lexer  = fileContext.getLexer(),
+          parser = fileContext.getParser(),
           labelNode = labelNodeFromLabelString(labelString, lexer, parser),
           node = labelNode, ///
           label = new Label(node);

package/src/lemma.js

@@ -7,7 +7,7 @@ import { LEMMA_KIND } from "./kinds";
 export default class Lemma extends AxiomLemmaTheoremConjecture {
   static kind = LEMMA_KIND;
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, context); }
+  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Lemma,json, fileContext); }
 
   static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Lemma, labels, suppositions, consequence, proofContext); }
 }

package/src/metaType.js

@@ -54,16 +54,19 @@ export default class MetaType {
     return json;
   }
 
-  static fromJSON(json, context) {
-    const { name } = json,
+  static fromMetaTypeName(metaTypeName) {
+    const name = metaTypeName,  ///
           metaType = new MetaType(name);
 
     return metaType;
   }
 
-  static fromMetaTypeName(metaTypeName) {
-    const name = metaTypeName,  ///
-          metaType = new MetaType(name);
+  static fromJSONAndFileContext(json, fileContext) {
+    let metaType;
+
+    const { name } = json;
+
+    metaType = new MetaType(name);
 
     return metaType;
   }

package/src/metavariable.js

@@ -1,5 +1,9 @@
 "use strict";
 
+import MetaType from "./metaType";
+
+import { METAVARIABLE_KIND } from "./kinds";
+
 export default class Metavariable {
   constructor(name, metaType) {
     this.name = name;
@@ -20,6 +24,20 @@ export default class Metavariable {
     return matchesName;
   }
 
+  toJSON(tokens) {
+    const metaTypeJSON = this.metaType.toJSON(tokens),
+          kind = METAVARIABLE_KIND,
+          name = this.name, ///
+          metaType = metaTypeJSON,  ///
+          json = {
+            kind,
+            name,
+            metaType
+          };
+
+    return json;
+  }
+
   asString(tokens) {
     const metaTypeName = this.metaType.getName(),
           string = `${this.name}:${metaTypeName}`;
@@ -32,4 +50,22 @@ export default class Metavariable {
 
     return metavariable;
   }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    const { name } = json;
+
+    let { metaType } = json;
+
+    json = metaType;  ///
+
+    metaType = MetaType.fromJSONAndFileContext(json, fileContext);
+
+    const metaTypeName = metaType.getName();
+
+    metaType = fileContext.findTypeByTypeName(metaTypeName); ///
+
+    const metavariable = new Metavariable(name, metaType);
+
+    return metavariable;
+  }
 }

package/src/premise.js

@@ -124,11 +124,11 @@ export default class Premise {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     const { metastatement } = json,
           metastatementString = metastatement,  ///
-          lexer = context.getLexer(),
-          parser = context.getParser(),
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
           metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           premise = new Premise(metastatementNode);
 

package/src/rule.js

@@ -139,7 +139,7 @@ export default class Rule {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     let rule;
 
     let { labels } = json;
@@ -148,7 +148,7 @@ export default class Rule {
 
     labels = labelsJSON.map((labelJSON) => {
       const json = labelJSON, ///
-            label = Label.fromJSON(json, context);
+            label = Label.fromJSONAndFileContext(json, fileContext);
 
       return label;
     });
@@ -159,7 +159,7 @@ export default class Rule {
 
     premises = premisesJSON.map((premiseJSON) => {
       const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, context);
+            premise = Premise.fromJSONAndFileContext(json, fileContext);
 
       return premise;
     });
@@ -170,9 +170,9 @@ export default class Rule {
 
     json = conclusionJSON;  ///
 
-    conclusion = Conclusion.fromJSON(json, context);
+    conclusion = Conclusion.fromJSONAndFileContext(json, fileContext);
 
-    rule = new Rule(labels, premises, conclusion);
+    rule = new Rule(labels, premises, conclusion, fileContext);
 
     return rule;
   }

package/src/ruleNames.js

@@ -3,14 +3,17 @@
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
+export const VARIABLE_RULE_NAME = "variable";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
 export const STATEMENT_RULE_NAME = "statement";
+export const META_TYPE_RULE_NAME = "meta-type";
+export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
-export const CONSTRUCTOR_DECLARATIONRULE_NAME = "constructorDeclaration";
+export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/supposition.js

@@ -75,11 +75,11 @@ export default class Supposition {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     const { statement } = json,
           statementString = statement,  ///
-          lexer = context.getLexer(),
-          parser = context.getParser(),
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           supposition = new Supposition(statementNode);
 

package/src/theorem.js

@@ -7,7 +7,7 @@ import { THEOREM_KIND } from "./kinds";
 export default class Theorem extends AxiomLemmaTheoremConjecture {
   static kind = THEOREM_KIND;
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
+  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
 
   static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Theorem, labels, suppositions, consequence, proofContext); }
 }

package/src/type.js

@@ -133,14 +133,22 @@ export default class Type {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromTypeName(typeName) {
+    const name = typeName,  ///
+          superType = objectType, ///
+          type = new Type(name, superType);
+
+    return type;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
     let type;
 
     let { superType } = json;
 
     const superTypeJSON = superType;  ///
 
-    superType = superTypeFromSuperTypeJSON(superTypeJSON, context);
+    superType = superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext);
 
     const { name } = json;
 
@@ -149,14 +157,6 @@ export default class Type {
     return type;
   }
 
-  static fromTypeName(typeName) {
-    const name = typeName,  ///
-          superType = objectType, ///
-          type = new Type(name, superType);
-
-    return type;
-  }
-
   static fromTypeNameAndSuperType(typeName, superType) {
     const name = typeName,  ///
           type = new Type(name, superType);
@@ -190,7 +190,7 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSON(superTypeJSON, context) {
+function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
   let superType;
 
   const json = superTypeJSON, ///
@@ -200,11 +200,11 @@ function superTypeFromSuperTypeJSON(superTypeJSON, context) {
     superType = objectType; ///
   } else {
     const typeName = name,  ///
-          type = context.findTypeByTypeName(typeName);
+          type = fileContext.findTypeByTypeName(typeName);
 
     superType = (type !== null) ?
                   type :  ///
-                    Type.fromJSON(json, context);  ///
+                    Type.fromJSONAndFileContext(json, fileContext);  ///
   }
 
   return superType;