occam-model 1.0.484

package/src/release.js

@@ -0,0 +1,151 @@
+"use strict";
+
+import File from "./file";
+import Entries from "./entries";
+import entriesMixins from "./mixins/entries";
+
+import { DOUBLE_SPACE } from "./constants";
+import { isMetaJSONFileValid } from "./utilities/metaJSON";
+import { isFilePathReleaseFilePath } from "./utilities/filePath";
+import { readmeFileFromFiles, metaJSONFileFromFiles } from "./utilities/files";
+
+class Release {
+  constructor(name, entries) {
+    this.name = name;
+    this.entries = entries;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getEntries() {
+    return this.entries;
+  }
+
+  updateVersion(version) {
+    let repository = this.getRepository(),
+        dependencies = this.getDependencies();
+
+    const versionString = version.toString(),
+          repositoryJSON = repository,  ///
+          dependenciesJSON = dependencies.toJSON();
+
+    version = versionString;  ///
+    repository = repositoryJSON;  ///
+    dependencies = dependenciesJSON;  ///
+
+    const metaJSONFile = this.getMetaJSONFile(),
+          json = {
+            version,
+            repository,
+            dependencies
+          },
+          jsonString = JSON.stringify(json, null, DOUBLE_SPACE),
+          file = metaJSONFile,  ///
+          content = jsonString; ///
+
+    file.setContent(content);
+  }
+
+  toJSON() {
+    const entriesJSON = this.entries.toJSON(),
+          name = this.name,
+          entries = entriesJSON,  ///
+          json = {
+            name,
+            entries
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    let { entries } = json;
+
+    const { name } = json,
+          entriesJSON = entries;  ///
+
+    json = entriesJSON; ///
+
+    entries = Entries.fromJSON(json); ///
+
+    const release = new Release(name, entries);
+
+    return release;
+  }
+
+  static fromProject(project) {
+    let release = null,
+        entries = project.getEntries();
+
+    const entriesReleasable = areEntriesReleasable(entries);
+
+    if (entriesReleasable) {
+      const name = project.getName(),
+            releasedEntries = releaseEntriesFromEntries(entries);
+
+      entries = releasedEntries;  ///
+
+      release = new Release(name, entries);
+    }
+
+    return release;
+  }
+
+  static fromNameAndEntries(name, entries) {
+    let release = null;
+
+    const entriesReleasable = areEntriesReleasable(entries);
+
+    if (entriesReleasable) {
+      release = new Release(name, entries);
+    }
+
+    return release;
+  }
+}
+
+Object.assign(Release.prototype, entriesMixins);
+
+export default Release;
+
+function releaseEntriesFromEntries(entries) {
+  const releasedEntries = Entries.fromNothing(),  ///
+        files = entries.getFiles();
+
+  files.forEachFile((file) => {
+    const filePath = file.getPath(),
+          filePathReleaseFilePath = isFilePathReleaseFilePath(filePath);
+
+    if (filePathReleaseFilePath) {
+      const path = filePath,  ///
+            content = file.getContent(),
+            released = true;
+
+      file = File.fromPathContentAndReleased(path, content, released);  ///
+
+      releasedEntries.addFile(file);
+    }
+  });
+
+  return releasedEntries;
+}
+
+function areEntriesReleasable(entries) {
+  let entriesReleasable = false;
+
+  const files = entries.getFiles(),
+        readmeFile = readmeFileFromFiles(files),
+        metaJSONFile = metaJSONFileFromFiles(files);
+
+  if ((readmeFile !== null) && (metaJSONFile !== null)) {
+    const metaJSONFileValid = isMetaJSONFileValid(metaJSONFile);
+
+    if (metaJSONFileValid) {
+      entriesReleasable = true;
+    }
+  }
+
+  return entriesReleasable;
+}

package/src/releases.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { asynchronousUtilities } from "necessary";
+
+import Release from "./release";
+
+const { forEach } = asynchronousUtilities;
+
+export default class Releases {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  addRelease(release) { this.array.push(release); }
+
+  mapRelease(callback) { return this.array.map(callback); }
+
+  reduceRelease(callback, initialValue) { return this.array.reduce(callback, initialValue); }
+
+  forEachRelease(callback) { this.array.forEach(callback); }
+
+  asynchronousForEachRelease(callback, done) { forEach(this.array, callback, done); }
+
+  toJSON() {
+    const json = this.array.map((release) => {
+      const releaseJSON = release.toJSON();
+
+      return releaseJSON;
+    });
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const array = json.map((json) => {  ///
+            const release = Release.fromJSON(json);
+
+            return release;
+          }),
+          releases = new Releases(array);
+
+    return releases;
+  }
+
+  static fromNothing() {
+    const array = [],
+          releases = new Releases(array);
+
+    return releases;
+  }
+}
+

package/src/shortenedVersion.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { MAJOR_NUMBER_MULTIPLIER, MINOR_NUMBER_MULTIPLIER } from "./multiplers";
+import { majorNumberFromNumber, minorNumberFromNumber, majorNumberFromString, minorNumberFromString } from "./utilities/version";
+
+export default class ShortenedVersion {
+  constructor(majorNumber, minorNumber) {
+    this.majorNumber = majorNumber;
+    this.minorNumber = minorNumber;
+  }
+
+  getMajorNumber() {
+    return this.majorNumber;
+  }
+
+  getMinorNumber() {
+    return this.minorNumber;
+  }
+
+  toString() {
+    const string = `${this.majorNumber}.${this.minorNumber}`;
+
+    return string;
+  }
+
+  toVersionNumber() {
+    const versionNumber = this.majorNumber * MAJOR_NUMBER_MULTIPLIER + this.minorNumber * MINOR_NUMBER_MULTIPLIER;
+
+    return versionNumber;
+  }
+
+  getLeastMatchingVersionNumber() {
+    const versionNumber = this.toVersionNumber(),
+          leastMatchingVersionNumber = versionNumber; ///
+
+    return leastMatchingVersionNumber;
+  }
+
+  getGreatestMatchingVersionNumber() {
+    const majorNumber = this.majorNumber + 1,
+          minorNumber = 0,
+          shortenedVersion = ShortenedVersion.fromMajorNumberAndMinorNumber(majorNumber, minorNumber),
+          shortenedVersionNumber = shortenedVersion.toVersionNumber(),
+          greatestMatchingVersionNumber = shortenedVersionNumber - 1;
+
+    return greatestMatchingVersionNumber;
+  }
+
+  static fromString(string) {
+    const majorNumber = majorNumberFromString(string),
+          minorNumber = minorNumberFromString(string),
+          shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+
+    return shortenedVersion;
+  }
+
+  static fromVersionNumber(versionNumber) {
+    const number = versionNumber, ///
+          majorNumber = majorNumberFromNumber(number),
+          minorNumber = minorNumberFromNumber(number),
+          shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+
+    return shortenedVersion;
+  }
+
+  static fromMajorNumberAndMinorNumber(majorNumber, minorNumber) {
+    const shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+
+    return shortenedVersion;
+  }
+}

package/src/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export const FILE_TYPE = "File";
+export const DIRECTORY_TYPE = "Directory";

package/src/utilities/content.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { DOUBLE_SPACE, EMPTY_STRING, ESCAPED_AMPERSAND, ESCAPED_LESS_THAN, ESCAPED_GREATER_THAN } from "../constants";
+
+export function sanitiseContent(content) {
+  const sanitisedContent = content
+                             .replace(/&/g, ESCAPED_AMPERSAND)
+                             .replace(/</g, ESCAPED_LESS_THAN)
+                             .replace(/>/g, ESCAPED_GREATER_THAN);
+
+  return sanitisedContent;
+}
+
+export function trimDoubleQuotes(content) { return content.replace(/(^"|"$)/g, EMPTY_STRING); } ///
+
+export function convertContentTabsToWhitespace(content) { return content.replace(/\t/g, DOUBLE_SPACE); } ///
+
+export default {
+  sanitiseContent,
+  trimDoubleQuotes,
+  convertContentTabsToWhitespace
+};

package/src/utilities/filePath.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const readmeFilePathPattern = "^(?:[^\\/]+\\/){1}README\\.md$",
+      furtleFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.ftl$",
+      nominalFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.nml$",
+      markdownFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.md$",
+      metaJSONFilePathPattern = "^(?:[^\\/]+\\/){1}meta\\.json$",
+      indexJSONFilePathPattern = "^(?:[^\\/]+\\/){1}index\\.json$",
+      markdownStyleFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.mds$",
+      customGrammarBNFFilePathPattern = "^(?:[^\\/]+\\/){1}(term|statement)\\.bnf$",
+      defaultMarkdownStyleFilePathPattern = "^[^\\/]+\\/default\\.mds$",
+      customGrammarVocabularyFilePathPattern = "^(?:[^\\/]+\\/){1}(type|symbol)\\.vcb$",
+      releaseFilePathPattern = `${readmeFilePathPattern}|${furtleFilePathPattern}|${nominalFilePathPattern}|${metaJSONFilePathPattern}|${customGrammarBNFFilePathPattern}|${customGrammarVocabularyFilePathPattern}`,
+      recognisedFilePathPattern = `${releaseFilePathPattern}|${indexJSONFilePathPattern}|${markdownFilePathPattern}|${markdownStyleFilePathPattern}`;
+
+const readmeFilePathRegularExpression = new RegExp(readmeFilePathPattern),
+      furtleFilePathRegularExpression = new RegExp(furtleFilePathPattern),
+      releaseFilePathRegularExpression = new RegExp(releaseFilePathPattern),
+      nominalFilePathRegularExpression = new RegExp(nominalFilePathPattern),
+      markdownFilePathRegularExpression = new RegExp(markdownFilePathPattern),
+      metaJSONFilePathRegularExpression = new RegExp(metaJSONFilePathPattern),
+      indexJSONFilePathRegularExpression = new RegExp(indexJSONFilePathPattern),
+      recognisedFilePathRegularExpression = new RegExp(recognisedFilePathPattern),
+      markdownStyleFilePathRegularExpression = new RegExp(markdownStyleFilePathPattern),
+      customGrammarBNFFilePathRegularExpression = new RegExp(customGrammarBNFFilePathPattern),
+      defaultMarkdownStyleFilePathRegularExpression = new RegExp(defaultMarkdownStyleFilePathPattern),
+      customGrammarVocabularyFilePathRegularExpression = new RegExp(customGrammarVocabularyFilePathPattern);
+
+export function isFilePathReadmeFilePath(filePath) { return readmeFilePathRegularExpression.test(filePath); }
+
+export function isFilePathFurtleFilePath(filePath) { return furtleFilePathRegularExpression.test(filePath); }
+
+export function isFilePathReleaseFilePath(filePath) { return releaseFilePathRegularExpression.test(filePath); }
+
+export function isFilePathNominalFilePath(filePath) { return nominalFilePathRegularExpression.test(filePath); }
+
+export function isFilePathMarkdownFilePath(filePath) { return markdownFilePathRegularExpression.test(filePath); }
+
+export function isFilePathMetaJSONFilePath(filePath) { return metaJSONFilePathRegularExpression.test(filePath); }
+
+export function isFilePathIndexJSONFilePath(filePath) { return indexJSONFilePathRegularExpression.test(filePath); }
+
+export function isFilePathRecognisedFilePath(filePath) { return recognisedFilePathRegularExpression.test(filePath); }
+
+export function isFilePathMarkdownStyleFilePath(filePath) { return markdownStyleFilePathRegularExpression.test(filePath); }
+
+export function isFilePathCustomGrammarBNFFilePath(filePath) { return customGrammarBNFFilePathRegularExpression.test(filePath); }
+
+export function isFilePathDefaultMarkdownStyleFilePath(filePath) { return defaultMarkdownStyleFilePathRegularExpression.test(filePath); }
+
+export function isFilePathCustomGrammarVocabularyFilePath(filePath) { return customGrammarVocabularyFilePathRegularExpression.test(filePath); }
+
+export default {
+  isFilePathReadmeFilePath,
+  isFilePathFurtleFilePath,
+  isFilePathReleaseFilePath,
+  isFilePathNominalFilePath,
+  isFilePathMarkdownFilePath,
+  isFilePathMetaJSONFilePath,
+  isFilePathIndexJSONFilePath,
+  isFilePathRecognisedFilePath,
+  isFilePathMarkdownStyleFilePath,
+  isFilePathCustomGrammarBNFFilePath,
+  isFilePathDefaultMarkdownStyleFilePath,
+  isFilePathCustomGrammarVocabularyFilePath
+};

package/src/utilities/files.js

@@ -0,0 +1,114 @@
+"use strict";
+
+import { isFilePathReadmeFilePath,
+         isFilePathFurtleFilePath,
+         isFilePathNominalFilePath,
+         isFilePathMetaJSONFilePath,
+         isFilePathCustomGrammarBNFFilePath,
+         isFilePathCustomGrammarVocabularyFilePath } from "../utilities/filePath";
+
+export function readmeFileFromFiles(files) {
+  let readmeFile = null;
+
+  files.someFile((file) => {
+    const filePath = file.getPath(),
+          filePathReadmeFilePath = isFilePathReadmeFilePath(filePath);
+
+    if (filePathReadmeFilePath) {
+      readmeFile = file;  ///
+
+      return true;
+    }
+  });
+
+  return readmeFile;
+}
+
+export function furtleFilesFromFiles(files) {
+  const furtleFiles = files.reduceFile((furtleFiles, file) => {
+    const filePath = file.getPath(),
+          filePathFurtleFilePath = isFilePathFurtleFilePath(filePath),
+          fileFurtleFile = filePathFurtleFilePath;  ///
+
+    if (fileFurtleFile) {
+      const furtleFile = file;  ///
+
+      furtleFiles.push(furtleFile);
+    }
+
+    return furtleFiles;
+  }, []);
+
+  return furtleFiles;
+}
+
+export function nominalFilesFromFiles(files) {
+  const nominalFiles = files.reduceFile((nominalFiles, file) => {
+    const filePath = file.getPath(),
+      filePathNominalFilePath = isFilePathNominalFilePath(filePath),
+      fileNominalFile = filePathNominalFilePath;  ///
+
+    if (fileNominalFile) {
+      const nominalFile = file;  ///
+
+      nominalFiles.push(nominalFile);
+    }
+
+    return nominalFiles;
+  }, []);
+
+  return nominalFiles;
+}
+
+export function metaJSONFileFromFiles(files) {
+  let metaJSONFile = null;
+
+  files.someFile((file) => {
+    const filePath = file.getPath(),
+          filePathMetaJSONFilePath = isFilePathMetaJSONFilePath(filePath);
+
+    if (filePathMetaJSONFilePath) {
+      metaJSONFile = file;  ///
+
+      return true;
+    }
+  });
+
+  return metaJSONFile;
+}
+
+export function customGrammarBNFFilesFromFiles(files) {
+  const customGrammarBNFFiles = files.reduceFile((customGrammarBNFFiles, file) => {
+          const filePath = file.getPath(),
+                filePathCustomGrammarBNFFilePath = isFilePathCustomGrammarBNFFilePath(filePath),
+                fileCustomGrammarBNFFile = filePathCustomGrammarBNFFilePath;  ///
+
+          if (fileCustomGrammarBNFFile) {
+            const customGrammarBNFFile = file;  ///
+
+            customGrammarBNFFiles.push(customGrammarBNFFile);
+          }
+
+          return customGrammarBNFFiles;
+        }, []);
+
+  return customGrammarBNFFiles;
+}
+
+export function customGrammarVocabularyFilesFromFiles(files) {
+  const customGrammarVocabularyFiles = files.reduceFile((customGrammarVocabularyFiles, file) => {
+          const filePath = file.getPath(),
+                filePathCustomGrammarVocabularyFilePath = isFilePathCustomGrammarVocabularyFilePath(filePath),
+                fileCustomGrammarVocabularyFile = filePathCustomGrammarVocabularyFilePath;  ///
+
+          if (fileCustomGrammarVocabularyFile) {
+            const customGrammarVocabularyFile = file;  ///
+
+            customGrammarVocabularyFiles.push(customGrammarVocabularyFile);
+          }
+
+          return customGrammarVocabularyFiles;
+        }, []);
+
+  return customGrammarVocabularyFiles;
+}