occam-verify-cli 0.0.262

package/bin/utilities/string.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const { COMMA, EMPTY_STRING } = require("../constants");
+
+function nodeAsString(node, string = EMPTY_STRING) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node,
+          content = terminalNode.getContent();
+
+    string = `${string}${content}`;
+  } else {
+    const nonTerminalNode = node, ///
+          childNodes = nonTerminalNode.getChildNodes();
+
+    childNodes.forEach((childNode) => {
+      string = nodeAsString(childNode, string);
+    });
+  }
+
+  return string;
+}
+
+function nodesAsString(nodes) {
+  const string = nodes.reduce((string, node) => {
+    const nodeString = nodeAsString(node);
+
+    if (string === null) {
+      string = nodeString;  ///
+    } else {
+      string = `${string}${COMMA}${nodeString}`;
+    }
+
+    return string;
+  }, null);
+
+  return string;
+}
+
+function labelsAsString(labels) {
+  const labelsString = labels.join(COMMA);
+
+  return labelsString;
+}
+
+module.exports = {
+  nodeAsString,
+  nodesAsString,
+  labelsAsString
+};

package/bin/variable.js

@@ -0,0 +1,54 @@
+"use strict";
+
+class Variable {
+  constructor(type, name, value) {
+    this.type = type;
+    this.name = name;
+    this.value = value;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getValue() {
+    return this.value;
+  }
+
+  setValue(value) {
+    this.value = value;
+  }
+
+  matchName(name) {
+    const matchesName = (this.name === name);
+
+    return matchesName;
+  }
+
+  asString() {
+    let string;
+
+    if (this.type === null) {
+      string = this.name;
+    } else {
+      const typeName = this.type.getName();
+
+      string = `${this.name}:${typeName}`;
+    }
+
+    return string;
+  }
+
+  static fromTypeAndName(type, name) {
+    const value = undefined,
+          variable = new Variable(type, name, value);
+
+    return variable;
+  }
+}
+
+module.exports = Variable;

package/bin/verify/antecedent.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const Antecedent = require("../antecedent"),
+      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
+
+const { nodeQuery, nodesQuery } = require("../utilities/query");
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
+      unqualifiedStatementNodesQuery = nodesQuery("/antecedent/unqualifiedStatement");
+
+function verifyAntecedent(antecedentNode, antecedents, context) {
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(antecedentNode),
+        antecedentVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+
+          if (unqualifiedStatementVerified) {
+            return true;
+          }
+        });
+
+  if (antecedentVerified) {
+    const statementNodes = unqualifiedStatementNodes.map((unqualifiedStatementNode) => {
+            const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+            return statementNode;
+          }),
+          antecedent = Antecedent.fromStatementNodes(statementNodes);
+
+    antecedents.push(antecedent);
+  }
+
+  return antecedentVerified;
+}
+
+module.exports = verifyAntecedent;

package/bin/verify/axiom/IndicativeConditional.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const Axiom = require("../../axiom"),
+      verifyLabels = require("../../verify/labels"),
+      verifyAntecedent = 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 = verifyAntecedent(antecedentNode, antecedents, context);
+
+      if (antecedentVerified) {
+        const consequents = [],
+              consequentNode = consequentNodeQuery(indicativeConditionalNode),
+              consequentVerified = verifyConsequent(consequentNode, consequents, context);
+
+        if (consequentVerified) {
+          const firstAntecedent = first(antecedents),
+                firstConsequent = first(consequents),
+                antecedent = firstAntecedent, ///
+                consequent = firstConsequent, ///
+                axiom = Axiom.fromAntecedentConsequentAndLabels(antecedent, consequent, labels);
+
+          context.addAxiom(axiom);
+
+          indicativeConditionalAxiomVerified = true;
+        }
+      }
+    }
+  }
+
+  return indicativeConditionalAxiomVerified;
+}
+
+module.exports = verifyIndicativeConditionalAxiom;

package/bin/verify/axiom/unqualifiedStatement.js

@@ -0,0 +1,40 @@
+"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

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

@@ -0,0 +1,32 @@
+"use strict";
+
+const Conclusion = require("../conclusion"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+
+const { nodeQuery } = require("../utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
+
+function verifyConclusion(conclusionNode, conclusions, context) {
+  let conclusionVerified = false;
+
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
+
+  if (unqualifiedMetastatementNode !== null) {
+    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+    if (unqualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+
+      conclusions.push(conclusion);
+
+      conclusionVerified = true;
+    }
+  }
+
+  return conclusionVerified;
+}
+
+module.exports = verifyConclusion;

package/bin/verify/consequent.js

@@ -0,0 +1,32 @@
+"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/declaration/combinator.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const verifyStatementAsCombinator = require("../../verify/statementAsCombinator");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
+
+function verifyCombinatorDeclaration(combinatorDeclarationNode, context) {
+  const statementNode = statementNodeQuery(combinatorDeclarationNode),
+        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, context),
+        combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
+
+  return combinatorDeclarationVerified;
+}
+
+module.exports = verifyCombinatorDeclaration;

package/bin/verify/declaration/constructor.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const verifyTermAsConstructor = require("../../verify/termAsConstructor");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
+      typeNodeQuery = nodeQuery("/constructorDeclaration/type");
+
+function verifyConstructorDeclaration(constructorDeclarationNode, context) {
+  const termNode = termNodeQuery(constructorDeclarationNode),
+        typeNode = typeNodeQuery(constructorDeclarationNode),
+        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, context),
+        constructorDeclarationVerified = termVerifiedAsConstructor; ///
+
+  return constructorDeclarationVerified;
+}
+
+module.exports = verifyConstructorDeclaration;

package/bin/verify/declaration/topLevel.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const { nodeQuery } = require("../../utilities/query");
+
+const verifyRule = require("../../verify/rule"),
+      verifyAxiom = require("../../verify/axiom"),
+      verifyTypeDeclaration = require("../../verify/declaration/type"),
+      verifyVariableDeclaration = require("../../verify/declaration/variable"),
+      verifyCombinatorDeclaration = require("../../verify/declaration/combinator"),
+      verifyConstructorDeclaration = require("../../verify/declaration/constructor");
+
+const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
+      axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
+      typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
+      variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
+      combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
+      constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!");
+
+function verifyTopLevelDeclaration(topLevelDeclarationNode, context) {
+  let topLevelDeclarationVerified = false;
+
+  const node = topLevelDeclarationNode, ///
+        ruleNode = ruleNodeQuery(node),
+        axiomNode = axiomNodeQuery(node),
+        typeDeclarationNode = typeDeclarationNodeQuery(node),
+        variableDeclarationNode = variableDeclarationNodeQuery(node),
+        combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
+        constructorDeclarationNode = constructorDeclarationNodeQuery(node);
+
+  if (false) {
+    ///
+  } else if (ruleNode !== null) {
+    const ruleVerified = verifyRule(ruleNode, context);
+
+    topLevelDeclarationVerified = ruleVerified;  ///
+  } else if (axiomNode !== null) {
+    const axiomVerified = verifyAxiom(axiomNode, context);
+
+    topLevelDeclarationVerified = axiomVerified;  ///
+  } else if (typeDeclarationNode !== null) {
+    const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, context);
+
+    topLevelDeclarationVerified = typeDeclarationVerified;  ///
+  } else if (variableDeclarationNode !== null) {
+    const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, context);
+
+    topLevelDeclarationVerified = variableDeclarationVerified;  ///
+  } else if (combinatorDeclarationNode !== null) {
+    const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, context);
+
+    topLevelDeclarationVerified = combinatorDeclarationVerified;  ///
+  } else if (constructorDeclarationNode !== null) {
+    const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, context);
+
+    topLevelDeclarationVerified = constructorDeclarationVerified;  ///
+  }
+
+  return topLevelDeclarationVerified;
+}
+
+module.exports = verifyTopLevelDeclaration;

package/bin/verify/declaration/type.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const verifyType = require("../../verify/type");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
+      secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
+
+function verifyTypeDeclaration(typeDeclarationNode, context) {
+  const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
+        secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
+        typeNode = firstTypeNode, ///
+        superTypeNode = secondTypeNode, ///
+        typeVerified = verifyType(typeNode, superTypeNode, context),
+        typeDeclarationVerified = typeVerified; ///
+
+  return typeDeclarationVerified;
+}
+
+module.exports = verifyTypeDeclaration;

package/bin/verify/declaration/variable.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const verifyVariable = require("../../verify/variable");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
+      variableNodeQuery = nodeQuery("/variableDeclaration/variable");
+
+function verifyVariableDeclaration(variableDeclarationNode, context) {
+  const typeNode = typeNodeQuery(variableDeclarationNode),
+        variableNode = variableNodeQuery(variableDeclarationNode),
+        variableVVerified = verifyVariable(variableNode, typeNode, context),
+        variableDeclarationVerified = variableVVerified;  ///
+
+  return variableDeclarationVerified;
+}
+
+module.exports = verifyVariableDeclaration;

package/bin/verify/equality.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const verifyTerm = require("../verify/term");
+
+const { nodeQuery } = require("../utilities/query"),
+      { first, second } = require("../utilities/array");
+
+const firstTermNodeQuery = nodeQuery("/equality/term[0]"),
+      secondTermNodeQuery = nodeQuery("/equality/term[1]");
+
+function verifyEquality(equalityNode, context) {
+  let equalityVerified = false;
+
+  const types = [],
+        values = [],
+        firstTermNode = firstTermNodeQuery(equalityNode),
+        secondTermNode = secondTermNodeQuery(equalityNode),
+        firstTermVerified = verifyTerm(firstTermNode, types, values, context),
+        secondTermVerified = verifyTerm(secondTermNode, types, values, context);
+
+  if (firstTermVerified && secondTermVerified) {
+    const firstType = first(types),
+          secondType = second(types),
+          firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
+
+    if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
+      const derived = context.isDerived();
+
+      if (derived) {
+        const termsEqual = equateTerms(firstTermNode, secondTermNode, context);
+
+        if (termsEqual) {
+          equalityVerified = true;
+        }
+      } else {
+        equalityVerified = true;
+      }
+    }
+  }
+
+  return equalityVerified;
+}
+
+module.exports = verifyEquality;
+
+function equateTerms(firstTermNode, secondTermNode, context) {
+  let termsEqual = true;  ///
+
+  debugger
+
+  return termsEqual;
+}

package/bin/verify/file.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const FileContext = require("../context/file"),
+      PackageContext = require("../context/package"),
+      verifyTopLevelDeclaration = require("../verify/declaration/topLevel");
+
+const { nodesQuery } = require("../utilities/query");
+
+const { log } = loggingUtilities;
+
+const topLevelDeclarationNodesQuery = nodesQuery("/document/topLevelDeclaration");
+
+function verifyFile(filePath, packageContext = PackageContext.fromNothing()) {
+  let fileVerified = false;
+
+  log.debug(`Verifying the '${filePath}' file...`);
+
+  const fileContext = FileContext.fromPackageContextAndFilePath(packageContext, filePath),
+        context = fileContext,  ///
+        node = fileContext.getNode(),
+        topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
+        topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {
+          const topLevelDeclarationVerified = verifyTopLevelDeclaration(topLevelDeclarationNode, context);
+
+          if (topLevelDeclarationVerified) {
+            return true;
+          }
+        })
+
+  if (topLevelDeclarationsVerified) {
+    packageContext.addFileContext(fileContext);
+
+    fileVerified = true;
+
+    log.info(`Verified the '${filePath}' file.`);
+  }
+
+  return fileVerified;
+}
+
+module.exports = verifyFile;

package/bin/verify/files.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const verifyFile = require("../verify/file");
+
+const { leftDifference } = require("../utilities/array");
+
+function verifyFiles(packageContext) {
+  let filesVerified = false;
+
+  const filePaths = packageContext.getFilePaths();
+
+  for (;;) {
+    const filePathsLength = filePaths.length;
+
+    if (filePathsLength === 0) {
+      filesVerified = true;
+
+      break;
+    }
+
+    const verifiedFilePaths = [];
+
+    filePaths.forEach((filePath) => {
+      const fileVerified = verifyFile(filePath, packageContext);
+
+      if (fileVerified) {
+        const verifiedFilePath = filePath;  ///
+
+        verifiedFilePaths.push(verifiedFilePath);
+      }
+    });
+
+    const verifiedFilePathsLength = verifiedFilePaths.length,
+          fileVerified = (verifiedFilePathsLength > 0);
+
+    if (!fileVerified) {
+      break;
+    }
+
+    leftDifference(filePaths, verifiedFilePaths);
+  }
+
+  return filesVerified;
+}
+
+module.exports = verifyFiles;

package/bin/verify/label.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const { labelNameFromLabelNode } = require("../utilities/query");
+
+const { log } = loggingUtilities;
+
+function verifyLabel(labelNode, labels, context) {
+  let labelVerified = false;
+
+  const labelName = labelNameFromLabelNode(labelNode),
+        label = labelName,  ///
+        labelPresent = context.isLabelPresent(label);
+
+  if (labelPresent) {
+    log.error(`The label ${label} is already present`);
+  } else {
+    labels.push(label);
+
+    labelVerified = true;
+  }
+
+  return labelVerified;
+}
+
+module.exports = verifyLabel;

package/bin/verify/labels.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const verifyLabel = require("../verify/label");
+
+function verifyLabels(labelNodes, labels, context) {
+  const labelsVerified = labelNodes.every((labelNode) => {
+    const labelVerified = verifyLabel(labelNode, labels, context);
+
+    if (labelVerified) {
+      return true;
+    }
+  });
+
+  return labelsVerified;
+}
+
+module.exports = verifyLabels;