occam-verify-cli 1.0.421 → 1.0.428

package/lib/element/assertion/type.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
+var _assertion = /*#__PURE__*/ _interop_require_default(require("../assertion"));
+var _assign = require("../../process/assign");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+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;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _TypeAssertion;
+var _default = (0, _elements.define)((_TypeAssertion = /*#__PURE__*/ function(Assertion) {
+    _inherits(TypeAssertion, Assertion);
+    function TypeAssertion(string, node, term, type) {
+        _class_call_check(this, TypeAssertion);
+        var _this;
+        _this = _call_super(this, TypeAssertion, [
+            string,
+            node
+        ]);
+        _this.term = term;
+        _this.type = type;
+        return _this;
+    }
+    _create_class(TypeAssertion, [
+        {
+            key: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var typeAssertionString = this.getString(); ///
+                context.trace("Verifying the '".concat(typeAssertionString, "' type assertion..."));
+                var typeVerifies = this.verifyType(context);
+                if (typeVerifies) {
+                    var verifiesWhenStated = false, verifiesWhenDerived = false;
+                    if (stated) {
+                        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+                    } else {
+                        verifiesWhenDerived = this.verifyWhenDerived(context);
+                    }
+                    if (verifiesWhenStated || verifiesWhenDerived) {
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    if (stated) {
+                        this.assign(assignments, context);
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(typeAssertionString, "' type assertion."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyType",
+            value: function verifyType(context) {
+                var typeVerifies;
+                var typeString = this.type.getString();
+                context.trace("Verifying the '".concat(typeString, "' type..."));
+                var nominalTypeName = this.type.getNominalTypeName(), type = context.findTypeByNominalTypeName(nominalTypeName);
+                if (type !== null) {
+                    this.type = type;
+                    typeVerifies = true;
+                } else {
+                    context.debug("The '".concat(typeString, "' type is not present."));
+                }
+                if (typeVerifies) {
+                    context.debug("...verified the '".concat(typeString, "' type."));
+                }
+                return typeVerifies;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var _this = this;
+                var verifiesWhenStated = false;
+                var typeAssertionString = this.getString(); ///
+                context.trace("Verifying the '".concat(typeAssertionString, "' stated type assertion..."));
+                var termVerifies = this.term.verify(context, function() {
+                    var verifiesAhead;
+                    var termType = _this.term.getType(), typeEqualToOrSubTypeOfTermType = _this.type.isEqualToOrSubTypeOf(termType);
+                    if (typeEqualToOrSubTypeOfTermType) {
+                        verifiesAhead = true;
+                    }
+                    return verifiesAhead;
+                });
+                if (termVerifies) {
+                    verifiesWhenStated = true;
+                }
+                if (verifiesWhenStated) {
+                    context.debug("...verified the '".concat(typeAssertionString, "' stated type assertion."));
+                }
+                return verifiesWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(context) {
+                var _this = this;
+                var verifiesWhenDerived;
+                var typeAssertionString = this.getString(); ///
+                context.trace("Verifying the '".concat(typeAssertionString, "' derived type assertion..."));
+                var termVerifies = this.term.verify(context, function() {
+                    var verifiesAhead = false;
+                    var termType = _this.term.getType(), termTypeProvisional = termType.isProvisional();
+                    if (!termTypeProvisional) {
+                        var typeEqualToOrSuperTypeOfTermType = _this.type.isEqualToOrSuperTypeOf(termType);
+                        verifiesAhead = typeEqualToOrSuperTypeOfTermType; ///
+                    }
+                    return verifiesAhead;
+                });
+                verifiesWhenDerived = termVerifies; ///
+                if (verifiesWhenDerived) {
+                    context.debug("...verified the '".concat(typeAssertionString, "' derived type assertion."));
+                }
+                return verifiesWhenDerived;
+            }
+        },
+        {
+            key: "assign",
+            value: function assign(assignments, context) {
+                if (assignments === null) {
+                    return;
+                }
+                var Type = _elements.default.Type, Variable = _elements.default.Variable, termNode = this.term.getNode();
+                var type, provisional;
+                provisional = this.type.isProvisional();
+                if (!provisional) {
+                    type = this.type;
+                } else {
+                    provisional = false;
+                    type = Type.fromTypeAndProvisional(this.type, provisional);
+                }
+                var singularVariableNode = termNode.getSingularVariableNode();
+                if (singularVariableNode !== null) {
+                    var variableNode = singularVariableNode, variable = Variable.fromVariableNodeAndType(variableNode, type, context), variableAssignment = (0, _assign.variableAssignmentFromVariable)(variable), assignment = variableAssignment; ///
+                    assignments.push(assignment);
+                }
+            }
+        }
+    ]);
+    return TypeAssertion;
+}(_assertion.default), _define_property(_TypeAssertion, "name", "TypeAssertion"), _TypeAssertion));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../../elements\";\nimport Assertion from \"../assertion\";\n\nimport { define } from \"../../elements\";\nimport { variableAssignmentFromVariable } from \"../../process/assign\";\n\nexport default define(class TypeAssertion extends Assertion {\n  constructor(string, node, term, type) {\n    super(string, node);\n\n    this.term = term;\n    this.type = type;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    let typeAssertionString = this.getString();  ///\n\n    context.trace(`Verifying the '${typeAssertionString}' type assertion...`);\n\n    const typeVerifies = this.verifyType(context);\n\n    if (typeVerifies) {\n      let verifiesWhenStated = false,\n          verifiesWhenDerived = false;\n\n      if (stated) {\n        verifiesWhenStated = this.verifyWhenStated(assignments, context);\n      } else {\n        verifiesWhenDerived = this.verifyWhenDerived(context);\n      }\n\n      if (verifiesWhenStated || verifiesWhenDerived) {\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n      if (stated) {\n        this.assign(assignments, context);\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${typeAssertionString}' type assertion.`);\n    }\n\n    return verifies;\n  }\n\n  verifyType(context) {\n    let typeVerifies;\n\n    const typeString = this.type.getString();\n\n    context.trace(`Verifying the '${typeString}' type...`);\n\n    const nominalTypeName = this.type.getNominalTypeName(),\n          type = context.findTypeByNominalTypeName(nominalTypeName);\n\n    if (type !== null) {\n      this.type = type;\n\n      typeVerifies = true;\n    } else {\n      context.debug(`The '${typeString}' type is not present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${typeString}' type.`);\n    }\n\n    return typeVerifies;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiesWhenStated = false;\n\n    const typeAssertionString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);\n\n    const termVerifies = this.term.verify(context, () => {\n      let verifiesAhead;\n\n      const termType = this.term.getType(),\n            typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);\n\n      if (typeEqualToOrSubTypeOfTermType) {\n        verifiesAhead = true;\n      }\n\n      return verifiesAhead;\n    });\n\n    if (termVerifies) {\n      verifiesWhenStated = true;\n    }\n\n    if (verifiesWhenStated) {\n      context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);\n    }\n\n    return verifiesWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiesWhenDerived;\n\n    const typeAssertionString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);\n\n    const termVerifies = this.term.verify(context, () => {\n      let verifiesAhead = false;\n\n      const termType = this.term.getType(),\n            termTypeProvisional = termType.isProvisional();\n\n      if (!termTypeProvisional) {\n        const typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);\n\n        verifiesAhead = typeEqualToOrSuperTypeOfTermType; ///\n      }\n\n      return verifiesAhead;\n    });\n\n    verifiesWhenDerived = termVerifies; ///\n\n    if (verifiesWhenDerived) {\n      context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);\n    }\n\n    return verifiesWhenDerived;\n  }\n\n  assign(assignments, context) {\n    if (assignments === null) {\n      return;\n    }\n\n    const { Type, Variable } = elements,\n          termNode = this.term.getNode();\n\n    let type,\n        provisional;\n\n    provisional = this.type.isProvisional();\n\n    if (!provisional) {\n      type = this.type;\n    } else {\n      provisional = false;\n\n      type = Type.fromTypeAndProvisional(this.type, provisional);\n    }\n\n    const singularVariableNode = termNode.getSingularVariableNode();\n\n    if (singularVariableNode !== null) {\n      const variableNode = singularVariableNode,  ///\n            variable = Variable.fromVariableNodeAndType(variableNode, type, context),\n            variableAssignment = variableAssignmentFromVariable(variable),\n            assignment = variableAssignment;  ///\n\n      assignments.push(assignment);\n    }\n  }\n\n  static name = \"TypeAssertion\";\n});\n"],"names":["define","TypeAssertion","string","node","term","type","getTerm","getType","verify","assignments","stated","context","verifies","typeAssertionString","getString","trace","typeVerifies","verifyType","verifiesWhenStated","verifiesWhenDerived","verifyWhenStated","verifyWhenDerived","assign","debug","typeString","nominalTypeName","getNominalTypeName","findTypeByNominalTypeName","termVerifies","verifiesAhead","termType","typeEqualToOrSubTypeOfTermType","isEqualToOrSubTypeOf","termTypeProvisional","isProvisional","typeEqualToOrSuperTypeOfTermType","isEqualToOrSuperTypeOf","Type","elements","Variable","termNode","getNode","provisional","fromTypeAndProvisional","singularVariableNode","getSingularVariableNode","variableNode","variable","fromVariableNodeAndType","variableAssignment","variableAssignmentFromVariable","assignment","push","Assertion","name"],"mappings":"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"}

package/lib/{ontology → element}/assertion.js

@@ -28,13 +28,19 @@ function _create_class(Constructor, protoProps, staticProps) {
     return Constructor;
 }
 var Assertion = /*#__PURE__*/ function() {
-    function Assertion(string, node, tokens) {
+    function Assertion(context, string, node) {
         _class_call_check(this, Assertion);
+        this.context = context;
         this.string = string;
         this.node = node;
-        this.tokens = tokens;
     }
     _create_class(Assertion, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
         {
             key: "getString",
             value: function getString() {
@@ -47,12 +53,6 @@ var Assertion = /*#__PURE__*/ function() {
                 return this.node;
             }
         },
-        {
-            key: "getTokens",
-            value: function getTokens() {
-                return this.tokens;
-            }
-        },
         {
             key: "matchAssertionNode",
             value: function matchAssertionNode(assertionNode) {
@@ -63,4 +63,4 @@ var Assertion = /*#__PURE__*/ function() {
     return Assertion;
 }();
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vbnRvbG9neS9hc3NlcnRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFzc2VydGlvbiB7XG4gIGNvbnN0cnVjdG9yKHN0cmluZywgbm9kZSwgdG9rZW5zKSB7XG4gICAgdGhpcy5zdHJpbmcgPSBzdHJpbmc7XG4gICAgdGhpcy5ub2RlID0gbm9kZTtcbiAgICB0aGlzLnRva2VucyA9IHRva2VucztcbiAgfVxuXG4gIGdldFN0cmluZygpIHtcbiAgICByZXR1cm4gdGhpcy5zdHJpbmc7XG4gIH1cblxuICBnZXROb2RlKCkge1xuICAgIHJldHVybiB0aGlzLm5vZGU7XG4gIH1cblxuICBnZXRUb2tlbnMoKSB7XG4gICAgcmV0dXJuIHRoaXMudG9rZW5zO1xuICB9XG5cbiAgbWF0Y2hBc3NlcnRpb25Ob2RlKGFzc2VydGlvbk5vZGUpIHsgcmV0dXJuIHRoaXMubm9kZS5tYXRjaChhc3NlcnRpb25Ob2RlKTsgfVxufVxuIl0sIm5hbWVzIjpbIkFzc2VydGlvbiIsInN0cmluZyIsIm5vZGUiLCJ0b2tlbnMiLCJnZXRTdHJpbmciLCJnZXROb2RlIiwiZ2V0VG9rZW5zIiwibWF0Y2hBc3NlcnRpb25Ob2RlIiwiYXNzZXJ0aW9uTm9kZSIsIm1hdGNoIl0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7OztlQUVxQkE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBTixJQUFBLEFBQU1BLDBCQUFOO2FBQU1BLFVBQ1BDLE1BQU0sRUFBRUMsSUFBSSxFQUFFQyxNQUFNO2dDQURiSDtRQUVqQixJQUFJLENBQUNDLE1BQU0sR0FBR0E7UUFDZCxJQUFJLENBQUNDLElBQUksR0FBR0E7UUFDWixJQUFJLENBQUNDLE1BQU0sR0FBR0E7O2tCQUpHSDs7WUFPbkJJLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0gsTUFBTTtZQUNwQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0gsSUFBSTtZQUNsQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0gsTUFBTTtZQUNwQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQSxtQkFBbUJDLGFBQWE7Z0JBQUksT0FBTyxJQUFJLENBQUNOLElBQUksQ0FBQ08sS0FBSyxDQUFDRDtZQUFnQjs7O1dBbkJ4RFIifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbGVtZW50L2Fzc2VydGlvbi5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXNzZXJ0aW9uIHtcbiAgY29uc3RydWN0b3IoY29udGV4dCwgc3RyaW5nLCBub2RlKSB7XG4gICAgdGhpcy5jb250ZXh0ID0gY29udGV4dDtcbiAgICB0aGlzLnN0cmluZyA9IHN0cmluZztcbiAgICB0aGlzLm5vZGUgPSBub2RlO1xuICB9XG5cbiAgZ2V0Q29udGV4dCgpIHtcbiAgICByZXR1cm4gdGhpcy5jb250ZXh0O1xuICB9XG5cbiAgZ2V0U3RyaW5nKCkge1xuICAgIHJldHVybiB0aGlzLnN0cmluZztcbiAgfVxuXG4gIGdldE5vZGUoKSB7XG4gICAgcmV0dXJuIHRoaXMubm9kZTtcbiAgfVxuXG4gIG1hdGNoQXNzZXJ0aW9uTm9kZShhc3NlcnRpb25Ob2RlKSB7IHJldHVybiB0aGlzLm5vZGUubWF0Y2goYXNzZXJ0aW9uTm9kZSk7IH1cbn1cbiJdLCJuYW1lcyI6WyJBc3NlcnRpb24iLCJjb250ZXh0Iiwic3RyaW5nIiwibm9kZSIsImdldENvbnRleHQiLCJnZXRTdHJpbmciLCJnZXROb2RlIiwibWF0Y2hBc3NlcnRpb25Ob2RlIiwiYXNzZXJ0aW9uTm9kZSIsIm1hdGNoIl0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7OztlQUVxQkE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBTixJQUFBLEFBQU1BLDBCQUFOO2FBQU1BLFVBQ1BDLE9BQU8sRUFBRUMsTUFBTSxFQUFFQyxJQUFJO2dDQURkSDtRQUVqQixJQUFJLENBQUNDLE9BQU8sR0FBR0E7UUFDZixJQUFJLENBQUNDLE1BQU0sR0FBR0E7UUFDZCxJQUFJLENBQUNDLElBQUksR0FBR0E7O2tCQUpLSDs7WUFPbkJJLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0gsT0FBTztZQUNyQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0gsTUFBTTtZQUNwQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0gsSUFBSTtZQUNsQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQSxtQkFBbUJDLGFBQWE7Z0JBQUksT0FBTyxJQUFJLENBQUNMLElBQUksQ0FBQ00sS0FBSyxDQUFDRDtZQUFnQjs7O1dBbkJ4RFIifQ==