occam-entities 1.0.1

package/src/directory.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { DIRECTORY_TYPE } from "./types";
+
+export default class Directory {
+  constructor(path) {
+    this.path = path;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  isFile() {
+    const file = false;
+
+    return file;
+  }
+
+  isDirectory() {
+    const directory = true;
+
+    return directory;
+  }
+
+  toJSON() {
+    const { type } = Directory,
+          path = this.path,
+          json = {
+            type,
+            path
+          };
+
+    return json;
+  }
+
+  static type = DIRECTORY_TYPE;
+
+  static fromPath(path) {
+    const directory = new Directory(path);
+
+    return directory;
+  }
+
+  static fromJSON(json) {
+    let directory = null;
+
+    if (json !== null) {
+      const { type } = json;
+
+      if (type === DIRECTORY_TYPE) {
+        const { path } = json;
+
+        directory = new Directory(path);
+      }
+    }
+
+    return directory;
+  }
+}

package/src/entries.js

@@ -0,0 +1,217 @@
+"use strict";
+
+import { pathUtilities, arrayUtilities } from "necessary";
+
+import File from "./file";
+import Files from "./files";
+import Directory from "./directory";
+import bnfMixins from "./mixins/bnf";
+import filesMixins from "./mixins/files";
+import patternMixins from "./mixins/pattern";
+import metaJSONMixins from "./mixins/metaJSON";
+
+import { ENTRIES_MAXIMUM_LENGTH } from "./constants";
+import { ENTRIES_MAXIMUM_LENGTH_EXCEEDED_MESSAGE } from "./messages";
+
+const { first, filter } = arrayUtilities,
+      { topmostDirectoryNameFromPath } = pathUtilities;
+
+class Entries {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getTopmostDirectoryName() {
+    let topmostDirectoryName = null;
+    
+    const firstEntry = first(this.array); ///
+
+    if (firstEntry) { ///
+      const firstEntryPath = firstEntry.getPath();
+
+      topmostDirectoryName = topmostDirectoryNameFromPath(firstEntryPath);
+
+      if (topmostDirectoryName === null) {
+        topmostDirectoryName = firstEntryPath;  ///
+      }
+    }
+
+    return topmostDirectoryName;
+  }
+
+  removeFileByPath(path) {
+    filter(this.array, (entry) => {
+      const entryFile = entry.isFile();
+
+      if (entryFile) {
+        const file = entry, ///
+              filePath = file.getPath();
+
+        if (filePath === path) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+  }
+
+  getFile(filePath) {
+    const files = this.getFiles(),
+          file = files.findFile((file) => {
+            const path = file.getPath();
+
+            if (path === filePath) {
+              return true;
+            }
+          }) || null;
+
+    return file;
+  }
+
+  getFiles() {
+    const files = Files.fromNothing();
+
+    this.mapEntry((entry) => {
+      const entryFile = entry.isFile();
+
+      if (entryFile) {
+        const file = entry; ///
+
+        files.addFile(file);
+      }
+    });
+
+    return files;
+  }
+
+  getFilePaths() {
+    const filePaths = this.reduceEntry((filePaths, entry) => {
+      const entryFile = entry.isFile();
+
+      if (entryFile) {
+        const file = entry, ///
+              filePath = file.getPath();
+
+        filePaths.push(filePath);
+      }
+
+      return filePaths;
+    }, []);
+
+    return filePaths;
+  }
+
+  getDirectoryPaths() {
+    const directoryPaths = this.reduceEntry((directoryPaths, entry) => {
+      const entryDirectory = entry.isDirectory();
+
+      if (entryDirectory) {
+        const directory = entry, ///
+              directoryPath = directory.getPath();
+
+        directoryPaths.push(directoryPath);
+      }
+
+      return directoryPaths;
+    }, []);
+
+    return directoryPaths;
+  }
+
+  matchShortenedVersion(shortenedVersion) {
+    const version = this.getVersion(),
+          versionMatchesShortenedVersion = version.matchShortenedVersion(shortenedVersion);
+
+    return versionMatchesShortenedVersion;
+  }
+
+  addFile(file) {
+    const entry = file; ///
+
+    this.addEntry(entry);
+  }
+
+  addEntry(entry) {
+    this.array.push(entry);
+
+    const length = this.array.length;
+
+    if (length > ENTRIES_MAXIMUM_LENGTH) {
+      throw new Error(ENTRIES_MAXIMUM_LENGTH_EXCEEDED_MESSAGE)
+    }
+  }
+
+  addDirectory(directory) {
+    const entry = directory;  ///
+
+    this.addEntry(entry);
+  }
+
+  forEachFile(callback) {
+    const files = this.getFiles();
+
+    files.forEachFile(callback);
+  }
+
+  mapEntry(callback) { return this.array.map(callback); }
+
+  someEntry(callback) { return this.array.some(callback); }
+
+  everyEntry(callback) { return this.array.every(callback); }
+
+  forEachEntry(callback) { this.array.forEach(callback); }
+
+  reduceEntry(callback, initialValue) { return this.array.reduce(callback, initialValue); }
+
+  toJSON() {
+    const entriesJSON = this.array.map((entry) => {
+            const entryJSON = entry.toJSON();
+  
+            return entryJSON;
+          }),
+          json = entriesJSON; ///
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const array = [],
+          entries = new Entries(array),
+          entriesJSON = json; ///
+
+    entriesJSON.map((entryJSON) => {
+      const json = entryJSON, ///
+            file = File.fromJSON(json),
+            directory = Directory.fromJSON(json),
+            entry = file || directory;  ///
+
+      entries.addEntry(entry);
+    });
+
+    return entries;
+  }
+
+  static fromEntry(entry) {
+    const array = [
+            entry
+          ],
+          entries = new Entries(array);
+
+    return entries;
+  }
+
+  static fromNothing() {
+    const array = [],
+          entries = new Entries(array);
+
+    return entries;
+  }
+}
+
+Object.assign(Entries.prototype, bnfMixins);
+Object.assign(Entries.prototype, filesMixins);
+Object.assign(Entries.prototype, patternMixins);
+Object.assign(Entries.prototype, metaJSONMixins);
+
+export default Entries;

package/src/file.js

@@ -0,0 +1,107 @@
+"use strict";
+
+import { FILE_TYPE } from "./types";
+import { convertContentTabsToWhitespace } from "./utilities/content"
+
+export default class File {
+  constructor(path, content, released) {
+    this.path = path;
+    this.content = content;
+    this.released = released;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  isReleased() {
+    return this.released;
+  }
+
+  isFile() {
+    const file = true;
+
+    return file;
+  }
+
+  isDirectory() {
+    const directory = false;
+
+    return directory;
+  }
+
+  setPath(path) {
+    this.path = path;
+  }
+
+  setContent(content) {
+    this.content = content;
+  }
+
+  setReleased(released) {
+    this.released = released;
+  }
+
+  toJSON() {
+    const { type } = File,
+          path = this.path,
+          content = this.content,
+          released = this.released,
+          json = {
+            type,
+            path,
+            content,
+            released
+          };
+
+    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, released } = json;
+
+        content = convertContentTabsToWhitespace(content);  ///
+
+        file = new File(path, content, released);
+      }
+    }
+
+    return file;
+  }
+
+  static fromDocument(document) {
+    const filePath = document.getFilePath(),
+          released = document.isReleased(),
+          path = filePath;  ///
+
+    let content = document.getContent();
+
+    content = convertContentTabsToWhitespace(content);  ///
+
+    const file = new File(path, content, released);
+
+    return file;
+  }
+
+  static fromPathContentAndReleased(path, content, released) {
+    content = convertContentTabsToWhitespace(content);  ///
+
+    const file = new File(path, content, released);
+
+    return file;
+  }
+}

package/src/fileNames.js

@@ -0,0 +1,22 @@
+"use strict";
+
+export const README_MD_FILE_NAME = "README.md";
+export const META_JSON_FILE_NAME = "meta.json";
+
+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";
+
+export default {
+  README_MD_FILE_NAME,
+  META_JSON_FILE_NAME,
+  TERM_BNF_FILE_NAME,
+  STATEMENT_BNF_FILE_NAME,
+  METASTATEMENT_BNF_FILE_NAME,
+  TYPE_PATTERN_FILE_NAME,
+  SYMBOL_PATTERN_FILE_NAME,
+  OPERATOR_PATTERN_FILE_NAME
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+
+export { default as File } from "./file";
+export { default as Files } from "./files";
+export { default as Version } from "./version";
+export { default as Entries } from "./entries";
+export { default as Project } from "./project";
+export { default as Release } from "./release";
+export { default as Projects } from "./projects";
+export { default as Releases } from "./releases";
+export { default as fileNames } from "./fileNames";
+export { default as Dependency } from "./dependency";
+export { default as Dependencies } from "./dependencies";
+export { default as ShortenedVersion } from "./shortenedVersion";
+export { default as contentUtilities } from "./utilities/content";
+export { default as filePathUtilities } from "./utilities/filePath";
+export { default as metaJSONUtilities } from "./utilities/metaJSON";

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,73 @@
+"use strict";
+
+function forEachFile(callback) { return this.entries.forEachFile(callback); }
+
+function getFile(filePath) { return this.entries.getFile(filePath); }
+
+function getBNF() { return this.entries.getBNF(); }
+
+function getFiles() { return this.entries.getFiles(); }
+
+function getTermBNF() { return this.entries.getTermBNF(); }
+
+function getVersion() { return this.entries.getVersion(); }
+
+function getPattern() { return this.entries.getPattern(); }
+
+function getFilePaths() { return this.entries.getFilePaths(); }
+
+function getRepository() { return this.entries.getRepository(); }
+
+function getReadmeFile() { return this.entries.getReadmeFile(); }
+
+function getTypePattern() { return this.entries.getTypePattern(); }
+
+function getStatementBNF() { return this.entries.getStatementBNF(); }
+
+function getDependencies() { return this.entries.getDependencies(); }
+
+function getMetaJSONFile() { return this.entries.getMetaJSONFile(); }
+
+function getSymbolPattern() { return this.entries.getSymbolPattern(); }
+
+function getFlorenceFiles() { return this.entries.getFlorenceFiles(); }
+
+function getDirectoryPaths() { return this.entries.getDirectoryPaths(); }
+
+function getOperatorPattern() { return this.entries.getOperatorPattern(); }
+
+function getDependencyNames() { return this.entries.getDependencyNames(); }
+
+function getMetastatementBNF() { return this.entries.getMetastatementBNF(); }
+
+function getCustomGrammarBNFFiles() { return this.entries.getCustomGrammarBNFFiles(); }
+
+function getCustomGrammarPatternFiles() { return this.entries.getCustomGrammarPatternFiles(); }
+
+
+const entriesMixins = {
+  forEachFile,
+  getFile,
+  getBNF,
+  getFiles,
+  getTermBNF,
+  getVersion,
+  getPattern,
+  getFilePaths,
+  getRepository,
+  getReadmeFile,
+  getTypePattern,
+  getStatementBNF,
+  getDependencies,
+  getMetaJSONFile,
+  getSymbolPattern,
+  getFlorenceFiles,
+  getDirectoryPaths,
+  getOperatorPattern,
+  getDependencyNames,
+  getMetastatementBNF,
+  getCustomGrammarBNFFiles,
+  getCustomGrammarPatternFiles
+};
+
+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;