occam-verify-cli 0.0.1002 → 0.0.1005

package/lib/statement/unqualified.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return UnqualifiedStatement;
+    }
+});
+var _statement = /*#__PURE__*/ _interop_require_default(require("../statement"));
+var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+var _string = require("../utilities/string");
+var _query = require("../utilities/query");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var statementNodeQuery = (0, _query.nodeQuery)("/unqualifiedStatement/statement");
+var UnqualifiedStatement = /*#__PURE__*/ function() {
+    function UnqualifiedStatement(string, statement) {
+        _class_call_check(this, UnqualifiedStatement);
+        this.string = string;
+        this.statement = statement;
+    }
+    _create_class(UnqualifiedStatement, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, localContext) {
+                var verified;
+                var unqualifiedStatementString = (0, _string.trim)(this.string); ///
+                localContext.trace("Verifying the '".concat(unqualifiedStatementString, "' unqualified statement..."));
+                var statementVerified = this.statement.verify(assignments, stated, localContext);
+                verified = statementVerified; ///
+                if (verified) {
+                    localContext.debug("...verified the '".concat(unqualifiedStatementString, "' unqualified statement."));
+                }
+                return verified;
+            }
+        }
+    ], [
+        {
+            key: "fromUnqualifiedStatementNode",
+            value: function fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext) {
+                var unqualifiedStatement = null;
+                if (unqualifiedStatementNode !== null) {
+                    var statementNode = statementNodeQuery(unqualifiedStatementNode), localContext = _local.default.fromFileContext(fileContext), statement = statementNode !== null ? _statement.default.fromStatementNode(statementNode, localContext) : null, node = unqualifiedStatementNode, string = fileContext.nodeAsString(node);
+                    unqualifiedStatement = new UnqualifiedStatement(string, statement);
+                }
+                return unqualifiedStatement;
+            }
+        }
+    ]);
+    return UnqualifiedStatement;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/statement.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _shim = /*#__PURE__*/ _interop_require_default(require("./shim"));
+var _unify = /*#__PURE__*/ _interop_require_default(require("./mixins/statement/unify"));
+var _verify = /*#__PURE__*/ _interop_require_default(require("./mixins/statement/verify"));
+var _statementAsCombinator = /*#__PURE__*/ _interop_require_default(require("./verifier/statementAsCombinator"));
+var _node = require("./utilities/node");
+var _metaTypeNames = require("./metaTypeNames");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var Statement = /*#__PURE__*/ function() {
+    function Statement(string, node) {
+        _class_call_check(this, Statement);
+        this.string = string;
+        this.node = node;
+    }
+    _create_class(Statement, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(statement) {
+                var node = statement.getNode(), matches = this.node.match(node), equalTo = matches; ///
+                return equalTo;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, localContext) {
+                var verified = false;
+                var statement = this, statementString = this.string; ///
+                localContext.trace("Verifying the '".concat(statementString, "' statement..."));
+                if (!verified) {
+                    verified = _unify.default.some(function(unifyMixin) {
+                        var unified = unifyMixin(statement, assignments, stated, localContext);
+                        if (unified) {
+                            return true;
+                        }
+                    });
+                }
+                if (!verified) {
+                    verified = _verify.default.some(function(verifyMixin) {
+                        var verified = verifyMixin(statement, assignments, stated, localContext);
+                        if (verified) {
+                            return true;
+                        }
+                    });
+                }
+                if (verified) {
+                    localContext.debug("...verified the '".concat(statementString, "' statement."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "unifyWithMetaType",
+            value: function unifyWithMetaType(metaType, assignments, stated, localContext) {
+                var unifiedWithMetaType;
+                var verifiedGivenMetaType = this.verifyGivenMetaType(metaType, assignments, stated, localContext);
+                unifiedWithMetaType = verifiedGivenMetaType; ///
+                return unifiedWithMetaType;
+            }
+        },
+        {
+            key: "verifyAsCombinator",
+            value: function verifyAsCombinator(localContext) {
+                var verifiedAsCombinator;
+                var statementNode = this.node, statementString = this.string; ///
+                localContext.trace("Verifying the '".concat(statementString, "' statement as a combinator..."));
+                verifiedAsCombinator = _statementAsCombinator.default.verifyStatement(statementNode, localContext);
+                if (verifiedAsCombinator) {
+                    localContext.debug("...verified the '".concat(statementString, "' statement as a combinator."), statementNode);
+                }
+                return verifiedAsCombinator;
+            }
+        },
+        {
+            key: "verifyGivenMetaType",
+            value: function verifyGivenMetaType(metaType, assignments, stated, localContext) {
+                var verifiedGivenMetaType;
+                var metaTypeName = metaType.getName();
+                switch(metaTypeName){
+                    case _metaTypeNames.FRAME_META_TYPE_NAME:
+                    case _metaTypeNames.REFERENCE_META_TYPE_NAME:
+                        {
+                            debugger;
+                            break;
+                        }
+                    case _metaTypeNames.STATEMENT_META_TYPE_NAME:
+                        {
+                            var verified = this.verify(assignments, stated, localContext);
+                            verifiedGivenMetaType = verified; ///
+                            break;
+                        }
+                }
+                return verifiedGivenMetaType;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var string = this.string, json = {
+                    string: string
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, fileContext) {
+                var string = json.string, statementString = string, lexer = fileContext.getLexer(), parser = fileContext.getParser(), statementNode = (0, _node.statementNodeFromStatementString)(statementString, lexer, parser), node = statementNode, statement = new Statement(string, node);
+                return statement;
+            }
+        },
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, localContext) {
+                var statement;
+                if (statementNode !== null) {
+                    var node = statementNode, string = localContext.nodeAsString(node);
+                    statement = new Statement(string, node);
+                }
+                return statement;
+            }
+        }
+    ]);
+    return Statement;
+}();
+Object.assign(_shim.default, {
+    Statement: Statement
+});
+Object.assign(Statement.prototype, _unify.default);
+var _default = Statement;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/statement.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"./shim\";\nimport unifyMixins from \"./mixins/statement/unify\";\nimport verifyMixins from \"./mixins/statement/verify\";\nimport statementAsCombinatorVerifier from \"./verifier/statementAsCombinator\";\n\nimport { statementNodeFromStatementString } from \"./utilities/node\";\nimport { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from \"./metaTypeNames\";\n\nclass Statement {\n  constructor(string, node) {\n    this.string = string;\n    this.node = node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  isEqualTo(statement) {\n    const node = statement.getNode(),\n          matches = this.node.match(node),\n          equalTo = matches;  ///\n\n    return equalTo;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified = false;\n\n    const statement = this, ///\n          statementString = this.string;  ///\n\n    localContext.trace(`Verifying the '${statementString}' statement...`);\n\n    if (!verified) {\n      verified = unifyMixins.some((unifyMixin) => { ///\n        const unified = unifyMixin(statement, assignments, stated, localContext);\n\n        if (unified) {\n          return true;\n        }\n      });\n    }\n\n    if (!verified) {\n      verified = verifyMixins.some((verifyMixin) => {\n        const verified = verifyMixin(statement, assignments, stated, localContext);\n\n        if (verified) {\n          return true;\n        }\n      });\n    }\n\n    if (verified) {\n      localContext.debug(`...verified the '${statementString}' statement.`);\n    }\n\n    return verified;\n  }\n\n  unifyWithMetaType(metaType, assignments, stated, localContext) {\n    let unifiedWithMetaType;\n\n    const verifiedGivenMetaType = this.verifyGivenMetaType(metaType, assignments, stated, localContext);\n\n    unifiedWithMetaType = verifiedGivenMetaType;  ///\n\n    return unifiedWithMetaType;\n  }\n\n  verifyAsCombinator(localContext) {\n    let verifiedAsCombinator;\n\n    const statementNode = this.node,  ///\n          statementString = this.string;  ///\n\n    localContext.trace(`Verifying the '${statementString}' statement as a combinator...`);\n\n    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, localContext);\n\n    if (verifiedAsCombinator) {\n      localContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);\n    }\n\n    return verifiedAsCombinator;\n  }\n\n  verifyGivenMetaType(metaType, assignments, stated, localContext) {\n    let verifiedGivenMetaType;\n\n    const metaTypeName = metaType.getName();\n\n    switch (metaTypeName) {\n      case FRAME_META_TYPE_NAME:\n      case REFERENCE_META_TYPE_NAME: {\n        debugger\n\n        // verifiedGivenMetaType = false;\n        //\n        // const metavariableNode = metavariableNodeQuery(statementNode);\n        //\n        // if (metavariableNode !== null) {\n        //   const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),\n        //     metavariable = localContext.findMetavariableByMetavariableName(metavariableName);\n        //\n        //   if (metavariable !== null) {\n        //     const metavariableMetaType = metavariable.getMetaType();\n        //\n        //     if (metavariableMetaType === metaType) {\n        //       verifiedGivenMetaType = true;\n        //     }\n        //   }\n        // }\n\n        break;\n      }\n\n      case STATEMENT_META_TYPE_NAME: {\n        const verified = this.verify(assignments, stated, localContext)\n\n        verifiedGivenMetaType = verified; ///\n\n        break;\n      }\n    }\n\n    return verifiedGivenMetaType;\n  }\n\n  toJSON() {\n    const string = this.string, ///\n          json = {\n            string\n          };\n\n    return json;\n  }\n\n  static fromJSON(json, fileContext) {\n    const { string } = json,\n          statementString = string, ///\n          lexer = fileContext.getLexer(),\n          parser = fileContext.getParser(),\n          statementNode = statementNodeFromStatementString(statementString, lexer, parser),\n          node = statementNode,  ///\n          statement = new Statement(string, node);\n\n    return statement;\n  }\n\n  static fromStatementNode(statementNode, localContext) {\n    let statement;\n\n    if (statementNode !== null) {\n      const node = statementNode, ///\n            string = localContext.nodeAsString(node);\n\n      statement = new Statement(string, node);\n    }\n\n    return statement;\n  }\n}\n\nObject.assign(shim, {\n  Statement\n});\n\nObject.assign(Statement.prototype, unifyMixins);\n\nexport default Statement;\n\n"],"names":["Statement","string","node","getString","getNode","isEqualTo","statement","matches","match","equalTo","verify","assignments","stated","localContext","verified","statementString","trace","unifyMixins","some","unifyMixin","unified","verifyMixins","verifyMixin","debug","unifyWithMetaType","metaType","unifiedWithMetaType","verifiedGivenMetaType","verifyGivenMetaType","verifyAsCombinator","verifiedAsCombinator","statementNode","statementAsCombinatorVerifier","verifyStatement","metaTypeName","getName","FRAME_META_TYPE_NAME","REFERENCE_META_TYPE_NAME","STATEMENT_META_TYPE_NAME","toJSON","json","fromJSON","fileContext","lexer","getLexer","parser","getParser","statementNodeFromStatementString","fromStatementNode","nodeAsString","Object","assign","shim","prototype"],"mappings":"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"}

package/lib/subDerivation.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SubDerivation;
+    }
+});
+var _shim = /*#__PURE__*/ _interop_require_default(require("./shim"));
+var _array = require("./utilities/array");
+var _query = require("./utilities/query");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var proofStepNodesQuery = (0, _query.nodesQuery)("/subDerivation/proofStep|lastProofStep");
+var SubDerivation = /*#__PURE__*/ function() {
+    function SubDerivation(proofSteps) {
+        _class_call_check(this, SubDerivation);
+        this.proofSteps = proofSteps;
+    }
+    _create_class(SubDerivation, [
+        {
+            key: "getProofSteps",
+            value: function getProofSteps() {
+                return this.proofSteps;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                var lastProofStep = (0, _array.last)(this.proofSteps);
+                return lastProofStep;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, localContext) {
+                var verified;
+                verified = this.proofSteps.every(function(proofStep) {
+                    var proofStepVerified = proofStep.verify(substitutions, localContext);
+                    if (proofStepVerified) {
+                        return true;
+                    }
+                });
+                return verified;
+            }
+        }
+    ], [
+        {
+            key: "fromSubDerivationNode",
+            value: function fromSubDerivationNode(subDerivationNode, fileContext) {
+                var ProofStep = _shim.default.ProofStep, proofStepNodes = proofStepNodesQuery(subDerivationNode), proofSteps = proofStepNodes.map(function(proofStepNode) {
+                    var proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
+                    return proofStep;
+                }), subDerivation = new SubDerivation(proofSteps);
+                return subDerivation;
+            }
+        }
+    ]);
+    return SubDerivation;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/subproof.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Subproof;
+    }
+});
+var _supposition = /*#__PURE__*/ _interop_require_default(require("./supposition"));
+var _local = /*#__PURE__*/ _interop_require_default(require("./context/local"));
+var _subDerivation = /*#__PURE__*/ _interop_require_default(require("./subDerivation"));
+var _query = require("./utilities/query");
+var _subproof = require("./utilities/subproof");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var suppositionNodesQuery = (0, _query.nodesQuery)("/subproof/supposition"), subDerivationNodeQuery = (0, _query.nodeQuery)("/subproof/subDerivation");
+var Subproof = /*#__PURE__*/ function() {
+    function Subproof(string, suppositions, subDerivation) {
+        _class_call_check(this, Subproof);
+        this.string = string;
+        this.suppositions = suppositions;
+        this.subDerivation = subDerivation;
+    }
+    _create_class(Subproof, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getSuppositions",
+            value: function getSuppositions() {
+                return this.suppositions;
+            }
+        },
+        {
+            key: "getSubDerivation",
+            value: function getSubDerivation() {
+                return this.subDerivation;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                return this.subDerivation.getLastProofStep();
+            }
+        },
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                var lastProofStep = this.getLastProofStep(), suppositionStatements = this.suppositions.map(function(supposition) {
+                    var suppositionStatement = supposition.getStatement();
+                    return suppositionStatement;
+                }), lastProofStepStatement = lastProofStep.getStatement(), statements = _to_consumable_array(suppositionStatements).concat([
+                    lastProofStepStatement
+                ]);
+                return statements;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, localContext) {
+                var subproofVerified = false;
+                localContext = _local.default.fromLocalContext(localContext); ///
+                var suppositionsVerified = this.suppositions.every(function(supposition) {
+                    var suppositionVerified = supposition.verify(localContext);
+                    if (suppositionVerified) {
+                        return true;
+                    }
+                });
+                if (suppositionsVerified) {
+                    var subDerivationVerified = this.subDerivation.verify(substitutions, localContext);
+                    if (subDerivationVerified) {
+                        subproofVerified = true;
+                    }
+                }
+                return subproofVerified;
+            }
+        }
+    ], [
+        {
+            key: "fromSubproofNode",
+            value: function fromSubproofNode(subproofNode, fileContext) {
+                var subproof = null;
+                if (subproofNode !== null) {
+                    var subproofString = (0, _subproof.subproofStringFromSubproofNode)(subproofNode, fileContext), suppositionNodes = suppositionNodesQuery(subproofNode), subDerivationNode = subDerivationNodeQuery(subproofNode), string = subproofString, suppositions = suppositionNodes.map(function(suppositionNode) {
+                        var supposition = _supposition.default.fromSuppositionNode(suppositionNode, fileContext);
+                        return supposition;
+                    }), subDerivation = _subDerivation.default.fromSubDerivationNode(subDerivationNode, fileContext);
+                    subproof = new Subproof(string, suppositions, subDerivation);
+                }
+                return subproof;
+            }
+        }
+    ]);
+    return Subproof;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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