occam-verify-cli 0.0.262

package/README.md

@@ -0,0 +1,7 @@
+# Occam Verify-CLI
+
+[Occam](https://github.com/djalbat/occam)'s verifier.
+
+## Contact
+
+* james.smith@openmathematics.org

package/bin/abbreviations.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const { LOG_LEVEL_OPTION, PACKAGE_NAME_OPTIONS } = require("./options");
+
+const l = LOG_LEVEL_OPTION,
+      p = PACKAGE_NAME_OPTIONS;
+
+module.exports = {
+  l,
+  p
+};

package/bin/antecedent.js

@@ -0,0 +1,19 @@
+"use strict";
+
+class Antecedent {
+  constructor(statementNodes) {
+    this.statementNodes = statementNodes;
+  }
+
+  getStatementNodes() {
+    return this.statementNodes;
+  }
+
+  static fromStatementNodes(statementNodes) {
+    const antecedent = new Antecedent(statementNodes);
+
+    return antecedent;
+  }
+}
+
+module.exports = Antecedent;

package/bin/axiom.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { labelsAsString } = require("./utilities/string");
+
+class Axiom {
+  constructor(labels, antecedent, consequent, statementNode) {
+    this.labels = labels;
+    this.antecedent = antecedent;
+    this.consequent = consequent;
+    this.statementNode = statementNode;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getAntecedent() {
+    return this.antecedent;
+  }
+
+  getConsequent() {
+    return this.consequent;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  asString() {
+    const string = labelsAsString(this.labels);
+
+    return string;
+  }
+
+  static fromStatementNodeAndLabels(statementNode, labels) {
+    const antecedent = null,
+          consequent = null,
+          axiom = new Axiom(labels, antecedent, consequent, statementNode);
+
+    return axiom;
+  }
+
+  static fromAntecedentConsequentAndLabels(antecedent, consequent, labels) {
+    const statementNode = null,
+          axiom = new Axiom(labels, antecedent, consequent, statementNode);
+
+    return axiom;
+  }
+}
+
+module.exports = Axiom;
+

package/bin/combinator.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const { nodeAsString } = require("./utilities/string");
+
+class Combinator {
+  constructor(statementNode) {
+    this.statementNode = statementNode;
+  }
+
+  asString() {
+    let string;
+
+    const statementString = nodeAsString(this.statementNode);
+
+    string = `${statementString}`;
+
+    return string;
+  }
+
+  static fromStatementNode(statementNode) {
+    const combinator = new Combinator(statementNode);
+
+    return combinator;
+  }
+}
+
+module.exports = Combinator;

package/bin/conclusion.js

@@ -0,0 +1,19 @@
+"use strict";
+
+class Conclusion {
+  constructor(metastatementNode) {
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  static fromMetastatementNode(metastatementNode) {
+    const conclusion = new Conclusion(metastatementNode);
+
+    return conclusion;
+  }
+}
+
+module.exports = Conclusion;

package/bin/consequent.js

@@ -0,0 +1,19 @@
+"use strict";
+
+class Consequent {
+  constructor(statementNode) {
+    this.statementNode = statementNode;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  static fromStatementNode(statementNode) {
+    const consequent = new Consequent(statementNode);
+
+    return consequent;
+  }
+}
+
+module.exports = Consequent;

package/bin/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const COMMA = ',';
+const EMPTY_STRING = "";
+
+module.exports = {
+  COMMA,
+  EMPTY_STRING
+};

package/bin/constructor.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { nodeAsString } = require("./utilities/string");
+
+class Constructor {
+  constructor(termNode, type) {
+    this.termNode = termNode;
+    this.type = type;
+  }
+
+  getTermNode() {
+    return this.termNode;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  asString() {
+    let string;
+
+    const termString = nodeAsString(this.termNode);
+
+    if (this.type === null) {
+      string = `${termString}`;
+    } else {
+      const noSuperType = true,
+            typeString = this.type.asString(noSuperType);
+
+      string = `${termString}:${typeString}`;
+    }
+
+    return string;
+  }
+
+  static fromTermNodeAndType(termNode, type) {
+    const constructor = new Constructor(termNode, type);
+
+    return constructor;
+  }
+}
+
+module.exports = Constructor;

package/bin/context/file.js

@@ -0,0 +1,257 @@
+"use strict";
+
+const { rewriteNodes } = require("occam-grammar-utilities");
+
+const { push } = require("../utilities/array");
+
+class FileContext {
+  constructor(tokens, node, rules, types, axioms, variables, combinators, constructors, packageContext) {
+    this.tokens = tokens;
+    this.node = node;
+    this.rules = rules;
+    this.types = types;
+    this.axioms = axioms;
+    this.variables = variables;
+    this.combinators = combinators;
+    this.constructors = constructors;
+    this.packageContext = packageContext;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getRules(bubble = true) {
+    const rules = [
+      ...this.rules
+    ];
+
+    if (bubble) {
+      const packageContextRules = this.packageContext.getRules();
+
+      push(rules, packageContextRules);
+    }
+
+    return rules;
+  }
+
+  getTypes(bubble = true) {
+    const types = [
+      ...this.types
+    ];
+
+    if (bubble) {
+      const packageContextTypes = this.packageContext.getTypes();
+
+      push(types, packageContextTypes);
+    }
+
+    return types;
+  }
+
+  getAxioms(bubble = true) {
+    const axioms = [
+      ...this.axioms
+    ];
+
+    if (bubble) {
+      const packageContextAxioms = this.packageContext.getAxioms();
+
+      push(axioms, packageContextAxioms);
+    }
+
+    return axioms;
+  }
+
+  getLabels() {
+    const axioms = this.getAxioms(),
+          labels = axioms.reduce((labels, axiom) => {
+            const axiomLabels = axiom.getLabels();
+
+            push(labels, axiomLabels);
+
+            return labels;
+          }, []);
+
+    return labels;
+  }
+
+  getVariables() {
+    return this.variables;
+  }
+
+  getCombinators(bubble = true) {
+    const combinators = [
+      ...this.combinators
+    ];
+
+    if (bubble) {
+      const packageContextCombinators = this.packageContext.getCombinators();
+
+      push(combinators, packageContextCombinators);
+    }
+
+    return combinators;
+  }
+
+  getConstructors(bubble = true) {
+    const constructors = [
+      ...this.constructors
+    ];
+
+    if (bubble) {
+      const packageContextConstructors = this.packageContext.getConstructors();
+
+      push(constructors, packageContextConstructors);
+    }
+
+    return constructors;
+  }
+
+  getPackageContext() {
+    return this.packageContext;
+  }
+
+  findTypeByTypeName(typeName) {
+    const types = this.getTypes(),
+          type = types.find((type) => {
+            const matches = type.matchTypeName(typeName);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return type;
+  }
+
+  findRuleByReferenceName(referenceName) {
+    const label = referenceName,  ///
+          rules = this.getRules(),
+          rule = rules.find((rule) => {
+            const ruleLabels = rule.getLabels(),
+                  ruleLabelsIncludesLabel = ruleLabels.includes(label);
+
+            if (ruleLabelsIncludesLabel) {
+              return true;
+            }
+          }) || null;
+
+    return rule;
+  }
+
+  findAxiomByReferenceName(referenceName) {
+    const label = referenceName,  ///
+          axioms = this.getAxioms(),
+          axiom = axioms.find((axiom) => {
+            const axiomLabels = axiom.getLabels(),
+                  axiomLabelsIncludesLabel = axiomLabels.includes(label);
+
+            if (axiomLabelsIncludesLabel) {
+              return true;
+            }
+          }) || null;
+
+    return axiom;
+  }
+
+  findVariableByVariableName(variableName) {
+    const name = variableName,  ///
+          variable = this.variables.find((variable) => {
+            const matches = variable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
+
+  isDerived() {
+    const derived = false;
+
+    return derived;
+  }
+
+  isLabelPresent(label) {
+    const labels = this.getLabels(),
+          labelsIncludesLabel = labels.includes(label),
+          labelPresent = labelsIncludesLabel; ///
+
+    return labelPresent;
+  }
+
+  isTypePresentByTypeName(typeName) {
+    const type = this.findTypeByTypeName(typeName),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
+  isMetastatementNodePresent(metaStatementNode) {
+    const metastatementNodePresent = false;
+
+    return metastatementNodePresent;
+  }
+
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
+  addType(type) {
+    this.types.push(type);
+  }
+
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+
+  addAxiom(axiom) {
+    this.axioms.push(axiom);
+  }
+
+  addVariable(variable) {
+    this.variables.push(variable);
+  }
+
+  addCombinator(combinator) {
+    this.combinators.push(combinator);
+  }
+
+  addConstructor(constructor) {
+    this.constructors.push(constructor);
+  }
+
+  setInAntecedent(inAntecedent) {
+    ///
+  }
+
+  static fromPackageContextAndFilePath(packageContext, filePath) {
+    const fileContent = packageContext.getFileContent(filePath),
+          content = fileContent,  ///
+          tokens = packageContext.tokenise(content),
+          node = packageContext.parse(tokens);
+
+    rewriteNodes(node);
+
+    const rules = [],
+          types = [],
+          axioms = [],
+          variables = [],
+          combinators = [],
+          constructors = [],
+          fileContext = new FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, packageContext);
+
+    return fileContext;
+  }
+}
+
+module.exports = FileContext;

package/bin/context/metaproof.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const { nodeAsString } = require("../utilities/string");
+
+class MetaproofContext {
+  constructor(context, derived, metastatementNodes) {
+    this.context = context;
+    this.derived = derived;
+    this.metastatementNodes = metastatementNodes;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  isDerived() {
+    return this.derived;
+  }
+
+  getMetastatementNodes() {
+    return this.metastatementNodes;
+  }
+
+  getRules() { return this.context.getRules(); }
+
+  getTypes() { return this.context.getTypes(); }
+
+  getAxioms() { return this.context.getAxioms(); }
+
+  getCombinators() { return this.context.getCombinators(); }
+
+  getConstructors() { return this.context.getConstructors(); }
+
+  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
+
+  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
+
+  findVariableByVariableName(variableName) { return this.context.findVariableByVariableName(variableName); }
+
+  isLabelPresent(label) { return this.context.isLabelPresent(label); }
+
+  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+
+  isMetastatementNodePresent(metaStatementNode) {
+    const metastatementNodeA = metaStatementNode; ///
+
+    let metastatementNodePresent = this.metastatementNodes.some((metaStatementNode) => {
+      const metastatementNodeB = metaStatementNode, ///
+            metastatementNodeAString = nodeAsString(metastatementNodeA),
+            metastatementNodeBString = nodeAsString(metastatementNodeB),
+            matches = (metastatementNodeAString === metastatementNodeBString);
+
+      if (matches) {
+        return true;
+      }
+    });
+
+    if (!metastatementNodePresent) {
+      metastatementNodePresent = this.context.isMetastatementNodePresent(metaStatementNode);
+    }
+
+    return metastatementNodePresent;
+  }
+
+  isVariablePresentByVariableName(variableName) { return this.context.isVariablePresentByVariableName(variableName); }
+
+  setDerived(derived) {
+    if (derived) {
+      this.metastatementNodes.pop();
+    }
+
+    this.derived = derived;
+  }
+
+  addRule(rule) { this.context.addRule(rule); }
+
+  addMetastatementNode(metastatementNode) {
+    this.metastatementNodes.push(metastatementNode);
+  }
+
+  static fromContext(context) {
+    const derived = false,
+          metastatementNodes = [],
+          metaproofContext = new MetaproofContext(context, derived, metastatementNodes);
+
+    return metaproofContext;
+  }
+}
+
+module.exports = MetaproofContext;

package/bin/context/package/fileSystem.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const { fileSystemUtilities } = require("necessary");
+
+const PackageContext = require("../../context/package");
+
+const { filePathsFromPackageName, dependencyPackageNamesFromPackageName } = require("../../utilities/fileSystem"),
+      { TERM_BNF_FILE_NAME,
+        STATEMENT_BNF_FILE_NAME,
+        METASTATEMENT_BNF_FILE_NAME,
+        TYPE_PATTERN_FILE_NAME,
+        SYMBOL_PATTERN_FILE_NAME,
+        OPERATOR_PATTERN_FILE_NAME } = require("../../fileNames");
+
+const { readFile, checkFileExists } = fileSystemUtilities;
+
+class FileSystemPackageContext extends PackageContext {
+  getFilePaths() {
+    const packageName = this.getPackageName(),
+          filePaths = filePathsFromPackageName(packageName);
+
+    return filePaths;
+  }
+
+  getFileContent(filePath) {
+    const fileContent = readFile(filePath);
+
+    return fileContent;
+  }
+
+  getDependencyPackageNames() {
+    const packageName = this.getPackageName(),
+          dependencyPackageNames = dependencyPackageNamesFromPackageName(packageName);
+
+    return dependencyPackageNames;
+  }
+
+  getTermBNF() {
+    const packageName = this.getPackageName(),
+          directoryName = packageName,  ///
+          fileName = TERM_BNF_FILE_NAME, ///
+          fileContent = fileContentFromDirectoryNameAndFileName(directoryName, fileName),
+          termBNF = fileContent;  ///
+
+    return termBNF;
+  }
+
+  getStatementBNF() {
+    const packageName = this.getPackageName(),
+          directoryName = packageName,  ///
+          fileName = STATEMENT_BNF_FILE_NAME, ///
+          fileContent = fileContentFromDirectoryNameAndFileName(directoryName, fileName),
+          termBNF = fileContent;  ///
+
+    return termBNF;
+  }
+
+  getMetastatementBNF() {
+    const packageName = this.getPackageName(),
+          directoryName = packageName,  ///
+          fileName = METASTATEMENT_BNF_FILE_NAME, ///
+          fileContent = fileContentFromDirectoryNameAndFileName(directoryName, fileName),
+          termBNF = fileContent;  ///
+
+    return termBNF;
+  }
+
+  getTypePattern() {
+    const packageName = this.getPackageName(),
+          directoryName = packageName,  ///
+          fileName = TYPE_PATTERN_FILE_NAME, ///
+          fileContent = fileContentFromDirectoryNameAndFileName(directoryName, fileName),
+          termBNF = fileContent;  ///
+
+    return termBNF;
+  }
+
+  getSymbolPattern() {
+    const packageName = this.getPackageName(),
+          directoryName = packageName,  ///
+          fileName = SYMBOL_PATTERN_FILE_NAME, ///
+          fileContent = fileContentFromDirectoryNameAndFileName(directoryName, fileName),
+          termBNF = fileContent;  ///
+
+    return termBNF;
+  }
+
+  getOperatorPattern() {
+    const packageName = this.getPackageName(),
+          directoryName = packageName,  ///
+          fileName = OPERATOR_PATTERN_FILE_NAME, ///
+          fileContent = fileContentFromDirectoryNameAndFileName(directoryName, fileName),
+          termBNF = fileContent;  ///
+
+    return termBNF;
+  }
+
+  static fromPackageName(packageName) { return PackageContext.fromPackageName(FileSystemPackageContext, packageName); }
+}
+
+module.exports = FileSystemPackageContext;
+
+function fileContentFromDirectoryNameAndFileName(directoryName, fileName) {
+  const filePath = `${directoryName}/${fileName}`,
+        fileExists = checkFileExists(filePath),
+        fileContent = fileExists ?
+                        readFile(filePath) :
+                          null;
+
+  return fileContent;
+}