occam-verify-cli 1.0.383 → 1.0.386

package/lib/ontology/term.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../ontology"));
+var _verify = /*#__PURE__*/ _interop_require_default(require("../mixins/term/verify"));
+var _node = require("../utilities/node");
+var _term = require("../context/partial/term");
+var _json = require("../utilities/json");
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Term;
+var filter = _necessary.arrayUtilities.filter, compress = _necessary.arrayUtilities.compress;
+var _default = (0, _ontology.define)((_Term = /*#__PURE__*/ function() {
+    function Term(string, node, type) {
+        _class_call_check(this, Term);
+        this.string = string;
+        this.node = node;
+        this.type = type;
+    }
+    _create_class(Term, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "setType",
+            value: function setType(type) {
+                this.type = type;
+            }
+        },
+        {
+            key: "getVariable",
+            value: function getVariable(context) {
+                var Variable = _ontology.default.Variable, termNode = this.node, variable = Variable.fromTermNode(termNode, context);
+                return variable;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables(context) {
+                var termNode = this.node, variableNodes = termNode.getVariableNodes(), variables = variableNodes.map(function(variableNode) {
+                    var Variable = _ontology.default.Variable, variable = Variable.fromVariableNode(variableNode, context);
+                    return variable;
+                });
+                compress(variables, function(variableA, variableB) {
+                    var variableAEqualToVariableB = variableA.isEqualTo(variableB);
+                    if (variableAEqualToVariableB) {
+                        return true;
+                    }
+                });
+                return variables;
+            }
+        },
+        {
+            key: "matchTermNode",
+            value: function matchTermNode(termNode) {
+                var termNodeMatches = this.node.match(termNode);
+                return termNodeMatches;
+            }
+        },
+        {
+            key: "isProvisional",
+            value: function isProvisional() {
+                return this.type.isProvisional();
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(term) {
+                var termString = term.getString(), equalTo = termString === this.string;
+                return equalTo;
+            }
+        },
+        {
+            key: "isSimple",
+            value: function isSimple() {
+                var termNode = this.node, singularVariableNode = termNode.getSingularVariableNode(), simple = singularVariableNode !== null;
+                return simple;
+            }
+        },
+        {
+            key: "isGrounded",
+            value: function isGrounded(definedVariables, context) {
+                var variables = this.getVariables(context);
+                filter(variables, function(variable) {
+                    var definedVariablesIncludesVariable = definedVariables.includes(variable);
+                    if (!definedVariablesIncludesVariable) {
+                        return true;
+                    }
+                });
+                var undefinedVariables = variables, undefinedVariablesLength = undefinedVariables.length, grounded = undefinedVariablesLength <= 1;
+                return grounded;
+            }
+        },
+        {
+            key: "isInitiallyGrounded",
+            value: function isInitiallyGrounded(context) {
+                var variables = this.getVariables(context), variablesLength = variables.length, initiallyGrounded = variablesLength === 0;
+                return initiallyGrounded;
+            }
+        },
+        {
+            key: "isImplicitlyGrounded",
+            value: function isImplicitlyGrounded(definedVariables, context) {
+                var grounded = this.isGrounded(definedVariables, context), implicitlyGrounded = grounded; ///
+                return implicitlyGrounded;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context, verifyAhead) {
+                var _this = this;
+                var verifies;
+                var termString = this.string; ///
+                context.trace("Verifying the '".concat(termString, "' term..."));
+                verifies = _verify.default.some(function(verifyMixin) {
+                    var term = _this, verifies = verifyMixin(term, context, verifyAhead);
+                    if (verifies) {
+                        return true;
+                    }
+                });
+                if (verifies) {
+                    context.debug("...verified the '".concat(termString, "' term."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyGivenType",
+            value: function verifyGivenType(type, generalContext, specificContext) {
+                var _this = this;
+                var verifiesGivenType;
+                var typeString = type.getString(), termString = this.getString(); ///
+                specificContext.trace("Verifying the '".concat(termString, "' term given the '").concat(typeString, "' type..."));
+                var context = specificContext, verifies = this.verify(context, function() {
+                    var verifiesAhead;
+                    var typeEqualToOrSubTypeOfGivenTypeType = _this.type.isEqualToOrSubTypeOf(type);
+                    if (typeEqualToOrSubTypeOfGivenTypeType) {
+                        verifiesAhead = true;
+                    }
+                    return verifiesAhead;
+                });
+                verifiesGivenType = verifies; ///
+                if (verifiesGivenType) {
+                    specificContext.debug("...verified the '".concat(termString, "' term given the '").concat(typeString, "' type."));
+                }
+                return verifiesGivenType;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var typeJSON = (0, _json.typeToTypeJSON)(this.type), string = this.string, type = typeJSON, json = {
+                    type: type,
+                    string: string
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var string = json.string, termString = string, termNode = (0, _term.termNodeFromTermString)(termString, context), node = termNode, type = (0, _json.typeFromJSON)(json, context), term = new Term(string, node, type);
+                return term;
+            }
+        },
+        {
+            key: "fromTermNode",
+            value: function fromTermNode(termNode, context) {
+                var term = (0, _node.termFromTermNode)(termNode, context);
+                return term;
+            }
+        },
+        {
+            key: "fromTermNodeAndType",
+            value: function fromTermNodeAndType(termNode, type, context) {
+                var node = termNode, string = context.nodeAsString(node), term = new Term(string, node, type);
+                return term;
+            }
+        },
+        {
+            key: "fromTypeAssertionNode",
+            value: function fromTypeAssertionNode(typeAssertionNode, context) {
+                var term = null;
+                var termNode = typeAssertionNode.getTermNode();
+                if (termNode !== null) {
+                    term = (0, _node.termFromTermNode)(termNode, context);
+                }
+                return term;
+            }
+        },
+        {
+            key: "fromDefinedAssertionNode",
+            value: function fromDefinedAssertionNode(definedAssertionNode, context) {
+                var term = null;
+                var termNode = definedAssertionNode.getTermNode();
+                if (termNode !== null) {
+                    term = (0, _node.termFromTermNode)(termNode, context);
+                }
+                return term;
+            }
+        },
+        {
+            key: "fromPropertyRelationNode",
+            value: function fromPropertyRelationNode(propertyRelationNode, context) {
+                var termNode = propertyRelationNode.getTermNode(), term = (0, _node.termFromTermNode)(termNode, context);
+                return term;
+            }
+        },
+        {
+            key: "fromPropertyAssertionNode",
+            value: function fromPropertyAssertionNode(propertyAssertionNode, context) {
+                var termNode = propertyAssertionNode.getTermNode(), term = (0, _node.termFromTermNode)(termNode, context);
+                return term;
+            }
+        },
+        {
+            key: "fromContainedAssertionNode",
+            value: function fromContainedAssertionNode(containedAssertionNode, context) {
+                var term = null;
+                var termNode = containedAssertionNode.getTermNode();
+                if (termNode !== null) {
+                    term = (0, _node.termFromTermNode)(termNode, context);
+                }
+                return term;
+            }
+        },
+        {
+            key: "fromConstructorDeclarationNode",
+            value: function fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+                var Type = _ontology.default.Type, termNode = constructorDeclarationNode.getTermNode(), term = (0, _node.termFromTermNode)(termNode, context), type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
+                term.setType(type);
+                return term;
+            }
+        }
+    ]);
+    return Term;
+}(), _define_property(_Term, "name", "Term"), _Term));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/term.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport ontology from \"../ontology\";\nimport verifyMixins from \"../mixins/term/verify\";\n\nimport { define } from \"../ontology\";\nimport { termFromTermNode } from \"../utilities/node\";\nimport { termNodeFromTermString } from \"../context/partial/term\";\nimport { typeFromJSON, typeToTypeJSON } from \"../utilities/json\";\n\nconst { filter, compress } = arrayUtilities;\n\nexport default define(class Term {\n  constructor(string, node, type) {\n    this.string = string;\n    this.node = node;\n    this.type = type;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  setType(type) {\n    this.type = type;\n  }\n\n  getVariable(context) {\n    const { Variable } = ontology,\n          termNode = this.node, ///\n          variable = Variable.fromTermNode(termNode, context);\n\n    return variable;\n  }\n\n  getVariables(context) {\n    const termNode = this.node,\n          variableNodes = termNode.getVariableNodes(),\n          variables = variableNodes.map((variableNode) => {\n            const { Variable } = ontology,\n                  variable = Variable.fromVariableNode(variableNode, context);\n\n            return variable;\n          });\n\n    compress(variables, (variableA, variableB) => {\n      const variableAEqualToVariableB = variableA.isEqualTo(variableB);\n\n      if (variableAEqualToVariableB) {\n        return true;\n      }\n    });\n\n    return variables;\n  }\n\n  matchTermNode(termNode) {\n    const termNodeMatches = this.node.match(termNode);\n\n    return termNodeMatches;\n  }\n\n  isProvisional() { return this.type.isProvisional(); }\n\n  isEqualTo(term) {\n    const termString = term.getString(),\n          equalTo = (termString === this.string);\n\n    return equalTo;\n  }\n\n  isSimple() {\n    const termNode = this.node,\n          singularVariableNode = termNode.getSingularVariableNode(),\n          simple = (singularVariableNode !== null);\n\n    return simple;\n  }\n\n  isGrounded(definedVariables, context) {\n    const variables = this.getVariables(context);\n\n    filter(variables, (variable) => {\n      const definedVariablesIncludesVariable = definedVariables.includes(variable);\n\n      if (!definedVariablesIncludesVariable) {\n        return true;\n      }\n    });\n\n    const undefinedVariables = variables, ///\n          undefinedVariablesLength = undefinedVariables.length,\n          grounded = (undefinedVariablesLength <= 1);\n\n    return grounded;\n  }\n\n  isInitiallyGrounded(context) {\n    const variables = this.getVariables(context),\n          variablesLength = variables.length,\n          initiallyGrounded = (variablesLength === 0);\n\n    return initiallyGrounded;\n  }\n\n  isImplicitlyGrounded(definedVariables, context) {\n    const grounded = this.isGrounded(definedVariables, context),\n          implicitlyGrounded = grounded;  ///\n\n    return implicitlyGrounded;\n  }\n\n  verify(context, verifyAhead) {\n    let verifies;\n\n    const termString = this.string;  ///\n\n    context.trace(`Verifying the '${termString}' term...`);\n\n    verifies = verifyMixins.some((verifyMixin) => {\n      const term = this, ///\n            verifies = verifyMixin(term, context, verifyAhead);\n\n      if (verifies) {\n        return true;\n      }\n    });\n\n    if (verifies) {\n      context.debug(`...verified the '${termString}' term.`);\n    }\n\n    return verifies;\n  }\n\n  verifyGivenType(type, generalContext, specificContext) {\n    let verifiesGivenType;\n\n    const typeString = type.getString(),\n          termString = this.getString();  ///\n\n    specificContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);\n\n    const context = specificContext, ///\n          verifies = this.verify(context, () => {\n            let verifiesAhead;\n\n            const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);\n\n            if (typeEqualToOrSubTypeOfGivenTypeType) {\n              verifiesAhead = true;\n            }\n\n            return verifiesAhead;\n          });\n\n    verifiesGivenType = verifies; ///\n\n    if (verifiesGivenType) {\n      specificContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);\n    }\n\n    return verifiesGivenType;\n  }\n\n  toJSON() {\n    const typeJSON = typeToTypeJSON(this.type),\n          string = this.string, ///\n          type = typeJSON,  ///\n          json = {\n            type,\n            string\n          };\n\n    return json;\n  }\n\n  static name = \"Term\";\n\n  static fromJSON(json, context) {\n    const { string } = json,\n          termString = string,  ///\n          termNode = termNodeFromTermString(termString, context),\n          node = termNode,  ///\n          type = typeFromJSON(json, context),\n          term = new Term(string, node, type);\n\n    return term;\n  }\n\n  static fromTermNode(termNode, context) {\n    const term = termFromTermNode(termNode, context);\n\n    return term;\n  }\n\n  static fromTermNodeAndType(termNode, type, context) {\n    const node = termNode,  ///\n          string = context.nodeAsString(node),\n          term = new Term(string, node, type);\n\n    return term;\n  }\n\n  static fromTypeAssertionNode(typeAssertionNode, context) {\n    let term = null;\n\n    const termNode = typeAssertionNode.getTermNode();\n\n    if (termNode !== null) {\n      term = termFromTermNode(termNode, context);\n    }\n\n    return term;\n  }\n\n  static fromDefinedAssertionNode(definedAssertionNode, context) {\n    let term = null;\n\n    const termNode = definedAssertionNode.getTermNode();\n\n    if (termNode !== null) {\n      term = termFromTermNode(termNode, context);\n    }\n\n    return term;\n  }\n\n  static fromPropertyRelationNode(propertyRelationNode, context) {\n    const termNode = propertyRelationNode.getTermNode(),\n          term = termFromTermNode(termNode, context);\n\n    return term;\n  }\n\n  static fromPropertyAssertionNode(propertyAssertionNode, context) {\n    const termNode = propertyAssertionNode.getTermNode(),\n          term = termFromTermNode(termNode, context);\n\n    return term;\n  }\n\n  static fromContainedAssertionNode(containedAssertionNode, context) {\n    let term = null;\n\n    const termNode = containedAssertionNode.getTermNode();\n\n    if (termNode !== null) {\n      term = termFromTermNode(termNode, context);\n    }\n\n    return term;\n  }\n\n  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {\n    const { Type } = ontology,\n          termNode = constructorDeclarationNode.getTermNode(),\n          term = termFromTermNode(termNode, context),\n          type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);\n\n    term.setType(type);\n\n    return term;\n  }\n});\n\n"],"names":["filter","arrayUtilities","compress","define","Term","string","node","type","getString","getNode","getType","setType","getVariable","context","Variable","ontology","termNode","variable","fromTermNode","getVariables","variableNodes","getVariableNodes","variables","map","variableNode","fromVariableNode","variableA","variableB","variableAEqualToVariableB","isEqualTo","matchTermNode","termNodeMatches","match","isProvisional","term","termString","equalTo","isSimple","singularVariableNode","getSingularVariableNode","simple","isGrounded","definedVariables","definedVariablesIncludesVariable","includes","undefinedVariables","undefinedVariablesLength","length","grounded","isInitiallyGrounded","variablesLength","initiallyGrounded","isImplicitlyGrounded","implicitlyGrounded","verify","verifyAhead","verifies","trace","verifyMixins","some","verifyMixin","debug","verifyGivenType","generalContext","specificContext","verifiesGivenType","typeString","verifiesAhead","typeEqualToOrSubTypeOfGivenTypeType","isEqualToOrSubTypeOf","toJSON","typeJSON","typeToTypeJSON","json","fromJSON","termNodeFromTermString","typeFromJSON","termFromTermNode","fromTermNodeAndType","nodeAsString","fromTypeAssertionNode","typeAssertionNode","getTermNode","fromDefinedAssertionNode","definedAssertionNode","fromPropertyRelationNode","propertyRelationNode","fromPropertyAssertionNode","propertyAssertionNode","fromContainedAssertionNode","containedAssertionNode","fromConstructorDeclarationNode","constructorDeclarationNode","Type","name"],"mappings":"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"}

package/lib/{dom → ontology}/theorem.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _topLevelAssertion = /*#__PURE__*/ _interop_require_default(require("./topLevelAssertion"));
-var _dom = require("../dom");
+var _ontology = require("../ontology");
 function _assert_this_initialized(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -125,7 +125,7 @@ function _is_native_reflect_construct() {
     })();
 }
 var _Theorem;
-var _default = (0, _dom.domAssigned)((_Theorem = /*#__PURE__*/ function(TopLevelAssertion) {
+var _default = (0, _ontology.define)((_Theorem = /*#__PURE__*/ function(TopLevelAssertion) {
     _inherits(Theorem, TopLevelAssertion);
     function Theorem() {
         _class_call_check(this, Theorem);
@@ -165,4 +165,4 @@ var _default = (0, _dom.domAssigned)((_Theorem = /*#__PURE__*/ function(TopLevel
     return Theorem;
 }(_topLevelAssertion.default), _define_property(_Theorem, "name", "Theorem"), _Theorem));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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