occam-verify-cli 0.0.262

package/bin/context/package.js

@@ -0,0 +1,221 @@
+"use strict";
+
+const { CustomGrammar, lexersUtilities, parsersUtilities, CombinedCustomGrammar } = require("occam-custom-grammars");
+
+const { push } = require("../utilities/array");
+
+const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+
+class PackageContext {
+  constructor(packageName, fileContexts, florenceLexer, florenceParser, packageContexts, packageVerified) {
+    this.packageName = packageName;
+    this.fileContexts = fileContexts;
+    this.florenceLexer = florenceLexer;
+    this.florenceParser = florenceParser;
+    this.packageContexts = packageContexts;
+    this.packageVerified = packageVerified;
+  }
+
+  getPackageName() {
+    return this.packageName;
+  }
+
+  getFileContexts() {
+    return this.fileContexts;
+  }
+
+  getFlorenceLexer() {
+    return this.florenceLexer;
+  }
+
+  getFlorenceParser() {
+    return this.florenceParser;
+  }
+
+  getPackageContexts() {
+    return this.packageContexts;
+  }
+
+  isPackageVerified() {
+    return this.packageVerified;
+  }
+
+  getRules(packageNames = []) {
+    const rules = [],
+          packageNamesIncludesPackageName = packageNames.includes(this.packageName);
+
+    if (!packageNamesIncludesPackageName) {
+      packageNames.push(this.packageName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextRules = fileContext.getRules(bubble);
+
+        push(rules, fileContextRules);
+      });
+
+      this.packageContexts.forEach((packageContext) => {
+        const packageContextRules = packageContext.getRules(packageNames);
+
+        push(rules, packageContextRules);
+      });
+    }
+
+    return rules;
+  }
+
+  getTypes(packageNames = []) {
+    const types = [],
+          packageNamesIncludesPackageName = packageNames.includes(this.packageName);
+
+    if (!packageNamesIncludesPackageName) {
+      packageNames.push(this.packageName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextTypes = fileContext.getTypes(bubble);
+
+        push(types, fileContextTypes);
+      });
+
+      this.packageContexts.forEach((packageContext) => {
+        const packageContextTypes = packageContext.getTypes(packageNames);
+
+        push(types, packageContextTypes);
+      });
+    }
+
+    return types;
+  }
+
+  getAxioms(packageNames = []) {
+    const axioms = [],
+          packageNamesIncludesPackageName = packageNames.includes(this.packageName);
+
+    if (!packageNamesIncludesPackageName) {
+      packageNames.push(this.packageName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextAxioms = fileContext.getAxioms(bubble);
+
+        push(axioms, fileContextAxioms);
+      });
+
+      this.packageContexts.forEach((packageContext) => {
+        const packageContextAxioms = packageContext.getAxioms(packageNames);
+
+        push(axioms, packageContextAxioms);
+      });
+    }
+
+    return axioms;
+  }
+
+  getCombinators(packageNames = []) {
+    const combinators = [],
+          packageNamesIncludesPackageName = packageNames.includes(this.packageName);
+
+    if (!packageNamesIncludesPackageName) {
+      packageNames.push(this.packageName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextCombinators = fileContext.getCombinators(bubble);
+
+        push(combinators, fileContextCombinators);
+      });
+
+      this.packageContexts.forEach((packageContext) => {
+        const packageContextCombinators = packageContext.getCombinators(packageNames);
+
+        push(combinators, packageContextCombinators);
+      });
+    }
+
+    return combinators;
+  }
+
+  getConstructors(packageNames = []) {
+    const constructors = [],
+          packageNamesIncludesPackageName = packageNames.includes(this.packageName);
+
+    if (!packageNamesIncludesPackageName) {
+      packageNames.push(this.packageName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextConstructors = fileContext.getConstructors(bubble);
+
+        push(constructors, fileContextConstructors);
+      });
+
+      this.packageContexts.forEach((packageContext) => {
+        const packageContextConstructors = packageContext.getConstructors(packageNames);
+
+        push(constructors, packageContextConstructors);
+      });
+    }
+
+    return constructors;
+  }
+
+  getCustomGrammar() {
+    const name = this.packageName, ///
+          termBNF = this.getTermBNF(),
+          statementBNF = this.getStatementBNF(),
+          metastatementBNF = this.getMetastatementBNF(),
+          typePattern = this.getTypePattern(),
+          symbolPattern = this.getSymbolPattern(),
+          operatorPattern = this.getOperatorPattern(),
+          customGrammar = new CustomGrammar(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+
+    return customGrammar;
+  }
+
+  addFileContext(fileContext) {
+    this.fileContexts.push(fileContext);
+  }
+
+  tokenise(content) { return this.florenceLexer.tokenise(content); }
+
+  parse(tokens) { return this.florenceParser.parse(tokens); }
+
+  initialise(packageContexts, dependencyPackageContexts) {
+    this.packageContexts = packageContexts;
+
+    const packageContext = this;  ///
+
+    packageContexts = [ packageContext, ...dependencyPackageContexts ]; ///
+
+    const customGrammars = packageContexts.map((packageContext) => {
+            const customGrammar = packageContext.getCustomGrammar();
+
+            return customGrammar;
+          }),
+          combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+
+    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+
+    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+  }
+
+  static fromPackageName(Class, packageName, ...remainingArguments) {
+    const fileContexts = [],
+          florenceLexer = null,
+          florenceParser = null,
+          packageContexts = [],
+          packageVerified = false,
+          packageContext = new Class(packageName, fileContexts, florenceLexer, florenceParser, packageContexts, packageVerified, ...remainingArguments);
+
+    return packageContext;
+  }
+}
+
+module.exports = PackageContext;

package/bin/context/proof.js

@@ -0,0 +1,93 @@
+"use strict";
+
+class ProofContext {
+  constructor(context, derived, variables, statementNodes) {
+    this.context = context;
+    this.derived = derived;
+    this.variables = variables;
+    this.statementNodes = statementNodes;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  isDerived() {
+    return this.derived;
+  }
+
+  getVariables() {
+    return this.variables;
+  }
+
+  getStatementNodes() {
+    return this.statementNodes;
+  }
+
+  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) {
+    const name = variableName,  ///
+          variable = this.variables.find((variable) => {
+            const matches = variable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || this.context.findVariableByVariableName(variableName);  ///
+
+    return variable;
+  }
+
+  isLabelPresent(label) { return this.context.isLabelPresent(label); }
+
+  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
+  setDerived(derived) {
+    if (derived) {
+      this.statementNodes.pop();
+    }
+
+    this.derived = derived;
+  }
+
+  addAxiom(axiom) { this.context.addAxiom(axiom); }
+
+  addVariable(variable) {
+    this.variables.push(variable);
+  }
+
+  addStatementNode(statementNode) {
+    this.statementNodes.push(statementNode);
+  }
+
+  static fromContext(context) {
+    const derived = false,
+          variables = [],
+          statementNodes = [],
+          proofContext = new ProofContext(context, derived, variables, statementNodes);
+
+    return proofContext;
+  }
+}
+
+module.exports = ProofContext;

package/bin/fileNames.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const TERM_BNF_FILE_NAME = "term.bnf";
+const STATEMENT_BNF_FILE_NAME = "statement.bnf";
+const METASTATEMENT_BNF_FILE_NAME = "metastatement.bnf";
+const TYPE_PATTERN_FILE_NAME = "type.ptn";
+const SYMBOL_PATTERN_FILE_NAME = "symbol.ptn";
+const OPERATOR_PATTERN_FILE_NAME = "operator.ptn";
+
+module.exports = {
+  TERM_BNF_FILE_NAME,
+  STATEMENT_BNF_FILE_NAME,
+  METASTATEMENT_BNF_FILE_NAME,
+  TYPE_PATTERN_FILE_NAME,
+  SYMBOL_PATTERN_FILE_NAME,
+  OPERATOR_PATTERN_FILE_NAME
+};

package/bin/loadPackageContexts.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const FileSystemPackageContext = require("./context/package/fileSystem");
+
+const { first } = require("./utilities/array");
+
+const { log } = loggingUtilities;
+
+function loadPackageContexts(packageName, packageContextMap = {}, dependentPackageNames = []) {
+  const cyclicDependencyExists = checkCyclicDependencyExists(packageName, dependentPackageNames);
+
+  if (!cyclicDependencyExists) {
+    const packageContext = packageContextMap[packageName] || null;
+
+    if (packageContext === null) {
+      const fileSystemPackageContext = FileSystemPackageContext.fromPackageName(packageName),
+            packageContext = fileSystemPackageContext;  ///
+
+      packageContextMap[packageName] = packageContext;
+
+      const dependencyPackageNames = packageContext.getDependencyPackageNames(packageName);
+
+      dependentPackageNames = [ ...dependentPackageNames, packageName ];  ///
+
+      dependencyPackageNames.forEach((dependencyPackageName) => {
+        const packageName = dependencyPackageName;  ///
+
+        loadPackageContexts(packageName, packageContextMap, dependentPackageNames);
+      });
+    }
+  }
+
+  return packageContextMap;
+}
+
+module.exports = loadPackageContexts;
+
+function checkCyclicDependencyExists(packageName, dependentPackageNames) {
+  const dependentPackageNamesIncludesPackageName = dependentPackageNames.includes(packageName),
+        cyclicDependencyExists = dependentPackageNamesIncludesPackageName;  ///
+
+  if (cyclicDependencyExists) {
+    const firstDependentPackageName = first(dependentPackageNames),
+          packageNames = dependentPackageNames.concat(firstDependentPackageName),
+          packageNamesString = packageNames.join(`' -> '`);
+
+    log.error(`There is a cyclic dependency: '${packageNamesString}'.`);
+  }
+
+  return cyclicDependencyExists;
+}

package/bin/main.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const verifyPackage = require("./verify/package"),
+      loadPackageContexts = require("./loadPackageContexts");
+
+const { first } = require("./utilities/array");
+
+const { log } = loggingUtilities;
+
+function main(commands, options) {
+  const firstCommand = first(commands),
+        { logLevel = null, packageName = firstCommand } = options; ///
+
+  if (logLevel !== null) {
+    log.setLogLevel(logLevel);
+  }
+
+  const packageContextMap = loadPackageContexts(packageName);
+
+  verifyPackage(packageName, packageContextMap);
+}
+
+module.exports = main;

package/bin/metaAntecedent.js

@@ -0,0 +1,19 @@
+"use strict";
+
+class MetaAntecedent {
+  constructor(metastatementNodes) {
+    this.metastatementNodes = metastatementNodes;
+  }
+
+  getMetastatementNodes() {
+    return this.metastatementNodes;
+  }
+
+  static fromMetastatementNodes(metastatementNodes) {
+    const metaAntecedent = new MetaAntecedent(metastatementNodes);
+
+    return metaAntecedent;
+  }
+}
+
+module.exports = MetaAntecedent;

package/bin/metaConsequent.js

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

package/bin/metaSubstitution.js

@@ -0,0 +1,24 @@
+"use strict";
+
+class MetaSubstitution {
+  constructor(metavariableName, nonTerminalNode) {
+    this.metavariableName = metavariableName;
+    this.nonTerminalNode = nonTerminalNode;
+  }
+
+  getMetavariableName() {
+    return this.metavariableName;
+  }
+
+  getNonTerminalNode() {
+    return this.nonTerminalNode;
+  }
+
+  static fromMetavariableNameAndNonTerminalNode(metavariableName, nonTerminalNode) {
+    const metaSubstitution = new MetaSubstitution(metavariableName, nonTerminalNode);
+
+    return metaSubstitution;
+  }
+}
+
+module.exports = MetaSubstitution;

package/bin/options.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const LOG_LEVEL_OPTION = "log-level",
+      PACKAGE_NAME_OPTIONS = "package-name";
+
+module.exports = {
+  LOG_LEVEL_OPTION,
+  PACKAGE_NAME_OPTIONS
+};

package/bin/premise.js

@@ -0,0 +1,19 @@
+"use strict";
+
+class Premise {
+  constructor(metastatementNodes) {
+    this.metastatementNodes = metastatementNodes;
+  }
+
+  getMetastatementNodes() {
+    return this.metastatementNodes;
+  }
+
+  static fromMetastatementNodes(metastatementNodes) {
+    const premise = new Premise(metastatementNodes);
+
+    return premise;
+  }
+}
+
+module.exports = Premise;

package/bin/rule.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const { labelsAsString } = require("./utilities/string");
+
+class Rule {
+  constructor(labels, premise, conclusion, metastatementNode) {
+    this.labels = labels;
+    this.premise = premise;
+    this.conclusion = conclusion;
+    this.metastatementNode = metastatementNode;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getPremise() {
+    return this.premise;
+  }
+
+  getConclusion() {
+    return this.conclusion;
+  }
+
+  getPremiseMetastatementNodes() {
+    const metastatementNodes = (this.premise !== null) ?
+                                  this.premise.getMetastatementNodes() :
+                                    [];
+
+    return metastatementNodes;
+  }
+
+  getConclusionMetastatementNode() {
+    const metastatementNode = (this.conclusion !== null) ?
+                                 this.conclusion.getMetastatementNode() :
+                                   this.metastatementNode;
+
+    return metastatementNode;
+  }
+
+  asString() {
+    const string = labelsAsString(this.labels);
+
+    return string;
+  }
+
+  static fromMetastatementNodeAndLabels(metastatementNode, labels) {
+    const premise = null,
+          conclusion = null,
+          rule = new Rule(labels, premise, conclusion, metastatementNode);
+
+    return rule;
+  }
+
+  static fromPremiseConclusionAndLabels(premise, conclusion, labels) {
+    const metastatementNode = null,
+          rule = new Rule(labels, premise, conclusion, metastatementNode);
+
+    return rule;
+  }
+}
+
+module.exports = Rule;
+

package/bin/ruleNames.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const TERM_RULE_NAME = "term",
+      TYPE_RULE_NAME = "type",
+      ARGUMENT_RULE_NAME = "argument",
+      METAVARIABLE_RULE_NAME = "metavariable",
+      META_SUBLEMMA_RULE_NAME = "metaSublemma",
+      QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement",
+      UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";
+
+module.exports = {
+  TERM_RULE_NAME,
+  TYPE_RULE_NAME,
+  ARGUMENT_RULE_NAME,
+  METAVARIABLE_RULE_NAME,
+  META_SUBLEMMA_RULE_NAME,
+  QUALIFIED_METASTATEMENT_RULE_NAME,
+  UNQUALIFIED_METASTATEMENT_RULE_NAME
+};