occam-model 1.0.484

package/lib/version.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Version;
+    }
+});
+var _multiplers = require("./multiplers");
+var _version = require("./utilities/version");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var Version = /*#__PURE__*/ function() {
+    function Version(majorNumber, minorNumber, patchNumber) {
+        _class_call_check(this, Version);
+        this.majorNumber = majorNumber;
+        this.minorNumber = minorNumber;
+        this.patchNumber = patchNumber;
+    }
+    _create_class(Version, [
+        {
+            key: "getMajorNumber",
+            value: function getMajorNumber() {
+                return this.majorNumber;
+            }
+        },
+        {
+            key: "getMinorNumber",
+            value: function getMinorNumber() {
+                return this.minorNumber;
+            }
+        },
+        {
+            key: "getPatchNumber",
+            value: function getPatchNumber() {
+                return this.patchNumber;
+            }
+        },
+        {
+            key: "bumpMajorNumber",
+            value: function bumpMajorNumber() {
+                this.majorNumber += 1;
+            }
+        },
+        {
+            key: "bumpMinorNumber",
+            value: function bumpMinorNumber() {
+                this.minorNumber += 1;
+            }
+        },
+        {
+            key: "bumpPatchNumber",
+            value: function bumpPatchNumber() {
+                this.patchNumber += 1;
+            }
+        },
+        {
+            key: "resetMajorNumber",
+            value: function resetMajorNumber() {
+                this.majorNumber = 0;
+            }
+        },
+        {
+            key: "resetMinorNumber",
+            value: function resetMinorNumber() {
+                this.minorNumber = 0;
+            }
+        },
+        {
+            key: "resetPatchNumber",
+            value: function resetPatchNumber() {
+                this.patchNumber = 0;
+            }
+        },
+        {
+            key: "matchShortenedVersion",
+            value: function matchShortenedVersion(shortenedVersion) {
+                var matchesShortenedVersion = false;
+                if (shortenedVersion === null) {
+                    matchesShortenedVersion = true;
+                } else {
+                    var majorNumber = shortenedVersion.getMajorNumber();
+                    if (this.majorNumber === majorNumber) {
+                        var minorNumber = shortenedVersion.getMinorNumber();
+                        if (this.minorNumber >= minorNumber) {
+                            matchesShortenedVersion = true;
+                        }
+                    }
+                }
+                return matchesShortenedVersion;
+            }
+        },
+        {
+            key: "toString",
+            value: function toString() {
+                var string = "".concat(this.majorNumber, ".").concat(this.minorNumber, ".").concat(this.patchNumber);
+                return string;
+            }
+        },
+        {
+            key: "toVersionNumber",
+            value: function toVersionNumber() {
+                var versionNumber = this.majorNumber * _multiplers.MAJOR_NUMBER_MULTIPLIER + this.minorNumber * _multiplers.MINOR_NUMBER_MULTIPLIER + this.patchNumber * _multiplers.PATCH_NUMBER_MULTIPLIER;
+                return versionNumber;
+            }
+        }
+    ], [
+        {
+            key: "fromString",
+            value: function fromString(string) {
+                var majorNumber = (0, _version.majorNumberFromString)(string), minorNumber = (0, _version.minorNumberFromString)(string), patchNumber = (0, _version.patchNumberFromString)(string), version = new Version(majorNumber, minorNumber, patchNumber);
+                return version;
+            }
+        },
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var majorNumber = 0, minorNumber = 0, patchNumber = 0, version = new Version(majorNumber, minorNumber, patchNumber);
+                return version;
+            }
+        },
+        {
+            key: "fromVersion",
+            value: function fromVersion(version) {
+                var majorNumber = version.getMajorNumber(), minorNumber = version.getMinorNumber(), patchNumber = version.getPatchNumber();
+                version = new Version(majorNumber, minorNumber, patchNumber); ///
+                return version;
+            }
+        },
+        {
+            key: "fromVersionNumber",
+            value: function fromVersionNumber(versionNumber) {
+                var number = versionNumber, majorNumber = (0, _version.majorNumberFromNumber)(number), minorNumber = (0, _version.minorNumberFromNumber)(number), patchNumber = (0, _version.patchNumberFromNumber)(number), version = new Version(majorNumber, minorNumber, patchNumber);
+                return version;
+            }
+        }
+    ]);
+    return Version;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/license.txt

@@ -0,0 +1,48 @@
+MIT And Anti-996 Licenses
+
+Copyright (c) 2023 James Smith
+
+These licenses shall be included in all copies or substantial portions of
+this software and associated documentation files (the "Software").
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this Software, to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+1. The individual or the legal entity must conspicuously display,
+without modification, this License and the notice on each redistributed
+or derivative copy of the Licensed Work.
+
+2. The individual or the legal entity must strictly comply with all
+applicable laws, regulations, rules and standards of the jurisdiction
+relating to labor and employment where the individual is physically
+located or where the individual was born or naturalized; or where the
+legal entity is registered or is operating (whichever is stricter). In
+case that the jurisdiction has no such laws, regulations, rules and
+standards or its laws, regulations, rules and standards are
+unenforceable, the individual or the legal entity are required to
+comply with Core International Labor Standards.
+
+3. The individual or the legal entity shall not induce, suggest or force
+its employee(s), whether full-time or part-time, or its independent
+contractor(s), in any methods, to agree in oral or written form, to
+directly or indirectly restrict, weaken or relinquish his or her
+rights or remedies under such laws, regulations, rules and standards
+relating to labor and employment as mentioned above, no matter whether
+such written or oral agreements are enforceable under the laws of the
+said jurisdiction, nor shall such individual or the legal entity
+limit, in any methods, the rights of its employee(s) or independent
+contractor(s) from reporting or complaining to the copyright holder or
+relevant authorities monitoring the compliance of the license about
+its violation(s) of the said license.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "occam-model",
+  "author": "James Smith",
+  "version": "1.0.484",
+  "license": "MIT, Anti-996",
+  "homepage": "https://github.com/djalbat/occam-model",
+  "description": "Parts of Occam's model.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/djalbat/occam-model"
+  },
+  "dependencies": {
+    "necessary": "^17.0.9",
+    "occam-grammars": "^1.3.510",
+    "occam-query": "^4.1.142"
+  },
+  "devDependencies": {
+    "@swc/core": "1.13.20",
+    "watchful-cli": "^1.7.67"
+  },
+  "scripts": {
+    "clean": "rm -rf ./lib",
+    "watchful": "watchful -m --transpiler=swc --source-directory=./src --lib-directory=./lib",
+    "batch": "npm run watchful batch --",
+    "batch-debug": "npm run watchful batch -- --debug",
+    "incremental": "npm run watchful incremental --",
+    "incremental-debug": "npm run watchful incremental -- --debug",
+    "build": "npm run clean && npm run batch",
+    "build-debug": "npm run clean && npm run batch-debug",
+    "watch": "npm run clean && npm run batch && npm run incremental",
+    "watch-debug": "npm run clean && npm run batch-debug && npm run incremental-debug"
+  },
+  "main": "./lib/index.js"
+}

package/src/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export const EMPTY_STRING = "";
+export const DOUBLE_SPACE = "  ";
+export const ESCAPED_AMPERSAND = "&";
+export const ESCAPED_LESS_THAN = "<";
+export const ESCAPED_GREATER_THAN = ">";

package/src/dependencies.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import { asynchronousUtilities } from "necessary";
+
+import Dependency from "./dependency";
+import ShortenedVersion from "./shortenedVersion";
+
+const { forEach } = asynchronousUtilities;
+
+export default class Dependencies {
+  constructor(array) {
+    this.array = array;
+  }
+
+  addDependency(dependency) { this.array.push(dependency); }
+
+  mapDependency(callback) { return this.array.map(callback); }
+
+  everyDependency(callback) { return this.array.every(callback); }
+
+  reduceDependency(callback, initialValue) { return this.array.reduce(callback, initialValue); }
+
+  forEachDependency(callback) { this.array.forEach(callback); }
+
+  asynchronousForEachDependency(operation, done) { forEach(this.array, operation, done); }
+
+  toJSON() {
+    const dependenciesJSON = this.array.reduce((dependenciesJSON, dependency) => {
+            const name = dependency.getName(),
+                  shortenedVersion = dependency.getShortedVersion(),
+                  shortenedVersionString = shortenedVersion.toString();
+
+            dependenciesJSON[name] = shortenedVersionString;
+  
+            return dependenciesJSON;
+          }, {}),
+          json = dependenciesJSON; ///
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const dependenciesJSON = json, ///
+          dependenciesJSONKeys = Object.keys(dependenciesJSON),
+          names = dependenciesJSONKeys, ///
+          array = names.map((name) => {
+            const shortenedVersionString = dependenciesJSON[name],
+                  string = shortenedVersionString,  ///
+                  shortenedVersion = ShortenedVersion.fromString(string),
+                  dependency = Dependency.fromNameAndShortenedVersion(name, shortenedVersion);
+
+            return dependency;
+          }),
+          dependencies = new Dependencies(array);
+
+    return dependencies;
+  }
+
+  static fromNothing() {
+    const array = [],
+          dependencies = new Dependencies(array);
+
+    return dependencies;
+  }
+}

package/src/dependency.js

@@ -0,0 +1,43 @@
+"use strict";
+
+export default class Dependency {
+  constructor(name, shortenedVersion) {
+    this.name = name;
+    this.shortenedVersion = shortenedVersion;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getShortedVersion() {
+    return this.shortenedVersion;
+  }
+
+  asString() {
+    let string;
+
+    if (this.shortenedVersion !== null) {
+      const shortenedVersionString = this.shortenedVersion.toString();
+
+      string = `${this.name}@${shortenedVersionString}`;
+    } else {
+      string = this.name; ///
+    }
+
+    return string;
+  }
+
+  static fromName(name) {
+    const shortenedVersion = null,
+          dependency = new Dependency(name, shortenedVersion);
+
+    return dependency;
+  }
+
+  static fromNameAndShortenedVersion(name, shortenedVersion) {
+    const dependency = new Dependency(name, shortenedVersion);
+
+    return dependency;
+  }
+}

package/src/directory.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { DIRECTORY_TYPE } from "./types";
+
+export default class Directory {
+  constructor(path) {
+    this.path = path;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  isFile() {
+    const file = false;
+
+    return file;
+  }
+
+  isDirectory() {
+    const directory = true;
+
+    return directory;
+  }
+
+  toJSON() {
+    const { type } = Directory,
+          path = this.path,
+          json = {
+            type,
+            path
+          };
+
+    return json;
+  }
+
+  static type = DIRECTORY_TYPE;
+
+  static fromPath(path) {
+    const directory = new Directory(path);
+
+    return directory;
+  }
+
+  static fromJSON(json) {
+    let directory = null;
+
+    if (json !== null) {
+      const { type } = json;
+
+      if (type === DIRECTORY_TYPE) {
+        const { path } = json;
+
+        directory = new Directory(path);
+      }
+    }
+
+    return directory;
+  }
+}

package/src/entries.js

@@ -0,0 +1,206 @@
+"use strict";
+
+import { pathUtilities, arrayUtilities } from "necessary";
+
+import File from "./file";
+import Files from "./files";
+import Directory from "./directory";
+import bnfMixins from "./mixins/bnf";
+import filesMixins from "./mixins/files";
+import metaJSONMixins from "./mixins/metaJSON";
+import vocabularyMixins from "./mixins/vocabulary";
+
+const { first, filter } = arrayUtilities,
+      { topmostDirectoryNameFromPath } = pathUtilities;
+
+class Entries {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getTopmostDirectoryName() {
+    let topmostDirectoryName = null;
+    
+    const firstEntry = first(this.array); ///
+
+    if (firstEntry) { ///
+      const firstEntryPath = firstEntry.getPath();
+
+      topmostDirectoryName = topmostDirectoryNameFromPath(firstEntryPath);
+
+      if (topmostDirectoryName === null) {
+        topmostDirectoryName = firstEntryPath;  ///
+      }
+    }
+
+    return topmostDirectoryName;
+  }
+
+  removeFileByPath(path) {
+    filter(this.array, (entry) => {
+      const entryFile = entry.isFile();
+
+      if (entryFile) {
+        const file = entry, ///
+              filePath = file.getPath();
+
+        if (filePath === path) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+  }
+
+  findFile(filePath) {
+    const files = this.getFiles(),
+          file = files.findFile((file) => {
+            const filePathMatches = file.matchFilePath(filePath);
+
+            if (filePathMatches) {
+              return true;
+            }
+          }) || null;
+
+    return file;
+  }
+
+  getFiles() {
+    const files = Files.fromNothing();
+
+    this.mapEntry((entry) => {
+      const entryFile = entry.isFile();
+
+      if (entryFile) {
+        const file = entry; ///
+
+        files.addFile(file);
+      }
+    });
+
+    return files;
+  }
+
+  getFilePaths() {
+    const filePaths = this.reduceEntry((filePaths, entry) => {
+      const entryFile = entry.isFile();
+
+      if (entryFile) {
+        const file = entry, ///
+              filePath = file.getPath();
+
+        filePaths.push(filePath);
+      }
+
+      return filePaths;
+    }, []);
+
+    return filePaths;
+  }
+
+  getDirectoryPaths() {
+    const directoryPaths = this.reduceEntry((directoryPaths, entry) => {
+      const entryDirectory = entry.isDirectory();
+
+      if (entryDirectory) {
+        const directory = entry, ///
+              directoryPath = directory.getPath();
+
+        directoryPaths.push(directoryPath);
+      }
+
+      return directoryPaths;
+    }, []);
+
+    return directoryPaths;
+  }
+
+  matchShortenedVersion(shortenedVersion) {
+    const version = this.getVersion(),
+          versionMatchesShortenedVersion = version.matchShortenedVersion(shortenedVersion);
+
+    return versionMatchesShortenedVersion;
+  }
+
+  addFile(file) {
+    const entry = file; ///
+
+    this.addEntry(entry);
+  }
+
+  addEntry(entry) { this.array.push(entry); }
+
+  addDirectory(directory) {
+    const entry = directory;  ///
+
+    this.addEntry(entry);
+  }
+
+  forEachFile(callback) {
+    const files = this.getFiles();
+
+    files.forEachFile(callback);
+  }
+
+  mapEntry(callback) { return this.array.map(callback); }
+
+  someEntry(callback) { return this.array.some(callback); }
+
+  everyEntry(callback) { return this.array.every(callback); }
+
+  forEachEntry(callback) { this.array.forEach(callback); }
+
+  reduceEntry(callback, initialValue) { return this.array.reduce(callback, initialValue); }
+
+  toJSON() {
+    const entriesJSON = this.array.map((entry) => {
+            const entryJSON = entry.toJSON();
+  
+            return entryJSON;
+          }),
+          json = entriesJSON; ///
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const array = [],
+          entries = new Entries(array),
+          entriesJSON = json; ///
+
+    entriesJSON.map((entryJSON) => {
+      const json = entryJSON, ///
+            file = File.fromJSON(json),
+            directory = Directory.fromJSON(json),
+            entry = file || directory;  ///
+
+      entries.addEntry(entry);
+    });
+
+    return entries;
+  }
+
+  static fromEntry(entry) {
+    const array = [
+            entry
+          ],
+          entries = new Entries(array);
+
+    return entries;
+  }
+
+  static fromNothing() {
+    const array = [],
+          entries = new Entries(array);
+
+    return entries;
+  }
+}
+
+Object.assign(Entries.prototype, bnfMixins);
+Object.assign(Entries.prototype, filesMixins);
+Object.assign(Entries.prototype, metaJSONMixins);
+Object.assign(Entries.prototype, vocabularyMixins);
+
+export default Entries;