occam-file-system 5.0.13 → 5.0.15

package/src/file.js

@@ -0,0 +1,95 @@
+"use strict";
+
+import { FILE_TYPE } from "./types";
+import { convertContentTabsToWhitespace } from "./utilities/content"
+
+export default class File {
+  constructor(path, content) {
+    this.path = path;
+    this.content = content;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  isFile() {
+    const file = true;
+
+    return file;
+  }
+
+  isDirectory() {
+    const directory = false;
+
+    return directory;
+  }
+
+  setPath(path) {
+    this.path = path;
+  }
+
+  setContent(content) {
+    this.content = content;
+  }
+
+  toJSON() {
+    const { type } = File,
+          path = this.path,
+          content = this.content,
+          json = {
+            type,
+            path,
+            content
+          };
+
+    return json;
+  }
+
+  static type = FILE_TYPE;
+
+  static fromJSON(json) {
+    let file = null;
+
+    if (json !== null) {
+      const { type } = json;
+
+      if (type === FILE_TYPE) {
+        let { content } = json;
+
+        const { path } = json;
+
+        content = convertContentTabsToWhitespace(content);  ///
+
+        file = new File(path, content);
+      }
+    }
+
+    return file;
+  }
+
+  static fromDocument(document) {
+    const filePath = document.getFilePath(),
+          path = filePath;  ///
+
+    let content = document.getContent();
+
+    content = convertContentTabsToWhitespace(content);  ///
+
+    const file = new File(path, content);
+
+    return file;
+  }
+
+  static fromPathAndContent(path, content) {
+    content = convertContentTabsToWhitespace(content);  ///
+
+    const file = new File(path, content);
+
+    return file;
+  }
+}

package/src/fileNames.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export const TERM_BNF_FILE_NAME = "term.bnf";
+export const STATEMENT_BNF_FILE_NAME = "statement.bnf";
+export const METASTATEMENT_BNF_FILE_NAME = "metastatement.bnf";
+export const TYPE_PATTERN_FILE_NAME = "type.ptn";
+export const SYMBOL_PATTERN_FILE_NAME = "symbol.ptn";
+export const OPERATOR_PATTERN_FILE_NAME = "operator.ptn";

package/src/files.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import File from "./file";
+
+export default class Files {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getFilePaths() {
+    const filePaths = this.mapFile((file) => {
+      const filePath = file.getPath();
+
+      return filePath;
+    });
+
+    return filePaths;
+  }
+
+  addFile(file) {
+    this.array.push(file);
+  }
+
+  mapFile(callback) {
+    return this.array.map(callback);
+  }
+
+  someFile(callback) {
+    return this.array.some(callback);
+  }
+
+  reduceFile(callback, initialValue) {
+    return this.array.reduce(callback, initialValue);
+  }
+
+  forEachFile(callback) {
+    this.array.forEach(callback);
+  }
+
+  findFile(callback) {
+    return this.array.find(callback) || null; ///
+  }
+
+  toJSON() {
+    const filesJSON = this.array.map((file) => {
+            const fileJSON = (file !== null) ?
+                                file.toJSON() :
+                                  null;
+  
+            return fileJSON;
+          }),
+          json = filesJSON; ///
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const filesJSON = json, ///
+          array = [],
+          files = new Files(array);
+    
+    filesJSON.forEach((fileJSON) => {
+      const json = fileJSON,  ///
+            file = File.fromJSON(json);
+
+      files.addFile(file);
+    });
+    
+    return files;
+  }
+
+  static fromNothing() {
+    const array = [],
+          files = new Files(array);
+
+    return files;
+  }
+}

package/src/loadProjects.js

@@ -9,7 +9,7 @@ export default function loadProjects(projectsDirectoryPath, json, callback) {
 
   json = (projects !== null) ?  ///
             projects.toJSON():
-                null;
+              null;
 
   callback(json);
 }

package/src/loadReleases.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { loadReleases as loadReleasesEx } from "./utilities/fileSystem";
+
+export default function loadReleases(projectsDirectoryPath, json, callback) {
+  const releases = loadReleasesEx(projectsDirectoryPath);
+
+  json = (releases !== null) ?  ///
+            releases.toJSON():
+              null;
+
+  callback(json);
+}

package/src/main.js

@@ -0,0 +1,25 @@
+"use strict";
+
+export { default as File } from "./file";
+export { default as Files } from "./files";
+export { default as Version } from "./version";
+export { default as Release } from "./release";
+export { default as Entries } from "./entries";
+export { default as Project } from "./project";
+export { default as Projects } from "./projects";
+export { default as Dependency } from "./dependency";
+export { default as Dependencies } from "./dependencies";
+export { default as ShortenedVersion } from "./shortenedVersion";
+
+export { default as httpUtilities } from "./utilities/http";
+export { default as contentUtilities } from "./utilities/content";
+export { default as metaJSONUtilities } from "./utilities/metaJSON";
+
+export { default as loadFile } from "./loadFile";
+export { default as saveFile } from "./saveFile";
+export { default as loadFiles } from "./loadFiles";
+export { default as saveFiles } from "./saveFiles";
+export { default as loadProjects } from "./loadProjects";
+export { default as loadReleases } from "./loadReleases";
+export { default as moveProjectEntries } from "./moveProjectEntries";
+export { default as removeProjectEntries } from "./removeProjectEntries";

package/src/messages.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export const ENTRIES_MAXIMUM_LENGTH_EXCEEDED_MESSAGE = "The maximum entries length has been exceeded.";

package/src/mixins/bnf.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import { fileNameFromFilePath } from "../utilities/name";
+import { TERM_BNF_FILE_NAME, STATEMENT_BNF_FILE_NAME, METASTATEMENT_BNF_FILE_NAME } from "../fileNames";
+
+function getBNF(bnfFileName) {
+  let bnf = null;
+
+  const customGrammarBNFFiles = this.getCustomGrammarBNFFiles(),
+        customGrammarBNFFile = customGrammarBNFFiles.find((customGrammarBNFFile) => {
+        const customGrammarBNFFilePath = customGrammarBNFFile.getPath(),
+              customGrammarBNFFileName = fileNameFromFilePath(customGrammarBNFFilePath);
+
+        if (customGrammarBNFFileName === bnfFileName) {
+          return true;
+        }
+      }) || null;
+
+  if (customGrammarBNFFile !== null) {
+    const customGrammarBNFFileContent = customGrammarBNFFile.getContent();
+
+    bnf = customGrammarBNFFileContent;  ///
+  }
+
+  return bnf;
+}
+
+function getTermBNF() {
+  const fileName = TERM_BNF_FILE_NAME, ///
+        bnf = this.getBNF(fileName),
+        termBNF = bnf;  ///
+
+  return termBNF;
+}
+
+function getStatementBNF() {
+  const fileName = STATEMENT_BNF_FILE_NAME, ///
+        bnf = this.getBNF(fileName),
+        statementBNF = bnf;  ///
+
+  return statementBNF;
+}
+
+function getMetastatementBNF() {
+  const fileName = METASTATEMENT_BNF_FILE_NAME, ///
+        bnf = this.getBNF(fileName),
+        metastatementBNF = bnf;  ///
+
+  return metastatementBNF;
+}
+
+const bnfMixins = {
+  getBNF,
+  getTermBNF,
+  getStatementBNF,
+  getMetastatementBNF
+};
+
+export default bnfMixins;

package/src/mixins/entries.js

@@ -0,0 +1,18 @@
+"use strict";
+
+function getFile(filePath) { return this.entries.getFile(filePath); }
+
+function getFiles() { return this.entries.getFiles(); }
+
+function getFilePaths() { return this.entries.getFilePaths(); }
+
+function getDirectoryPaths() { return this.entries.getDirectoryPaths(); }
+
+const entriesMixins = {
+  getFile,
+  getFiles,
+  getFilePaths,
+  getDirectoryPaths
+};
+
+export default entriesMixins;

package/src/mixins/files.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import { readmeFileFromFiles,
+         metaJSONFileFromFiles,
+         florenceFilesFromFiles,
+         customGrammarBNFFilesFromFiles,
+         customGrammarPatternFilesFromFiles } from "../utilities/files";
+
+function getReadmeFile() {
+  const files = this.getFiles(),
+        readmeFile = readmeFileFromFiles(files);
+
+  return readmeFile;
+}
+
+function getMetaJSONFile() {
+  const files = this.getFiles(),
+        metaJSONFile = metaJSONFileFromFiles(files);
+
+  return metaJSONFile;
+}
+
+function getFlorenceFiles() {
+  const files = this.getFiles(),
+        florenceFiles = florenceFilesFromFiles(files);
+
+  return florenceFiles;
+}
+
+function getCustomGrammarBNFFiles() {
+  const files = this.getFiles(),
+        customGrammarBNFFiles = customGrammarBNFFilesFromFiles(files);
+
+  return customGrammarBNFFiles;
+}
+
+function getCustomGrammarPatternFiles() {
+  const files = this.getFiles(),
+        customGrammarPatternFiles = customGrammarPatternFilesFromFiles(files);
+
+  return customGrammarPatternFiles;
+}
+
+const filesMixins = {
+  getReadmeFile,
+  getMetaJSONFile,
+  getFlorenceFiles,
+  getCustomGrammarBNFFiles,
+  getCustomGrammarPatternFiles
+};
+
+export default filesMixins;

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

@@ -0,0 +1,92 @@
+"use strict";
+
+import Entries from "./entries";
+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 Project {
+  constructor(name, entries, repository, dependencies) {
+    this.name = name;
+    this.entries = entries;
+    this.repository = repository;
+    this.dependendies = dependencies;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getEntries() {
+    return this.entries;
+  }
+
+  getRepository() {
+    return this.repository;
+  }
+
+  getDependencies() {
+    return this.dependendies;
+  }
+
+  toJSON() {
+    const entriesJSON = this.entries.toJSON(),
+          dependenciesJSON = this.dependendies.toJSON(),
+          name = this.name,
+          entries = entriesJSON,  ///
+          repository = this.repository,
+          dependencies = dependenciesJSON,  ///
+          json = {
+            name,
+            entries,
+            repository,
+            dependencies
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    let { entries, dependencies } = json;
+
+    const { name, repository } = json,
+          entriesJSON = entries,  ///
+          dependenciesJSON = dependencies; ///
+
+    json = entriesJSON; ///
+
+    entries = Entries.fromJSON(json); ///
+
+    json = dependenciesJSON; ///
+
+    dependencies = Dependencies.fromJSON(json);
+
+    const release = new Release(name, entries, repository, dependencies);
+
+    return release;
+  }
+
+  static fromName(name) {
+    const entries = Entries.fromNothing(),
+          repository = null,  ///
+          dependencies = Dependencies.fromNothing(),
+          project = new Project(name, entries, repository, dependencies);
+
+    return project;
+  }
+
+  static fromNameEntriesRepositoryAndDependencies(name, entries, repository, dependencies) {
+    const project = new Project(name, entries, repository, dependencies);
+
+    return project;
+  }
+}
+
+Object.assign(Project.prototype, bnfMixins);
+Object.assign(Project.prototype, filesMixins);
+Object.assign(Project.prototype, entriesMixins);
+Object.assign(Project.prototype, patternMixins);
+
+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,97 @@
+"use strict";
+
+import Entries from "./entries";
+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.version = version;
+    this.repository = repository;
+    this.dependendies = dependencies;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getEntries() {
+    return this.entries;
+  }
+
+  getVersion() {
+    return this.version;
+  }
+
+  getRepository() {
+    return this.repository;
+  }
+
+  getDependencies() {
+    return this.dependendies;
+  }
+
+  toJSON() {
+    const entriesJSON = this.entries.toJSON(),
+          versionJSON = this.version.toJSON(),
+          dependenciesJSON = this.dependendies.toJSON(),
+          name = this.name,
+          entries = entriesJSON,  ///
+          version = versionJSON,  ///
+          repository = this.repository,
+          dependencies = dependenciesJSON,  ///
+          json = {
+            name,
+            entries,
+            version,
+            repository,
+            dependencies
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    let { entries, version, dependencies } = json;
+
+    const { name, repository } = json,
+          entriesJSON = entries,  ///
+          versionJSOM = version,  ///
+          dependenciesJSON = dependencies; ///
+
+    json = entriesJSON; ///
+
+    entries = Entries.fromJSON(json); ///
+
+    json = versionJSOM; ///
+
+    version = Version.fromJSON(json);
+
+    json = dependenciesJSON; ///
+
+    dependencies = Dependencies.fromJSON(json);
+
+    const release = new Release(name, entries, version, repository, dependencies);
+
+    return release;
+  }
+
+  static fromNameEntriesVersionRepositoryAndDependencies(name, entries, version, repository, dependencies) {
+    const release = new Release(name, entries, version, repository, dependencies);
+
+    return release;
+  }
+}
+
+Object.assign(Release.prototype, bnfMixins);
+Object.assign(Release.prototype, filesMixins);
+Object.assign(Release.prototype, entriesMixins);
+Object.assign(Release.prototype, patternMixins);
+
+export default Release;