occam-verify-cli 0.0.272 → 0.0.274

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

@@ -1,12 +1,12 @@
 "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("/unqualifiedStatement/statement!");
 
-function verifyUnqualifiedStatement(unqualifiedStatementNode, context) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, context) {
   let unqualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
@@ -23,5 +23,3 @@ function verifyUnqualifiedStatement(unqualifiedStatementNode, context) {
 
   return unqualifiedStatementVerified;
 }
-
-module.exports = verifyUnqualifiedStatement;

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

@@ -1,24 +1,20 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import verifyEquality from "../verify/equality";
+import verifyTypeAssertion from "../verify/assertion/type";
 
-const verifyEquality = require("../verify/equality"),
-      verifyTypeAssertion = require("../verify/assertion/type");
-
-const { nodeQuery } = require("../utilities/query"),
-      { nodeAsString } = require("../utilities/string");
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-const { log } = loggingUtilities;
-
-function verifyStatement(statementNode, context) {
+export default function verifyStatement(statementNode, context) {
   let statementVerified = false;
 
   const statementString = nodeAsString(statementNode);
 
-  log.debug(`Verifying the '${statementString}' statement...`);
+  context.debug(`Verifying the '${statementString}' statement...`);
 
   const equalityNode = equalityNodeQuery(statementNode),
         typeAssertionNode = typeAssertionNodeQuery(statementNode);
@@ -38,10 +34,8 @@ function verifyStatement(statementNode, context) {
   }
 
   if (statementVerified) {
-    log.info(`Verified the '${statementString}' statement.`);
+    context.info(`Verified the '${statementString}' statement.`);
   }
 
   return statementVerified;
 }
-
-module.exports = verifyStatement;

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

@@ -1,21 +1,17 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import Combinator from "../combinator";
 
-const Combinator = require("../combinator");
+import { nodeAsString } from "../utilities/string";
+import { typeNameFromTypeNode } from "../utilities/query";
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
 
-const { nodeAsString } = require("../utilities/string"),
-      { typeNameFromTypeNode } = require("../utilities/query"),
-      { TERM_RULE_NAME, TYPE_RULE_NAME } = require("../ruleNames");
-
-const { log } = loggingUtilities;
-
-function verifyStatementAsCombinator(statementNode, context) {
+export default function verifyStatementAsCombinator(statementNode, context) {
   let statementVerifiedAsCombinator = false;
 
   const statementString = nodeAsString(statementNode);
 
-  log.debug(`Verifying the ${statementString} statement as a combinator...`);
+  context.debug(`Verifying the ${statementString} statement as a combinator...`);
 
   const nonTerminalNode = statementNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -32,14 +28,12 @@ function verifyStatementAsCombinator(statementNode, context) {
 
     const statementString = nodeAsString(statementNode);
 
-    log.info(`Verified the '${statementString}' combinator.`);
+    context.info(`Verified the '${statementString}' combinator.`);
   }
 
   return statementVerifiedAsCombinator;
 }
 
-module.exports = verifyStatementAsCombinator;
-
 function verifyNode(node, context) {
   let nodeVerified;
 
@@ -123,7 +117,7 @@ function verifyTypeNode(typeNode, context) {
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    log.error(`The type '${typeName}' is missing.`);
+    context.error(`The type '${typeName}' is missing.`);
   } else {
     typeNodeVerified = true;
   }

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

@@ -1,13 +1,13 @@
 "use strict";
 
-const Assertion = require("../assertion"),
-      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
+import Assertion from "../assertion";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
-const { nodeQuery } = require("../utilities/query");
+import { nodeQuery } from "../utilities/query";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
 
-function verifySupposition(suppositionNode, suppositions, context) {
+export default function verifySupposition(suppositionNode, suppositions, context) {
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
         unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context),
         suppositionVerified = unqualifiedStatementVerified;
@@ -20,5 +20,3 @@ function verifySupposition(suppositionNode, suppositions, context) {
 
   return suppositionVerified;
 }
-
-module.exports = verifySupposition;

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

@@ -1,20 +1,16 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary/lib/main");
+import verifyTermAsVariable from "../verify/termAsVariable";
 
-const verifyTermAsVariable = require("../verify/termAsVariable");
-
-const { first } = require("../utilities/array"),
-      { nodeAsString } = require("../utilities/string"),
-      { ARGUMENT_RULE_NAME } = require("../ruleNames"),
-      { nodeQuery, typeNameFromTypeNode } = require("../utilities/query");
-
-const { log } = loggingUtilities;
+import { first } from "../utilities/array";
+import { nodeAsString } from "../utilities/string";
+import { ARGUMENT_RULE_NAME } from "../ruleNames";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!")
 
-function verifyTerm(termNode, types, values, context) {
+export default function verifyTerm(termNode, types, values, context) {
   let termVerified = false;
 
   const names = [],
@@ -47,8 +43,6 @@ function verifyTerm(termNode, types, values, context) {
   return termVerified;
 }
 
-module.exports = verifyTerm;
-
 function verifyTermAgainstConstructor(termNode, constructor, context) {
   const constructorTermNode = constructor.getTermNode(),
         node = termNode,  ///
@@ -159,7 +153,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    log.error(`The ${argumentString} argument should be a term, not a type`);
+    context.error(`The ${argumentString} argument should be a term, not a type`);
   } else {
     const types = [],
           values = [],

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

@@ -1,25 +1,21 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import verifyTerm from "../verify/term";
+import Constructor from "../constructor";
 
-const verifyTerm = require("../verify/term"),
-      Constructor = require("../constructor");
-
-const { first } = require("../utilities/array"),
-      { nodeAsString } = require("../utilities/string"),
-      { nodeQuery, typeNameFromTypeNode } = require("../utilities/query"),
-      { TERM_RULE_NAME, ARGUMENT_RULE_NAME } = require("../ruleNames");
-
-const { log } = loggingUtilities;
+import { first } from "../utilities/array";
+import { nodeAsString } from "../utilities/string";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../ruleNames";
 
 const typeNodeQuery = nodeQuery("/argument/type");
 
-function verifyTermAsConstructor(termNode, typeNode, context) {
+export default function verifyTermAsConstructor(termNode, typeNode, context) {
   let termVerifiedAsConstructor = false;
 
   const termString = nodeAsString(termNode);
 
-  log.debug(`Verifying the '${termString}' term as a constructor...`);
+  context.debug(`Verifying the '${termString}' term as a constructor...`);
 
   const nonTerminalNode = termNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -40,7 +36,7 @@ function verifyTermAsConstructor(termNode, typeNode, context) {
       } else {
         const termString = nodeAsString(termNode);
 
-        log.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
+        context.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
       }
     }
   }
@@ -52,14 +48,12 @@ function verifyTermAsConstructor(termNode, typeNode, context) {
 
     const termString = nodeAsString(termNode);
 
-    log.info(`Verified the '${termString}' constructor.`);
+    context.info(`Verified the '${termString}' constructor.`);
   }
 
   return termVerifiedAsConstructor;
 }
 
-module.exports = verifyTermAsConstructor;
-
 function verifyNode(node, context) {
   let nodeVerified;
 
@@ -127,7 +121,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
         if (type !== null) {
           const termString = nodeAsString(termNode);
 
-          log.error(`The type of the constructor's compound '${termString}' term node is not null.`);
+          context.error(`The type of the constructor's compound '${termString}' term node is not null.`);
         } else {
           nonTerminalNodeVerified = true; ///
         }
@@ -157,13 +151,13 @@ function verifyArgumentNode(argumentNode, context) {
   if (typeNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    log.error(`The ${argumentString} argument should be a type.`);
+    context.error(`The ${argumentString} argument should be a type.`);
   } else {
     const typeName = typeNameFromTypeNode(typeNode),
           typePresent = context.isTypePresentByTypeName(typeName);
 
     if (!typePresent) {
-      log.error(`The type '${typeName}' is missing.`);
+      context.error(`The type '${typeName}' is missing.`);
     } else {
       typeNodeVerified = true;
     }

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

@@ -1,14 +1,10 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
-
-const { nodeQuery, variableNameFromVariableNode} = require("../utilities/query");
+import { nodeQuery, variableNameFromVariableNode} from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
-const { log } = loggingUtilities;
-
-function verifyTermAsVariable(termNode, types, names, values, context) {
+export default function verifyTermAsVariable(termNode, types, names, values, context) {
   let termVerifiedAsVariable = false;
 
   const variableNode = variableNodeQuery(termNode);
@@ -18,7 +14,7 @@ function verifyTermAsVariable(termNode, types, names, values, context) {
           variablePresent = context.isVariablePresentByVariableName(variableName);
 
     if (!variablePresent) {
-      log.error(`The ${variableName} variable is not present.`)
+      context.error(`The ${variableName} variable is not present.`)
     } else {
       const variable = context.findVariableByVariableName(variableName),
             type = variable.getType(),
@@ -37,5 +33,3 @@ function verifyTermAsVariable(termNode, types, names, values, context) {
 
   return termVerifiedAsVariable;
 }
-
-module.exports = verifyTermAsVariable;

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

@@ -1,21 +1,17 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import Type from "../type";
 
-const Type = require("../type");
+import { typeNameFromTypeNode } from "../utilities/query";
 
-const { typeNameFromTypeNode } = require("../utilities/query");
-
-const { log } = loggingUtilities;
-
-function verifyType(typeNode, superTypeNode, context) {
+export default function verifyType(typeNode, superTypeNode, context) {
   let typeVerified = false;
 
   const typeName = typeNameFromTypeNode(typeNode),
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (typePresent) {
-    log.error(`The type '${typeName}' is already present.`);
+    context.error(`The type '${typeName}' is already present.`);
   } else {
     const superTypeName = typeNameFromTypeNode(superTypeNode);
 
@@ -27,12 +23,12 @@ function verifyType(typeNode, superTypeNode, context) {
 
       typeVerified = true;
 
-      log.info(`Verified the '${typeString}' type.`);
+      context.info(`Verified the '${typeString}' type.`);
     } else {
       const superType = context.findTypeByTypeName(superTypeName);
 
       if (superType === null) {
-        log.error(`The super-type '${superTypeName}' is missing.`);
+        context.error(`The super-type '${superTypeName}' is missing.`);
       } else {
         const type = Type.fromTypeNameAndSuperType(typeName, superType),
               typeString = type.asString();
@@ -41,7 +37,7 @@ function verifyType(typeNode, superTypeNode, context) {
 
         typeVerified = true;
 
-        log.info(`Verified the '${typeString}' type.`);
+        context.info(`Verified the '${typeString}' type.`);
       }
     }
   }
@@ -49,5 +45,3 @@ function verifyType(typeNode, superTypeNode, context) {
   return typeVerified;
 }
 
-module.exports = verifyType;
-

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

@@ -1,21 +1,16 @@
 "use strict";
 
-const Conclusion = require("../conclusion"),
-      MetaproofContext = require("../context/metaproof"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+import Conclusion from "../conclusion";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
-const { nodeQuery } = require("../utilities/query");
+import { nodeQuery } from "../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!");
 
-function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
+export default function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
   let unconditionalInferenceVerified = false;
 
-  const metaproofContext = MetaproofContext.fromContext(context);
-
-  context = metaproofContext; ///
-
   const metastatementNode = metastatementNodeQuery(unconditionalInferenceNode),
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
         unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
@@ -30,5 +25,3 @@ function verifyUnconditionalInference(unconditionalInferenceNode, premises, conc
 
   return unconditionalInferenceVerified;
 }
-
-module.exports = verifyUnconditionalInference;

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

@@ -1,21 +1,17 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import Variable from "../variable";
 
-const Variable = require("../variable");
+import { typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
 
-const { typeNameFromTypeNode, variableNameFromVariableNode } = require("../utilities/query");
-
-const { log } = loggingUtilities;
-
-function verifyVariable(variableNode, typeNode, context) {
+export default function verifyVariable(variableNode, typeNode, context) {
   let variableVerified = false;
 
   const variableName = variableNameFromVariableNode(variableNode),
         variablePresent = context.isVariablePresentByVariableName(variableName);
 
   if (variablePresent) {
-    log.error(`The variable '${variableName}' is already present.`);
+    context.error(`The variable '${variableName}' is already present.`);
   } else {
     let variable = null;
 
@@ -30,7 +26,7 @@ function verifyVariable(variableNode, typeNode, context) {
       const type = context.findTypeByTypeName(typeName);
 
       if (type === null) {
-        log.error(`The '${variableName}' variable's '${typeName}' type is missing.`);
+        context.error(`The '${variableName}' variable's '${typeName}' type is missing.`);
       } else {
         const name = variableName;  ///
 
@@ -45,11 +41,9 @@ function verifyVariable(variableNode, typeNode, context) {
 
       variableVerified = true;
 
-      log.info(`Verified the '${variableString}' variable.`);
+      context.info(`Verified the '${variableString}' variable.`);
     }
   }
 
   return variableVerified;
 }
-
-module.exports = verifyVariable;

package/bin/axiom.js

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

package/bin/consequent.js

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

@@ -1,19 +0,0 @@
-"use strict";
-
-const COMMA = ',';
-const EMPTY_STRING = "";
-const LEFT_BRACKET = "(";
-const RIGHT_BRACKET = ")";
-const MAXIMUM_INDEXES_LENGTH = 10;
-const MAXIMUM_PERMUTATION_LENGTH = 5;
-const BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH = 3;
-
-module.exports = {
-  COMMA,
-  EMPTY_STRING,
-  LEFT_BRACKET,
-  RIGHT_BRACKET,
-  MAXIMUM_INDEXES_LENGTH,
-  MAXIMUM_PERMUTATION_LENGTH,
-  BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH
-};