occam-model 1.0.484

package/src/utilities/metaJSON.js

@@ -0,0 +1,254 @@
+"use strict";
+
+import { JSONLexer, JSONParser } 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";
+import { isStringVersionString, isStringShortenedVersionString } from "../utilities/validate";
+import { VERSION_PROPERTY_NAME, REPOSITORY_PROPERTY_NAME, DEPENDENCIES_PROPERTY_NAME } from "../propertyNames";
+
+const jsonLexer = JSONLexer.fromNothing(),
+      jsonParser = JSONParser.fromNothing();
+
+const errorNodesQuery = nodesQuery("/*/error"),
+      propertyNodesQuery = nodesQuery("/property/json/object/property"),
+      documentPropertyNodesQuery = nodesQuery("/document/json/object/property"),
+      propertyStringLiteralTerminalNodeQuery = nodeQuery("/property/@string-literal"),
+      propertyJSONStringLiteralTerminalNodeQuery = nodeQuery("/property/json/@string-literal!");
+
+export function isMetaJSONFileValid(metaJSONFile) {
+  let metaJSONFileValid = false;
+
+  const documentNode = documentNodeFromMetaJSONFile(metaJSONFile);
+
+  if (documentNode !== null) {
+    const errorNodes = errorNodesQuery(documentNode),
+          errorNodesLength = errorNodes.length;
+
+    if (errorNodesLength === 0) {
+      const version = versionFromDocumentNode(documentNode),
+            repository = repositoryFromDocumentNode(documentNode),
+            dependencies = dependenciesFromDocumentNode(documentNode);
+
+      metaJSONFileValid = ((version !== null) && (repository !== null) && (dependencies !== null));
+    }
+  }
+
+  return metaJSONFileValid;
+}
+
+export function updateMetaJSONFileVersion(metaJSONFile, version) {
+  const documentNode = documentNodeFromMetaJSONFile(metaJSONFile),
+        repository = repositoryFromDocumentNode(documentNode);
+
+  let dependencies = dependenciesFromDocumentNode(documentNode);
+
+  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 documentNodeFromMetaJSONFile(metaJSONFile) {
+  let documentNode = null;
+
+  if (metaJSONFile !== null) {
+    const content = metaJSONFile.getContent(),
+          tokens = jsonLexer.tokenise(content),
+          node = jsonParser.parse(tokens);
+
+    documentNode = node;  ///
+  }
+
+  return documentNode;
+}
+
+export function versionFromDocumentNode(documentNode) {
+  let version = null;
+
+  const documentPropertyNodes = documentPropertyNodesFromDocumentNode(documentNode);
+
+  documentPropertyNodes.some((documentPropertyNode) => {
+    const propertyNode = documentPropertyNode,  ///
+          propertyName = propertyNameFromPropertyNode(propertyNode);
+
+    if (propertyName === VERSION_PROPERTY_NAME) {
+      const stringPropertyValue = stringPropertyValueFromPropertyNode(propertyNode);
+
+      if (stringPropertyValue !== null) {
+        const string = stringPropertyValue, ///
+              stringVersionString = isStringVersionString(string);
+
+        if (stringVersionString) {
+          version = Version.fromString(string);
+        }
+
+        return true;
+      }
+    }
+  });
+
+  return version;
+}
+
+export function repositoryFromDocumentNode(documentNode) {
+  let repository = null;
+
+  const documentPropertyNodes = documentPropertyNodesFromDocumentNode(documentNode);
+
+  documentPropertyNodes.some((documentPropertyNode) => {
+    const propertyNode = documentPropertyNode,  ///
+          propertyName = propertyNameFromPropertyNode(propertyNode);
+
+    if (propertyName === REPOSITORY_PROPERTY_NAME) {
+      const stringPropertyValue = stringPropertyValueFromPropertyNode(propertyNode);
+
+      if (stringPropertyValue !== null) {
+        repository = stringPropertyValue;  ///
+
+        return true;
+      }
+    }
+  });
+
+  return repository;
+}
+
+export function dependenciesFromDocumentNode(documentNode) {
+  let dependencies = null;
+
+  const dependenciesPropertyNode = dependenciesPropertyNodeFromDocumentNode(documentNode);
+
+  if (dependenciesPropertyNode !== null) {
+    dependencies = Dependencies.fromNothing();
+
+    const propertyNode = dependenciesPropertyNode,  ///
+          propertyNodes = propertyNodesQuery(propertyNode);
+
+    propertyNodes.forEach((propertyNode) => {
+      const stringPropertyValue = stringPropertyValueFromPropertyNode(propertyNode);
+
+      if (stringPropertyValue !== null) {
+        const string = stringPropertyValue, ///
+              stringShortenedVersionString = isStringShortenedVersionString(string);
+
+        if (stringShortenedVersionString) {
+          const propertyName = propertyNameFromPropertyNode(propertyNode),
+                name = propertyName,  ///
+                shortenedVersion = ShortenedVersion.fromString(string),
+                dependency = Dependency.fromNameAndShortenedVersion(name, shortenedVersion);
+
+          dependencies.addDependency(dependency);
+        }
+      }
+    });
+  }
+
+  return dependencies;
+}
+
+export function dependencyNamesFromDocumentNode(documentNode) {
+  let dependencyNames = null;
+
+  const dependenciesPropertyNode = dependenciesPropertyNodeFromDocumentNode(documentNode);
+
+  if (dependenciesPropertyNode !== null) {
+    dependencyNames = [];
+
+    const propertyNode = dependenciesPropertyNode,  ///
+          propertyNodes = propertyNodesQuery(propertyNode);
+
+    propertyNodes.forEach((propertyNode) => {
+      const stringPropertyValue = stringPropertyValueFromPropertyNode(propertyNode);
+
+      if (stringPropertyValue !== null) {
+        const string = stringPropertyValue, ///
+              stringShortenedVersionString = isStringShortenedVersionString(string);
+
+        if (stringShortenedVersionString) {
+          const propertyName = propertyNameFromPropertyNode(propertyNode),
+                dependencyName = propertyName;  ///
+
+          dependencyNames.push(dependencyName);
+        }
+      }
+    });
+  }
+
+  return dependencyNames;
+}
+
+export default {
+  isMetaJSONFileValid,
+  updateMetaJSONFileVersion,
+  documentNodeFromMetaJSONFile,
+  versionFromDocumentNode,
+  repositoryFromDocumentNode,
+  dependenciesFromDocumentNode,
+  dependencyNamesFromDocumentNode
+};
+
+function propertyNameFromPropertyNode(propertyNode) {
+  const propertyStringLiteralTerminalNode = propertyStringLiteralTerminalNodeQuery(propertyNode),
+        propertyStringLiteralTerminalNodeContent = propertyStringLiteralTerminalNode.getContent(),
+        propertyName = trimDoubleQuotes(propertyStringLiteralTerminalNodeContent); ///
+
+  return propertyName;
+}
+
+function stringPropertyValueFromPropertyNode(propertyNode) {
+  let stringPropertyValue = null;
+
+  const propertyJSONStringLiteralTerminalNode = propertyJSONStringLiteralTerminalNodeQuery(propertyNode);
+
+  if (propertyJSONStringLiteralTerminalNode !== null) {
+    const propertyJSONStringLiteralTerminalNodeContent = propertyJSONStringLiteralTerminalNode.getContent();
+
+    stringPropertyValue = trimDoubleQuotes(propertyJSONStringLiteralTerminalNodeContent); ///
+  }
+
+  return stringPropertyValue;
+}
+
+function documentPropertyNodesFromDocumentNode(documentNode) {
+  const documentPropertyNodes = documentPropertyNodesQuery(documentNode);
+
+  return documentPropertyNodes;
+}
+
+function dependenciesPropertyNodeFromDocumentNode(documentNode) {
+  let dependenciesPropertyNode = null;
+
+  const documentPropertyNodes = documentPropertyNodesFromDocumentNode(documentNode);
+
+  documentPropertyNodes.some((documentPropertyNode) => {
+    const propertyNode = documentPropertyNode,  ///
+          propertyName = propertyNameFromPropertyNode(propertyNode);
+
+    if (propertyName === DEPENDENCIES_PROPERTY_NAME) {
+      dependenciesPropertyNode = propertyNode;  ///
+
+      return true;
+    }
+  });
+
+  return dependenciesPropertyNode;
+}

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,25 @@
+"use strict";
+
+import { Query } from "occam-query";
+
+export function nodeQuery(expressionString) {
+  const query = Query.fromExpressionString(expressionString);
+
+  return function(node) {
+    const nodes = query.execute(node);
+
+    node = nodes.shift() || null; ///
+
+    return node;
+  };
+}
+
+export function nodesQuery(expressionString) {
+  const query = Query.fromExpressionString(expressionString);
+
+  return function(node) {
+    const nodes = query.execute(node);
+
+    return nodes;
+  };
+}

package/src/utilities/validate.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export function isStringVersionString(string) { return /(?:0|([1-9]\d*))\.(?:0|([1-9]\d*))\.(?:0|([1-9]\d*))/.test(string); }
+
+export function isStringShortenedVersionString(string) { return /(?:0|([1-9]\d*))\.(?:0|([1-9]\d*))/.test(string); }

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;
+  }
+}