occam-verify-cli 0.0.462 → 0.0.463

package/bin/action/verify.js

@@ -4,7 +4,7 @@ const { Dependency } = require("occam-file-system"),
       { loggingUtilities } = require("necessary"),
       { verifyRelease, releaseContextUtilities } = require("../../lib/index");  ///
 
-const { EMPTY_STRING } = require("../constants"),
+const { trimTrailingSlash } = require("../utilities/string"),
       { releaseContextFromDependencyAndDependentNames } = require("../utilities/fileSystem");
 
 const { log } = loggingUtilities,
@@ -12,7 +12,7 @@ const { log } = loggingUtilities,
       { createReleaseContext, initialiseReleaseContext } = releaseContextUtilities;
 
 function verifyAction(argument, logLevel) {
-  const name = argument.replace(/\/$/, EMPTY_STRING),
+  const name = trimTrailingSlash(argument), ///
         context = {},
         dependency = Dependency.fromName(name),
         dependentNames = [],

package/bin/utilities/string.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const { EMPTY_STRING } = require("../constants");
+
+function trimTrailingSlash(string) {
+  string = string.replace(/\/$/, EMPTY_STRING); ///
+
+  return string;
+}
+
+module.exports = {
+  trimTrailingSlash
+};

package/lib/verify/assertion/type.js

@@ -12,6 +12,12 @@ var _array = require("../../utilities/array");
 var _string = require("../../utilities/string");
 var _query = require("../../utilities/query");
 var _term = require("../../verify/term");
+var _variable = /*#__PURE__*/ _interopRequireDefault(require("../../variable"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type");
 function verifyTypeAssertion(typeAssertionNode, proofContext) {
     var typeAssertionVerified = false;
@@ -22,27 +28,13 @@ function verifyTypeAssertion(typeAssertionNode, proofContext) {
     if (!typePresent) {
         proofContext.error("The ".concat(typeName, " type is not present."));
     } else {
-        var assertedType = null;
-        var type = proofContext.findTypeByTypeName(typeName), context = proofContext, termNode = termNodeQuery(typeAssertionNode);
-        var variables = [], termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context);
+        var context = proofContext, termNode = termNodeQuery(typeAssertionNode), variables = [], termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context);
         if (termVerifiedAsVariable) {
-            var firstVariable = (0, _array.first)(variables), variable = firstVariable, variableType = variable.getType();
-            assertedType = variableType; ///
+            var variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
+            typeAssertionVerified = variableTypeAssertionVerified; ///
         } else {
-            var types = [], termVerifiedAgainstConstructors = (0, _term.verifyTermAgainstConstructors)(termNode, types, context);
-            if (termVerifiedAgainstConstructors) {
-                var firstType = (0, _array.first)(types), termType = firstType; ///
-                assertedType = termType; ///
-            }
-        }
-        if (assertedType !== null) {
-            var typeEqualToOrSubTypeOfAssertedType = type.isEqualToOrSubTypeOf(assertedType);
-            if (!typeEqualToOrSubTypeOfAssertedType) {
-                var termString = (0, _string.nodeAsString)(termNode);
-                proofContext.error("The type of the '".concat(termString, "' term or variable is not equal to or a sub-type of the asserted type."));
-            } else {
-                typeAssertionVerified = true;
-            }
+            var termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
+            typeAssertionVerified = termTypeAssertionVerified; ///
         }
     }
     if (typeAssertionVerified) {
@@ -51,5 +43,36 @@ function verifyTypeAssertion(typeAssertionNode, proofContext) {
     typeAssertionVerified ? proofContext.complete(typeAssertionNode) : proofContext.halt(typeAssertionNode);
     return typeAssertionVerified;
 }
+function verifyTermTypeAssertion(typeAssertionNode, proofContext) {
+    var termTypeAssertionVerified = false;
+    var types = [], context = proofContext, termNode = termNodeQuery(typeAssertionNode), termVerifiedAgainstConstructors = (0, _term.verifyTermAgainstConstructors)(termNode, types, context);
+    if (termVerifiedAgainstConstructors) {
+        var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = proofContext.findTypeByTypeName(assertedTypeName), firstType = (0, _array.first)(types), termType = firstType, assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+        if (!assertedTypeEqualToOrSubTypeOfTermType) {
+            var termString = (0, _string.nodeAsString)(termNode);
+            proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(termString, "' term type."));
+        } else {
+            termTypeAssertionVerified = true;
+        }
+    }
+    return termTypeAssertionVerified;
+}
+function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
+    var variableTypeAssertionVerified = false;
+    var context = proofContext, variables = [], termNode = termNodeQuery(typeAssertionNode);
+    (0, _term.verifyTermAsVariable)(termNode, variables, context);
+    var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = proofContext.findTypeByTypeName(assertedTypeName), firstVariable = (0, _array.first)(variables), variable = firstVariable, variableName = variable.getName(), variableType = variable.getType(), assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+    if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+        proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(variableName, "' variable type."));
+    } else {
+        var derived = proofContext.isDerived();
+        if (!derived) {
+            var type = assertedType, name = variableName, variable1 = _variable.default.fromTypeAndName(type, name);
+            proofContext.addVariable(variable1);
+        }
+        variableTypeAssertionVerified = true;
+    }
+    return variableTypeAssertionVerified;
+}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verify/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeAsString } from \"../../utilities/string\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../../verify/term\";\nimport Variable from \"../../variable\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, proofContext) {\n  let typeAssertionVerified = false;\n\n  proofContext.begin(typeAssertionNode);\n\n  const typeAssertionString = nodeAsString(typeAssertionNode);\n\n  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        typePresent = proofContext.isTypePresentByTypeName(typeName);\n\n  if (!typePresent) {\n    proofContext.error(`The ${typeName} type is not present.`);\n  } else {\n    const context = proofContext, ///\n          termNode = termNodeQuery(typeAssertionNode),\n          variables = [],\n          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n    if (termVerifiedAsVariable) {\n      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);\n\n      typeAssertionVerified = variableTypeAssertionVerified;  ///\n    } else {\n      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);\n\n      typeAssertionVerified = termTypeAssertionVerified;  ///\n    }\n  }\n\n  if (typeAssertionVerified) {\n    proofContext.info(`Verified the '${typeAssertionString}' type assertion.`);\n  }\n\n  typeAssertionVerified ?\n    proofContext.complete(typeAssertionNode) :\n      proofContext.halt(typeAssertionNode);\n\n  return typeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, proofContext) {\n  let termTypeAssertionVerified = false;\n\n  const types = [],\n        context = proofContext, ///\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n  if (termVerifiedAgainstConstructors) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = proofContext.findTypeByTypeName(assertedTypeName),\n          firstType = first(types),\n          termType = firstType,\n          assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);\n\n    if (!assertedTypeEqualToOrSubTypeOfTermType) {\n      const termString = nodeAsString(termNode);\n\n      proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);\n    } else {\n      termTypeAssertionVerified = true;\n    }\n  }\n\n  return termTypeAssertionVerified;\n}\n\nfunction verifyVariableTypeAssertion(typeAssertionNode, proofContext) {\n  let variableTypeAssertionVerified = false;\n\n  const context = proofContext, ///\n        variables = [],\n        termNode = termNodeQuery(typeAssertionNode);\n\n  verifyTermAsVariable(termNode, variables, context);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        assertedTypeName = typeName,  ///\n        assertedType = proofContext.findTypeByTypeName(assertedTypeName),\n        firstVariable = first(variables),\n        variable = firstVariable, ///\n        variableName = variable.getName(),\n        variableType = variable.getType(),\n        assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);\n\n  if (!assertedTypeEqualToOrSubTypeOfVariableType) {\n    proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);\n  } else {\n    const derived = proofContext.isDerived();\n\n    if (!derived) {\n      const type = assertedType,  ///\n            name = variableName,  ///\n            variable = Variable.fromTypeAndName(type, name);\n\n      proofContext.addVariable(variable);\n    }\n\n    variableTypeAssertionVerified = true;\n  }\n\n  return variableTypeAssertionVerified;\n}\n"],"names":["verifyTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNode","proofContext","typeAssertionVerified","begin","typeAssertionString","nodeAsString","debug","typeNode","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","error","context","termNode","variables","termVerifiedAsVariable","verifyTermAsVariable","variableTypeAssertionVerified","verifyVariableTypeAssertion","termTypeAssertionVerified","verifyTermTypeAssertion","info","complete","halt","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","assertedTypeName","assertedType","findTypeByTypeName","firstType","first","termType","assertedTypeEqualToOrSubTypeOfTermType","isEqualToOrSubTypeOf","termString","firstVariable","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSubTypeOfVariableType","derived","isDerived","type","name","Variable","fromTypeAndName","addVariable"],"mappings":"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"}

package/lib/verify/statement/unqualified.js

@@ -2,59 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default" // if (derived) {
- //   debugger
- // } else {
- //   const types = [],
- //     context = proofContext, ///
- //     termNode = termNodeQuery(typeAssertionNode),
- //     variables = [],
- //     termString = nodeAsString(termNode),
- //     termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
- //
- //   if (termVerifiedAsVariable) {
- //     const firstValue = first(values),
- //       variableName = termString, ///
- //       value = firstValue; ///
- //
- //     if (value !== undefined) {
- //       proofContext.error(`The value of the ${variableName} variable is not undefined.`);
- //     } else {
- //       const type = proofContext.findTypeByTypeName(typeName),
- //         firstType = first(types),
- //         variableType = firstType, ///
- //         typeEqualToOrSubTypeOfVariableType = type.isEqualToOrSubTypeOf(variableType);
- //
- //       if (!typeEqualToOrSubTypeOfVariableType) {
- //         proofContext.error(`The asserted type of the ${variableName} variable is not equal to or a sub-type of its declared type.`);
- //       } else {
- //         const name = variableName,  ///
- //           variable = Variable.fromTypeAndName(type, name);
- //
- //         proofContext.addVariable(variable);
- //
- //         typeAssertionVerified = true;
- //       }
- //     }
- //   } else {
- //     const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
- //
- //     if (termVerifiedAgainstConstructors) {
- //       const type = proofContext.findTypeByTypeName(typeName),
- //         firstType = first(types),
- //         termType = firstType, ///
- //         typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
- //
- //       if (!typeEqualToOrSubTypeOfTermType) {
- //         proofContext.error(`The asserted type of the '${termString}' term is not equal to or a sub-type of its declared type.`);
- //       } else {
- //
- //         typeAssertionVerified = true;
- //       }
- //     }
- //   }
- // }
-, {
+Object.defineProperty(exports, "default", {
     enumerable: true,
     get: function() {
         return verifyUnqualifiedStatement;
@@ -95,4 +43,4 @@ function verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext) {
     return unqualifiedStatementVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.462",
+  "version": "0.0.463",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/verify/assertion/type.js

@@ -4,6 +4,7 @@ import { first } from "../../utilities/array";
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
 import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
+import Variable from "../../variable";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
@@ -24,43 +25,19 @@ export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
   if (!typePresent) {
     proofContext.error(`The ${typeName} type is not present.`);
   } else {
-    let assertedType = null;
-
-    const type = proofContext.findTypeByTypeName(typeName),
-          context = proofContext, ///
-          termNode = termNodeQuery(typeAssertionNode);
-
-    const variables = [],
+    const context = proofContext, ///
+          termNode = termNodeQuery(typeAssertionNode),
+          variables = [],
           termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
     if (termVerifiedAsVariable) {
-      const firstVariable = first(variables),
-            variable = firstVariable, ///
-            variableType = variable.getType();
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
 
-      assertedType = variableType;  ///
+      typeAssertionVerified = variableTypeAssertionVerified;  ///
     } else {
-      const types = [],
-            termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
-
-      if (termVerifiedAgainstConstructors) {
-        const firstType = first(types),
-              termType = firstType; ///
-
-        assertedType = termType;  ///
-      }
-    }
-
-    if (assertedType !== null) {
-      const typeEqualToOrSubTypeOfAssertedType = type.isEqualToOrSubTypeOf(assertedType);
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
 
-      if (!typeEqualToOrSubTypeOfAssertedType) {
-        const termString = nodeAsString(termNode);
-
-        proofContext.error(`The type of the '${termString}' term or variable is not equal to or a sub-type of the asserted type.`);
-      } else {
-        typeAssertionVerified = true;
-      }
+      typeAssertionVerified = termTypeAssertionVerified;  ///
     }
   }
 
@@ -74,3 +51,70 @@ export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
 
   return typeAssertionVerified;
 }
+
+function verifyTermTypeAssertion(typeAssertionNode, proofContext) {
+  let termTypeAssertionVerified = false;
+
+  const types = [],
+        context = proofContext, ///
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+
+  if (termVerifiedAgainstConstructors) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+          firstType = first(types),
+          termType = firstType,
+          assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+
+    if (!assertedTypeEqualToOrSubTypeOfTermType) {
+      const termString = nodeAsString(termNode);
+
+      proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);
+    } else {
+      termTypeAssertionVerified = true;
+    }
+  }
+
+  return termTypeAssertionVerified;
+}
+
+function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
+  let variableTypeAssertionVerified = false;
+
+  const context = proofContext, ///
+        variables = [],
+        termNode = termNodeQuery(typeAssertionNode);
+
+  verifyTermAsVariable(termNode, variables, context);
+
+  const typeNode = typeNodeQuery(typeAssertionNode),
+        typeName = typeNameFromTypeNode(typeNode),
+        assertedTypeName = typeName,  ///
+        assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+        firstVariable = first(variables),
+        variable = firstVariable, ///
+        variableName = variable.getName(),
+        variableType = variable.getType(),
+        assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+
+  if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+    proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);
+  } else {
+    const derived = proofContext.isDerived();
+
+    if (!derived) {
+      const type = assertedType,  ///
+            name = variableName,  ///
+            variable = Variable.fromTypeAndName(type, name);
+
+      proofContext.addVariable(variable);
+    }
+
+    variableTypeAssertionVerified = true;
+  }
+
+  return variableTypeAssertionVerified;
+}

package/src/verify/statement/unqualified.js

@@ -47,56 +47,3 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
 
   return unqualifiedStatementVerified;
 }
-
-// if (derived) {
-//   debugger
-// } else {
-//   const types = [],
-//     context = proofContext, ///
-//     termNode = termNodeQuery(typeAssertionNode),
-//     variables = [],
-//     termString = nodeAsString(termNode),
-//     termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
-//
-//   if (termVerifiedAsVariable) {
-//     const firstValue = first(values),
-//       variableName = termString, ///
-//       value = firstValue; ///
-//
-//     if (value !== undefined) {
-//       proofContext.error(`The value of the ${variableName} variable is not undefined.`);
-//     } else {
-//       const type = proofContext.findTypeByTypeName(typeName),
-//         firstType = first(types),
-//         variableType = firstType, ///
-//         typeEqualToOrSubTypeOfVariableType = type.isEqualToOrSubTypeOf(variableType);
-//
-//       if (!typeEqualToOrSubTypeOfVariableType) {
-//         proofContext.error(`The asserted type of the ${variableName} variable is not equal to or a sub-type of its declared type.`);
-//       } else {
-//         const name = variableName,  ///
-//           variable = Variable.fromTypeAndName(type, name);
-//
-//         proofContext.addVariable(variable);
-//
-//         typeAssertionVerified = true;
-//       }
-//     }
-//   } else {
-//     const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
-//
-//     if (termVerifiedAgainstConstructors) {
-//       const type = proofContext.findTypeByTypeName(typeName),
-//         firstType = first(types),
-//         termType = firstType, ///
-//         typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
-//
-//       if (!typeEqualToOrSubTypeOfTermType) {
-//         proofContext.error(`The asserted type of the '${termString}' term is not equal to or a sub-type of its declared type.`);
-//       } else {
-//
-//         typeAssertionVerified = true;
-//       }
-//     }
-//   }
-// }