occam-verify-cli 0.0.369 → 0.0.371

package/bin/utilities/fileSystem.js

@@ -1,7 +1,7 @@
 "use strict";
 
-const { ReleaseContext } = require("../../lib/index"),  ///
-      { fileSystemUtilities : occamFileSystemUtilities } = require("occam-file-system"),
+const { DirectoryReleaseContext } = require("../../lib/index"),  ///
+      { Entries, fileSystemUtilities : occamFileSystemUtilities } = require("occam-file-system"),
       { loggingUtilities, fileSystemUtilities : necessaryFileSystemUtilities } = require("necessary");
 
 const callbacks = require("../callbacks");
@@ -29,9 +29,16 @@ function releaseContextFromFile(name, projectsDirectoryPath) {
   let releaseContext = null;
 
   const filePath = `${projectsDirectoryPath}/${name}`,
-        content = readFile(filePath);
+        content = readFile(filePath),
+        releaseJSONString = content,  ///
+        releaseJSON = JSON.parse(releaseJSONString);
+
+  let { entries } = releaseJSON;
+
+  const json = entries; ///
+
+  entries = Entries.fromJSON(json);
 
-  debugger
 
   return releaseContext;
 }
@@ -43,7 +50,9 @@ function releaseContextFromDirectory(name, projectsDirectoryPath) {
         release = loadRelease(topmostDirectoryName, projectsDirectoryPath);
 
   if (release !== null) {
-    releaseContext = ReleaseContext.fromLogReleaseAndCallbacks(log, release, callbacks);
+    const directoryReleaseContext = DirectoryReleaseContext.fromLogReleaseAndCallbacks(log, release, callbacks);
+
+    releaseContext = directoryReleaseContext; ///
   }
 
   return releaseContext;

package/lib/context/release/directory.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return DirectoryReleaseContext;
+    }
+});
+var _release = /*#__PURE__*/ _interopRequireDefault(require("../../context/release"));
+var _array = require("../../utilities/array");
+var _customGrammar = require("../../utilities/customGrammar");
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(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) _setPrototypeOf(subClass, superClass);
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var DirectoryReleaseContext = /*#__PURE__*/ function(ReleaseContext) {
+    _inherits(DirectoryReleaseContext, ReleaseContext);
+    var _super = _createSuper(DirectoryReleaseContext);
+    function DirectoryReleaseContext(log, verified, callbacks, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts, release) {
+        _classCallCheck(this, DirectoryReleaseContext);
+        var _this;
+        _this = _super.call(this, log, verified, callbacks, customGrammar, florenceLexer, florenceParser, releaseContexts);
+        _this.fileContexts = fileContexts;
+        _this.release = release;
+        return _this;
+    }
+    _createClass(DirectoryReleaseContext, [
+        {
+            key: "getFileContexts",
+            value: function getFileContexts() {
+                return this.fileContexts;
+            }
+        },
+        {
+            key: "getRelease",
+            value: function getRelease() {
+                return this.release;
+            }
+        },
+        {
+            key: "getReleaseName",
+            value: function getReleaseName() {
+                var releaseName = this.release.getName();
+                return releaseName;
+            }
+        },
+        {
+            key: "getFile",
+            value: function getFile(filePath) {
+                return this.release.getFile(filePath);
+            }
+        },
+        {
+            key: "getVersion",
+            value: function getVersion() {
+                return this.release.getVersion();
+            }
+        },
+        {
+            key: "getFilePaths",
+            value: function getFilePaths() {
+                return this.release.getFilePaths();
+            }
+        },
+        {
+            key: "getDependencies",
+            value: function getDependencies() {
+                return this.release.getDependencies();
+            }
+        },
+        {
+            key: "matchShortenedVersion",
+            value: function matchShortenedVersion(shortenedVersion) {
+                return this.release.matchShortenedVersion(shortenedVersion);
+            }
+        },
+        {
+            key: "getRules",
+            value: function getRules() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var rules = [], releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextRules = fileContext.getRules(bubble);
+                        (0, _array.push)(rules, fileContextRules);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextRules = releaseContext.getRules(releaseNames);
+                        (0, _array.push)(rules, releaseContextRules);
+                    });
+                }
+                return rules;
+            }
+        },
+        {
+            key: "getTypes",
+            value: function getTypes() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var types = [], releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextTypes = fileContext.getTypes(bubble);
+                        (0, _array.push)(types, fileContextTypes);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextTypes = releaseContext.getTypes(releaseNames);
+                        (0, _array.push)(types, releaseContextTypes);
+                    });
+                }
+                return types;
+            }
+        },
+        {
+            key: "getAxioms",
+            value: function getAxioms() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var axioms = [], releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextAxioms = fileContext.getAxioms(bubble);
+                        (0, _array.push)(axioms, fileContextAxioms);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+                        (0, _array.push)(axioms, releaseContextAxioms);
+                    });
+                }
+                return axioms;
+            }
+        },
+        {
+            key: "getLabels",
+            value: function getLabels() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var labels = [], releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextLabels = fileContext.getLabels(bubble);
+                        (0, _array.push)(labels, fileContextLabels);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextLabels = releaseContext.getLabels(releaseNames);
+                        (0, _array.push)(labels, releaseContextLabels);
+                    });
+                }
+                return labels;
+            }
+        },
+        {
+            key: "getCombinators",
+            value: function getCombinators() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var combinators = [], releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextCombinators = fileContext.getCombinators(bubble);
+                        (0, _array.push)(combinators, fileContextCombinators);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+                        (0, _array.push)(combinators, releaseContextCombinators);
+                    });
+                }
+                return combinators;
+            }
+        },
+        {
+            key: "getConstructors",
+            value: function getConstructors() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var constructors = [], releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextConstructors = fileContext.getConstructors(bubble);
+                        (0, _array.push)(constructors, fileContextConstructors);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+                        (0, _array.push)(constructors, releaseContextConstructors);
+                    });
+                }
+                return constructors;
+            }
+        },
+        {
+            key: "addFileContext",
+            value: function addFileContext(fileContext) {
+                this.fileContexts.push(fileContext);
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var json = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var fileContextJSON = fileContext.toJSON();
+                    (0, _array.push)(json, fileContextJSON);
+                });
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromLogReleaseAndCallbacks",
+            value: function fromLogReleaseAndCallbacks(log, release, callbacks) {
+                var entries = release.getEntries(), verified = false, customGrammar = (0, _customGrammar.customGrammarFromEntries)(entries), florenceLexer = null, florenceParser = null, releaseContexts = null, fileContexts = [], releaseContext = new DirectoryReleaseContext(log, verified, callbacks, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts, release);
+                return releaseContext;
+            }
+        }
+    ]);
+    return DirectoryReleaseContext;
+}(_release.default);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/context/release/directory.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nimport ReleaseContext from \"../../context/release\";\n\nimport { push } from \"../../utilities/array\";\nimport { customGrammarFromEntries } from \"../../utilities/customGrammar\";\n\nexport default class DirectoryReleaseContext extends ReleaseContext {\n  constructor(log, verified, callbacks, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts, release) {\n    super(log, verified, callbacks, customGrammar, florenceLexer, florenceParser, releaseContexts);\n\n    this.fileContexts = fileContexts;\n    this.release = release;\n  }\n\n  getFileContexts() {\n    return this.fileContexts;\n  }\n\n  getRelease() {\n    return this.release;\n  }\n\n  getReleaseName() {\n    const releaseName = this.release.getName();\n\n    return releaseName;\n  }\n\n  getFile(filePath) { return this.release.getFile(filePath); }\n\n  getVersion() { return this.release.getVersion(); }\n\n  getFilePaths() { return this.release.getFilePaths(); }\n\n  getDependencies() { return this.release.getDependencies(); }\n\n  matchShortenedVersion(shortenedVersion) { return this.release.matchShortenedVersion(shortenedVersion); }\n\n  getRules(releaseNames = []) {\n    const rules = [],\n        releaseName = this.getReleaseName(),\n        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextRules = fileContext.getRules(bubble);\n\n        push(rules, fileContextRules);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextRules = releaseContext.getRules(releaseNames);\n\n        push(rules, releaseContextRules);\n      });\n    }\n\n    return rules;\n  }\n\n  getTypes(releaseNames = []) {\n    const types = [],\n        releaseName = this.getReleaseName(),\n        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextTypes = fileContext.getTypes(bubble);\n\n        push(types, fileContextTypes);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextTypes = releaseContext.getTypes(releaseNames);\n\n        push(types, releaseContextTypes);\n      });\n    }\n\n    return types;\n  }\n\n  getAxioms(releaseNames = []) {\n    const axioms = [],\n        releaseName = this.getReleaseName(),\n        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextAxioms = fileContext.getAxioms(bubble);\n\n        push(axioms, fileContextAxioms);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);\n\n        push(axioms, releaseContextAxioms);\n      });\n    }\n\n    return axioms;\n  }\n\n  getLabels(releaseNames = []) {\n    const labels = [],\n        releaseName = this.getReleaseName(),\n        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextLabels = fileContext.getLabels(bubble);\n\n        push(labels, fileContextLabels);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextLabels = releaseContext.getLabels(releaseNames);\n\n        push(labels, releaseContextLabels);\n      });\n    }\n\n    return labels;\n  }\n\n  getCombinators(releaseNames = []) {\n    const combinators = [],\n        releaseName = this.getReleaseName(),\n        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextCombinators = fileContext.getCombinators(bubble);\n\n        push(combinators, fileContextCombinators);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);\n\n        push(combinators, releaseContextCombinators);\n      });\n    }\n\n    return combinators;\n  }\n\n  getConstructors(releaseNames = []) {\n    const constructors = [],\n        releaseName = this.getReleaseName(),\n        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextConstructors = fileContext.getConstructors(bubble);\n\n        push(constructors, fileContextConstructors);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);\n\n        push(constructors, releaseContextConstructors);\n      });\n    }\n\n    return constructors;\n  }\n\n  addFileContext(fileContext) {\n    this.fileContexts.push(fileContext);\n  }\n\n  toJSON() {\n    const json = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const fileContextJSON = fileContext.toJSON();\n\n      push(json, fileContextJSON);\n    });\n\n    return json;\n  }\n\n  static fromLogReleaseAndCallbacks(log, release, callbacks) {\n    const entries = release.getEntries(),\n          verified = false,\n          customGrammar = customGrammarFromEntries(entries),\n          florenceLexer = null,\n          florenceParser = null,\n          releaseContexts = null,\n          fileContexts = [],\n          releaseContext = new DirectoryReleaseContext(log, verified, callbacks, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts, release);\n\n    return releaseContext;\n  }\n}\n","React.createElement"],"names":["DirectoryReleaseContext","log","verified","callbacks","customGrammar","florenceLexer","florenceParser","releaseContexts","fileContexts","release","getFileContexts","getRelease","getReleaseName","releaseName","getName","getFile","filePath","getVersion","getFilePaths","getDependencies","matchShortenedVersion","shortenedVersion","getRules","releaseNames","rules","releaseNamesIncludesReleaseName","includes","push","bubble","forEach","fileContext","fileContextRules","releaseContext","releaseContextRules","getTypes","types","fileContextTypes","releaseContextTypes","getAxioms","axioms","fileContextAxioms","releaseContextAxioms","getLabels","labels","fileContextLabels","releaseContextLabels","getCombinators","combinators","fileContextCombinators","releaseContextCombinators","getConstructors","constructors","fileContextConstructors","releaseContextConstructors","addFileContext","toJSON","json","fileContextJSON","fromLogReleaseAndCallbacks","entries","getEntries","customGrammarFromEntries","ReleaseContext"],"mappings":"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"}