occam-entities 1.0.1

package/src/mixins/metaJSON.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import { versionFromNode, repositoryFromNode, dependenciesFromNode, dependencyNamesFromNode, metaJSONNodeFromMetaJSONFile } from "../utilities/metaJSON";
+
+function getVersion() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),
+        node = metaJSONNode,  ///
+        version = versionFromNode(node);
+
+  return version;
+}
+
+function getRepository() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),
+        node = metaJSONNode,  ///
+        repository = repositoryFromNode(node);
+
+  return repository;
+}
+
+function getDependencies() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),
+        node = metaJSONNode,  ///
+        dependencies = dependenciesFromNode(node);
+
+  return dependencies;
+}
+
+function getDependencyNames() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),
+        node = metaJSONNode,  ///
+        dependencyNames = dependencyNamesFromNode(node);
+
+  return dependencyNames;
+}
+
+const metaJSONMixins = {
+  getVersion,
+  getRepository,
+  getDependencies,
+  getDependencyNames
+};
+
+export default metaJSONMixins;

package/src/mixins/pattern.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import { fileNameFromFilePath } from "../utilities/name";
+import { TYPE_PATTERN_FILE_NAME, SYMBOL_PATTERN_FILE_NAME, OPERATOR_PATTERN_FILE_NAME } from "../fileNames";
+
+function getPattern(patternFileName) {
+  let pattern = null;
+
+  const customGrammarPatternFiles = this.getCustomGrammarPatternFiles(),
+        customGrammarPatternFile = customGrammarPatternFiles.find((customGrammarPatternFile) => {
+        const customGrammarPatternFilePath = customGrammarPatternFile.getPath(),
+              customGrammarPatternFileName = fileNameFromFilePath(customGrammarPatternFilePath);
+
+        if (customGrammarPatternFileName === patternFileName) {
+          return true;
+        }
+      }) || null;
+
+  if (customGrammarPatternFile !== null) {
+    const customGrammarPatternFileContent = customGrammarPatternFile.getContent();
+
+    pattern = customGrammarPatternFileContent;  ///
+  }
+
+  return pattern;
+}
+
+function getTypePattern() {
+  const fileName = TYPE_PATTERN_FILE_NAME, ///
+        pattern = this.getPattern(fileName),
+        typePattern = pattern;  ///
+
+  return typePattern;
+}
+
+function getSymbolPattern() {
+  const fileName = SYMBOL_PATTERN_FILE_NAME, ///
+        pattern = this.getPattern(fileName),
+        symbolPattern = pattern;  ///
+
+  return symbolPattern;
+}
+
+function getOperatorPattern() {
+  const fileName = OPERATOR_PATTERN_FILE_NAME, ///
+        pattern = this.getPattern(fileName),
+        operatorPattern = pattern;  ///
+
+  return operatorPattern;
+}
+
+const patternMixins =  {
+  getPattern,
+  getTypePattern,
+  getSymbolPattern,
+  getOperatorPattern
+};
+
+export default patternMixins;

package/src/multiplers.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const MAJOR_NUMBER_MULTIPLIER = 1e12;
+export const MINOR_NUMBER_MULTIPLIER = 1e6;
+export const PATCH_NUMBER_MULTIPLIER = 1e0;

package/src/project.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import Entries from "./entries";
+import entriesMixins from "./mixins/entries";
+
+class Project {
+  constructor(name, entries) {
+    this.name = name;
+    this.entries = entries;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getEntries() {
+    return this.entries;
+  }
+
+  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 project = new Project(name, entries);
+
+    return project;
+  }
+
+  static fromName(name) {
+    const entries = Entries.fromNothing(),
+          project = new Project(name, entries);
+
+    return project;
+  }
+
+  static fromNameAndEntries(name, entries) {
+    const project = new Project(name, entries);
+
+    return project;
+  }
+}
+
+Object.assign(Project.prototype, entriesMixins);
+
+export default Project;

package/src/projects.js

@@ -0,0 +1,66 @@
+"use strict";
+
+import { asynchronousUtilities } from "necessary";
+
+import Project from "./project";
+
+const { forEach } = asynchronousUtilities;
+
+export default class Projects {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() {
+    return this.array.length;
+  }
+
+  addProject(project) {
+    this.array.push(project);
+  }
+
+  mapProject(callback) {
+    return this.array.map(callback);
+  }
+
+  reduceProject(callback, initialValue) {
+    return this.array.reduce(callback, initialValue);
+  }
+
+  forEachProject(callback) {
+    this.array.forEach(callback);
+  }
+
+  asynchronousForEachProject(callback, done) {
+    forEach(this.array, callback, done);
+  }
+
+  toJSON() {
+    const json = this.array.map((project) => {
+      const projectJSON = project.toJSON();
+
+      return projectJSON;
+    });
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const array = json.map((json) => {  ///
+            const project = Project.fromJSON(json);
+
+            return project;
+          }),
+          projects = new Projects(array);
+
+    return projects;
+  }
+
+  static fromNothing() {
+    const array = [],
+          projects = new Projects(array);
+
+    return projects;
+  }
+}
+

package/src/release.js

@@ -0,0 +1,145 @@
+"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 { 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 fromNameAndEntries(name, entries) {
+    let release = null;
+
+    const entriesReleasable = areEntriesReleasable(entries);
+
+    if (entriesReleasable) {
+      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 = releaseEntries(entries);
+
+      entries = releasedEntries;  ///
+
+      release = new Release(name, entries);
+    }
+
+    return release;
+  }
+}
+
+Object.assign(Release.prototype, entriesMixins);
+
+export default Release;
+
+function releaseEntries(entries) {
+  const releasedEntries = Entries.fromNothing(),  ///
+        files = entries.getFiles();
+
+  files.forEachFile((file) => {
+    const path = file.getPath(),
+          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,66 @@
+"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,12 @@
+"use strict";
+
+import { EMPTY_STRING, DOUBLE_SPACE } from "../constants";
+
+export function trimDoubleQuotes(content) { return content.replace(/(^"|"$)/g, EMPTY_STRING); } ///
+
+export function convertContentTabsToWhitespace(content) { return content.replace(/\t/g, DOUBLE_SPACE); } ///
+
+export default {
+  trimDoubleQuotes,
+  convertContentTabsToWhitespace
+};

package/src/utilities/filePath.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const readmeFilePathPattern = "^(?:[^\\/]+\\/){1}README\\.md$",
+      florenceFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.fls$",
+      metaJSONFilePathPattern = "^(?:[^\\/]+\\/){1}meta\\.json$",
+      customGrammarBNFFilePathPattern = "^(?:[^\\/]+\\/){1}(term|statement|metastatement)\\.bnf$",
+      customGrammarPatternFilePathPattern = "^(?:[^\\/]+\\/){1}(type|symbol|operator)\\.ptn$",
+      recognisedFilePathPattern = `${readmeFilePathPattern}|${florenceFilePathPattern}|${metaJSONFilePathPattern}|${customGrammarBNFFilePathPattern}|${customGrammarPatternFilePathPattern}`;
+
+const readmeFilePathRegularExpression = new RegExp(readmeFilePathPattern),
+      florenceFilePathRegularExpression = new RegExp(florenceFilePathPattern),
+      metaJSONFilePathRegularExpression = new RegExp(metaJSONFilePathPattern),
+      recognisedFilePathRegularExpression = new RegExp(recognisedFilePathPattern),
+      customGrammarBNFFilePathRegularExpression = new RegExp(customGrammarBNFFilePathPattern),
+      customGrammarPatternFilePathRegularExpression = new RegExp(customGrammarPatternFilePathPattern);
+
+export function isFilePathReadmeFilePath(filePath) { return readmeFilePathRegularExpression.test(filePath); }
+
+export function isFilePathFlorenceFilePath(filePath) { return florenceFilePathRegularExpression.test(filePath); }
+
+export function isFilePathMetaJSONFilePath(filePath) { return metaJSONFilePathRegularExpression.test(filePath); }
+
+export function isFilePathRecognisedFilePath(filePath) { return recognisedFilePathRegularExpression.test(filePath); }
+
+export function isFilePathCustomGrammarBNFFilePath(filePath) { return customGrammarBNFFilePathRegularExpression.test(filePath); }
+
+export function isFilePathCustomGrammarPatternFilePath(filePath) { return customGrammarPatternFilePathRegularExpression.test(filePath); }
+
+export default {
+  isFilePathReadmeFilePath,
+  isFilePathFlorenceFilePath,
+  isFilePathMetaJSONFilePath,
+  isFilePathRecognisedFilePath,
+  isFilePathCustomGrammarBNFFilePath,
+  isFilePathCustomGrammarPatternFilePath
+};

package/src/utilities/files.js

@@ -0,0 +1,95 @@
+"use strict";
+
+import { isFilePathReadmeFilePath,
+         isFilePathFlorenceFilePath,
+         isFilePathMetaJSONFilePath,
+         isFilePathCustomGrammarBNFFilePath,
+         isFilePathCustomGrammarPatternFilePath } 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 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 florenceFilesFromFiles(files) {
+  const florenceFiles = files.reduceFile((florenceFiles, file) => {
+          const filePath = file.getPath(),
+                filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath),
+                fileFlorenceFile = filePathFlorenceFilePath;  ///
+
+          if (fileFlorenceFile) {
+            const florenceFile = file;  ///
+
+            florenceFiles.push(florenceFile);
+          }
+
+          return florenceFiles;
+        }, []);
+
+  return florenceFiles;
+}
+
+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 customGrammarPatternFilesFromFiles(files) {
+  const customGrammarPatternFiles = files.reduceFile((customGrammarPatternFiles, file) => {
+          const filePath = file.getPath(),
+                filePathCustomGrammarPatternFilePath = isFilePathCustomGrammarPatternFilePath(filePath),
+                fileCustomGrammarPatternFile = filePathCustomGrammarPatternFilePath;  ///
+
+          if (fileCustomGrammarPatternFile) {
+            const customGrammarPatternFile = file;  ///
+
+            customGrammarPatternFiles.push(customGrammarPatternFile);
+          }
+
+          return customGrammarPatternFiles;
+        }, []);
+
+  return customGrammarPatternFiles;
+}