occam-verify-cli 0.0.373 → 0.0.374

package/bin/main.js

@@ -9,7 +9,7 @@ const { DEFAULT_LOG_LEVEL } = require("./defaults"),
 const { log } = loggingUtilities,
       { first } = arrayUtilities,
       { setLogLevel } = log,
-      { createReleaseContext } = releaseContextUtilities;
+      { createReleaseContext, initialiseReleaseContexts } = releaseContextUtilities;
 
 function main(commands, options) {
   const firstCommand = first(commands),
@@ -31,6 +31,8 @@ function main(commands, options) {
       return;
     }
 
+    initialiseReleaseContexts(releaseName, releaseContextMap);
+
     const releaseVerified = verifyRelease(releaseName, releaseContextMap);
 
     if (releaseVerified) {

package/bin/utilities/fileSystem.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { DirectoryReleaseContext } = require("../../lib/index"),  ///
+const { FileReleaseContext, DirectoryReleaseContext } = require("../../lib/index"),  ///
       { Entries, fileSystemUtilities : occamFileSystemUtilities } = require("occam-file-system"),
       { loggingUtilities, fileSystemUtilities : necessaryFileSystemUtilities } = require("necessary");
 
@@ -15,8 +15,8 @@ function releaseContextFromReleaseName(name, context, callback) {
         entryPath = `${projectsDirectoryPath}/${name}`,
         entryFile = isEntryFile(entryPath),
         releaseContext = entryFile ?
-                           releaseContextFromFile(name, projectsDirectoryPath) :
-                             releaseContextFromDirectory(name, projectsDirectoryPath);
+                           fileReleaseContextFromNameAndProjectsDirectoryPath(name, projectsDirectoryPath) :
+                             directoryReleaseContextFromNameAndProjectsDirectoryPath(name, projectsDirectoryPath);
 
   callback(releaseContext);
 }
@@ -25,13 +25,13 @@ module.exports = {
   releaseContextFromReleaseName
 };
 
-function releaseContextFromFile(name, projectsDirectoryPath) {
-  let releaseContext = null;
-
+function fileReleaseContextFromNameAndProjectsDirectoryPath(name, projectsDirectoryPath) {
   const filePath = `${projectsDirectoryPath}/${name}`,
         content = readFile(filePath),
         releaseJSONString = content,  ///
-        releaseJSON = JSON.parse(releaseJSONString);
+        releaseJSON = JSON.parse(releaseJSONString),
+        { context } = releaseJSON,
+        contextJSON = context;  ///
 
   let { entries } = releaseJSON;
 
@@ -39,11 +39,13 @@ function releaseContextFromFile(name, projectsDirectoryPath) {
 
   entries = Entries.fromJSON(json);
 
+  const fileReleaseContext = FileReleaseContext.fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON),
+        releaseContext = fileReleaseContext;  ///
 
   return releaseContext;
 }
 
-function releaseContextFromDirectory(name, projectsDirectoryPath) {
+function directoryReleaseContextFromNameAndProjectsDirectoryPath(name, projectsDirectoryPath) {
   let releaseContext = null;
 
   const topmostDirectoryName = name, ///

package/lib/context/release/directory.js

@@ -259,12 +259,12 @@ var DirectoryReleaseContext = /*#__PURE__*/ function(ReleaseContext) {
         {
             key: "fromLogNameEntriesAndCallbacks",
             value: function fromLogNameEntriesAndCallbacks(log, name, entries, callbacks) {
-                var verified = false, customGrammar = (0, _customGrammar.customGrammarFromNameAndEntries)(name, entries), florenceLexer = null, florenceParser = null, releaseContexts = null, fileContexts = [], releaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
-                return releaseContext;
+                var verified = false, customGrammar = (0, _customGrammar.customGrammarFromNameAndEntries)(name, entries), florenceLexer = null, florenceParser = null, releaseContexts = null, fileContexts = [], directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
+                return directoryReleaseContext;
             }
         }
     ]);
     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 { customGrammarFromNameAndEntries } from \"../../utilities/customGrammar\";\n\nexport default class DirectoryReleaseContext extends ReleaseContext {\n  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts) {\n    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);\n\n    this.fileContexts = fileContexts;\n  }\n\n  getFileContexts() {\n    return this.fileContexts;\n  }\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 fromLogNameEntriesAndCallbacks(log, name, entries, callbacks) {\n    const verified = false,\n          customGrammar = customGrammarFromNameAndEntries(name, entries),\n          florenceLexer = null,\n          florenceParser = null,\n          releaseContexts = null,\n          fileContexts = [],\n          releaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);\n\n    return releaseContext;\n  }\n}\n","React.createElement"],"names":["DirectoryReleaseContext","log","name","entries","callbacks","verified","customGrammar","florenceLexer","florenceParser","releaseContexts","fileContexts","getFileContexts","getRules","releaseNames","rules","releaseName","getReleaseName","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","fromLogNameEntriesAndCallbacks","customGrammarFromNameAndEntries","ReleaseContext"],"mappings":"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"}
+//# 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 { customGrammarFromNameAndEntries } from \"../../utilities/customGrammar\";\n\nexport default class DirectoryReleaseContext extends ReleaseContext {\n  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts) {\n    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);\n\n    this.fileContexts = fileContexts;\n  }\n\n  getFileContexts() {\n    return this.fileContexts;\n  }\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 fromLogNameEntriesAndCallbacks(log, name, entries, callbacks) {\n    const verified = false,\n          customGrammar = customGrammarFromNameAndEntries(name, entries),\n          florenceLexer = null,\n          florenceParser = null,\n          releaseContexts = null,\n          fileContexts = [],\n          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);\n\n    return directoryReleaseContext;\n  }\n}\n","React.createElement"],"names":["DirectoryReleaseContext","log","name","entries","callbacks","verified","customGrammar","florenceLexer","florenceParser","releaseContexts","fileContexts","getFileContexts","getRules","releaseNames","rules","releaseName","getReleaseName","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","fromLogNameEntriesAndCallbacks","customGrammarFromNameAndEntries","directoryReleaseContext","ReleaseContext"],"mappings":"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"}

package/lib/context/release/file.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return FileReleaseContext;
+    }
+});
+var _release = /*#__PURE__*/ _interopRequireDefault(require("../../context/release"));
+var _array = require("../../utilities/array");
+var _customGrammar = require("../../utilities/customGrammar");
+function _arrayLikeToArray(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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+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 _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function _get(target, property, receiver) {
+            var base = _superPropBase(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+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 _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    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 _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);
+}
+function _superPropBase(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _getPrototypeOf(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(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 _arrayLikeToArray(o, minLen);
+}
+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 FileReleaseContext = /*#__PURE__*/ function(ReleaseContext) {
+    _inherits(FileReleaseContext, ReleaseContext);
+    var _super = _createSuper(FileReleaseContext);
+    function FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors) {
+        _classCallCheck(this, FileReleaseContext);
+        var _this;
+        _this = _super.call(this, log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);
+        _this.rules = rules;
+        _this.types = types;
+        _this.axioms = axioms;
+        _this.labels = labels;
+        _this.combinators = combinators;
+        _this.constructors = constructors;
+        _this.contextJSON = contextJSON;
+        return _this;
+    }
+    _createClass(FileReleaseContext, [
+        {
+            key: "getContextJSON",
+            value: function getContextJSON() {
+                return this.contextJSON;
+            }
+        },
+        {
+            key: "getRules",
+            value: function getRules() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var rules = _toConsumableArray(this.rules), releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    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 = _toConsumableArray(this.types), releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    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 = _toConsumableArray(this.axioms), releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    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 = _toConsumableArray(this.labels), releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    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 = _toConsumableArray(this.combinators), releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    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 = _toConsumableArray(this.constructors), releaseName = this.getReleaseName(), releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(releaseName);
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+                        (0, _array.push)(constructors, releaseContextConstructors);
+                    });
+                }
+                return constructors;
+            }
+        },
+        {
+            key: "initialise",
+            value: function initialise(dependencyReleaseContexts) {
+                _get(_getPrototypeOf(FileReleaseContext.prototype), "initialise", this).call(this, dependencyReleaseContexts);
+                debugger;
+            }
+        }
+    ], [
+        {
+            key: "fromLogNameEntriesCallbacksAndContextJSON",
+            value: function fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {
+                var verified = false, customGrammar = (0, _customGrammar.customGrammarFromNameAndEntries)(name, entries), florenceLexer = null, florenceParser = null, releaseContexts = null, rules = null, types = null, axioms = null, labels = null, combinators = null, constructors = null, releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors);
+                return releaseContext;
+            }
+        }
+    ]);
+    return FileReleaseContext;
+}(_release.default);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/context/release/file.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nimport ReleaseContext from \"../../context/release\";\n\nimport { push } from \"../../utilities/array\";\nimport {combinedCustomGrammarFromReleaseContexts, customGrammarFromNameAndEntries} from \"../../utilities/customGrammar\";\n\nexport default class FileReleaseContext extends ReleaseContext {\n  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors) {\n    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);\n\n    this.rules = rules;\n    this.types = types;\n    this.axioms = axioms;\n    this.labels = labels;\n    this.combinators = combinators;\n    this.constructors = constructors;\n    this.contextJSON = contextJSON;\n  }\n\n  getContextJSON() {\n    return this.contextJSON;\n  }\n\n  getRules(releaseNames = []) {\n    const rules = [\n            ...this.rules\n          ],\n          releaseName = this.getReleaseName(),\n          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\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            ...this.types\n          ],\n          releaseName = this.getReleaseName(),\n          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\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            ...this.axioms\n          ],\n          releaseName = this.getReleaseName(),\n          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\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            ...this.labels\n          ],\n          releaseName = this.getReleaseName(),\n          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\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            ...this.combinators\n          ],\n          releaseName = this.getReleaseName(),\n          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\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            ...this.constructors\n          ],\n          releaseName = this.getReleaseName(),\n          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(releaseName);\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  initialise(dependencyReleaseContexts) {\n    super.initialise(dependencyReleaseContexts);\n\n    debugger\n  }\n\n  static fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {\n    const verified = false, ///\n          customGrammar = customGrammarFromNameAndEntries(name, entries),\n          florenceLexer = null,\n          florenceParser = null,\n          releaseContexts = null,\n          rules = null,\n          types = null,\n          axioms = null,\n          labels = null,\n          combinators = null,\n          constructors = null,\n          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors);\n\n    return releaseContext;\n  }\n}\n","React.createElement"],"names":["FileReleaseContext","log","name","entries","callbacks","verified","customGrammar","florenceLexer","florenceParser","releaseContexts","contextJSON","rules","types","axioms","labels","combinators","constructors","getContextJSON","getRules","releaseNames","releaseName","getReleaseName","releaseNamesIncludesReleaseName","includes","push","forEach","releaseContext","releaseContextRules","getTypes","releaseContextTypes","getAxioms","releaseContextAxioms","getLabels","releaseContextLabels","getCombinators","releaseContextCombinators","getConstructors","releaseContextConstructors","initialise","dependencyReleaseContexts","fromLogNameEntriesCallbacksAndContextJSON","customGrammarFromNameAndEntries","ReleaseContext"],"mappings":"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"}

package/lib/context/release.js

@@ -130,6 +130,13 @@ var ReleaseContext = /*#__PURE__*/ function() {
                 return releaseName;
             }
         },
+        {
+            key: "isInitialised",
+            value: function isInitialised() {
+                var initialised = this.releaseContexts !== null; ///
+                return initialised;
+            }
+        },
         {
             key: "getFile",
             value: function getFile(filePath) {
@@ -234,12 +241,10 @@ var ReleaseContext = /*#__PURE__*/ function() {
         },
         {
             key: "initialise",
-            value: function initialise(releaseContexts, dependencyReleaseContexts) {
-                var releaseContext = this; ///
-                releaseContexts = [
+            value: function initialise(dependencyReleaseContexts) {
+                var releaseContext = this, releaseContexts = [
                     releaseContext
-                ].concat(_toConsumableArray(dependencyReleaseContexts)); ///
-                var combinedCustomGrammar = (0, _customGrammar.combinedCustomGrammarFromReleaseContexts)(releaseContexts);
+                ].concat(_toConsumableArray(dependencyReleaseContexts)), combinedCustomGrammar = (0, _customGrammar.combinedCustomGrammarFromReleaseContexts)(releaseContexts);
                 this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
                 this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
                 this.releaseContexts = releaseContexts;
@@ -249,4 +254,4 @@ var ReleaseContext = /*#__PURE__*/ function() {
     return ReleaseContext;
 }();
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/release.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nimport { lexersUtilities, parsersUtilities } from \"occam-custom-grammars\";\n\nimport { combinedCustomGrammarFromReleaseContexts } from \"../utilities/customGrammar\";\n\nconst { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,\n      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;\n\nexport default class ReleaseContext {\n  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts) {\n    this.log = log;\n    this.name = name;\n    this.entries = entries;\n    this.callbacks = callbacks;\n    this.verified = verified;\n    this.customGrammar = customGrammar;\n    this.florenceLexer = florenceLexer;\n    this.florenceParser = florenceParser;\n    this.releaseContexts = releaseContexts;\n  }\n\n  getLog() {\n    return this.log;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getEntries() {\n    return this.entries;\n  }\n\n  getCallbacks() {\n    return this.callbacks;\n  }\n\n  isVerified() {\n    return this.verified;\n  }\n\n  getCustomGrammar() {\n    return this.customGrammar;\n  }\n\n  getFlorenceLexer() {\n    return this.florenceLexer;\n  }\n\n  getFlorenceParser() {\n    return this.florenceParser;\n  }\n\n  getReleaseContexts() {\n    return this.releaseContexts;\n  }\n\n  getReleaseName() {\n    const name = this.getName(),\n        releaseName = name; ///\n\n    return releaseName;\n  }\n\n  getFile(filePath) { return this.entries.getFile(filePath); }\n\n  getVersion() { return this.entries.getVersion(); }\n\n  getFilePaths() { return this.entries.getFilePaths(); }\n\n  getDependencies() { return this.entries.getDependencies(); }\n\n  matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }\n\n  setVerified(verified) {\n    this.verified = verified;\n  }\n\n  tokenise(content) { return this.florenceLexer.tokenise(content); }\n\n  parse(tokens) { return this.florenceParser.parse(tokens); }\n\n  trace(message) { this.log.trace(message); }\n\n  debug(message) { this.log.debug(message); }\n\n  info(message) { this.log.info(message); }\n\n  warning(message) { this.log.warning(message); }\n\n  error(message) { this.log.error(message); }\n\n  fatal(message) { this.log.fatal(message); }\n\n  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }\n\n  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }\n\n  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }\n\n  initialise(releaseContexts, dependencyReleaseContexts) {\n    const releaseContext = this;  ///\n\n    releaseContexts = [ releaseContext, ...dependencyReleaseContexts ]; ///\n\n    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);\n\n    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);\n\n    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);\n\n    this.releaseContexts = releaseContexts;\n  }\n}\n","React.createElement"],"names":["ReleaseContext","florenceLexerFromCombinedCustomGrammar","lexersUtilities","florenceParserFromCombinedCustomGrammar","parsersUtilities","log","name","entries","callbacks","verified","customGrammar","florenceLexer","florenceParser","releaseContexts","getLog","getName","getEntries","getCallbacks","isVerified","getCustomGrammar","getFlorenceLexer","getFlorenceParser","getReleaseContexts","getReleaseName","releaseName","getFile","filePath","getVersion","getFilePaths","getDependencies","matchShortenedVersion","shortenedVersion","setVerified","tokenise","content","parse","tokens","trace","message","debug","info","warning","error","fatal","halt","leastLineIndex","greatestLineIndex","begin","complete","initialise","dependencyReleaseContexts","releaseContext","combinedCustomGrammar","combinedCustomGrammarFromReleaseContexts"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/release.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nimport { lexersUtilities, parsersUtilities } from \"occam-custom-grammars\";\n\nimport { combinedCustomGrammarFromReleaseContexts } from \"../utilities/customGrammar\";\n\nconst { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,\n      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;\n\nexport default class ReleaseContext {\n  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts) {\n    this.log = log;\n    this.name = name;\n    this.entries = entries;\n    this.callbacks = callbacks;\n    this.verified = verified;\n    this.customGrammar = customGrammar;\n    this.florenceLexer = florenceLexer;\n    this.florenceParser = florenceParser;\n    this.releaseContexts = releaseContexts;\n  }\n\n  getLog() {\n    return this.log;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getEntries() {\n    return this.entries;\n  }\n\n  getCallbacks() {\n    return this.callbacks;\n  }\n\n  isVerified() {\n    return this.verified;\n  }\n\n  getCustomGrammar() {\n    return this.customGrammar;\n  }\n\n  getFlorenceLexer() {\n    return this.florenceLexer;\n  }\n\n  getFlorenceParser() {\n    return this.florenceParser;\n  }\n\n  getReleaseContexts() {\n    return this.releaseContexts;\n  }\n\n  getReleaseName() {\n    const name = this.getName(),\n         releaseName = name; ///\n\n    return releaseName;\n  }\n\n  isInitialised() {\n    const initialised = (this.releaseContexts !== null);  ///\n\n    return initialised;\n  }\n\n  getFile(filePath) { return this.entries.getFile(filePath); }\n\n  getVersion() { return this.entries.getVersion(); }\n\n  getFilePaths() { return this.entries.getFilePaths(); }\n\n  getDependencies() { return this.entries.getDependencies(); }\n\n  matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }\n\n  setVerified(verified) {\n    this.verified = verified;\n  }\n\n  tokenise(content) { return this.florenceLexer.tokenise(content); }\n\n  parse(tokens) { return this.florenceParser.parse(tokens); }\n\n  trace(message) { this.log.trace(message); }\n\n  debug(message) { this.log.debug(message); }\n\n  info(message) { this.log.info(message); }\n\n  warning(message) { this.log.warning(message); }\n\n  error(message) { this.log.error(message); }\n\n  fatal(message) { this.log.fatal(message); }\n\n  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }\n\n  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }\n\n  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }\n\n  initialise(dependencyReleaseContexts) {\n    const releaseContext = this,  ///\n          releaseContexts = [\n            releaseContext,\n            ...dependencyReleaseContexts\n          ],\n          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);\n\n    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);\n\n    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);\n\n    this.releaseContexts = releaseContexts;\n  }\n}\n","React.createElement"],"names":["ReleaseContext","florenceLexerFromCombinedCustomGrammar","lexersUtilities","florenceParserFromCombinedCustomGrammar","parsersUtilities","log","name","entries","callbacks","verified","customGrammar","florenceLexer","florenceParser","releaseContexts","getLog","getName","getEntries","getCallbacks","isVerified","getCustomGrammar","getFlorenceLexer","getFlorenceParser","getReleaseContexts","getReleaseName","releaseName","isInitialised","initialised","getFile","filePath","getVersion","getFilePaths","getDependencies","matchShortenedVersion","shortenedVersion","setVerified","tokenise","content","parse","tokens","trace","message","debug","info","warning","error","fatal","halt","leastLineIndex","greatestLineIndex","begin","complete","initialise","dependencyReleaseContexts","releaseContext","combinedCustomGrammar","combinedCustomGrammarFromReleaseContexts"],"mappings":"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"}

package/lib/index.js

@@ -21,6 +21,9 @@ _export(exports, {
     versionChanges: function() {
         return _versionChanges.default;
     },
+    FileReleaseContext: function() {
+        return _file.default;
+    },
     DirectoryReleaseContext: function() {
         return _directory.default;
     },
@@ -41,6 +44,7 @@ var _callbacks = /*#__PURE__*/ _interopRequireDefault(require("./callbacks"));
 var _release = /*#__PURE__*/ _interopRequireDefault(require("./verify/release"));
 var _release1 = /*#__PURE__*/ _interopRequireDefault(require("./context/release"));
 var _versionChanges = /*#__PURE__*/ _interopRequireDefault(require("./versionChanges"));
+var _file = /*#__PURE__*/ _interopRequireDefault(require("./context/release/file"));
 var _directory = /*#__PURE__*/ _interopRequireDefault(require("./context/release/directory"));
 var _json = /*#__PURE__*/ _interopRequireDefault(require("./utilities/json"));
 var _version = /*#__PURE__*/ _interopRequireDefault(require("./utilities/version"));
@@ -52,4 +56,4 @@ function _interopRequireDefault(obj) {
     };
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IHsgZGVmYXVsdCBhcyBDYWxsYmFja3MgfSBmcm9tIFwiLi9jYWxsYmFja3NcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgdmVyaWZ5UmVsZWFzZSB9IGZyb20gXCIuL3ZlcmlmeS9yZWxlYXNlXCI7XG5leHBvcnQgeyBkZWZhdWx0IGFzIFJlbGVhc2VDb250ZXh0IH0gZnJvbSBcIi4vY29udGV4dC9yZWxlYXNlXCI7XG5leHBvcnQgeyBkZWZhdWx0IGFzIHZlcnNpb25DaGFuZ2VzIH0gZnJvbSBcIi4vdmVyc2lvbkNoYW5nZXNcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgRGlyZWN0b3J5UmVsZWFzZUNvbnRleHQgfSBmcm9tIFwiLi9jb250ZXh0L3JlbGVhc2UvZGlyZWN0b3J5XCI7XG5cbmV4cG9ydCB7IGRlZmF1bHQgYXMganNvblV0aWxpdGllcyB9IGZyb20gXCIuL3V0aWxpdGllcy9qc29uXCI7XG5leHBvcnQgeyBkZWZhdWx0IGFzIHZlcnNpb25VdGlsaXRpZXMgfSBmcm9tIFwiLi91dGlsaXRpZXMvdmVyc2lvblwiO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBjdXN0b21HcmFtbWFyVXRpbGl0aWVzIH0gZnJvbSBcIi4vdXRpbGl0aWVzL2N1c3RvbUdyYW1tYXJcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgcmVsZWFzZUNvbnRleHRVdGlsaXRpZXMgfSBmcm9tIFwiLi91dGlsaXRpZXMvcmVsZWFzZUNvbnRleHRcIjtcbiJdLCJuYW1lcyI6WyJDYWxsYmFja3MiLCJ2ZXJpZnlSZWxlYXNlIiwiUmVsZWFzZUNvbnRleHQiLCJ2ZXJzaW9uQ2hhbmdlcyIsIkRpcmVjdG9yeVJlbGVhc2VDb250ZXh0IiwianNvblV0aWxpdGllcyIsInZlcnNpb25VdGlsaXRpZXMiLCJjdXN0b21HcmFtbWFyVXRpbGl0aWVzIiwicmVsZWFzZUNvbnRleHRVdGlsaXRpZXMiXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztJQUVvQkEsU0FBUztlQUFUQSxrQkFBUzs7SUFDVEMsYUFBYTtlQUFiQSxnQkFBYTs7SUFDYkMsY0FBYztlQUFkQSxpQkFBYzs7SUFDZEMsY0FBYztlQUFkQSx1QkFBYzs7SUFDZEMsdUJBQXVCO2VBQXZCQSxrQkFBdUI7O0lBRXZCQyxhQUFhO2VBQWJBLGFBQWE7O0lBQ2JDLGdCQUFnQjtlQUFoQkEsZ0JBQWdCOztJQUNoQkMsc0JBQXNCO2VBQXRCQSxzQkFBc0I7O0lBQ3RCQyx1QkFBdUI7ZUFBdkJBLHVCQUF1Qjs7OzhEQVROOzREQUNJOzZEQUNDO21FQUNBOzhEQUNTO3lEQUVWOzREQUNHO2tFQUNNO21FQUNDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IHsgZGVmYXVsdCBhcyBDYWxsYmFja3MgfSBmcm9tIFwiLi9jYWxsYmFja3NcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgdmVyaWZ5UmVsZWFzZSB9IGZyb20gXCIuL3ZlcmlmeS9yZWxlYXNlXCI7XG5leHBvcnQgeyBkZWZhdWx0IGFzIFJlbGVhc2VDb250ZXh0IH0gZnJvbSBcIi4vY29udGV4dC9yZWxlYXNlXCI7XG5leHBvcnQgeyBkZWZhdWx0IGFzIHZlcnNpb25DaGFuZ2VzIH0gZnJvbSBcIi4vdmVyc2lvbkNoYW5nZXNcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgRmlsZVJlbGVhc2VDb250ZXh0IH0gZnJvbSBcIi4vY29udGV4dC9yZWxlYXNlL2ZpbGVcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgRGlyZWN0b3J5UmVsZWFzZUNvbnRleHQgfSBmcm9tIFwiLi9jb250ZXh0L3JlbGVhc2UvZGlyZWN0b3J5XCI7XG5cbmV4cG9ydCB7IGRlZmF1bHQgYXMganNvblV0aWxpdGllcyB9IGZyb20gXCIuL3V0aWxpdGllcy9qc29uXCI7XG5leHBvcnQgeyBkZWZhdWx0IGFzIHZlcnNpb25VdGlsaXRpZXMgfSBmcm9tIFwiLi91dGlsaXRpZXMvdmVyc2lvblwiO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBjdXN0b21HcmFtbWFyVXRpbGl0aWVzIH0gZnJvbSBcIi4vdXRpbGl0aWVzL2N1c3RvbUdyYW1tYXJcIjtcbmV4cG9ydCB7IGRlZmF1bHQgYXMgcmVsZWFzZUNvbnRleHRVdGlsaXRpZXMgfSBmcm9tIFwiLi91dGlsaXRpZXMvcmVsZWFzZUNvbnRleHRcIjtcbiJdLCJuYW1lcyI6WyJDYWxsYmFja3MiLCJ2ZXJpZnlSZWxlYXNlIiwiUmVsZWFzZUNvbnRleHQiLCJ2ZXJzaW9uQ2hhbmdlcyIsIkZpbGVSZWxlYXNlQ29udGV4dCIsIkRpcmVjdG9yeVJlbGVhc2VDb250ZXh0IiwianNvblV0aWxpdGllcyIsInZlcnNpb25VdGlsaXRpZXMiLCJjdXN0b21HcmFtbWFyVXRpbGl0aWVzIiwicmVsZWFzZUNvbnRleHRVdGlsaXRpZXMiXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztJQUVvQkEsU0FBUztlQUFUQSxrQkFBUzs7SUFDVEMsYUFBYTtlQUFiQSxnQkFBYTs7SUFDYkMsY0FBYztlQUFkQSxpQkFBYzs7SUFDZEMsY0FBYztlQUFkQSx1QkFBYzs7SUFDZEMsa0JBQWtCO2VBQWxCQSxhQUFrQjs7SUFDbEJDLHVCQUF1QjtlQUF2QkEsa0JBQXVCOztJQUV2QkMsYUFBYTtlQUFiQSxhQUFhOztJQUNiQyxnQkFBZ0I7ZUFBaEJBLGdCQUFnQjs7SUFDaEJDLHNCQUFzQjtlQUF0QkEsc0JBQXNCOztJQUN0QkMsdUJBQXVCO2VBQXZCQSx1QkFBdUI7Ozs4REFWTjs0REFDSTs2REFDQzttRUFDQTt5REFDSTs4REFDSzt5REFFVjs0REFDRztrRUFDTTttRUFDQyJ9

package/lib/utilities/releaseContext.js

@@ -12,6 +12,9 @@ _export(exports, {
     createReleaseContext: function() {
         return createReleaseContext;
     },
+    initialiseReleaseContexts: function() {
+        return initialiseReleaseContexts;
+    },
     default: function() {
         return _default;
     }
@@ -69,9 +72,27 @@ function createReleaseContext(releaseName, dependentNames, shortenedVersion, con
         });
     }, context);
 }
+function initialiseReleaseContexts(releaseName, releaseContextMap) {
+    var releaseContext = releaseContextMap[releaseName];
+    initialiseReleaseContext(releaseContext, releaseContextMap);
+}
 var _default = {
-    createReleaseContext: createReleaseContext
+    createReleaseContext: createReleaseContext,
+    initialiseReleaseContexts: initialiseReleaseContexts
 };
+function initialiseReleaseContext(releaseContext, releaseContextMap) {
+    var initialised = releaseContext.isInitialised();
+    if (initialised) {
+        return;
+    }
+    var dependencies = releaseContext.getDependencies();
+    dependencies.forEachDependency(function(dependency) {
+        var name = dependency.getName(), releaseName = name, _$releaseContext = releaseContextMap[releaseName];
+        initialiseReleaseContext(_$releaseContext, releaseContextMap);
+    });
+    var dependencyReleaseContexts = retrieveDependencyReleaseContexts(releaseContext, releaseContextMap);
+    releaseContext.initialise(dependencyReleaseContexts);
+}
 function checkCyclicDependencyExists(releaseName, dependentNames, releaseContext) {
     var dependentNamesIncludesReleaseName = dependentNames.includes(releaseName), cyclicDependencyExists = dependentNamesIncludesReleaseName; ///
     if (cyclicDependencyExists) {
@@ -105,6 +126,19 @@ function createDependencyReleaseContexts(releaseContext, dependentNames, context
         });
     }, done);
 }
+function retrieveDependencyReleaseContexts(releaseContext, releaseContextMap) {
+    var dependencyReleaseContexts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+    var dependencies = releaseContext.getDependencies();
+    dependencies.forEachDependency(function(dependency) {
+        var dependencyName = dependency.getName(), dependencyReleaseName = dependencyName, dependencyReleaseContext = releaseContextMap[dependencyReleaseName], dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
+        if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
+            var _$releaseContext = dependencyReleaseContext; ///
+            retrieveDependencyReleaseContexts(_$releaseContext, releaseContextMap, dependencyReleaseContexts);
+            dependencyReleaseContexts.push(dependencyReleaseContext);
+        }
+    });
+    return dependencyReleaseContexts;
+}
 function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
     var entries = releaseContext.getEntries(), releaseMatchesShortedVersion = entries.matchShortenedVersion(shortenedVersion);
     if (!releaseMatchesShortedVersion) {
@@ -114,4 +148,4 @@ function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
     return releaseMatchesShortedVersion;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/releaseContext.js"],"sourcesContent":["\"use strict\";\n\nexport function createReleaseContext(releaseName, dependentNames, shortenedVersion, context, callback) {\n  const { releaseContextMap } = context,\n        releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext !== null) {\n    const error = false;\n\n    callback(error);\n\n    return;\n  }\n\n  const { releaseContextFromReleaseName } = context;\n\n  releaseContextFromReleaseName(releaseName, context, (releaseContext) => {\n    if (releaseContext === null) {\n      const error = true;\n\n      callback(error);\n\n      return;\n    }\n\n    const releaseMatchesShortedVersion = checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion);\n\n    if (!releaseMatchesShortedVersion) {\n      const error = true;\n\n      callback(error);\n\n      return;\n    }\n\n    createDependencyReleaseContexts(releaseContext, dependentNames, context, (error) => {\n      if (!error) {\n        releaseContextMap[releaseName] = releaseContext;\n      }\n\n      callback(error);\n    });\n  }, context);\n}\n\nexport default {\n  createReleaseContext\n};\n\nfunction checkCyclicDependencyExists(releaseName, dependentNames, releaseContext) {\n  const dependentNamesIncludesReleaseName = dependentNames.includes(releaseName),\n        cyclicDependencyExists = dependentNamesIncludesReleaseName;  ///\n\n  if (cyclicDependencyExists) {\n    const firstDependentName = first(dependentNames),\n          dependencyNames = dependentNames.concat(firstDependentName),\n          dependencyNamesString = dependencyNames.join(`' -> '`);\n\n    releaseContext.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);\n  }\n\n  return cyclicDependencyExists;\n}\n\nfunction createDependencyReleaseContexts(releaseContext, dependentNames, context, callback) {\n  const releaseName = releaseContext.getReleaseName(),\n        dependencies = releaseContext.getDependencies(),\n        done = () => {\n          const error = false;\n\n          callback(error);\n        }\n\n  dependentNames = [ ...dependentNames, releaseName ];  ///\n\n  dependencies.asynchronousForEachDependency((dependency, next, done) => {\n    const name = dependency.getName(),\n          releaseName = name, //\n          shortenedVersion = dependency.getShortedVersion(),\n          cyclicDependencyExists = checkCyclicDependencyExists(releaseName, dependentNames, releaseContext);\n\n    if (cyclicDependencyExists) {\n      const error = true;\n\n      callback(error);\n\n      return;\n    }\n\n    createReleaseContext(releaseName, dependentNames, shortenedVersion, context, (error) => {\n      if (error) {\n        error = !!error;  ///\n\n        callback(error);\n\n        return;\n      }\n\n      next();\n    });\n  }, done);\n}\n\nfunction checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {\n  const entries = releaseContext.getEntries(),\n        releaseMatchesShortedVersion = entries.matchShortenedVersion(shortenedVersion);\n\n  if (!releaseMatchesShortedVersion) {\n    const version = releaseContext.getVersion(),\n          releaseName = releaseContext.getReleaseName(),\n          versionString = version.toString(),\n          shortenedVersionString = shortenedVersion.toString();\n\n    releaseContext.error(`The '${releaseName}' package's version of ${versionString} does not match the dependency's shortened version of ${shortenedVersionString}.`);\n  }\n\n  return releaseMatchesShortedVersion;\n}\n"],"names":["createReleaseContext","releaseName","dependentNames","shortenedVersion","context","callback","releaseContextMap","releaseContext","error","releaseContextFromReleaseName","releaseMatchesShortedVersion","checkReleaseMatchesShortenedVersion","createDependencyReleaseContexts","checkCyclicDependencyExists","dependentNamesIncludesReleaseName","includes","cyclicDependencyExists","firstDependentName","first","dependencyNames","concat","dependencyNamesString","join","getReleaseName","dependencies","getDependencies","done","asynchronousForEachDependency","dependency","next","name","getName","getShortedVersion","entries","getEntries","matchShortenedVersion","version","getVersion","versionString","toString","shortenedVersionString"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/releaseContext.js"],"sourcesContent":["\"use strict\";\n\nexport function createReleaseContext(releaseName, dependentNames, shortenedVersion, context, callback) {\n  const { releaseContextMap } = context,\n        releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext !== null) {\n    const error = false;\n\n    callback(error);\n\n    return;\n  }\n\n  const { releaseContextFromReleaseName } = context;\n\n  releaseContextFromReleaseName(releaseName, context, (releaseContext) => {\n    if (releaseContext === null) {\n      const error = true;\n\n      callback(error);\n\n      return;\n    }\n\n    const releaseMatchesShortedVersion = checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion);\n\n    if (!releaseMatchesShortedVersion) {\n      const error = true;\n\n      callback(error);\n\n      return;\n    }\n\n    createDependencyReleaseContexts(releaseContext, dependentNames, context, (error) => {\n      if (!error) {\n        releaseContextMap[releaseName] = releaseContext;\n      }\n\n      callback(error);\n    });\n  }, context);\n}\n\nexport function initialiseReleaseContexts(releaseName, releaseContextMap) {\n  const releaseContext = releaseContextMap[releaseName];\n\n  initialiseReleaseContext(releaseContext, releaseContextMap);\n}\n\nexport default {\n  createReleaseContext,\n  initialiseReleaseContexts\n};\n\nfunction initialiseReleaseContext(releaseContext, releaseContextMap) {\n  const initialised = releaseContext.isInitialised();\n\n  if (initialised) {\n    return;\n  }\n\n  const dependencies = releaseContext.getDependencies();\n\n  dependencies.forEachDependency((dependency) => {\n    const name = dependency.getName(),\n          releaseName = name, ///\n          releaseContext = releaseContextMap[releaseName];\n\n    initialiseReleaseContext(releaseContext, releaseContextMap);\n  });\n\n  const dependencyReleaseContexts = retrieveDependencyReleaseContexts(releaseContext, releaseContextMap);\n\n  releaseContext.initialise(dependencyReleaseContexts);\n}\n\nfunction checkCyclicDependencyExists(releaseName, dependentNames, releaseContext) {\n  const dependentNamesIncludesReleaseName = dependentNames.includes(releaseName),\n        cyclicDependencyExists = dependentNamesIncludesReleaseName;  ///\n\n  if (cyclicDependencyExists) {\n    const firstDependentName = first(dependentNames),\n          dependencyNames = dependentNames.concat(firstDependentName),\n          dependencyNamesString = dependencyNames.join(`' -> '`);\n\n    releaseContext.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);\n  }\n\n  return cyclicDependencyExists;\n}\n\nfunction createDependencyReleaseContexts(releaseContext, dependentNames, context, callback) {\n  const releaseName = releaseContext.getReleaseName(),\n        dependencies = releaseContext.getDependencies(),\n        done = () => {\n          const error = false;\n\n          callback(error);\n        }\n\n  dependentNames = [ ...dependentNames, releaseName ];  ///\n\n  dependencies.asynchronousForEachDependency((dependency, next, done) => {\n    const name = dependency.getName(),\n          releaseName = name, //\n          shortenedVersion = dependency.getShortedVersion(),\n          cyclicDependencyExists = checkCyclicDependencyExists(releaseName, dependentNames, releaseContext);\n\n    if (cyclicDependencyExists) {\n      const error = true;\n\n      callback(error);\n\n      return;\n    }\n\n    createReleaseContext(releaseName, dependentNames, shortenedVersion, context, (error) => {\n      if (error) {\n        error = !!error;  ///\n\n        callback(error);\n\n        return;\n      }\n\n      next();\n    });\n  }, done);\n}\n\nfunction retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, dependencyReleaseContexts = []) {\n  const dependencies = releaseContext.getDependencies();\n\n  dependencies.forEachDependency((dependency) => {\n    const dependencyName = dependency.getName(),\n          dependencyReleaseName = dependencyName, ///\n          dependencyReleaseContext = releaseContextMap[dependencyReleaseName],\n          dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);\n\n    if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {\n      const releaseContext = dependencyReleaseContext;  ///\n\n      retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, dependencyReleaseContexts);\n\n      dependencyReleaseContexts.push(dependencyReleaseContext);\n    }\n  });\n\n  return dependencyReleaseContexts;\n}\n\nfunction checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {\n  const entries = releaseContext.getEntries(),\n        releaseMatchesShortedVersion = entries.matchShortenedVersion(shortenedVersion);\n\n  if (!releaseMatchesShortedVersion) {\n    const version = releaseContext.getVersion(),\n          releaseName = releaseContext.getReleaseName(),\n          versionString = version.toString(),\n          shortenedVersionString = shortenedVersion.toString();\n\n    releaseContext.error(`The '${releaseName}' package's version of ${versionString} does not match the dependency's shortened version of ${shortenedVersionString}.`);\n  }\n\n  return releaseMatchesShortedVersion;\n}\n"],"names":["createReleaseContext","initialiseReleaseContexts","releaseName","dependentNames","shortenedVersion","context","callback","releaseContextMap","releaseContext","error","releaseContextFromReleaseName","releaseMatchesShortedVersion","checkReleaseMatchesShortenedVersion","createDependencyReleaseContexts","initialiseReleaseContext","initialised","isInitialised","dependencies","getDependencies","forEachDependency","dependency","name","getName","dependencyReleaseContexts","retrieveDependencyReleaseContexts","initialise","checkCyclicDependencyExists","dependentNamesIncludesReleaseName","includes","cyclicDependencyExists","firstDependentName","first","dependencyNames","concat","dependencyNamesString","join","getReleaseName","done","asynchronousForEachDependency","next","getShortedVersion","dependencyName","dependencyReleaseName","dependencyReleaseContext","dependencyReleaseContextsIncludesDependencyReleaseContext","push","entries","getEntries","matchShortenedVersion","version","getVersion","versionString","toString","shortenedVersionString"],"mappings":"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"}

package/lib/verify/release.js

@@ -21,7 +21,7 @@ function verifyRelease(releaseName, releaseContextMap) {
         releaseContext.debug("Verifying the '".concat(releaseName, "' package..."));
         var dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, releaseContextMap);
         if (dependencyReleasesVVerified) {
-            var releaseFilesVerified = verifyReleaseFiles(releaseContext, releaseContextMap);
+            var releaseFilesVerified = verifyReleaseFiles(releaseContext);
             if (releaseFilesVerified) {
                 releaseVerified = true;
             }
@@ -34,12 +34,7 @@ function verifyRelease(releaseName, releaseContextMap) {
     }
     return releaseVerified;
 }
-function verifyReleaseFiles(releaseContext, releaseContextMap) {
-    var dependencies = releaseContext.getDependencies(), releaseContexts = dependencies.mapDependency(function(dependency) {
-        var name = dependency.getName(), releaseName = name, _$releaseContext = releaseContextMap[releaseName];
-        return _$releaseContext;
-    }), dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependencies, releaseContextMap);
-    releaseContext.initialise(releaseContexts, dependencyReleaseContexts);
+function verifyReleaseFiles(releaseContext) {
     var filesVerified = (0, _files.default)(releaseContext), releaseFilesVerified = filesVerified; ///
     return releaseFilesVerified;
 }
@@ -52,17 +47,5 @@ function verifyDependencyReleases(releaseContext, releaseContextMap) {
     });
     return dependencyReleasesVVerified;
 }
-function retrieveDependencyReleaseContexts(dependencies, releaseContextMap) {
-    var dependencyReleaseContexts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
-    dependencies.forEachDependency(function(dependency) {
-        var dependencyName = dependency.getName(), dependencyReleaseName = dependencyName, dependencyReleaseContext = releaseContextMap[dependencyReleaseName], dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
-        if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
-            var releaseContext = dependencyReleaseContext, _$dependencies = releaseContext.getDependencies();
-            retrieveDependencyReleaseContexts(_$dependencies, releaseContextMap, dependencyReleaseContexts);
-            dependencyReleaseContexts.push(dependencyReleaseContext);
-        }
-    });
-    return dependencyReleaseContexts;
-}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.373",
+  "version": "0.0.374",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/context/release/directory.js

@@ -44,8 +44,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getTypes(releaseNames = []) {
     const types = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -70,8 +70,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getAxioms(releaseNames = []) {
     const axioms = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -96,8 +96,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getLabels(releaseNames = []) {
     const labels = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -122,8 +122,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getCombinators(releaseNames = []) {
     const combinators = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -148,8 +148,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
 
   getConstructors(releaseNames = []) {
     const constructors = [],
-        releaseName = this.getReleaseName(),
-        releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
       releaseNames.push(releaseName);
@@ -195,8 +195,8 @@ export default class DirectoryReleaseContext extends ReleaseContext {
           florenceParser = null,
           releaseContexts = null,
           fileContexts = [],
-          releaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
+          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, fileContexts);
 
-    return releaseContext;
+    return directoryReleaseContext;
   }
 }

package/src/context/release/file.js

@@ -0,0 +1,167 @@
+"use strict";
+
+import ReleaseContext from "../../context/release";
+
+import { push } from "../../utilities/array";
+import {combinedCustomGrammarFromReleaseContexts, customGrammarFromNameAndEntries} from "../../utilities/customGrammar";
+
+export default class FileReleaseContext extends ReleaseContext {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors) {
+    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts);
+
+    this.rules = rules;
+    this.types = types;
+    this.axioms = axioms;
+    this.labels = labels;
+    this.combinators = combinators;
+    this.constructors = constructors;
+    this.contextJSON = contextJSON;
+  }
+
+  getContextJSON() {
+    return this.contextJSON;
+  }
+
+  getRules(releaseNames = []) {
+    const rules = [
+            ...this.rules
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextRules = releaseContext.getRules(releaseNames);
+
+        push(rules, releaseContextRules);
+      });
+    }
+
+    return rules;
+  }
+
+  getTypes(releaseNames = []) {
+    const types = [
+            ...this.types
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+
+        push(types, releaseContextTypes);
+      });
+    }
+
+    return types;
+  }
+
+  getAxioms(releaseNames = []) {
+    const axioms = [
+            ...this.axioms
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+
+        push(axioms, releaseContextAxioms);
+      });
+    }
+
+    return axioms;
+  }
+
+  getLabels(releaseNames = []) {
+    const labels = [
+            ...this.labels
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextLabels = releaseContext.getLabels(releaseNames);
+
+        push(labels, releaseContextLabels);
+      });
+    }
+
+    return labels;
+  }
+
+  getCombinators(releaseNames = []) {
+    const combinators = [
+            ...this.combinators
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+
+        push(combinators, releaseContextCombinators);
+      });
+    }
+
+    return combinators;
+  }
+
+  getConstructors(releaseNames = []) {
+    const constructors = [
+            ...this.constructors
+          ],
+          releaseName = this.getReleaseName(),
+          releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(releaseName);
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+
+        push(constructors, releaseContextConstructors);
+      });
+    }
+
+    return constructors;
+  }
+
+  initialise(dependencyReleaseContexts) {
+    super.initialise(dependencyReleaseContexts);
+
+    debugger
+  }
+
+  static fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {
+    const verified = false, ///
+          customGrammar = customGrammarFromNameAndEntries(name, entries),
+          florenceLexer = null,
+          florenceParser = null,
+          releaseContexts = null,
+          rules = null,
+          types = null,
+          axioms = null,
+          labels = null,
+          combinators = null,
+          constructors = null,
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, releaseContexts, contextJSON, rules, types, axioms, labels, combinators, constructors);
+
+    return releaseContext;
+  }
+}

package/src/context/release.js

@@ -58,11 +58,17 @@ export default class ReleaseContext {
 
   getReleaseName() {
     const name = this.getName(),
-        releaseName = name; ///
+         releaseName = name; ///
 
     return releaseName;
   }
 
+  isInitialised() {
+    const initialised = (this.releaseContexts !== null);  ///
+
+    return initialised;
+  }
+
   getFile(filePath) { return this.entries.getFile(filePath); }
 
   getVersion() { return this.entries.getVersion(); }
@@ -99,12 +105,13 @@ export default class ReleaseContext {
 
   complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
 
-  initialise(releaseContexts, dependencyReleaseContexts) {
-    const releaseContext = this;  ///
-
-    releaseContexts = [ releaseContext, ...dependencyReleaseContexts ]; ///
-
-    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
+  initialise(dependencyReleaseContexts) {
+    const releaseContext = this,  ///
+          releaseContexts = [
+            releaseContext,
+            ...dependencyReleaseContexts
+          ],
+          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
 
     this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 

package/src/index.js

@@ -4,6 +4,7 @@ export { default as Callbacks } from "./callbacks";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
 export { default as versionChanges } from "./versionChanges";
+export { default as FileReleaseContext } from "./context/release/file";
 export { default as DirectoryReleaseContext } from "./context/release/directory";
 
 export { default as jsonUtilities } from "./utilities/json";

package/src/utilities/releaseContext.js

@@ -43,10 +43,39 @@ export function createReleaseContext(releaseName, dependentNames, shortenedVersi
   }, context);
 }
 
+export function initialiseReleaseContexts(releaseName, releaseContextMap) {
+  const releaseContext = releaseContextMap[releaseName];
+
+  initialiseReleaseContext(releaseContext, releaseContextMap);
+}
+
 export default {
-  createReleaseContext
+  createReleaseContext,
+  initialiseReleaseContexts
 };
 
+function initialiseReleaseContext(releaseContext, releaseContextMap) {
+  const initialised = releaseContext.isInitialised();
+
+  if (initialised) {
+    return;
+  }
+
+  const dependencies = releaseContext.getDependencies();
+
+  dependencies.forEachDependency((dependency) => {
+    const name = dependency.getName(),
+          releaseName = name, ///
+          releaseContext = releaseContextMap[releaseName];
+
+    initialiseReleaseContext(releaseContext, releaseContextMap);
+  });
+
+  const dependencyReleaseContexts = retrieveDependencyReleaseContexts(releaseContext, releaseContextMap);
+
+  releaseContext.initialise(dependencyReleaseContexts);
+}
+
 function checkCyclicDependencyExists(releaseName, dependentNames, releaseContext) {
   const dependentNamesIncludesReleaseName = dependentNames.includes(releaseName),
         cyclicDependencyExists = dependentNamesIncludesReleaseName;  ///
@@ -101,6 +130,27 @@ function createDependencyReleaseContexts(releaseContext, dependentNames, context
   }, done);
 }
 
+function retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, dependencyReleaseContexts = []) {
+  const dependencies = releaseContext.getDependencies();
+
+  dependencies.forEachDependency((dependency) => {
+    const dependencyName = dependency.getName(),
+          dependencyReleaseName = dependencyName, ///
+          dependencyReleaseContext = releaseContextMap[dependencyReleaseName],
+          dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
+
+    if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
+      const releaseContext = dependencyReleaseContext;  ///
+
+      retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, dependencyReleaseContexts);
+
+      dependencyReleaseContexts.push(dependencyReleaseContext);
+    }
+  });
+
+  return dependencyReleaseContexts;
+}
+
 function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
   const entries = releaseContext.getEntries(),
         releaseMatchesShortedVersion = entries.matchShortenedVersion(shortenedVersion);

package/src/verify/release.js

@@ -14,7 +14,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
     const dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, releaseContextMap);
 
     if (dependencyReleasesVVerified) {
-      const releaseFilesVerified = verifyReleaseFiles(releaseContext, releaseContextMap);
+      const releaseFilesVerified = verifyReleaseFiles(releaseContext);
 
       if (releaseFilesVerified) {
         releaseVerified = true;
@@ -33,19 +33,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
   return releaseVerified;
 }
 
-function verifyReleaseFiles(releaseContext, releaseContextMap) {
-  const dependencies = releaseContext.getDependencies(),
-        releaseContexts = dependencies.mapDependency((dependency) => {
-          const name = dependency.getName(),
-                releaseName = name, ///
-                releaseContext = releaseContextMap[releaseName];
-
-          return releaseContext;
-        }),
-        dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependencies, releaseContextMap);
-
-  releaseContext.initialise(releaseContexts, dependencyReleaseContexts);
-
+function verifyReleaseFiles(releaseContext) {
   const filesVerified = verifyFiles(releaseContext),
         releaseFilesVerified = filesVerified; ///
 
@@ -66,23 +54,3 @@ function verifyDependencyReleases(releaseContext, releaseContextMap) {
 
   return dependencyReleasesVVerified;
 }
-
-function retrieveDependencyReleaseContexts(dependencies, releaseContextMap, dependencyReleaseContexts = []) {
-  dependencies.forEachDependency((dependency) => {
-    const dependencyName = dependency.getName(),
-          dependencyReleaseName = dependencyName, ///
-          dependencyReleaseContext = releaseContextMap[dependencyReleaseName],
-          dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
-
-    if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
-      const releaseContext = dependencyReleaseContext,  ///
-            dependencies = releaseContext.getDependencies();
-
-      retrieveDependencyReleaseContexts(dependencies, releaseContextMap, dependencyReleaseContexts);
-
-      dependencyReleaseContexts.push(dependencyReleaseContext);
-    }
-  });
-
-  return dependencyReleaseContexts;
-}