occam-entities 1.0.1

package/src/utilities/metaJSON.js

@@ -0,0 +1,149 @@
+"use strict";
+
+import { MetaJSONLexer, MetaJSONParser } from "occam-grammars";
+
+import Version from "../version";
+import Dependency from "../dependency";
+import Dependencies from "../dependencies";
+import ShortenedVersion from "../shortenedVersion";
+
+import { DOUBLE_SPACE } from "../constants";
+import { trimDoubleQuotes } from "../utilities/content";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const metaJSONLexer = MetaJSONLexer.fromNothing(),
+      metaJSONParser = MetaJSONParser.fromNothing(),
+      errorNodesQuery = nodesQuery("//error"),
+      dependencyNodesQuery = nodesQuery("//dependencies/dependency"),
+      repositoryTerminalNodeQuery = nodeQuery("//repository!/@*!"),
+      versionNumberTerminalNodeQuery = nodeQuery("//version!/versionNumber!/@*!"),
+      dependencyNameTerminalNodeQuery = nodeQuery("/dependency/name!/@*!"),
+      shortenedVersionNumberTerminalNodeQuery = nodeQuery("//dependency/shortenedVersionNumber/@*!");
+
+export function versionFromNode(node) {
+  let version = null;
+
+  if (node !== null) {
+    const versionNumberTerminalNode = versionNumberTerminalNodeQuery(node),
+          versionNumberTerminalNodeContent = versionNumberTerminalNode.getContent(),
+          string = trimDoubleQuotes(versionNumberTerminalNodeContent); //
+
+    version = Version.fromString(string);
+  }
+
+  return version;
+}
+
+export function repositoryFromNode(node) {
+  let repository = null;
+
+  if (node !== null) {
+    const repositoryTerminalNode = repositoryTerminalNodeQuery(node),
+          repositoryTerminalNodeContent = repositoryTerminalNode.getContent();
+
+    repository = trimDoubleQuotes(repositoryTerminalNodeContent); //
+  }
+
+  return repository;
+}
+
+export function isMetaJSONFileValid(metaJSONFile) {
+  let metaJSONFileValid = false;
+
+  const metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile);
+
+  if (metaJSONNode !== null) {
+    const node = metaJSONNode,  ///
+          errorNodes = errorNodesQuery(node),
+          errorNodesLength = errorNodes.length;
+
+    if (errorNodesLength === 0) {
+      metaJSONFileValid = true;
+    }
+  }
+
+  return metaJSONFileValid;
+}
+
+export function dependenciesFromNode(node) {
+  const dependencies = Dependencies.fromNothing();
+
+  if (node !== null) {
+    const dependencyNodes = dependencyNodesQuery(node);
+
+    dependencyNodes.forEach((dependencyNode) => {
+      const dependencyNameTerminalNode = dependencyNameTerminalNodeQuery(dependencyNode),
+            shortenedVersionNumberTerminalNode = shortenedVersionNumberTerminalNodeQuery(dependencyNode),
+            dependencyNameTerminalNodeContent = dependencyNameTerminalNode.getContent(),
+            shortenedVersionNumberTerminalNodeContent = shortenedVersionNumberTerminalNode.getContent(),
+            string = trimDoubleQuotes(shortenedVersionNumberTerminalNodeContent),  ///
+            name = trimDoubleQuotes(dependencyNameTerminalNodeContent),///
+            shortenedVersion = ShortenedVersion.fromString(string),
+            dependency = Dependency.fromNameAndShortenedVersion(name, shortenedVersion);
+
+      dependencies.addDependency(dependency);
+    });
+  }
+
+  return dependencies;
+}
+
+export function dependencyNamesFromNode(node) {
+  const dependencies = dependenciesFromNode(node),
+        dependencyNames = dependencies.mapDependency((dependency) => {
+          const dependencyName = dependency.getName();
+
+          return dependencyName;
+        });
+
+  return dependencyNames;
+}
+
+export function updateMetaJSONFileVersion(metaJSONFile, version) {
+  const metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),
+        node = metaJSONNode,  ///
+        repository = repositoryFromNode(node);
+
+  let dependencies = dependenciesFromNode(node);
+
+  const string = version.toString(),
+      dependenciesJSON = dependencies.toJSON();
+
+  version = string;  ///
+
+  dependencies = dependenciesJSON;  ///
+
+  const metaJSON = {
+          version,
+          repository,
+          dependencies
+        },
+        metaJSONString = JSON.stringify(metaJSON, null, DOUBLE_SPACE),
+        metaJSONFileContent = metaJSONString; ///
+
+  metaJSONFile.setContent(metaJSONFileContent);
+}
+
+export function metaJSONNodeFromMetaJSONFile(metaJSONFile) {
+  let metaJSONNode = null;
+
+  if (metaJSONFile !== null) {
+    const content = metaJSONFile.getContent(),
+          tokens = metaJSONLexer.tokenise(content),
+          node = metaJSONParser.parse(tokens);
+
+    metaJSONNode = node;  ///
+  }
+
+  return metaJSONNode;
+}
+
+export default {
+  versionFromNode,
+  repositoryFromNode,
+  isMetaJSONFileValid,
+  dependenciesFromNode,
+  dependencyNamesFromNode,
+  updateMetaJSONFileVersion,
+  metaJSONNodeFromMetaJSONFile
+};

package/src/utilities/name.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { pathUtilities } from "necessary";
+
+const { bottommostNameFromPath } = pathUtilities;
+
+export function fileNameFromFilePath(filePath) {
+  const path = filePath,  ///
+        bottommostName = bottommostNameFromPath(path),
+        fileName = bottommostName;  //
+
+  return fileName;
+}

package/src/utilities/query.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { Query } from "occam-dom";
+
+export function nodeQuery(expression) {
+  const query = Query.fromExpression(expression);
+
+  return function(node) {
+    if (node !== null) {
+      const nodes = query.execute(node);
+
+      node = nodes.shift() || null; ///
+    }
+
+    return node;
+  };
+}
+
+export function nodesQuery(expression) {
+  const query = Query.fromExpression(expression);
+
+  return function(node) {
+    let nodes = null;
+
+    if (node !== null) {
+      nodes = query.execute(node);
+    }
+
+    return nodes;
+  };
+}

package/src/utilities/version.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { MAJOR_NUMBER_MULTIPLIER, MINOR_NUMBER_MULTIPLIER, PATCH_NUMBER_MULTIPLIER } from "../multiplers";
+
+const { second } = arrayUtilities;
+
+export function majorNumberFromNumber(number) {
+  const majorNumber = (number !== null) ?
+                        Math.floor(number / MAJOR_NUMBER_MULTIPLIER) :
+                          0;  ///
+
+  return majorNumber;
+}
+
+export function minorNumberFromNumber(number) {
+  const minorNumber = (number !== null) ?
+                        Math.floor((number % MAJOR_NUMBER_MULTIPLIER) / MINOR_NUMBER_MULTIPLIER) :
+                          0;  ///
+
+  return minorNumber;
+}
+
+export function patchNumberFromNumber(number) {
+  const patchNumber = (number !== null) ?
+                        Math.floor((number % MINOR_NUMBER_MULTIPLIER) / PATCH_NUMBER_MULTIPLIER) :
+                          0;  ///
+
+  return patchNumber;
+}
+
+export function majorNumberFromString(string) {
+  let majorNumber = 0;
+
+  if (string) {
+    const matches = string.match(/^(\d+)/),
+          secondMatch = second(matches);
+
+    majorNumber = Number(secondMatch);  ///
+  }
+
+  return majorNumber;
+}
+
+export function minorNumberFromString(string) {
+  let minorNumber = 0;
+
+  if (string) {
+    const matches = string.match(/^\d+\.(\d+)/),
+          secondMatch = second(matches);
+
+    minorNumber = Number(secondMatch);  ///
+  }
+
+  return minorNumber;
+}
+
+export function patchNumberFromString(string) {
+  let patchNumber = 0;
+
+  if (string) {
+    const matches = string.match(/^\d+\.\d+\.(\d+)/),
+          secondMatch = second(matches);
+
+    patchNumber = Number(secondMatch);  ///
+  }
+
+  return patchNumber;
+}

package/src/version.js

@@ -0,0 +1,123 @@
+"use strict";
+
+import { MAJOR_NUMBER_MULTIPLIER, MINOR_NUMBER_MULTIPLIER, PATCH_NUMBER_MULTIPLIER } from "./multiplers";
+import { majorNumberFromNumber,
+         minorNumberFromNumber,
+         patchNumberFromNumber,
+         majorNumberFromString,
+         minorNumberFromString,
+         patchNumberFromString } from "./utilities/version";
+
+export default class Version {
+  constructor(majorNumber, minorNumber, patchNumber) {
+    this.majorNumber = majorNumber;
+    this.minorNumber = minorNumber;
+    this.patchNumber = patchNumber;
+  }
+
+  getMajorNumber() {
+    return this.majorNumber;
+  }
+
+  getMinorNumber() {
+    return this.minorNumber;
+  }
+
+  getPatchNumber() {
+    return this.patchNumber;
+  }
+
+  bumpMajorNumber() {
+    this.majorNumber += 1;
+  }
+
+  bumpMinorNumber() {
+    this.minorNumber += 1;
+  }
+
+  bumpPatchNumber() {
+    this.patchNumber += 1;
+  }
+
+  resetMajorNumber() {
+    this.majorNumber = 0;
+  }
+
+  resetMinorNumber() {
+    this.minorNumber = 0;
+  }
+
+  resetPatchNumber() {
+    this.patchNumber = 0;
+  }
+
+  matchShortenedVersion(shortenedVersion) {
+    let matchesShortenedVersion = false;
+
+    if (shortenedVersion === null) {
+      matchesShortenedVersion = true;
+    } else {
+      const majorNumber = shortenedVersion.getMajorNumber();
+
+      if (this.majorNumber === majorNumber) {
+        const minorNumber = shortenedVersion.getMinorNumber();
+
+        if (this.minorNumber >= minorNumber) {
+          matchesShortenedVersion = true;
+        }
+      }
+    }
+
+    return matchesShortenedVersion;
+  }
+
+  toString() {
+    const string = `${this.majorNumber}.${this.minorNumber}.${this.patchNumber}`;
+
+    return string;
+  }
+
+  toVersionNumber() {
+    const versionNumber = this.majorNumber * MAJOR_NUMBER_MULTIPLIER + this.minorNumber * MINOR_NUMBER_MULTIPLIER + this.patchNumber * PATCH_NUMBER_MULTIPLIER;
+
+    return versionNumber;
+  }
+
+  static fromString(string) {
+    const majorNumber = majorNumberFromString(string),
+          minorNumber = minorNumberFromString(string),
+          patchNumber = patchNumberFromString(string),
+          version = new Version(majorNumber, minorNumber, patchNumber);
+
+    return version;
+  }
+
+  static fromNothing() {
+    const majorNumber = 0,
+          minorNumber = 0,
+          patchNumber = 0,
+          version = new Version(majorNumber, minorNumber, patchNumber);
+
+    return version;
+  }
+
+  static fromVersion(version) {
+    const majorNumber = version.getMajorNumber(),
+          minorNumber = version.getMinorNumber(),
+          patchNumber = version.getPatchNumber();
+
+    version = new Version(majorNumber, minorNumber, patchNumber); ///
+
+    return version;
+  }
+
+  static fromVersionNumber(versionNumber) {
+    const number = versionNumber, ///
+          majorNumber = majorNumberFromNumber(number),
+          minorNumber = minorNumberFromNumber(number),
+          patchNumber = patchNumberFromNumber(number),
+          version = new Version(majorNumber, minorNumber, patchNumber);
+
+    return version;
+  }
+}