occam-verify-cli 0.0.538 → 0.0.540

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,6 +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 fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Lemma, labels, suppositions, consequence); }
+  static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Lemma, labels, suppositions, consequence, proofContext); }
 }

package/src/metaType.js

@@ -0,0 +1,81 @@
+"use strict";
+
+import { META_TYPE_KIND } from "./kinds";
+import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
+
+export default class MetaType {
+  constructor(name) {
+    this.name = name;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  isEqualTo(metaType) {
+    const equalTo = (this === metaType);
+
+    return equalTo;
+  }
+
+  match(metaType) {
+    const equalToMetaType = this.isEqualTo(metaType),
+          matches = equalToMetaType;  ///
+
+    return matches;
+  }
+
+  matchName(name) {
+    const matchesName = (this.name === name);
+
+    return matchesName;
+  }
+
+  matchMetaTypeName(metaTypeName) {
+    const matchesMetaTypeName = (this.name === metaTypeName);
+
+    return matchesMetaTypeName;
+  }
+
+  asString(tokens) {
+    const string = `${this.name}`;
+
+    return string;
+  }
+
+  toJSON(tokens) {
+    const kind = META_TYPE_KIND,
+          name = this.name,
+          json = {
+            kind,
+            name
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, context) {
+    const { name } = json,
+          metaType = new MetaType(name);
+
+    return metaType;
+  }
+
+  static fromMetaTypeName(metaTypeName) {
+    const name = metaTypeName,  ///
+          metaType = new MetaType(name);
+
+    return metaType;
+  }
+}
+
+class StatementMetaType extends MetaType {
+  static fromNothing() {
+    const name = STATEMENT_META_TYPE_NAME,
+          objectMetaType = new StatementMetaType(name);
+
+    return objectMetaType;
+  }
+}
+
+export const statementMetaType = StatementMetaType.fromNothing();

package/src/metavariable.js

@@ -0,0 +1,39 @@
+"use strict";
+
+export default class Metavariable {
+  constructor(name, metaType) {
+    this.name = name;
+    this.metaType = metaType;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getMetaType() {
+    return this.metaType;
+  }
+
+  matchName(name) {
+    const matchesName = (this.name === name);
+
+    return matchesName;
+  }
+
+  asString(tokens) {
+    const metaTypeName = this.metaType.getName(),
+          string = `${this.name}:${metaTypeName}`;
+
+    return string;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    debugger
+  }
+
+  static fromNameAndMetaType(name, metaType) {
+    const metavariable = new Metavariable(name, metaType);
+
+    return metavariable;
+  }
+}

package/src/premise.js

@@ -22,7 +22,7 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions) {
+  matchSubproofNode(subproofNode, substitutions, fileContext, statementProofContext) {
     let subproofNodeMatches = false;
 
     const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -43,7 +43,9 @@ export default class Premise {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                fileContextA = fileContext, ///
+                proofContextB = statementProofContext,  ///
+                nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -55,16 +57,18 @@ export default class Premise {
     return subproofNodeMatches;
   }
 
-  matchStatementNode(statementNode, substitutions) {
+  matchStatementNode(statementNode, substitutions, fileContext, statementProofContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          fileContextA = fileContext, ///
+          proofContextB = statementProofContext,  ///
+          nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetaproofContext) {
     let ruleSubproofNodeMatches = false;
 
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -85,7 +89,9 @@ export default class Premise {
           const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                fileContextA = fileContext, ///
+                metaproofContextB = metastatementMetaproofContext,  ///
+                nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -97,10 +103,12 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          fileContextA = fileContext, ///
+          metaproofContextB = metastatementMetaproofContext,  ///
+          nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB),
           metastatementNodeMatches = nonTerminalNodeVerified; ///
 
     return metastatementNodeMatches;
@@ -116,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);