occam-verify-cli 0.0.272 → 0.0.274

package/bin/context/package.js

@@ -1,221 +0,0 @@
-"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/loadPackageContexts.js

@@ -1,53 +0,0 @@
-"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/permutations.js

@@ -1,3 +0,0 @@
-"use strict";
-      
-[[0,1,2],[1,0,2],[1,2,0],[0,2,1],[2,0,1],[2,1,0],[0,1,3],[1,0,3],[1,3,0],[0,3,1],[3,0,1],[3,1,0],[0,1,4],[1,0,4],[1,4,0],[0,4,1],[4,0,1],[4,1,0],[0,2,3],[2,0,3],[2,3,0],[0,3,2],[3,0,2],[3,2,0],[0,2,4],[2,0,4],[2,4,0],[0,4,2],[4,0,2],[4,2,0],[0,3,4],[3,0,4],[3,4,0],[0,4,3],[4,0,3],[4,3,0],[1,2,3],[2,1,3],[2,3,1],[1,3,2],[3,1,2],[3,2,1],[1,2,4],[2,1,4],[2,4,1],[1,4,2],[4,1,2],[4,2,1],[1,3,4],[3,1,4],[3,4,1],[1,4,3],[4,1,3],[4,3,1],[2,3,4],[3,2,4],[3,4,2],[2,4,3],[4,2,3],[4,3,2]]      

package/bin/ruleNames.js

@@ -1,23 +0,0 @@
-"use strict";
-
-const TERM_RULE_NAME = "term",
-      TYPE_RULE_NAME = "type",
-      ARGUMENT_RULE_NAME = "argument",
-      METAVARIABLE_RULE_NAME = "metavariable",
-      METASTATEMENT_RULE_NAME = "metastatement",
-      META_SUBPROOF_RULE_NAME = "metaSubproof",
-      META_SUBPROOF_ASSERTION_RULE_NAME = "metaSubproofAssertion",
-      QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement",
-      UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";
-
-module.exports = {
-  TERM_RULE_NAME,
-  TYPE_RULE_NAME,
-  ARGUMENT_RULE_NAME,
-  METAVARIABLE_RULE_NAME,
-  METASTATEMENT_RULE_NAME,
-  META_SUBPROOF_RULE_NAME,
-  META_SUBPROOF_ASSERTION_RULE_NAME,
-  QUALIFIED_METASTATEMENT_RULE_NAME,
-  UNQUALIFIED_METASTATEMENT_RULE_NAME
-};

package/bin/verify/axiom/IndicativeConditional.js

@@ -1,54 +0,0 @@
-"use strict";
-
-const Axiom = require("../../axiom"),
-      verifyLabels = require("../../verify/labels"),
-      verifySupposition = require("../../verify/antecedent"),
-      verifyConsequent = require("../../verify/consequent");
-
-const { first } = require("../../utilities/array"),
-      { nodeQuery, nodesQuery } = require("../../utilities/query");
-
-const labelNodesQuery = nodesQuery("/axiom/label"),
-      antecedentNodeQuery = nodeQuery("/indicativeConditional/antecedent!"),
-      consequentNodeQuery = nodeQuery("/indicativeConditional/consequent!"),
-      indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
-
-function verifyIndicativeConditionalAxiom(axiomNode, context) {
-  let indicativeConditionalAxiomVerified = false;
-
-  const indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
-
-  if (indicativeConditionalNode !== null) {
-    const labels = [],
-          labelNodes = labelNodesQuery(axiomNode),
-          labelsVerified = verifyLabels(labelNodes, labels, context);
-
-    if (labelsVerified) {
-      const antecedents = [],
-            antecedentNode = antecedentNodeQuery(indicativeConditionalNode),
-            antecedentVerified = verifySupposition(antecedentNode, antecedents, context);
-
-      if (antecedentVerified) {
-        const consequents = [],
-              consequentNode = consequentNodeQuery(indicativeConditionalNode),
-              consequentVerified = verifyConsequent(consequentNode, consequents, context);
-
-        if (consequentVerified) {
-          const firstSupposition = first(antecedents),
-                firstConsequent = first(consequents),
-                antecedent = firstSupposition, ///
-                consequent = firstConsequent, ///
-                axiom = Axiom.fromSuppositionConsequentAndLabels(antecedent, consequent, labels);
-
-          context.addAxiom(axiom);
-
-          indicativeConditionalAxiomVerified = true;
-        }
-      }
-    }
-  }
-
-  return indicativeConditionalAxiomVerified;
-}
-
-module.exports = verifyIndicativeConditionalAxiom;

package/bin/verify/axiom/unqualifiedStatement.js

@@ -1,40 +0,0 @@
-"use strict";
-
-const Axiom = require("../../axiom"),
-      verifyLabels = require("../../verify/labels"),
-      verifyUnqualifiedStatement = require("../../verify/statement/unqualified");
-
-const { nodeQuery, nodesQuery } = require("../../utilities/query");
-
-const labelNodesQuery = nodesQuery("/axiom/label"),
-      statementNodeQuery = nodeQuery("/*/statement"),
-      unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!");
-
-function verifyUnqualifiedStatementAxiom(axiomNode, context) {
-  let unqualifiedStatementAxiomVerified = false;
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const labels = [],
-          labelNodes = labelNodesQuery(axiomNode),
-          labelsVerified = verifyLabels(labelNodes, labels, context);
-
-    if (labelsVerified) {
-      const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
-
-      if (unqualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode),
-              axiom = Axiom.fromStatementNodeAndLabels(statementNode, labels);
-
-        context.addAxiom(axiom);
-
-        unqualifiedStatementAxiomVerified = true;
-      }
-    }
-  }
-
-  return unqualifiedStatementAxiomVerified;
-}
-
-module.exports = verifyUnqualifiedStatementAxiom;

package/bin/verify/axiom.js

@@ -1,37 +0,0 @@
-"use strict";
-
-const { loggingUtilities } = require("necessary");
-
-const ProofContext = require("../context/proof"),
-      verifyUnqualifiedStatementAxiom = require("../verify/axiom/unqualifiedStatement"),
-      verifyIndicativeConditionalAxiom = require("../verify/axiom/indicativeConditional");
-
-const { nodesQuery } = require("../utilities/query"),
-      { nodesAsString } = require("../utilities/string");
-
-const { log } = loggingUtilities;
-
-const labelNodesQuery = nodesQuery("/axiom/label");
-
-function verifyAxiom(axiomNode, context) {
-  const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = nodesAsString(labelNodes);
-
-  log.debug(`Verifying the '${labelsString}' axiom...`);
-
-  const proofContext = ProofContext.fromContext(context);
-
-  context = proofContext; ///
-
-  const unqualifiedStatementAxiomVerified = verifyUnqualifiedStatementAxiom(axiomNode, context),
-        indicativeConditionalAxiomVerified = verifyIndicativeConditionalAxiom(axiomNode, context),
-        axiomVerified = (unqualifiedStatementAxiomVerified || indicativeConditionalAxiomVerified);
-
-  if (axiomVerified) {
-    log.info(`Verified the '${labelsString}' axiom.`);
-  }
-
-  return axiomVerified;
-}
-
-module.exports = verifyAxiom;

package/bin/verify/conditinalInference.js

@@ -1,42 +0,0 @@
-"use strict";
-
-const verifyMetaproof = require("../verify/metaproof"),
-      MetaproofContext = require("../context/metaproof"),
-      verifyConclusion = require("../verify/conclusion"),
-      verifyPremiseOrPremises = require("../verify/premiseOrPremises");
-
-const { nodeQuery } = require("../utilities/query");
-const Conclusion = require("../conclusion");
-
-const conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
-      metastatementNodeQuery = nodeQuery("/conditionalInference/conclusion!/unqualifiedMetastatement!/metastatement!"),
-      premiseOrPremisesNodeQuery = nodeQuery("/conditionalInference/premise|premises!");
-
-function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
-  let conditionalInferenceVerified = false;
-
-  const metaproofContext = MetaproofContext.fromContext(context);
-
-  context = metaproofContext; ///
-
-  const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
-        metastatementNode = metastatementNodeQuery(conditionalInferenceNode),
-        premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
-        premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
-
-  if (premiseOrPremisesVerified) {
-    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
-
-    if (conclusionVerified) {
-      const conclusion = Conclusion.fromMetastatementNode(metastatementNode);
-
-      conclusions.push(conclusion);
-
-      conditionalInferenceVerified = true;
-    }
-  }
-
-  return conditionalInferenceVerified;
-}
-
-module.exports = verifyConditionalInference;

package/bin/verify/consequent.js

@@ -1,32 +0,0 @@
-"use strict";
-
-const Consequent = require("../consequent"),
-      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
-
-const { nodeQuery } = require("../utilities/query");
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/consequent/unqualifiedStatement!");
-
-function verifyConsequent(consequentNode, consequents, context) {
-  let consequentVerified = false;
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
-
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            consequent = Consequent.fromStatementNode(statementNode);
-
-      consequents.push(consequent);
-
-      consequentVerified = true;
-    }
-  }
-
-  return consequentVerified;
-}
-
-module.exports = verifyConsequent;

package/bin/verify/metaConsequent.js

@@ -1,23 +0,0 @@
-"use strict";
-
-const verifyUnqualifiedMetaStatement = require("../verify/metastatement/unqualified");
-
-const { nodeQuery } = require("../utilities/query");
-
-const unqualifiedMetaStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetaStatement!");
-
-function verifyMetaConsequent(metaConsequentNode, metaConsequents, context) {
-  let metaConsequentVerified = false;
-
-  const unqualifiedMetaStatementNode = unqualifiedMetaStatementNodeQuery(metaConsequentNode);
-
-  if (unqualifiedMetaStatementNode !== null) {
-    const unqualifiedMetaStatementVerified = verifyUnqualifiedMetaStatement(unqualifiedMetaStatementNode, context);
-
-    metaConsequentVerified = unqualifiedMetaStatementVerified;
-  }
-
-  return metaConsequentVerified;
-}
-
-module.exports = verifyMetaConsequent;

package/bin/verify/metaSupposition.js

@@ -1,24 +0,0 @@
-"use strict";
-
-const MetaAssertion = require("../metaAssertion"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
-
-const { nodeQuery } = require("../utilities/query");
-
-const unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
-
-function verifyMetaSupposition(metaSuppositionNode, context) {
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context),
-        metaSuppositionVerified = unqualifiedMetastatementVerified;  ///
-
-  if (metaSuppositionVerified) {
-    const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
-
-    context.addMetaAssertion(metaAssertion);
-  }
-
-  return metaSuppositionVerified;
-}
-
-module.exports = verifyMetaSupposition;

package/bin/verify/package.js

@@ -1,81 +0,0 @@
-"use strict";
-
-const { loggingUtilities } = require("necessary");
-
-const verifyFiles = require("../verify/files");
-
-const { log } = loggingUtilities;
-
-function verifyPackage(packageName, packageContextMap, packageContexts = []) {
-  const packageContext = packageContextMap[packageName];
-
-  let packageVerified = packageContext.isPackageVerified();
-
-  if (!packageVerified) {
-    log.debug(`Verifying the '${packageName}' package...`);
-
-    const dependencyPackageNames = packageContext.getDependencyPackageNames(),
-          dependencyPackagesVVerified = dependencyPackageNames.every((dependencyPackageName) => {
-            const packageName = dependencyPackageName,  ///
-                  packageVerified = verifyPackage(packageName, packageContextMap, packageContexts);
-
-            if (packageVerified) {
-              return true;
-            }
-          });
-
-    if (dependencyPackagesVVerified) {
-      const packageNames = dependencyPackageNames,  ///
-            packageContexts = packageNames.map((packageName) => {
-              const packageContext = packageContextMap[packageName];
-
-              return packageContext;
-            });
-
-      const dependencyPackageContexts = retrieveDependencyPackageContexts(dependencyPackageNames, packageContextMap);
-
-      sortDependencyPackageContexts(dependencyPackageContexts, packageContexts);
-
-      packageContext.initialise(packageContexts, dependencyPackageContexts);
-
-      const filesVerified = verifyFiles(packageContext);
-
-      packageVerified = filesVerified;  ///
-
-      if (packageVerified) {
-        packageContexts.push(packageContext);
-
-        log.info(`Verified the '${packageName}' package.`);
-      }
-    }
-  }
-
-  return packageVerified;
-}
-
-module.exports = verifyPackage;
-
-function sortDependencyPackageContexts(dependencyPackageContexts, packageContexts) {
-  dependencyPackageContexts.sort((dependencyPackageContextA, dependencyPackageContextB) => {
-    const indexA = packageContexts.indexOf(dependencyPackageContextA),
-          indexB = packageContexts.indexOf(dependencyPackageContextB),
-          difference = (indexB - indexA);
-
-    return difference;
-  });
-}
-
-function retrieveDependencyPackageContexts(dependencyPackageNames, packageContextMap, dependencyPackageContexts = []) {
-  dependencyPackageNames.forEach((dependencyPackageName) => {
-    const dependencyPackageContext = packageContextMap[dependencyPackageName],
-          dependencyPackageContextsIncludesDependencyPackageContext = dependencyPackageContexts.includes(dependencyPackageContext);
-
-    if (!dependencyPackageContextsIncludesDependencyPackageContext) {
-      dependencyPackageContexts.push(dependencyPackageContext);
-
-      retrieveDependencyPackageContexts(dependencyPackageNames, packageContextMap, dependencyPackageContexts);
-    }
-  });
-
-  return dependencyPackageContexts;
-}

package/index.js

@@ -1,9 +0,0 @@
-"use strict";
-
-const verifyPackage = require("./bin/verify/package"),
-      PackageContext = require("./bin/context/package");
-
-module.exports = {
-  verifyPackage,
-  PackageContext
-};