occam-verify-cli 0.0.262

package/bin/verify/statementAsCombinator.js

@@ -0,0 +1,140 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const Combinator = require("../combinator");
+
+const { nodeAsString } = require("../utilities/string"),
+      { typeNameFromTypeNode } = require("../utilities/query"),
+      { TERM_RULE_NAME, TYPE_RULE_NAME } = require("../ruleNames");
+
+const { log } = loggingUtilities;
+
+function verifyStatementAsCombinator(statementNode, context) {
+  let statementVerifiedAsCombinator = false;
+
+  const statementString = nodeAsString(statementNode);
+
+  log.debug(`Verifying the ${statementString} statement as a combinator...`);
+
+  const nonTerminalNode = statementNode,  ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        childNodesVerified = verifyChildNodes(childNodes, context);
+
+  if (childNodesVerified) {
+    statementVerifiedAsCombinator = true;
+  }
+
+  if (statementVerifiedAsCombinator) {
+    const combinator = Combinator.fromStatementNode(statementNode);
+
+    context.addCombinator(combinator);
+
+    const statementString = nodeAsString(statementNode);
+
+    log.info(`Verified the '${statementString}' combinator.`);
+  }
+
+  return statementVerifiedAsCombinator;
+}
+
+module.exports = verifyStatementAsCombinator;
+
+function verifyNode(node, context) {
+  let nodeVerified;
+
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node,  ///
+          terminalNodeVerified = verifyTerminalNode(terminalNode, context);
+
+    nodeVerified = terminalNodeVerified;  ///
+  } else {
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, context);
+
+    nodeVerified = nonTerminalNodeVerified; ///
+  }
+
+  return nodeVerified;
+}
+
+function verifyChildNodes(childNodes, context) {
+  const childNodesVerified = childNodes.every((childNode) => {
+    const node = childNode, ///
+          nodeVerified = verifyNode(node, context);
+
+    if (nodeVerified) {
+      return true;
+    }
+  });
+
+  return childNodesVerified;
+}
+
+function verifyTerminalNode(terminalNode, context) {
+  const terminalNodeVerified = true;
+
+  return terminalNodeVerified;
+}
+
+function verifyNonTerminalNode(nonTerminalNode, context) {
+  let nonTerminalNodeVerified;
+
+  const ruleName = nonTerminalNode.getRuleName();
+
+  switch (ruleName) {
+    case TYPE_RULE_NAME: {
+      const typeNode = nonTerminalNode, ///
+            typeNodeVerified = verifyTypeNode(typeNode, context);
+
+      nonTerminalNodeVerified = typeNodeVerified; ///
+
+      break;
+    }
+
+    case TERM_RULE_NAME: {
+      const termNode = nonTerminalNode, ///
+            termNodeVerified = verifyTermNode(termNode, context);
+
+      nonTerminalNodeVerified = termNodeVerified; ///
+
+      break;
+    }
+
+    default: {
+      const childNodes = nonTerminalNode.getChildNodes(),
+            childNodesVerified = verifyChildNodes(childNodes, context);
+
+      nonTerminalNodeVerified = childNodesVerified; ///
+
+      break;
+    }
+  }
+
+  return nonTerminalNodeVerified;
+}
+
+function verifyTypeNode(typeNode, context) {
+  let typeNodeVerified = false;
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        typePresent = context.isTypePresentByTypeName(typeName);
+
+  if (!typePresent) {
+    log.error(`The type '${typeName}' is missing.`);
+  } else {
+    typeNodeVerified = true;
+  }
+
+  return typeNodeVerified;
+}
+
+function verifyTermNode(termNode, context) {
+  let termNodeVerified = false;
+
+  debugger
+
+  return termNodeVerified;
+}

package/bin/verify/term.js

@@ -0,0 +1,183 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary/lib/main");
+
+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;
+
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!")
+
+function verifyTerm(termNode, types, values, context) {
+  let termVerified = false;
+
+  const names = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, types, names, values, context);
+
+  if (termVerifiedAsVariable) {
+    termVerified = true;
+  } else {
+    const constructors = context.getConstructors(),
+          constructor = constructors.find((constructor) => {
+            const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
+
+            if (termVerifiedAgainstConstructor) {
+              return true;
+            }
+          }) || null;
+
+    if (constructor !== null) {
+      const type = constructor.getType(),
+            value = termNode; ///
+
+      types.push(type);
+
+      values.push(value);
+
+      termVerified = true;
+    }
+  }
+
+  return termVerified;
+}
+
+module.exports = verifyTerm;
+
+function verifyTermAgainstConstructor(termNode, constructor, context) {
+  const constructorTermNode = constructor.getTermNode(),
+        node = termNode,  ///
+        constructorNode = constructorTermNode, ///
+        nodeVerified = verifyNode(node, constructorNode, context),
+        termVerifiedAgainstConstructor = nodeVerified;  ///
+
+  return termVerifiedAgainstConstructor;
+}
+
+function verifyNode(node, constructorNode, context) {
+  let nodeVerified;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        constructorNodeTerminalNode = constructorNode.isTerminalNode();
+
+  if (nodeTerminalNode === constructorNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            constructorTerminalNode = constructorNode,  ///
+            terminalNodeVerified = verifyTerminalNode(terminalNode, constructorTerminalNode, context);
+
+      nodeVerified = terminalNodeVerified;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            constructorNonTerminalNode = constructorNode,  ///
+            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context);
+
+      nodeVerified = nonTerminalNodeVerified; ///
+    }
+  }
+
+  return nodeVerified;
+}
+
+function verifyChildNodes(childNodes, constructorChildNodes, context) {
+  let childNodesVerified = false;
+
+  const childNodesLength = childNodes.length,
+        constructorChildNodesLength = constructorChildNodes.length;
+
+  if (childNodesLength === constructorChildNodesLength) {
+    childNodesVerified = childNodes.every((childNode, index) => {
+      const constructorChildNode = constructorChildNodes[index],
+            node = childNode, ///
+            constructorNode = constructorChildNode,  ///
+            nodeVerified = verifyNode(node, constructorNode, context);
+
+      if (nodeVerified) {
+        return true;
+      }
+    });
+  }
+
+  return childNodesVerified;
+}
+
+function verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
+  let terminalNodeVerified = false;
+
+  const matches = terminalNode.match(constructorTerminalNode);
+
+  if (matches) {
+    terminalNodeVerified = true;
+  }
+
+  return terminalNodeVerified;
+}
+
+function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
+  let nonTerminalNodeVerified = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        constructorRuleName = constructorNonTerminalNode.getRuleName();
+
+  if (ruleName === constructorRuleName) {
+    switch (ruleName) {
+      case ARGUMENT_RULE_NAME: {
+        const argumentNode = nonTerminalNode, ///
+              constructorArgumentNode = constructorNonTerminalNode, ///
+              argumentNodeVerified = verifyArgumentNode(argumentNode, constructorArgumentNode, context);
+
+        nonTerminalNodeVerified = argumentNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        const childNodes = nonTerminalNode.getChildNodes(),
+              constructorChildNodes = constructorNonTerminalNode.getChildNodes(),
+              childNodesVerified = verifyChildNodes(childNodes, constructorChildNodes, context);
+
+        nonTerminalNodeVerified = childNodesVerified; ///
+
+        break;
+      }
+    }
+  }
+
+  return nonTerminalNodeVerified;
+}
+
+function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
+  let argumentNodeVerified = false;
+
+  const termNode = termNodeQuery(argumentNode);
+
+  if (termNode === null) {
+    const argumentString = nodeAsString(argumentNode);
+
+    log.error(`The ${argumentString} argument should be a term, not a type`);
+  } else {
+    const types = [],
+          values = [],
+          termVerified = verifyTerm(termNode, types, values, context);
+
+    if (termVerified) {
+      const firstType = first(types),
+            termType = firstType, ///
+            typeNode = typeNodeQuery(constructorArgumentNode),
+            typeName = typeNameFromTypeNode(typeNode),
+            type = context.findTypeByTypeName(typeName),
+            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+      if (termTypeEqualToOrSubTypeOfType) {
+        argumentNodeVerified = true;
+      }
+    }
+  }
+
+  return argumentNodeVerified;
+}

package/bin/verify/termAsConstructor.js

@@ -0,0 +1,173 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+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;
+
+const typeNodeQuery = nodeQuery("/argument/type");
+
+function verifyTermAsConstructor(termNode, typeNode, context) {
+  let termVerifiedAsConstructor = false;
+
+  const termString = nodeAsString(termNode);
+
+  log.debug(`Verifying the '${termString}' term as a constructor...`);
+
+  const nonTerminalNode = termNode,  ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        childNodesVerified = verifyChildNodes(childNodes, context);
+
+  let type = null;
+
+  if (childNodesVerified) {
+    if (typeNode === null) {
+      termVerifiedAsConstructor = true;
+    } else {
+      const typeName = typeNameFromTypeNode(typeNode);
+
+      type = context.findTypeByTypeName(typeName);
+
+      if (type !== null) {
+        termVerifiedAsConstructor = true;
+      } else {
+        const termString = nodeAsString(termNode);
+
+        log.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
+      }
+    }
+  }
+
+  if (termVerifiedAsConstructor) {
+    const constructor = Constructor.fromTermNodeAndType(termNode, type);
+
+    context.addConstructor(constructor);
+
+    const termString = nodeAsString(termNode);
+
+    log.info(`Verified the '${termString}' constructor.`);
+  }
+
+  return termVerifiedAsConstructor;
+}
+
+module.exports = verifyTermAsConstructor;
+
+function verifyNode(node, context) {
+  let nodeVerified;
+
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node,  ///
+          terminalNodeVerified = verifyTerminalNode(terminalNode, context);
+
+    nodeVerified = terminalNodeVerified;  ///
+  } else {
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, context);
+
+    nodeVerified = nonTerminalNodeVerified; ///
+  }
+
+  return nodeVerified;
+}
+
+function verifyChildNodes(childNodes, context) {
+  const childNodesVerified = childNodes.every((childNode) => {
+    const node = childNode, ///
+          nodeVerified = verifyNode(node, context);
+
+    if (nodeVerified) {
+      return true;
+    }
+  });
+
+  return childNodesVerified;
+}
+
+function verifyTerminalNode(terminalNode, context) {
+  const terminalNodeVerified = true;
+
+  return terminalNodeVerified;
+}
+
+function verifyNonTerminalNode(nonTerminalNode, context) {
+  let nonTerminalNodeVerified;
+
+  const ruleName = nonTerminalNode.getRuleName();
+
+  switch (ruleName) {
+    case ARGUMENT_RULE_NAME: {
+      const argumentNode = nonTerminalNode, ///
+            argumentNodeVerified = verifyArgumentNode(argumentNode, context);
+
+      nonTerminalNodeVerified = argumentNodeVerified; ///
+
+      break;
+    }
+
+    case TERM_RULE_NAME: {
+      const termNode = nonTerminalNode, ///
+            types = [],
+            values = [],
+            termVerified = verifyTerm(termNode, types, values, context);
+
+      if (termVerified) {
+        const firstType = first(types),
+              type = firstType; ///
+
+        if (type !== null) {
+          const termString = nodeAsString(termNode);
+
+          log.error(`The type of the constructor's compound '${termString}' term node is not null.`);
+        } else {
+          nonTerminalNodeVerified = true; ///
+        }
+      }
+
+      break;
+    }
+
+    default: {
+      const childNodes = nonTerminalNode.getChildNodes(),
+            childNodesVerified = verifyChildNodes(childNodes, context);
+
+      nonTerminalNodeVerified = childNodesVerified; ///
+
+      break;
+    }
+  }
+
+  return nonTerminalNodeVerified;
+}
+
+function verifyArgumentNode(argumentNode, context) {
+  let typeNodeVerified = false;
+
+  const typeNode = typeNodeQuery(argumentNode);
+
+  if (typeNode === null) {
+    const argumentString = nodeAsString(argumentNode);
+
+    log.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.`);
+    } else {
+      typeNodeVerified = true;
+    }
+  }
+
+  return typeNodeVerified;
+}

package/bin/verify/termAsVariable.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const { nodeQuery, variableNameFromVariableNode} = require("../utilities/query");
+
+const variableNodeQuery = nodeQuery("/term/variable!");
+
+const { log } = loggingUtilities;
+
+function verifyTermAsVariable(termNode, types, names, values, context) {
+  let termVerifiedAsVariable = false;
+
+  const variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    const variableName = variableNameFromVariableNode(variableNode),
+          variablePresent = context.isVariablePresentByVariableName(variableName);
+
+    if (!variablePresent) {
+      log.error(`The ${variableName} variable is not present.`)
+    } else {
+      const variable = context.findVariableByVariableName(variableName),
+            type = variable.getType(),
+            name = variableName,  ///
+            value = variable.getValue();
+
+      types.push(type);
+
+      names.push(name);
+
+      values.push(value);
+
+      termVerifiedAsVariable = true;
+    }
+  }
+
+  return termVerifiedAsVariable;
+}
+
+module.exports = verifyTermAsVariable;

package/bin/verify/type.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const Type = require("../type");
+
+const { typeNameFromTypeNode } = require("../utilities/query");
+
+const { log } = loggingUtilities;
+
+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.`);
+  } else {
+    const superTypeName = typeNameFromTypeNode(superTypeNode);
+
+    if (superTypeName === null) {
+      const type = Type.fromTypeName(typeName),
+            typeString = type.asString();
+
+      context.addType(type);
+
+      typeVerified = true;
+
+      log.info(`Verified the '${typeString}' type.`);
+    } else {
+      const superType = context.findTypeByTypeName(superTypeName);
+
+      if (superType === null) {
+        log.error(`The super-type '${superTypeName}' is missing.`);
+      } else {
+        const type = Type.fromTypeNameAndSuperType(typeName, superType),
+              typeString = type.asString();
+
+        context.addType(type);
+
+        typeVerified = true;
+
+        log.info(`Verified the '${typeString}' type.`);
+      }
+    }
+  }
+
+  return typeVerified;
+}
+
+module.exports = verifyType;
+

package/bin/verify/typeAssertion.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const Variable = require("../variable"),
+      verifyTermAsVariable = require("../verify/termAsVariable");
+
+const { first } = require("../utilities/array"),
+      { nodeQuery, typeNameFromTypeNode } = require("../utilities/query");
+
+const { log } = loggingUtilities;
+
+const termNodeQuery = nodeQuery("/typeAssertion/term"),
+      typeNodeQuery = nodeQuery("/typeAssertion/type");
+
+function verifyTypeAssertion(typeAssertionNode, context) {
+  let typeAssertionVerified = false;
+
+  const typeNode = typeNodeQuery(typeAssertionNode),
+        typeName = typeNameFromTypeNode(typeNode),
+        typePresent = context.isTypePresentByTypeName(typeName);
+
+  if (!typePresent) {
+    log.error(`The ${typeName} type is not present.`);
+  } else {
+    const derived = context.isDerived();
+
+    if (derived) {
+      debugger
+    } else {
+      const types = [],
+            names = [],
+            values = [],
+            termNode = termNodeQuery(typeAssertionNode),
+            termVerified = verifyTermAsVariable(termNode, types, names, values, context);
+
+      if (termVerified) {
+        const firstName = first(names),
+              firstValue = first(values),
+              variableName = firstName, ///
+              value = firstValue;
+
+        if (value !== undefined) {
+          log.error(`The value of the ${variableName} variable is not undefined.`);
+        } else {
+          const type = context.findTypeByTypeName(typeName),
+                firstType = first(types),
+                variableType = firstType, ///
+                typeSubTypeOfVariableType = type.isSubTypeOf(variableType);
+
+          if (!typeSubTypeOfVariableType) {
+            log.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
+          } else {
+            const name = variableName,  ///
+                  variable = Variable.fromTypeAndName(type, name);
+
+            context.addVariable(variable);
+
+            typeAssertionVerified = true;
+          }
+        }
+      }
+    }
+  }
+
+  return typeAssertionVerified;
+}
+
+module.exports = verifyTypeAssertion;