occam-verify-cli 0.0.272 → 0.0.274

package/{bin → src}/verify/declaration/topLevel.js

@@ -1,13 +1,13 @@
 "use strict";
 
-const { nodeQuery } = require("../../utilities/query");
+import { nodeQuery } from "../../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");
+import verifyRule from "../../verify/rule";
+import verifyAxiom from "../../verify/axiom";
+import verifyTypeDeclaration from "../../verify/declaration/type";
+import verifyVariableDeclaration from "../../verify/declaration/variable";
+import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
+import verifyConstructorDeclaration from "../../verify/declaration/constructor";
 
 const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
@@ -16,7 +16,7 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
       constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!");
 
-function verifyTopLevelDeclaration(topLevelDeclarationNode, context) {
+export default function verifyTopLevelDeclaration(topLevelDeclarationNode, context) {
   let topLevelDeclarationVerified = false;
 
   const node = topLevelDeclarationNode, ///
@@ -57,5 +57,3 @@ function verifyTopLevelDeclaration(topLevelDeclarationNode, context) {
 
   return topLevelDeclarationVerified;
 }
-
-module.exports = verifyTopLevelDeclaration;

package/{bin → src}/verify/declaration/type.js

@@ -1,13 +1,13 @@
 "use strict";
 
-const verifyType = require("../../verify/type");
+import verifyType from "../../verify/type";
 
-const { nodeQuery } = require("../../utilities/query");
+import { nodeQuery } from "../../utilities/query";
 
 const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
 
-function verifyTypeDeclaration(typeDeclarationNode, context) {
+export default function verifyTypeDeclaration(typeDeclarationNode, context) {
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
@@ -17,5 +17,3 @@ function verifyTypeDeclaration(typeDeclarationNode, context) {
 
   return typeDeclarationVerified;
 }
-
-module.exports = verifyTypeDeclaration;

package/{bin → src}/verify/declaration/variable.js

@@ -1,13 +1,13 @@
 "use strict";
 
-const verifyVariable = require("../../verify/variable");
+import verifyVariable from "../../verify/variable";
 
-const { nodeQuery } = require("../../utilities/query");
+import { nodeQuery } from "../../utilities/query";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable");
 
-function verifyVariableDeclaration(variableDeclarationNode, context) {
+export default function verifyVariableDeclaration(variableDeclarationNode, context) {
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
         variableVVerified = verifyVariable(variableNode, typeNode, context),
@@ -15,5 +15,3 @@ function verifyVariableDeclaration(variableDeclarationNode, context) {
 
   return variableDeclarationVerified;
 }
-
-module.exports = verifyVariableDeclaration;

package/{bin → src}/verify/equality.js

@@ -1,14 +1,14 @@
 "use strict";
 
-const verifyTerm = require("../verify/term");
+import verifyTerm from "../verify/term";
 
-const { nodeQuery } = require("../utilities/query"),
-      { first, second } = require("../utilities/array");
+import { nodeQuery } from "../utilities/query";
+import { first, second } from "../utilities/array";
 
 const firstTermNodeQuery = nodeQuery("/equality/term[0]"),
       secondTermNodeQuery = nodeQuery("/equality/term[1]");
 
-function verifyEquality(equalityNode, context) {
+export default function verifyEquality(equalityNode, context) {
   let equalityVerified = false;
 
   const types = [],
@@ -41,8 +41,6 @@ function verifyEquality(equalityNode, context) {
   return equalityVerified;
 }
 
-module.exports = verifyEquality;
-
 function equateTerms(firstTermNode, secondTermNode, context) {
   let termsEqual = true;  ///
 

package/{bin → src}/verify/file.js

@@ -1,23 +1,19 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import FileContext from "../context/file";
+import ReleaseContext from "../context/release";
+import verifyTopLevelDeclaration from "../verify/declaration/topLevel";
 
-const FileContext = require("../context/file"),
-      PackageContext = require("../context/package"),
-      verifyTopLevelDeclaration = require("../verify/declaration/topLevel");
-
-const { nodesQuery } = require("../utilities/query");
-
-const { log } = loggingUtilities;
+import { nodesQuery } from "../utilities/query";
 
 const topLevelDeclarationNodesQuery = nodesQuery("/document/topLevelDeclaration");
 
-function verifyFile(filePath, packageContext = PackageContext.fromNothing()) {
+export default function verifyFile(filePath, releaseContext = ReleaseContext.fromNothing()) {
   let fileVerified = false;
 
-  log.debug(`Verifying the '${filePath}' file...`);
+  releaseContext.debug(`Verifying the '${filePath}' file...`);
 
-  const fileContext = FileContext.fromPackageContextAndFilePath(packageContext, filePath),
+  const fileContext = FileContext.fromReleaseContextAndFilePath(releaseContext, filePath),
         context = fileContext,  ///
         node = fileContext.getNode(),
         topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
@@ -30,14 +26,12 @@ function verifyFile(filePath, packageContext = PackageContext.fromNothing()) {
         })
 
   if (topLevelDeclarationsVerified) {
-    packageContext.addFileContext(fileContext);
+    releaseContext.addFileContext(fileContext);
 
     fileVerified = true;
 
-    log.info(`Verified the '${filePath}' file.`);
+    releaseContext.info(`Verified the '${filePath}' file.`);
   }
 
   return fileVerified;
 }
-
-module.exports = verifyFile;

package/{bin → src}/verify/files.js

@@ -1,13 +1,13 @@
 "use strict";
 
-const verifyFile = require("../verify/file");
+import verifyFile from "../verify/file";
 
-const { leftDifference } = require("../utilities/array");
+import { leftDifference } from "../utilities/array";
 
-function verifyFiles(packageContext) {
+export default function verifyFiles(releaseContext) {
   let filesVerified = false;
 
-  const filePaths = packageContext.getFilePaths();
+  const filePaths = releaseContext.getFilePaths();
 
   for (;;) {
     const filePathsLength = filePaths.length;
@@ -21,7 +21,7 @@ function verifyFiles(packageContext) {
     const verifiedFilePaths = [];
 
     filePaths.forEach((filePath) => {
-      const fileVerified = verifyFile(filePath, packageContext);
+      const fileVerified = verifyFile(filePath, releaseContext);
 
       if (fileVerified) {
         const verifiedFilePath = filePath;  ///
@@ -42,5 +42,3 @@ function verifyFiles(packageContext) {
 
   return filesVerified;
 }
-
-module.exports = verifyFiles;

package/{bin → src}/verify/label.js

@@ -1,12 +1,8 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import { labelNameFromLabelNode } from "../utilities/query";
 
-const { labelNameFromLabelNode } = require("../utilities/query");
-
-const { log } = loggingUtilities;
-
-function verifyLabel(labelNode, labels, context) {
+export default function verifyLabel(labelNode, labels, context) {
   let labelVerified = false;
 
   const labelName = labelNameFromLabelNode(labelNode),
@@ -14,7 +10,7 @@ function verifyLabel(labelNode, labels, context) {
         labelPresent = context.isLabelPresent(label);
 
   if (labelPresent) {
-    log.error(`The label ${label} is already present`);
+    context.error(`The label ${label} is already present`);
   } else {
     labels.push(label);
 
@@ -23,5 +19,3 @@ function verifyLabel(labelNode, labels, context) {
 
   return labelVerified;
 }
-
-module.exports = verifyLabel;

package/{bin → src}/verify/labels.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const verifyLabel = require("../verify/label");
+import verifyLabel from "../verify/label";
 
-function verifyLabels(labelNodes, labels, context) {
+export default function verifyLabels(labelNodes, labels, context) {
   const labelsVerified = labelNodes.every((labelNode) => {
     const labelVerified = verifyLabel(labelNode, labels, context);
 
@@ -13,5 +13,3 @@ function verifyLabels(labelNodes, labels, context) {
 
   return labelsVerified;
 }
-
-module.exports = verifyLabels;

package/{bin → src}/verify/metaDerivation.js

@@ -1,21 +1,21 @@
 "use strict";
 
-const MetaAssertion = require("../metaAssertion"),
-      MetaproofContext = require("../context/metaproof"),
-      verifyMetaSupposition = require("../verify/metaSupposition"),
-      verifyQualifiedMetastatement = require("../verify/metastatement/qualified"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+import MetaAssertion from "../metaAssertion";
+import MetaproofContext from "../context/metaproof";
+import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
-const { nodeQuery, nodesQuery } = require("../utilities/query"),
-      { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
+import { first, second } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
-const metaSuppositionNodeQuery = nodeQuery("/metaSubproof/metaSupposition!"),
-      metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
+const metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
       metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/qualifiedMetastatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/unqualifiedMetastatement!");
+      qualifiedMetastatementNodeQuery = nodeQuery("/qualifiedMetastatement"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/unqualifiedMetastatement!"),
+      qualifiedOrUnqualifiedMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement")
 
-function verifyMetaDerivation(metaDerivationNode, context) {
+export default function verifyMetaDerivation(metaDerivationNode, context) {
   const derived = true;
 
   context.setDerived(derived);
@@ -80,8 +80,6 @@ function verifyMetaDerivation(metaDerivationNode, context) {
   return metaDerivationVerified;
 }
 
-module.exports = verifyMetaDerivation;
-
 function verifyMetaSubproof(metaSubproofNode, context) {
   let metaSubproofVerified = false;
 
@@ -89,10 +87,16 @@ function verifyMetaSubproof(metaSubproofNode, context) {
 
   context = metaproofContext; ///
 
-  const metaSuppositionNode = metaSuppositionNodeQuery(metaSubproofNode),
-        metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, context);
+  const qualifiedOrUnqualifiedMetastatementNodes = qualifiedOrUnqualifiedMetastatementNodesQuery(metaSubproofNode),
+        firstQualifiedOrUnqualifiedMetastatementNode = first(qualifiedOrUnqualifiedMetastatementNodes),
+        unqualifiedMetastatementNode = firstQualifiedOrUnqualifiedMetastatementNode,  ///
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+  if (unqualifiedMetastatementVerified) {
+    const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+    context.addMetaAssertion(metaAssertion);
 
-  if (metaSuppositionVerified) {
     let metaDerivationVerified = true;
 
     const metaDerivationNode = metaDerivationNodeQuery(metaSubproofNode);
@@ -102,8 +106,10 @@ function verifyMetaSubproof(metaSubproofNode, context) {
     }
 
     if (metaDerivationVerified) {
-      const qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaSubproofNode),
-            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSubproofNode);
+      const secondQualifiedOrUnqualifiedMetastatementNode = second(qualifiedOrUnqualifiedMetastatementNodes),
+            qualifiedOrUnqualifiedMetastatementNode = secondQualifiedOrUnqualifiedMetastatementNode,  ///
+            qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(qualifiedOrUnqualifiedMetastatementNode),
+            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(qualifiedOrUnqualifiedMetastatementNode);
 
       if (qualifiedMetastatementNode !== null) {
         const qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);

package/{bin → src}/verify/metaproof.js

@@ -1,15 +1,15 @@
 "use strict";
 
-const verifyMetaDerivation = require("../verify/metaDerivation"),
-      verifyQualifiedMetastatement = require("../verify/metastatement/qualified");
+import verifyMetaDerivation from "../verify/metaDerivation";
+import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 
-const { nodeQuery } = require("../utilities/query");
+import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
       qualifiedStatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!"),
       metaProofMetastatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement/metastatement!");
 
-function verifyMetaproof(metaproofNode, metastatementNode, context) {
+export default function verifyMetaproof(metaproofNode, conclusion, context) {
   let metaproofVerified = false;
 
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode);
@@ -25,7 +25,8 @@ function verifyMetaproof(metaproofNode, metastatementNode, context) {
           qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
     if (qualifiedMetastatementVerified) {
-      const metaProofMetastatementNode = metaProofMetastatementNodeQuery(metaproofNode),
+      const metastatementNode = conclusion.getMetastatementNode(),
+            metaProofMetastatementNode = metaProofMetastatementNodeQuery(metaproofNode),
             metaProofMetastatementNodeMatches = matchMetaProofMetastatementNode(metaProofMetastatementNode, metastatementNode);
 
       metaproofVerified = metaProofMetastatementNodeMatches;  ///
@@ -35,8 +36,6 @@ function verifyMetaproof(metaproofNode, metastatementNode, context) {
   return metaproofVerified;
 }
 
-module.exports = verifyMetaproof;
-
 function matchMetaProofMetastatementNode(metaProofMetastatementNode, metastatementNode) {
   const metaProofNonTerminalNode = metaProofMetastatementNode,  ///
         nonTerminalNode = metastatementNode,  ///

package/{bin → src}/verify/metastatement/qualified.js

@@ -1,16 +1,12 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
-
-const { nodeAsString } = require("../../utilities/string"),
-      { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
-
-const { log } = loggingUtilities;
+import { nodeAsString } from "../../utilities/string";
+import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
   let qualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
@@ -30,10 +26,8 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
   if (qualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    log.debug(`Verified the '${metastatementString}' qualified metastatement.`);
+    context.debug(`Verified the '${metastatementString}' qualified metastatement.`);
   }
 
   return qualifiedMetastatementVerified;
 }
-
-module.exports = verifyQualifiedMetastatement;

package/{bin → src}/verify/metastatement/unqualified.js

@@ -1,17 +1,13 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import MetaAssertion from "../../metaAssertion";
 
-const MetaAssertion = require("../../metaAssertion");
-
-const { nodeQuery } = require("../../utilities/query"),
-      { nodeAsString } = require("../../utilities/string");
-
-const { log } = loggingUtilities;
+import { nodeQuery } from "../../utilities/query";
+import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
   let unqualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
@@ -32,10 +28,8 @@ function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
   if (unqualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    log.debug(`Verified the '${metastatementString}' unqualified metastatement.`);
+    context.debug(`Verified the '${metastatementString}' unqualified metastatement.`);
   }
 
   return unqualifiedMetastatementVerified;
 }
-
-module.exports = verifyUnqualifiedMetastatement;

package/{bin → src}/verify/premiseOrPremises.js

@@ -1,20 +1,24 @@
 "use strict";
 
-const Premise = require("../premise"),
-      MetaAssertion = require("../metaAssertion"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+import Premise from "../premise";
+import MetaAssertion from "../metaAssertion";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
-const { nodeQuery, nodesQuery } = require("../utilities/query");
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
       unqualifiedMetastatementNodesQuery = nodesQuery("/premise|premises/unqualifiedMetastatement");
 
-function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
+export default function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
   const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseOrPremisesNode),
         premiseOrPremisesVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
           const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
           if (unqualifiedMetastatementVerified) {
+            const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+            context.addMetaAssertion(metaAssertion);
+
             return true;
           }
         });
@@ -22,16 +26,11 @@ function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
   if (premiseOrPremisesVerified) {
     unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
             premise = Premise.fromMetastatementNode(metastatementNode);
 
-      context.addMetaAssertion(metaAssertion);
-
       premises.push(premise);
     });
   }
 
   return premiseOrPremisesVerified;
 }
-
-module.exports = verifyPremiseOrPremises;

package/src/verify/release.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import { loggingUtilities } from "necessary";
+
+import verifyFiles from "../verify/files";
+
+const { log } = loggingUtilities;
+
+export default function verifyRelease(releaseName, releaseContextMap, releaseContexts = []) {
+  const releaseContext = releaseContextMap[releaseName];
+
+  let releaseVerified = releaseContext.isReleaseVerified();
+
+  if (!releaseVerified) {
+    log.debug(`Verifying the '${releaseName}' package...`);
+
+    const dependencyReleaseNames = releaseContext.getDependencyReleaseNames(),
+          dependencyReleasesVVerified = dependencyReleaseNames.every((dependencyReleaseName) => {
+            const releaseName = dependencyReleaseName,  ///
+                  releaseVerified = verifyRelease(releaseName, releaseContextMap, releaseContexts);
+
+            if (releaseVerified) {
+              return true;
+            }
+          });
+
+    if (dependencyReleasesVVerified) {
+      const releaseNames = dependencyReleaseNames,  ///
+            releaseContexts = releaseNames.map((releaseName) => {
+              const releaseContext = releaseContextMap[releaseName];
+
+              return releaseContext;
+            });
+
+      const dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependencyReleaseNames, releaseContextMap);
+
+      releaseContext.initialise(releaseContexts, dependencyReleaseContexts);
+
+      const filesVerified = verifyFiles(releaseContext);
+
+      releaseVerified = filesVerified;  ///
+
+      if (releaseVerified) {
+        releaseContexts.push(releaseContext);
+
+        log.info(`Verified the '${releaseName}' release.`);
+      }
+    }
+  }
+
+  return releaseVerified;
+}
+
+function retrieveDependencyReleaseContexts(dependencyReleaseNames, releaseContextMap, dependencyReleaseContexts = []) {
+  dependencyReleaseNames.forEach((dependencyReleaseName) => {
+    const dependencyReleaseContext = releaseContextMap[dependencyReleaseName],
+          dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
+
+    if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
+      const releaseContext = dependencyReleaseContext,  ///
+            dependencyReleaseNames = releaseContext.getDependencyReleaseNames();
+
+      retrieveDependencyReleaseContexts(dependencyReleaseNames, releaseContextMap, dependencyReleaseContexts);
+
+      dependencyReleaseContexts.push(dependencyReleaseContext);
+    }
+  });
+
+  return dependencyReleaseContexts;
+}

package/{bin → src}/verify/rule.js

@@ -1,31 +1,32 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import Rule from "../rule";
+import verifyLabels from "../verify/labels";
+import verifyMetaproof from "../verify/metaproof";
+import MetaproofContext from "../context/metaproof";
+import verifyConditionalInference from "../verify/conditinalInference";
+import verifyUnconditionalInference from "../verify/unconditionalInference";
 
-const Rule = require("../rule"),
-      verifyLabels = require("../verify/labels"),
-      verifyMetaproof = require("../verify/metaproof"),
-      verifyConditionalInference = require("../verify/conditinalInference"),
-      verifyUnconditionalInference = require("../verify/unconditionalInference");
-
-const { first } = require("../utilities/array"),
-      { nodesAsString } = require("../utilities/string"),
-      { nodeQuery, nodesQuery } = require("../utilities/query");
-
-const { log } = loggingUtilities;
+import { first } from "../utilities/array";
+import { nodesAsString } from "../utilities/string";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/rule/label"),
       metaproofNodeQuery = nodeQuery("/rule/metaproof!"),
       conditionalInferenceNodeQuery = nodeQuery("/rule/conditionalInference!"),
       unconditionalInferenceNodeQuery = nodeQuery("/rule/unconditionalInference!");
 
-function verifyRule(ruleNode, context) {
+export default function verifyRule(ruleNode, context) {
   let ruleVerified = false;
 
   const labelNodes = labelNodesQuery(ruleNode),
         labelsString = nodesAsString(labelNodes);
 
-  log.debug(`Verifying the '${labelsString}' rule...`);
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
+  context.debug(`Verifying the '${labelsString}' rule...`);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, context);
@@ -55,9 +56,7 @@ function verifyRule(ruleNode, context) {
       let metaproofVerified = true;
 
       if (metaproofNode !== null) {
-        const metastatementNode = conclusion.getMetastatementNode();
-
-        metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, context);
+        metaproofVerified = verifyMetaproof(metaproofNode, conclusion, context);
       }
 
       if (metaproofVerified) {
@@ -70,11 +69,9 @@ function verifyRule(ruleNode, context) {
     }
 
     if (ruleVerified) {
-      log.info(`Verified the '${labelsString}' rule.`);
+      context.info(`Verified the '${labelsString}' rule.`);
     }
   }
 
   return ruleVerified;
 }
-
-module.exports = verifyRule;

package/{bin → src}/verify/statement/qualified.js

@@ -1,17 +1,15 @@
 "use strict";
 
-const verifyStatement = require("../../verify/statement");
+import verifyStatement from "../../verify/statement";
 
-const { nodeQuery } = require("../../utilities/query");
+import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-function verifyQualifiedStatement(qualifiedStatementNode, context) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, context) {
   const statementNode = statementNodeQuery(qualifiedStatementNode),
         statementVerified = verifyStatement(statementNode, context),
         qualifiedStatementVerified = statementVerified; ///
 
   return qualifiedStatementVerified;
 }
-
-module.exports = verifyQualifiedStatement;