occam-verify-cli 1.0.444 → 1.0.457

package/lib/context/transient.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return TransientContext;
+    }
+});
+var _necessary = require("necessary");
+var _context = require("../utilities/context");
+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 _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 extract = _necessary.arrayUtilities.extract, compress = _necessary.arrayUtilities.compress;
+var TransientContext = /*#__PURE__*/ function() {
+    function TransientContext(context, terms, frames, statements, assertions, references, substitutions) {
+        _class_call_check(this, TransientContext);
+        this.context = context;
+        this.terms = terms;
+        this.frames = frames;
+        this.statements = statements;
+        this.assertions = assertions;
+        this.references = references;
+        this.substitutions = substitutions;
+        return (0, _context.chainContext)(this);
+    }
+    _create_class(TransientContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getTerms",
+            value: function getTerms() {
+                return this.terms;
+            }
+        },
+        {
+            key: "getFrames",
+            value: function getFrames() {
+                return this.frames;
+            }
+        },
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                return this.statements;
+            }
+        },
+        {
+            key: "getAssertions",
+            value: function getAssertions() {
+                return this.assertions;
+            }
+        },
+        {
+            key: "getReferences",
+            value: function getReferences() {
+                return this.references;
+            }
+        },
+        {
+            key: "getSubstitutions",
+            value: function getSubstitutions() {
+                return this.substitutions;
+            }
+        },
+        {
+            key: "addTerm",
+            value: function addTerm(term) {
+                var termA = term, context = this, termString = term.getString();
+                extract(this.terms, function(term) {
+                    var termB = term, termAEqualToTermB = termA.isEqualTo(termB);
+                    if (termAEqualToTermB) {
+                        return true;
+                    }
+                });
+                context.trace("ADded the '".concat(termString, "' term to the context."));
+                this.terms.push(term);
+            }
+        },
+        {
+            key: "addFrame",
+            value: function addFrame(frame) {
+                var frameA = frame, context = this, frameString = frame.getString();
+                extract(this.frames, function(frame) {
+                    var frameB = frame, frameAEqualToFrameB = frameA.isEqualTo(frameB);
+                    if (frameAEqualToFrameB) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(frameString, "' frame to the context."));
+                this.frames.push(frame);
+            }
+        },
+        {
+            key: "addStatement",
+            value: function addStatement(statement) {
+                var context = this, statementA = statement, statementString = statement.getString();
+                extract(this.statements, function(statement) {
+                    var statementB = statement, statementAEqualToFrameB = statementA.isEqualTo(statementB);
+                    if (statementAEqualToFrameB) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(statementString, "' statement to the context."));
+                this.statements.push(statement);
+            }
+        },
+        {
+            key: "addAssertion",
+            value: function addAssertion(assertion) {
+                var context = this, assertionA = assertion, assertionString = assertion.getString();
+                extract(this.assertions, function(assertion) {
+                    var assertionB = assertion, assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+                    if (assertionAEqualToAssertionB) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(assertionString, "' assertion to the context."));
+                this.assertions.push(assertion);
+            }
+        },
+        {
+            key: "addReference",
+            value: function addReference(reference) {
+                var context = this, referenceA = reference, referenceString = reference.getString();
+                extract(this.references, function(reference) {
+                    var referenceB = reference, referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+                    if (referenceAEqualToReferenceB) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(referenceString, "' reference to the context."));
+                this.references.push(reference);
+            }
+        },
+        {
+            key: "addSubstitution",
+            value: function addSubstitution(substitution) {
+                var context = this, substitutionA = substitution, substitutionString = substitution.getString();
+                extract(this.substitutions, function(substitution) {
+                    var substitutionB = substitution, substituionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+                    if (substituionAEqualToSubstitutionB) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(substitutionString, "' substitution to the context."));
+                this.substitutions.push(substitution);
+            }
+        },
+        {
+            key: "findTermByTermNode",
+            value: function findTermByTermNode(termNode) {
+                var term = this.terms.find(function(term) {
+                    var termNodeMatches = term.matchNode(termNode);
+                    if (termNodeMatches) {
+                        return true;
+                    }
+                }) || null;
+                return term;
+            }
+        },
+        {
+            key: "findFrameByFrameNode",
+            value: function findFrameByFrameNode(frameNode) {
+                var frame = this.frames.find(function(frame) {
+                    var frameNodeMatches = frame.matchNode(frameNode);
+                    if (frameNodeMatches) {
+                        return true;
+                    }
+                }) || null;
+                return frame;
+            }
+        },
+        {
+            key: "findStatementByStatementNode",
+            value: function findStatementByStatementNode(statementNode) {
+                var statement = this.statements.find(function(statement) {
+                    var statementNodeMatches = statement.matchNode(statementNode);
+                    if (statementNodeMatches) {
+                        return true;
+                    }
+                }) || null;
+                return statement;
+            }
+        },
+        {
+            key: "findAssertionByAssertionNode",
+            value: function findAssertionByAssertionNode(assertionNode) {
+                var assertion = this.assertions.find(function(assertion) {
+                    var assertionNodeMatches = assertion.matchNode(assertionNode);
+                    if (assertionNodeMatches) {
+                        return true;
+                    }
+                }) || null;
+                return assertion;
+            }
+        },
+        {
+            key: "findReferenceByMetavariableNode",
+            value: function findReferenceByMetavariableNode(metavariableNode) {
+                var reference = this.references.find(function(reference) {
+                    var referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
+                    if (referenceMatcheMetavariableNode) {
+                        return true;
+                    }
+                }) || null;
+                return reference;
+            }
+        },
+        {
+            key: "findSubstitutionBySubstitutionNode",
+            value: function findSubstitutionBySubstitutionNode(substitutionNode) {
+                var substitution = this.substitutions.find(function(substitution) {
+                    var substitutionNodeMatches = substitution.matchNode(substitutionNode);
+                    if (substitutionNodeMatches) {
+                        return true;
+                    }
+                }) || null;
+                return substitution;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                var nested = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                return this.context.getVariables(nested);
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                return this.context.addVariable(variable, nested);
+            }
+        },
+        {
+            key: "findVariableByVariableIdentifier",
+            value: function findVariableByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                return this.context.findVariableByVariableIdentifier(variableIdentifier, nested);
+            }
+        },
+        {
+            key: "isTypePresentByTypeName",
+            value: function isTypePresentByTypeName(typeName) {
+                var includeRelease = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, includeDependencies = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+                return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
+            }
+        },
+        {
+            key: "isVariablePresentByVariableIdentifier",
+            value: function isVariablePresentByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                return this.context.findVariableByVariableIdentifier(variableIdentifier, nested);
+            }
+        },
+        {
+            key: "merge",
+            value: function merge(context) {
+                var terms = context.getTerms(), frames = context.getFrames(), statements = context.getStatements(), assertions = context.getAssertions(), references = context.getReferences(), substitutions = context.getSubstitutions();
+                this.terms = _to_consumable_array(this.terms).concat(_to_consumable_array(terms));
+                this.frames = _to_consumable_array(this.frames).concat(_to_consumable_array(frames));
+                this.statements = _to_consumable_array(this.statements).concat(_to_consumable_array(statements));
+                this.assertions = _to_consumable_array(this.assertions).concat(_to_consumable_array(assertions));
+                this.references = _to_consumable_array(this.references).concat(_to_consumable_array(references));
+                this.substitutions = _to_consumable_array(this.substitutions).concat(_to_consumable_array(substitutions));
+                compress(this.terms, function(termA, termB) {
+                    var termAEqualToTermB = termA.isEqualTo(termB);
+                    if (!termAEqualToTermB) {
+                        return true;
+                    }
+                });
+                compress(this.frames, function(frameA, frameB) {
+                    var frameAEqualToFrameB = frameA.isEqualTo(frameB);
+                    if (!frameAEqualToFrameB) {
+                        return true;
+                    }
+                });
+                compress(this.statements, function(statementA, statementB) {
+                    var statementAEqualToStatementB = statementA.isEqualTo(statementB);
+                    if (!statementAEqualToStatementB) {
+                        return true;
+                    }
+                });
+                compress(this.assertions, function(assertionA, assertionB) {
+                    var assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+                    if (!assertionAEqualToAssertionB) {
+                        return true;
+                    }
+                });
+                compress(this.references, function(referenceA, referenceB) {
+                    var referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+                    if (!referenceAEqualToReferenceB) {
+                        return true;
+                    }
+                });
+                compress(this.substitutions, function(substitutionA, substitutionB) {
+                    var substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+                    if (!substitutionAEqualToSubstitutionB) {
+                        return true;
+                    }
+                });
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(context) {
+                var terms = [], frames = [], statements = [], assertions = [], references = [], substitutions = [], transientContext = new TransientContext(context, terms, frames, statements, assertions, references, substitutions);
+                return transientContext;
+            }
+        },
+        {
+            key: "fromTermsAndFrames",
+            value: function fromTermsAndFrames(terms, frames, context) {
+                var statements = [], assertions = [], references = [], substitutions = [], transientContext = new TransientContext(context, terms, frames, statements, assertions, references, substitutions);
+                return transientContext;
+            }
+        }
+    ]);
+    return TransientContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/transient.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport { chainContext } from \"../utilities/context\";\n\nconst { extract, compress } = arrayUtilities;\n\nexport default class TransientContext {\n  constructor(context, terms, frames, statements, assertions, references, substitutions) {\n    this.context = context;\n    this.terms = terms;\n    this.frames = frames;\n    this.statements = statements;\n    this.assertions = assertions;\n    this.references = references;\n    this.substitutions = substitutions;\n\n    return chainContext(this);\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getTerms() {\n    return this.terms;\n  }\n\n  getFrames() {\n    return this.frames;\n  }\n\n  getStatements() {\n    return this.statements;\n  }\n\n  getAssertions() {\n    return this.assertions;\n  }\n\n  getReferences() {\n    return this.references;\n  }\n\n  getSubstitutions() {\n    return this.substitutions;\n  }\n\n  addTerm(term) {\n    const termA = term, ///\n          context = this, ///\n          termString = term.getString();\n\n    extract(this.terms, (term) => {\n      const termB = term, ///\n            termAEqualToTermB = termA.isEqualTo(termB);\n\n      if (termAEqualToTermB) {\n        return true;\n      }\n    });\n\n    context.trace(`ADded the '${termString}' term to the context.`);\n\n    this.terms.push(term);\n  }\n\n  addFrame(frame) {\n    const frameA = frame, ///\n          context = this, ///\n          frameString = frame.getString();\n\n    extract(this.frames, (frame) => {\n      const frameB = frame, ///\n            frameAEqualToFrameB = frameA.isEqualTo(frameB);\n\n      if (frameAEqualToFrameB) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${frameString}' frame to the context.`);\n\n    this.frames.push(frame);\n  }\n\n  addStatement(statement) {\n    const context = this, ///\n          statementA = statement, ///\n          statementString = statement.getString();\n\n    extract(this.statements, (statement) => {\n      const statementB = statement, ///\n            statementAEqualToFrameB = statementA.isEqualTo(statementB);\n\n      if (statementAEqualToFrameB) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${statementString}' statement to the context.`);\n\n    this.statements.push(statement);\n  }\n\n  addAssertion(assertion) {\n    const context = this, ///\n          assertionA = assertion, ///\n          assertionString = assertion.getString();\n\n    extract(this.assertions, (assertion) => {\n      const assertionB = assertion, ///\n            assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);\n\n      if (assertionAEqualToAssertionB) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${assertionString}' assertion to the context.`);\n\n    this.assertions.push(assertion);\n  }\n\n  addReference(reference) {\n    const context = this, ///\n          referenceA = reference, ///\n          referenceString = reference.getString();\n\n    extract(this.references, (reference) => {\n      const referenceB = reference, ///\n            referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);\n\n      if (referenceAEqualToReferenceB) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${referenceString}' reference to the context.`);\n\n    this.references.push(reference);\n  }\n\n  addSubstitution(substitution) {\n    const context = this, ///\n          substitutionA = substitution, ///\n          substitutionString = substitution.getString();\n\n    extract(this.substitutions, (substitution) => {\n      const substitutionB = substitution, ///\n            substituionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);\n\n      if (substituionAEqualToSubstitutionB) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${substitutionString}' substitution to the context.`);\n\n    this.substitutions.push(substitution);\n  }\n\n  findTermByTermNode(termNode) {\n    const term = this.terms.find((term) => {\n      const termNodeMatches = term.matchNode(termNode);\n\n      if (termNodeMatches) {\n        return true;\n      }\n    }) || null;\n\n    return term;\n  }\n\n  findFrameByFrameNode(frameNode) {\n    const frame = this.frames.find((frame) => {\n      const frameNodeMatches = frame.matchNode(frameNode);\n\n      if (frameNodeMatches) {\n        return true;\n      }\n    }) || null;\n\n    return frame;\n  }\n\n  findStatementByStatementNode(statementNode) {\n    const statement = this.statements.find((statement) => {\n      const statementNodeMatches = statement.matchNode(statementNode);\n\n      if (statementNodeMatches) {\n        return true;\n      }\n    }) || null;\n\n    return statement;\n  }\n\n  findAssertionByAssertionNode(assertionNode) {\n    const assertion = this.assertions.find((assertion) => {\n      const assertionNodeMatches = assertion.matchNode(assertionNode);\n\n      if (assertionNodeMatches) {\n        return true;\n      }\n    }) || null;\n\n    return assertion;\n  }\n\n  findReferenceByMetavariableNode(metavariableNode) {\n    const reference = this.references.find((reference) => {\n      const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);\n\n      if (referenceMatcheMetavariableNode) {\n        return true;\n      }\n    }) || null;\n\n    return reference;\n  }\n\n  findSubstitutionBySubstitutionNode(substitutionNode) {\n    const substitution = this.substitutions.find((substitution) => {\n      const substitutionNodeMatches = substitution.matchNode(substitutionNode);\n\n      if (substitutionNodeMatches) {\n        return true;\n      }\n    }) || null;\n\n    return substitution;\n  }\n\n  getVariables(nested = true) { return this.context.getVariables(nested); }\n\n  addVariable(variable, nested = true) { return this.context.addVariable(variable, nested); }\n\n  findVariableByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }\n\n  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }\n\n  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }\n\n  merge(context) {\n    const terms = context.getTerms(),\n          frames = context.getFrames(),\n          statements = context.getStatements(),\n          assertions = context.getAssertions(),\n          references = context.getReferences(),\n          substitutions = context.getSubstitutions();\n\n    this.terms = [\n      ...this.terms,\n      ...terms\n    ];\n\n    this.frames = [\n      ...this.frames,\n      ...frames\n    ];\n\n    this.statements = [\n      ...this.statements,\n      ...statements\n    ];\n\n    this.assertions = [\n      ...this.assertions,\n      ...assertions\n    ];\n\n    this.references = [\n      ...this.references,\n      ...references\n    ];\n\n    this.substitutions = [\n      ...this.substitutions,\n      ...substitutions\n    ];\n\n    compress(this.terms, (termA, termB) => {\n      const termAEqualToTermB = termA.isEqualTo(termB);\n\n      if (!termAEqualToTermB) {\n        return true;\n      }\n    });\n\n    compress(this.frames, (frameA, frameB) => {\n      const frameAEqualToFrameB = frameA.isEqualTo(frameB);\n\n      if (!frameAEqualToFrameB) {\n        return true;\n      }\n    });\n\n    compress(this.statements, (statementA, statementB) => {\n      const statementAEqualToStatementB = statementA.isEqualTo(statementB);\n\n      if (!statementAEqualToStatementB) {\n        return true;\n      }\n    });\n\n    compress(this.assertions, (assertionA, assertionB) => {\n      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);\n\n      if (!assertionAEqualToAssertionB) {\n        return true;\n      }\n    });\n\n    compress(this.references, (referenceA, referenceB) => {\n      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);\n\n      if (!referenceAEqualToReferenceB) {\n        return true;\n      }\n    });\n\n    compress(this.substitutions, (substitutionA, substitutionB) => {\n      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);\n\n      if (!substitutionAEqualToSubstitutionB) {\n        return true;\n      }\n    });\n  }\n\n  static fromNothing(context) {\n    const terms = [],\n          frames = [],\n          statements = [],\n          assertions = [],\n          references = [],\n          substitutions = [],\n          transientContext = new TransientContext(context, terms, frames, statements, assertions, references, substitutions);\n\n    return transientContext;\n  }\n\n  static fromTermsAndFrames(terms, frames, context) {\n    const statements = [],\n          assertions = [],\n          references = [],\n          substitutions = [],\n          transientContext = new TransientContext(context, terms, frames, statements, assertions, references, substitutions);\n\n    return transientContext;\n  }\n}\n"],"names":["TransientContext","extract","arrayUtilities","compress","context","terms","frames","statements","assertions","references","substitutions","chainContext","getContext","getTerms","getFrames","getStatements","getAssertions","getReferences","getSubstitutions","addTerm","term","termA","termString","getString","termB","termAEqualToTermB","isEqualTo","trace","push","addFrame","frame","frameA","frameString","frameB","frameAEqualToFrameB","addStatement","statement","statementA","statementString","statementB","statementAEqualToFrameB","addAssertion","assertion","assertionA","assertionString","assertionB","assertionAEqualToAssertionB","addReference","reference","referenceA","referenceString","referenceB","referenceAEqualToReferenceB","addSubstitution","substitution","substitutionA","substitutionString","substitutionB","substituionAEqualToSubstitutionB","findTermByTermNode","termNode","find","termNodeMatches","matchNode","findFrameByFrameNode","frameNode","frameNodeMatches","findStatementByStatementNode","statementNode","statementNodeMatches","findAssertionByAssertionNode","assertionNode","assertionNodeMatches","findReferenceByMetavariableNode","metavariableNode","referenceMatcheMetavariableNode","matchMetavariableNode","findSubstitutionBySubstitutionNode","substitutionNode","substitutionNodeMatches","getVariables","nested","addVariable","variable","findVariableByVariableIdentifier","variableIdentifier","isTypePresentByTypeName","typeName","includeRelease","includeDependencies","isVariablePresentByVariableIdentifier","merge","statementAEqualToStatementB","substitutionAEqualToSubstitutionB","fromNothing","transientContext","fromTermsAndFrames"],"mappings":"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"}