occam-verify-cli 1.0.457 → 1.0.472

package/lib/constants.js

@@ -24,6 +24,9 @@ _export(exports, {
     get FUNCTION () {
         return FUNCTION;
     },
+    get LEVELS () {
+        return LEVELS;
+    },
     get MISSING () {
         return MISSING;
     },
@@ -46,6 +49,15 @@ _export(exports, {
         return UNDEFINED;
     }
 });
+var _necessary = require("necessary");
+var TRACE_LEVEL = _necessary.levels.TRACE_LEVEL, DEBUG_LEVEL = _necessary.levels.DEBUG_LEVEL, INFO_LEVEL = _necessary.levels.INFO_LEVEL, WARNING_LEVEL = _necessary.levels.WARNING_LEVEL, ERROR_LEVEL = _necessary.levels.ERROR_LEVEL;
+var LEVELS = [
+    TRACE_LEVEL,
+    DEBUG_LEVEL,
+    INFO_LEVEL,
+    WARNING_LEVEL,
+    ERROR_LEVEL
+];
 var S = "s";
 var MISSING = "missing";
 var FUNCTION = "function";
@@ -59,4 +71,4 @@ var OCCAM_VERIFY_CLI = "Occam Verify-CLI";
 var BRACKETED_TERM_DEPTH = 2;
 var BRACKETED_STATEMENT_DEPTH = 2;
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jb25zdGFudHMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCBTID0gXCJzXCI7XG5leHBvcnQgY29uc3QgTUlTU0lORyA9IFwibWlzc2luZ1wiO1xuZXhwb3J0IGNvbnN0IEZVTkNUSU9OID0gXCJmdW5jdGlvblwiO1xuZXhwb3J0IGNvbnN0IFVOREVGSU5FRCA9IFwidW5kZWZpbmVkXCI7XG5leHBvcnQgY29uc3QgUFJPVklTSU9OQUwgPSBcIlByb3Zpc2lvbmFsXCI7XG5leHBvcnQgY29uc3QgRU1QVFlfU1RSSU5HID0gXCJcIjtcbmV4cG9ydCBjb25zdCBTSU5HTEVfU1BBQ0UgPSBcIiBcIjtcbmV4cG9ydCBjb25zdCBQUk9WSVNJT05BTExZID0gXCJwcm92aXNpb25hbGx5XCI7XG5leHBvcnQgY29uc3QgQkFTRV9UWVBFX1NZTUJPTCA9IFwiPD5cIjtcbmV4cG9ydCBjb25zdCBPQ0NBTV9WRVJJRllfQ0xJID0gXCJPY2NhbSBWZXJpZnktQ0xJXCI7XG5leHBvcnQgY29uc3QgQlJBQ0tFVEVEX1RFUk1fREVQVEggPSAyO1xuZXhwb3J0IGNvbnN0IEJSQUNLRVRFRF9TVEFURU1FTlRfREVQVEggPSAyO1xuIl0sIm5hbWVzIjpbIkJBU0VfVFlQRV9TWU1CT0wiLCJCUkFDS0VURURfU1RBVEVNRU5UX0RFUFRIIiwiQlJBQ0tFVEVEX1RFUk1fREVQVEgiLCJFTVBUWV9TVFJJTkciLCJGVU5DVElPTiIsIk1JU1NJTkciLCJPQ0NBTV9WRVJJRllfQ0xJIiwiUFJPVklTSU9OQUwiLCJQUk9WSVNJT05BTExZIiwiUyIsIlNJTkdMRV9TUEFDRSIsIlVOREVGSU5FRCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O1FBVWFBO2VBQUFBOztRQUdBQztlQUFBQTs7UUFEQUM7ZUFBQUE7O1FBTEFDO2VBQUFBOztRQUhBQztlQUFBQTs7UUFEQUM7ZUFBQUE7O1FBUUFDO2VBQUFBOztRQUxBQztlQUFBQTs7UUFHQUM7ZUFBQUE7O1FBUEFDO2VBQUFBOztRQU1BQztlQUFBQTs7UUFIQUM7ZUFBQUE7OztBQUhOLElBQU1GLElBQUk7QUFDVixJQUFNSixVQUFVO0FBQ2hCLElBQU1ELFdBQVc7QUFDakIsSUFBTU8sWUFBWTtBQUNsQixJQUFNSixjQUFjO0FBQ3BCLElBQU1KLGVBQWU7QUFDckIsSUFBTU8sZUFBZTtBQUNyQixJQUFNRixnQkFBZ0I7QUFDdEIsSUFBTVIsbUJBQW1CO0FBQ3pCLElBQU1NLG1CQUFtQjtBQUN6QixJQUFNSix1QkFBdUI7QUFDN0IsSUFBTUQsNEJBQTRCIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context/ephemeral.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return EphemeralContext;
+    }
+});
+var _necessary = require("necessary");
+var _occamfurtle = require("occam-furtle");
+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;
+}
+var extract = _necessary.arrayUtilities.extract, chainContext = _occamfurtle.contextUtilities.chainContext;
+var EphemeralContext = /*#__PURE__*/ function() {
+    function EphemeralContext(context, terms, frames, statements, assertions, references, substitutions) {
+        _class_call_check(this, EphemeralContext);
+        this.context = context;
+        this.terms = terms;
+        this.frames = frames;
+        this.statements = statements;
+        this.assertions = assertions;
+        this.references = references;
+        this.substitutions = substitutions;
+        return chainContext(this);
+    }
+    _create_class(EphemeralContext, [
+        {
+            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, substitutionAEqualToAssertionB = substitutionA.isEqualTo(substitutionB);
+                    if (substitutionAEqualToAssertionB) {
+                        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: "getFileContext",
+            value: function getFileContext() {
+                return this.context.getFileContext();
+            }
+        },
+        {
+            key: "getDepth",
+            value: function getDepth() {
+                var depth = this.context.getDepth();
+                depth++;
+                return depth;
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(context) {
+                var terms = [], frames = [], statements = [], assertions = [], references = [], substitutions = [], emphemeralContext = new EphemeralContext(context, terms, frames, statements, assertions, references, substitutions);
+                return emphemeralContext;
+            }
+        }
+    ]);
+    return EphemeralContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/ephemeral.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\nimport { contextUtilities } from \"occam-furtle\";\n\nconst { extract } = arrayUtilities,\n      { chainContext } = contextUtilities;\n\nexport default class EphemeralContext {\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            substitutionAEqualToAssertionB = substitutionA.isEqualTo(substitutionB);\n\n      if (substitutionAEqualToAssertionB) {\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  getFileContext() { return this.context.getFileContext(); }\n\n  getDepth() {\n    let depth = this.context.getDepth();\n\n    depth++;\n\n    return depth;\n  }\n\n  static fromNothing(context) {\n    const terms = [],\n          frames = [],\n          statements = [],\n          assertions = [],\n          references = [],\n          substitutions = [],\n          emphemeralContext = new EphemeralContext(context, terms, frames, statements, assertions, references, substitutions);\n\n    return emphemeralContext;\n  }\n}\n"],"names":["EphemeralContext","extract","arrayUtilities","chainContext","contextUtilities","context","terms","frames","statements","assertions","references","substitutions","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","substitutionAEqualToAssertionB","findTermByTermNode","termNode","find","termNodeMatches","matchNode","findFrameByFrameNode","frameNode","frameNodeMatches","findStatementByStatementNode","statementNode","statementNodeMatches","findAssertionByAssertionNode","assertionNode","assertionNodeMatches","findReferenceByMetavariableNode","metavariableNode","referenceMatcheMetavariableNode","matchMetavariableNode","findSubstitutionBySubstitutionNode","substitutionNode","substitutionNodeMatches","getFileContext","getDepth","depth","fromNothing","emphemeralContext"],"mappings":"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"}