occam-verify-cli 1.0.383 → 1.0.385

package/lib/ontology/assertion/contained.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../../ontology"));
+var _local = /*#__PURE__*/ _interop_require_default(require("../../context/local"));
+var _substitutions = require("../../utilities/substitutions");
+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 _ContainedAssertion;
+var _default = (0, _ontology.define)((_ContainedAssertion = /*#__PURE__*/ function() {
+    function ContainedAssertion(string, node, tokens, term, frame, negated, statement) {
+        _class_call_check(this, ContainedAssertion);
+        this.string = string;
+        this.node = node;
+        this.tokens = tokens;
+        this.term = term;
+        this.frame = frame;
+        this.negated = negated;
+        this.statement = statement;
+    }
+    _create_class(ContainedAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getTokens",
+            value: function getTokens() {
+                return this.tokens;
+            }
+        },
+        {
+            key: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getFrame",
+            value: function getFrame() {
+                return this.frame;
+            }
+        },
+        {
+            key: "isNegated",
+            value: function isNegated() {
+                return this.negated;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var containedAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(containedAssertionString, "' contained assertion..."));
+                var termVerifies = this.verifyTerm(assignments, stated, context), frameVerifies = this.verifyFrame(assignments, stated, context), statementVerifies = this.verifyStatement(assignments, stated, context);
+                if (termVerifies || frameVerifies || statementVerifies) {
+                    var verifiesWhenStated = false, verifiesWhenDerived = false;
+                    if (stated) {
+                        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+                    } else {
+                        verifiesWhenDerived = this.verifyWhenDerived(context);
+                    }
+                    if (verifiesWhenStated || verifiesWhenDerived) {
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(containedAssertionString, "' contained assertion."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyTerm",
+            value: function verifyTerm(assignments, stated, context) {
+                var termVerifies = false;
+                if (this.term !== null) {
+                    var termString = this.term.getString();
+                    context.trace("Verifying the '".concat(termString, "' term..."));
+                    var termSimple = this.term.isSimple();
+                    if (!termSimple) {
+                        context.debug("The '".concat(termString, "' term is not simple."));
+                    } else {
+                        termVerifies = this.term.verify(context, function() {
+                            var verifiesAhead = true;
+                            return verifiesAhead;
+                        });
+                        if (termVerifies) {
+                            context.debug("...verified the '".concat(termString, "' term."));
+                        }
+                    }
+                }
+                return termVerifies;
+            }
+        },
+        {
+            key: "verifyFrame",
+            value: function verifyFrame(assignments, stated, context) {
+                var frameVerifies = false;
+                if (this.frame !== null) {
+                    var frameString = this.frame.getString();
+                    context.trace("Verifying the '".concat(frameString, "' frame..."));
+                    var frameSimple = this.frame.isSimple();
+                    if (!frameSimple) {
+                        context.debug("The '".concat(frameString, "' frame is not simple."));
+                    } else {
+                        stated = true; ///
+                        assignments = null; ///
+                        frameVerifies = this.frame.verify(assignments, stated, context);
+                        if (frameVerifies) {
+                            context.debug("...verified the '".concat(frameString, "' frame."));
+                        }
+                    }
+                }
+                return frameVerifies;
+            }
+        },
+        {
+            key: "verifyStatement",
+            value: function verifyStatement(assignments, stated, context) {
+                var statementVerifies = false;
+                if (this.statement !== null) {
+                    var statementString = this.statement.getString();
+                    context.trace("Verifying the '".concat(statementString, "' statement..."));
+                    stated = true; ///
+                    assignments = null; ///
+                    statementVerifies = this.statement.verify(assignments, stated, context);
+                    if (statementVerifies) {
+                        context.debug("...verified the '".concat(statementString, "' statement."));
+                    }
+                }
+                return statementVerifies;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var verifiesWhenStated;
+                var containedAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(containedAssertionString, "' stated contained assertion..."));
+                verifiesWhenStated = true;
+                if (verifiesWhenStated) {
+                    context.debug("...verified the '".concat(containedAssertionString, "' stated contained assertion."));
+                }
+                return verifiesWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived1(context) {
+                var verifiesWhenDerived;
+                var containedAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(containedAssertionString, "' derived contained assertion..."));
+                verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, context);
+                if (verifiesWhenDerived) {
+                    context.debug("...verified the '".concat(containedAssertionString, "' derived contained assertion."));
+                }
+                return verifiesWhenDerived;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently;
+                var containedAssertionString = this.string; ///
+                context.trace("Unifying the '".concat(containedAssertionString, "' contained assertion independently..."));
+                var localContext = _local.default.fromContextAndTokens(context, this.tokens);
+                context = localContext; ///
+                var term = (0, _substitutions.termFromTermAndSubstitutions)(this.term, substitutions, context), frame = (0, _substitutions.frameFromFrameAndSubstitutions)(this.frame, substitutions, context), statement = (0, _substitutions.statementFromStatementAndSubstitutions)(this.statement, substitutions, context), verifiesWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, context);
+                unifiesIndependently = verifiesWhenDerived; ///
+                if (unifiesIndependently) {
+                    context.debug("...unified the '".concat(containedAssertionString, "' contained assertion independently."));
+                }
+                return unifiesIndependently;
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var containedAssertion = null;
+                var containedAssertionNode = statementNode.getContainedAssertionNode();
+                if (containedAssertionNode !== null) {
+                    var Term = _ontology.default.Term, Frame = _ontology.default.Frame, Statement = _ontology.default.Statement, node = containedAssertionNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node), negated = containedAssertionNode.isNegated(), term = Term.fromContainedAssertionNode(containedAssertionNode, context), frame = Frame.fromContainedAssertionNode(containedAssertionNode, context), statement = Statement.fromContainedAssertionNode(containedAssertionNode, context);
+                    containedAssertion = new ContainedAssertion(string, node, tokens, term, frame, negated, statement);
+                }
+                return containedAssertion;
+            }
+        }
+    ]);
+    return ContainedAssertion;
+}(), _define_property(_ContainedAssertion, "name", "ContainedAssertion"), _ContainedAssertion));
+function verifyWhenDerived(term, frame, statement, negated, context) {
+    var verifiesWhenDerived = false;
+    if (statement !== null) {
+        if (term !== null) {
+            var termContained = statement.isTermContained(term, context);
+            if (!negated && termContained) {
+                verifiesWhenDerived = true;
+            }
+            if (negated && !termContained) {
+                verifiesWhenDerived = true;
+            }
+        }
+        if (frame !== null) {
+            var frameContained = statement.isFrameContained(frame, context);
+            if (!negated && frameContained) {
+                verifiesWhenDerived = true;
+            }
+            if (negated && !frameContained) {
+                verifiesWhenDerived = true;
+            }
+        }
+    }
+    return verifiesWhenDerived;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/assertion/contained.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\nimport LocalContext from \"../../context/local\";\n\nimport { define } from \"../../ontology\";\nimport { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from \"../../utilities/substitutions\";\n\nexport default define(class ContainedAssertion {\n  constructor(string, node, tokens, term, frame, negated, statement) {\n    this.string = string;\n    this.node = node;\n    this.tokens = tokens;\n    this.term = term;\n    this.frame = frame;\n    this.negated = negated;\n    this.statement = statement;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getTokens() {\n    return this.tokens;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getFrame() {\n    return this.frame;\n  }\n\n  isNegated() {\n    return this.negated;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    const containedAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);\n\n    const termVerifies = this.verifyTerm(assignments, stated, context),\n          frameVerifies = this.verifyFrame(assignments, stated, context),\n          statementVerifies = this.verifyStatement(assignments, stated, context)\n\n    if (termVerifies || frameVerifies || statementVerifies) {\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      context.debug(`...verified the '${containedAssertionString}' contained assertion.`);\n    }\n\n    return verifies;\n  }\n\n  verifyTerm(assignments, stated, context) {\n    let termVerifies = false;\n\n    if (this.term !== null) {\n      const termString = this.term.getString();\n\n      context.trace(`Verifying the '${termString}' term...`);\n\n      const termSimple = this.term.isSimple();\n\n      if (!termSimple) {\n        context.debug(`The '${termString}' term is not simple.`);\n      } else {\n        termVerifies = this.term.verify(context, () => {\n          const verifiesAhead = true;\n\n          return verifiesAhead;\n        });\n\n        if (termVerifies) {\n          context.debug(`...verified the '${termString}' term.`);\n        }\n      }\n    }\n\n    return termVerifies;\n  }\n\n  verifyFrame(assignments, stated, context) {\n    let frameVerifies = false;\n\n    if (this.frame !== null) {\n      const frameString = this.frame.getString();\n\n      context.trace(`Verifying the '${frameString}' frame...`);\n\n      const frameSimple = this.frame.isSimple();\n\n      if (!frameSimple) {\n        context.debug(`The '${frameString}' frame is not simple.`);\n      } else {\n        stated = true;  ///\n\n        assignments = null; ///\n\n        frameVerifies = this.frame.verify(assignments, stated, context);\n\n        if (frameVerifies) {\n          context.debug(`...verified the '${frameString}' frame.`);\n        }\n      }\n    }\n\n    return frameVerifies;\n  }\n\n  verifyStatement(assignments, stated, context) {\n    let statementVerifies = false;\n\n    if (this.statement !== null) {\n      const statementString = this.statement.getString();\n\n      context.trace(`Verifying the '${statementString}' statement...`);\n\n      stated = true;  ///\n\n      assignments = null; ///\n\n      statementVerifies = this.statement.verify(assignments, stated, context);\n\n      if (statementVerifies) {\n        context.debug(`...verified the '${statementString}' statement.`);\n      }\n    }\n\n    return statementVerifies;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiesWhenStated;\n\n    const containedAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);\n\n    verifiesWhenStated = true;\n\n    if (verifiesWhenStated) {\n      context.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);\n    }\n\n    return verifiesWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiesWhenDerived;\n\n    const containedAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);\n\n    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, context);\n\n    if (verifiesWhenDerived) {\n      context.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);\n    }\n\n    return verifiesWhenDerived;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently;\n\n    const containedAssertionString = this.string; ///\n\n    context.trace(`Unifying the '${containedAssertionString}' contained assertion independently...`);\n\n    const localContext = LocalContext.fromContextAndTokens(context, this.tokens);\n\n    context = localContext; ///\n\n    const term = termFromTermAndSubstitutions(this.term, substitutions, context),\n          frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),\n          statement = statementFromStatementAndSubstitutions(this.statement, substitutions, context),\n          verifiesWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, context);\n\n    unifiesIndependently = verifiesWhenDerived; ///\n\n    if (unifiesIndependently) {\n      context.debug(`...unified the '${containedAssertionString}' contained assertion independently.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  static name = \"ContainedAssertion\";\n\n  static fromStatementNode(statementNode, context) {\n    let containedAssertion = null;\n\n    const containedAssertionNode = statementNode.getContainedAssertionNode();\n\n    if (containedAssertionNode !== null) {\n      const { Term, Frame, Statement } = ontology,\n            node = containedAssertionNode,  ///\n            string = context.nodeAsString(node),\n            tokens = context.nodeAsTokens(node),\n            negated = containedAssertionNode.isNegated(),\n            term = Term.fromContainedAssertionNode(containedAssertionNode, context),\n            frame = Frame.fromContainedAssertionNode(containedAssertionNode, context),\n            statement = Statement.fromContainedAssertionNode(containedAssertionNode, context);\n\n      containedAssertion = new ContainedAssertion(string, node, tokens, term, frame, negated, statement);\n    }\n\n    return containedAssertion;\n  }\n});\n\nfunction verifyWhenDerived(term, frame, statement, negated, context) {\n  let verifiesWhenDerived = false;\n\n  if (statement !== null) {\n    if (term !== null) {\n      const termContained = statement.isTermContained(term, context);\n\n      if (!negated && termContained) {\n        verifiesWhenDerived = true;\n      }\n\n      if (negated && !termContained) {\n        verifiesWhenDerived = true;\n      }\n    }\n\n    if (frame !== null) {\n      const frameContained = statement.isFrameContained(frame, context);\n\n      if (!negated && frameContained) {\n        verifiesWhenDerived = true;\n      }\n\n      if (negated && !frameContained) {\n        verifiesWhenDerived = true;\n      }\n    }\n  }\n\n  return verifiesWhenDerived;\n}"],"names":["define","ContainedAssertion","string","node","tokens","term","frame","negated","statement","getString","getNode","getTokens","getTerm","getFrame","isNegated","getStatement","verify","assignments","stated","context","verifies","containedAssertionString","trace","termVerifies","verifyTerm","frameVerifies","verifyFrame","statementVerifies","verifyStatement","verifiesWhenStated","verifiesWhenDerived","verifyWhenStated","verifyWhenDerived","debug","termString","termSimple","isSimple","verifiesAhead","frameString","frameSimple","statementString","unifyIndependently","substitutions","unifiesIndependently","localContext","LocalContext","fromContextAndTokens","termFromTermAndSubstitutions","frameFromFrameAndSubstitutions","statementFromStatementAndSubstitutions","fromStatementNode","statementNode","containedAssertion","containedAssertionNode","getContainedAssertionNode","Term","ontology","Frame","Statement","nodeAsString","nodeAsTokens","fromContainedAssertionNode","name","termContained","isTermContained","frameContained","isFrameContained"],"mappings":"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"}