occam-verify-cli 0.0.539 → 0.0.540

package/src/context/file.js

@@ -2,16 +2,37 @@
 
 import { rewriteNodes } from "occam-grammar-utilities";
 
+import Type from "../type";
+import Rule from "../rule";
+import Axiom from "../axiom";
+import Lemma from "../lemma";
+import Theorem from "../theorem";
+import Variable from "../variable";
+import Conjecture from "../conjecture";
+import Combinator from "../combinator";
+import Constructor from "../constructor";
+import Metavariable from "../metavariable";
+
 import { push, filter } from "../utilities/array";
 import { statementMetaType } from "../metaType";
 import { nodeAsString, nodesAsString } from "../utilities/string";
+import { TYPE_KIND,
+         RULE_KIND,
+         AXIOM_KIND,
+         LEMMA_KIND,
+         THEOREM_KIND,
+         VARIABLE_KIND,
+         CONJECTURE_KIND,
+         COMBINATOR_KIND,
+         CONSTRUCTOR_KIND,
+         METAVARIABLE_KIND } from "../kinds";
 
 const metaTypes = [
   statementMetaType
 ];
 
 export default class FileContext {
-  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, variables, metavariables) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, conjectures, combinators, constructors, metavariables) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -21,10 +42,10 @@ export default class FileContext {
     this.axioms = axioms;
     this.lemmas = lemmas;
     this.theorems = theorems;
+    this.variables = variables;
     this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
-    this.variables = variables;
     this.metavariables = metavariables;
   }
 
@@ -83,6 +104,12 @@ export default class FileContext {
       push(labels, theoremLabels);
     });
 
+    this.conjectures.forEach((conjecture) => {
+      const conjectureLabels = conjecture.getLabels();
+
+      push(labels, conjectureLabels);
+    });
+
     if (includeRelease) {
       const releaseContextLabels = this.releaseContext.getLabels();
 
@@ -162,6 +189,10 @@ export default class FileContext {
     return theorems;
   }
 
+  getVariables(includeRelease = true) {
+    return this.variables;
+  }
+
   getMetaTypes(includeRelease = true) {
     return metaTypes;
   }
@@ -208,39 +239,35 @@ export default class FileContext {
     return constructors;
   }
 
-  getVariables() {
-    return this.variables;
-  }
-
-  getMetavariables() {
+  getMetavariables(includeRelease = true) {
     return this.metavariables;
   }
 
-  findTypeByTypeName(typeName) {
-    const types = this.getTypes(),
-          type = types.find((type) => {
-            const matches = type.matchTypeName(typeName);
+  findLabelByLabelName(labelName) {
+    const name = labelName,  ///
+          labels = this.getLabels(),
+          label = labels.find((label) => {
+            const matches = label.matchName(name);
 
             if (matches) {
               return true;
             }
           }) || null;
 
-    return type;
+    return label;
   }
 
-  findLabelByLabelName(labelName) {
-    const name = labelName,  ///
-          labels = this.getLabels(),
-          label = labels.find((label) => {
-            const matches = label.matchName(name);
+  findTypeByTypeName(typeName) {
+    const types = this.getTypes(),
+          type = types.find((type) => {
+            const matches = type.matchTypeName(typeName);
 
             if (matches) {
               return true;
             }
           }) || null;
 
-    return label;
+    return type;
   }
 
   findRuleByReferenceName(referenceName) {
@@ -354,13 +381,6 @@ export default class FileContext {
     return metavariable;
   }
 
-  isTypePresentByTypeName(typeName) {
-    const type = this.findTypeByTypeName(typeName),
-          typePresent = (type !== null);
-
-    return typePresent;
-  }
-
   isLabelPresentByLabelName(labelName) {
     const label = this.findLabelByLabelName(labelName),
           labelPresent = (label !== null);
@@ -368,6 +388,13 @@ export default class FileContext {
     return labelPresent;
   }
 
+  isTypePresentByTypeName(typeName) {
+    const type = this.findTypeByTypeName(typeName),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
   isVariablePresentByVariableName(variableName) {
     const variable = this.findVariableByVariableName(variableName),
           variablePresent = (variable !== null);
@@ -435,6 +462,10 @@ export default class FileContext {
     this.variables.push(variable);
   }
 
+  addConjecture(conjecture) {
+    this.conjectures.push(conjecture);
+  }
+
   addCombinator(combinator) {
     this.combinators.push(combinator);
   }
@@ -503,6 +534,12 @@ export default class FileContext {
       json.push(theoremJSON);
     });
 
+    this.variables.forEach((variable) => {
+      const variableJSON = variable.toJSON(this.tokens);
+
+      json.push(variableJSON)
+    });
+
     this.conjectures.forEach((conjecture) => {
       const conjectureJSON = conjecture.toJSON(this.tokens);
 
@@ -521,9 +558,106 @@ export default class FileContext {
       json.push(constructorJSON)
     });
 
+    this.metavariables.forEach((metavariable) => {
+      const metavariableJSON = metavariable.toJSON(this.tokens);
+
+      json.push(metavariableJSON)
+    });
+
     return json;
   }
 
+  static fromJSON(json) {
+    const jsonArray = json, ///
+          fileContext = this; ///
+
+    jsonArray.forEach((json) => {
+      const { kind } = json;
+
+      switch (kind) {
+        case TYPE_KIND: {
+          const type = Type.fromJSONAndFileContext(json, fileContext);
+
+          this.types.push(type);
+
+          break;
+        }
+
+        case RULE_KIND: {
+          const rule = Rule.fromJSONAndFileContext(json, fileContext);
+
+          this.rules.push(rule);
+
+          break;
+        }
+
+        case AXIOM_KIND: {
+          const axiom = Axiom.fromJSONAndFileContext(json, fileContext);
+
+          this.axioms.push(axiom);
+
+          break;
+        }
+
+        case LEMMA_KIND: {
+          const lemma = Lemma.fromJSONAndFileContext(json, fileContext);
+
+          this.lemmas.push(lemma);
+
+          break;
+        }
+
+        case THEOREM_KIND: {
+          const theorem = Theorem.fromJSONAndFileContext(json, fileContext);
+
+          this.theorems.push(theorem);
+
+          break;
+        }
+
+        case VARIABLE_KIND: {
+          const variable = Variable.fromJSONAndFileContext(json, fileContext);
+
+          this.variables.push(variable);
+
+          break;
+        }
+
+        case CONJECTURE_KIND: {
+          const conjecture = Conjecture.fromJSONAndFileContext(json, fileContext);
+
+          this.conjectures.push(conjecture);
+
+          break;
+        }
+
+        case COMBINATOR_KIND: {
+          const combinator = Combinator.fromJSONAndFileContext(json, fileContext);
+
+          this.combinators.push(combinator);
+
+          break;
+        }
+
+        case CONSTRUCTOR_KIND: {
+          const constructor = Constructor.fromJSONAndFileContext(json, fileContext);
+
+          this.constructors.push(constructor);
+
+          break;
+        }
+
+        case METAVARIABLE_KIND: {
+          const metavariable = Metavariable.fromJSONAndFileContext(json, fileContext);
+
+          this.metavariables.push(metavariable);
+
+          break;
+        }
+      }
+    });
+  }
+
   static fromReleaseContextAndFilePath(releaseContext, filePath) {
     const file = releaseContext.getFile(filePath),
           content = file.getContent(),
@@ -541,12 +675,12 @@ export default class FileContext {
           axioms = [],
           lemmas = [],
           theorems = [],
+          variables = [],
           conjectures = [],
           combinators = [],
           constructors = [],
-          variables = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, variables, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, theorems, conjectures, combinators, constructors, metavariables);
 
     return fileContext;
   }

package/src/context/metaproof.js

@@ -108,7 +108,7 @@ class MetaproofContext {
     return metavariable;
   }
 
-  isMetavariablePresentByVariableName(metavariableName) {
+  isMetavariablePresentByMetavariableName(metavariableName) {
     const metavariable = this.findMetavariableByMetavariableName(metavariableName),
           metavariablePresent = (metavariable !== null);
 

package/src/context/release.js

@@ -2,13 +2,16 @@
 
 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, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
     this.entries = entries;
@@ -16,6 +19,7 @@ export default class ReleaseContext {
     this.parser = parser;
     this.verified = verified;
     this.customGrammar = customGrammar;
+    this.fileContexts = fileContexts;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
@@ -47,10 +51,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) => {
@@ -123,4 +340,39 @@ export default class ReleaseContext {
 
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
+
+  toJSON() {
+    const json = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const fileContextJSON = fileContext.toJSON();
+
+      push(json, fileContextJSON);
+    });
+
+    return json;
+  }
+
+  fromJSON(json) {
+    const fileContextsJSON = json;  ///
+
+    this.fileContexts = fileContextsJSON.map((fileContextJSON) => {
+      const json = fileContextJSON, ///
+            fileContext = FileContext.fromJSON(json);
+
+      return fileContext;
+    });
+  }
+
+  static fromLogNameAndEntries(log, name, entries) {
+    const lexer = null,
+          parser = null,
+          verified = false,
+          customGrammar = customGrammarFromNameAndEntries(name, entries),
+          fileContexts = null,
+          dependencyReleaseContexts = null,
+          releaseContext = new ReleaseContext(log, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts);
+
+    return 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/metavariable.js

@@ -27,6 +27,10 @@ export default class Metavariable {
     return string;
   }
 
+  static fromJSONAndFileContext(json, fileContext) {
+    debugger
+  }
+
   static fromNameAndMetaType(name, metaType) {
     const metavariable = new Metavariable(name, metaType);
 

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;
   }