occam-open-cli 5.0.45 → 5.0.47

package/src/release.js

@@ -1,18 +1,20 @@
 "use strict";
 
 import Entries from "./entries";
-
-import { isFilePathReadmeFilePath,
-         isFilePathFlorenceFilePath,
-         isFilePathMetaJSONFilePath,
-         isFilePathCustomGrammarBNFFilePath,
-         isFilePathCustomGrammarPatternFilePath } from "./utilities/filePath";
-
-export default class Release {
-  constructor(name, entries, versionNumber) {
+import Version from "./version";
+import bnfMixins from "./mixins/bnf";
+import filesMixins from "./mixins/files";
+import Dependencies from "./dependencies";
+import entriesMixins from "./mixins/entries";
+import patternMixins from "./mixins/pattern";
+
+class Release {
+  constructor(name, entries, version, repository, dependencies) {
     this.name = name;
     this.entries = entries;
-    this.versionNumber = versionNumber;
+    this.version = version;
+    this.repository = repository;
+    this.dependendies = dependencies;
   }
 
   getName() {
@@ -23,143 +25,75 @@ export default class Release {
     return this.entries;
   }
 
-  getVersionNumber() {
-    return this.versionNumber;
+  getVersion() {
+    return this.version;
   }
 
-  getFile(filePath) { return this.entries.getFile(filePath); }
-
-  getFiles() { return this.entries.getFiles(); }
-
-  getFilePaths() { return this.entries.getFilePaths(); }
-
-  getReadmeFile() {
-    let readmeFile = null;
-
-    const files = this.getFiles();
-
-    files.someFile((file) => {
-      const filePath = file.getPath(),
-            filePathReadmeFilePath = isFilePathReadmeFilePath(filePath);
-
-      if (filePathReadmeFilePath) {
-        readmeFile = file;  ///
-
-        return true;
-      }
-    });
-
-    return readmeFile;
+  getRepository() {
+    return this.repository;
   }
 
-  getMetaJSONFile() {
-    let metaJSONFile = null;
-
-    const files = this.getFiles();
-
-    files.someFile((file) => {
-      const filePath = file.getPath(),
-            filePathMetaJSONFilePath = isFilePathMetaJSONFilePath(filePath);
-
-      if (filePathMetaJSONFilePath) {
-        metaJSONFile = file;  ///
-
-        return true;
-      }
-    });
-
-    return metaJSONFile;
-  }
-
-  getFlorenceFiles() {
-    const files = this.getFiles(),
-        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;
-  }
-
-  getCustomGrammarBNFFiles() {
-    const files = this.getFiles(),
-          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;
-  }
-
-  getCustomGrammarPatternFiles() {
-    const files = this.getFiles(),
-          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;
+  getDependencies() {
+    return this.dependendies;
   }
 
   toJSON() {
     const entriesJSON = this.entries.toJSON(),
+          versionJSON = this.version.toJSON(),
+          dependenciesJSON = this.dependendies.toJSON(),
           name = this.name,
           entries = entriesJSON,  ///
-          versionNumber = this.versionNumber,
+          version = versionJSON,  ///
+          repository = this.repository,
+          dependencies = dependenciesJSON,  ///
           json = {
             name,
             entries,
-            versionNumber
+            version,
+            repository,
+            dependencies
           };
 
     return json;
   }
 
   static fromJSON(json) {
-    let { entries } = json;
+    let { entries, version, dependencies } = json;
 
-    const { name, versionNumber } = json,
-          entriesJSON = entries;  ///
+    const { name, repository } = json,
+          entriesJSON = entries,  ///
+          versionJSOM = version,  ///
+          dependenciesJSON = dependencies; ///
 
     json = entriesJSON; ///
 
     entries = Entries.fromJSON(json); ///
 
-    const release = new Release(name, entries, versionNumber);
+    json = versionJSOM; ///
+
+    version = Version.fromJSON(json);
+
+    json = dependenciesJSON; ///
+
+    dependencies = Dependencies.fromJSON(json);
+
+    const release = new Release(name, entries, version, repository, dependencies);
 
     return release;
   }
 
-  static fromNameEntriesAndVersionNumber(name, entries, versionNumber) {
-    const release = new Release(name, entries, versionNumber);
+  static fromNameEntriesAndVersion(name, entries, version) {
+    const repository = repository,
+          dependencies = Dependencies.fromNothing(),
+          release = new Release(name, entries, version, repository, dependencies);
 
     return release;
   }
 }
+
+Objecct.assign(Release.prototype, bnfMixins);
+Objecct.assign(Release.prototype, filesMixins);
+Objecct.assign(Release.prototype, entriesMixins);
+Objecct.assign(Release.prototype, patternMixins);
+
+export default Release;

package/src/shortenedVersion.js

@@ -30,6 +30,24 @@ export default class ShortenedVersion {
     return number;
   }
 
+  toJSON() {
+    const majorNumber = this.majorNumber,
+          minorNumber = this.minorNumber,
+          json = {
+            majorNumber,
+            minorNumber
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const { majorNumber, minorNumber } = json,
+          shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+
+    return shortenedVersion;
+  }
+
   static fromString(string) {
     const majorNumber = majorNumberFromString(string),
           minorNumber = minorNumberFromString(string),

package/src/utilities/content.js

@@ -1,9 +1,12 @@
 "use strict";
 
-import { DOUBLE_SPACE } from "../constants";
+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/files.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import { isFilePathReadmeFilePath,
+         isFilePathFlorenceFilePath,
+         isFilePathMetaJSONFilePath,
+         isFilePathCustomGrammarBNFFilePath,
+         isFilePathCustomGrammarPatternFilePath } from "../utilities/filePath";
+
+function readmeFileFromFiles(files) {
+  let readmeFile = null;
+
+  files.someFile((file) => {
+    const filePath = file.getPath(),
+          filePathReadmeFilePath = isFilePathReadmeFilePath(filePath);
+
+    if (filePathReadmeFilePath) {
+      readmeFile = file;  ///
+
+      return true;
+    }
+  });
+
+  return readmeFile;
+}
+
+function metaJSONFileFromFiles(files) {
+  let metaJSONFile = null;
+
+  files.someFile((file) => {
+    const filePath = file.getPath(),
+          filePathMetaJSONFilePath = isFilePathMetaJSONFilePath(filePath);
+
+    if (filePathMetaJSONFilePath) {
+      metaJSONFile = file;  ///
+
+      return true;
+    }
+  });
+
+  return metaJSONFile;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+export default {
+  readmeFileFromFiles,
+  metaJSONFileFromFiles,
+  florenceFilesFromFiles,
+  customGrammarBNFFilesFromFiles,
+  customGrammarPatternFilesFromFiles
+};

package/src/utilities/metaJSON.js

@@ -0,0 +1,82 @@
+"use strict";
+
+import Version from "../version";
+import Dependency from "../dependency";
+import ShortenedVersion from "../shortenedVersion";
+
+import { trimDoubleQuotes } from "../utilities/content";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const 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(),
+          versionNumber = trimDoubleQuotes(versionNumberTerminalNodeContent); //
+
+    version = Version.fromVersionNumber(versionNumber);
+  }
+
+  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 dependenciesFromNode(node) {
+  const dependencies = [];
+
+  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.push(dependency);
+    });
+  }
+
+  return dependencies;
+}
+
+export function dependencyNamesFromNode(node) {
+  const dependencies = this.dependenciesFromNode(node),
+        dependencyNames = dependencies.map((dependency) => {
+          const dependencyName = dependency.getName();
+
+          return dependencyName;
+        })
+
+  return dependencyNames;
+}
+
+export default {
+  versionFromNode,
+  repositoryFromNode,
+  dependenciesFromNode,
+  dependencyNamesFromNode
+};

package/src/utilities/name.js

@@ -1,13 +1,26 @@
 "use strict";
 
+import { pathUtilities } from "necessary";
+
 const hiddenNameRegularExpression = /^\..+/;
 
+const { bottommostNameFromPath } = pathUtilities;
+
 export function isNameHiddenName(name) {
   const nameHiddenName = hiddenNameRegularExpression.test(name);
 
   return nameHiddenName;
 }
 
+function fileNameFromFilePath(filePath) {
+  const path = filePath,  ///
+        bottommostName = bottommostNameFromPath(path),
+        fileName = bottommostName;  //
+
+  return fileName;
+}
+
 export default {
-  isNameHiddenName
+  isNameHiddenName,
+  fileNameFromFilePath
 };

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/version.js

@@ -47,6 +47,26 @@ export default class Version {
     return number;
   }
 
+  toJSON() {
+    const majorNumber = this.majorNumber,
+          minorNumber = this.minorNumber,
+          patchNumber = this.patchNumber,
+          json = {
+            majorNumber,
+            minorNumber,
+            patchNumber
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const { majorNumber, minorNumber, patchNumber } = json,
+          version = new Version(majorNumber, minorNumber, patchNumber);
+
+    return version;
+  }
+
   static fromString(string) {
     const majorNumber = majorNumberFromString(string),
           minorNumber = minorNumberFromString(string),