occam-model 1.0.484

package/src/file.js

@@ -0,0 +1,113 @@
+"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;
+  }
+
+  matchFilePath(filePath) {
+    const filePathMatches = (this.path === filePath);
+
+    return filePathMatches;
+  }
+
+  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,18 @@
+"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 TYPE_VOCABULARY_FILE_NAME = "type.vcb";
+export const SYMBOL_VOCABULARY_FILE_NAME = "symbol.vcb";
+
+export default {
+  README_MD_FILE_NAME,
+  META_JSON_FILE_NAME,
+  TERM_BNF_FILE_NAME,
+  STATEMENT_BNF_FILE_NAME,
+  TYPE_VOCABULARY_FILE_NAME,
+  SYMBOL_VOCABULARY_FILE_NAME
+};

package/src/files.js

@@ -0,0 +1,66 @@
+"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,18 @@
+"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 Directory } from "./directory";
+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,51 @@
+"use strict";
+
+import { EMPTY_STRING } from "../constants";
+import { fileNameFromFilePath } from "../utilities/name";
+import { TERM_BNF_FILE_NAME, STATEMENT_BNF_FILE_NAME } from "../fileNames";
+
+function getBNF(bnfFileName) {
+  let bnf = EMPTY_STRING;
+
+  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;
+}
+
+const bnfMixins = {
+  getBNF,
+  getTermBNF,
+  getStatementBNF
+};
+
+export default bnfMixins;

package/src/mixins/entries.js

@@ -0,0 +1,69 @@
+"use strict";
+
+function forEachFile(callback) { return this.entries.forEachFile(callback); }
+
+function findFile(filePath) { return this.entries.findFile(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 getFilePaths() { return this.entries.getFilePaths(); }
+
+function getVocabulary() { return this.entries.getVocabulary(); }
+
+function getRepository() { return this.entries.getRepository(); }
+
+function getReadmeFile() { return this.entries.getReadmeFile(); }
+
+function getStatementBNF() { return this.entries.getStatementBNF(); }
+
+function getDependencies() { return this.entries.getDependencies(); }
+
+function getTypeVocabulary() { return this.entries.getTypeVocabulary(); }
+
+function getSymbolVocabulary() { return this.entries.getSymbolVocabulary(); }
+
+function getMetaJSONFile() { return this.entries.getMetaJSONFile(); }
+
+function getFurtleFiles() { return this.entries.getFurtleFiles(); }
+
+function getNominalFiles() { return this.entries.getNominalFiles(); }
+
+function getDirectoryPaths() { return this.entries.getDirectoryPaths(); }
+
+function getDependencyNames() { return this.entries.getDependencyNames(); }
+
+function getCustomGrammarBNFFiles() { return this.entries.getCustomGrammarBNFFiles(); }
+
+function getCustomGrammarVocabularyFiles() { return this.entries.getCustomGrammarVocabularyFiles(); }
+
+const entriesMixins = {
+  forEachFile,
+  findFile,
+  getBNF,
+  getFiles,
+  getTermBNF,
+  getVersion,
+  getFilePaths,
+  getVocabulary,
+  getRepository,
+  getReadmeFile,
+  getStatementBNF,
+  getDependencies,
+  getTypeVocabulary,
+  getSymbolVocabulary,
+  getMetaJSONFile,
+  getFurtleFiles,
+  getNominalFiles,
+  getDirectoryPaths,
+  getDependencyNames,
+  getCustomGrammarBNFFiles,
+  getCustomGrammarVocabularyFiles
+};
+
+export default entriesMixins;

package/src/mixins/files.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import { readmeFileFromFiles,
+         furtleFilesFromFiles,
+         nominalFilesFromFiles,
+         metaJSONFileFromFiles,
+         customGrammarBNFFilesFromFiles,
+         customGrammarVocabularyFilesFromFiles } from "../utilities/files";
+
+function getReadmeFile() {
+  const files = this.getFiles(),
+        readmeFile = readmeFileFromFiles(files);
+
+  return readmeFile;
+}
+
+function getFurtleFiles() {
+  const files = this.getFiles(),
+        furtleFiles = furtleFilesFromFiles(files);
+
+  return furtleFiles;
+}
+
+function getNominalFiles() {
+  const files = this.getFiles(),
+        nominalFiles = nominalFilesFromFiles(files);
+
+  return nominalFiles;
+}
+
+function getMetaJSONFile() {
+  const files = this.getFiles(),
+        metaJSONFile = metaJSONFileFromFiles(files);
+
+  return metaJSONFile;
+}
+
+function getCustomGrammarBNFFiles() {
+  const files = this.getFiles(),
+        customGrammarBNFFiles = customGrammarBNFFilesFromFiles(files);
+
+  return customGrammarBNFFiles;
+}
+
+function getCustomGrammarVocabularyFiles() {
+  const files = this.getFiles(),
+        customGrammarVocabularyFiles = customGrammarVocabularyFilesFromFiles(files);
+
+  return customGrammarVocabularyFiles;
+}
+
+const filesMixins = {
+  getReadmeFile,
+  getFurtleFiles,
+  getNominalFiles,
+  getMetaJSONFile,
+  getCustomGrammarBNFFiles,
+  getCustomGrammarVocabularyFiles
+};
+
+export default filesMixins;

package/src/mixins/metaJSON.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import { versionFromDocumentNode, repositoryFromDocumentNode, dependenciesFromDocumentNode, dependencyNamesFromDocumentNode, documentNodeFromMetaJSONFile } from "../utilities/metaJSON";
+
+function getVersion() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        documentNode = documentNodeFromMetaJSONFile(metaJSONFile),
+        version = versionFromDocumentNode(documentNode);
+
+  return version;
+}
+
+function getRepository() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        documentNode = documentNodeFromMetaJSONFile(metaJSONFile),
+        repository = repositoryFromDocumentNode(documentNode);
+
+  return repository;
+}
+
+function getDependencies() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        documentNode = documentNodeFromMetaJSONFile(metaJSONFile),
+        dependencies = dependenciesFromDocumentNode(documentNode);
+
+  return dependencies;
+}
+
+function getDependencyNames() {
+  const metaJSONFile = this.getMetaJSONFile(),
+        documentNode = documentNodeFromMetaJSONFile(metaJSONFile),
+        dependencyNames = dependencyNamesFromDocumentNode(documentNode);
+
+  return dependencyNames;
+}
+
+const metaJSONMixins = {
+  getVersion,
+  getRepository,
+  getDependencies,
+  getDependencyNames
+};
+
+export default metaJSONMixins;

package/src/mixins/vocabulary.js

@@ -0,0 +1,51 @@
+"use strict";
+
+import { EMPTY_STRING } from "../constants";
+import { fileNameFromFilePath } from "../utilities/name";
+import { TYPE_VOCABULARY_FILE_NAME, SYMBOL_VOCABULARY_FILE_NAME } from "../fileNames";
+
+function getVocabulary(vocabularyFileName) {
+  let vocabulary = EMPTY_STRING;
+
+  const customGrammarVocabularyFiles = this.getCustomGrammarVocabularyFiles(),
+        customGrammarVocabularyFile = customGrammarVocabularyFiles.find((customGrammarVocabularyFile) => {
+        const customGrammarVocabularyFilePath = customGrammarVocabularyFile.getPath(),
+              customGrammarVocabularyFileName = fileNameFromFilePath(customGrammarVocabularyFilePath);
+
+        if (customGrammarVocabularyFileName === vocabularyFileName) {
+          return true;
+        }
+      }) || null;
+
+  if (customGrammarVocabularyFile !== null) {
+    const customGrammarVocabularyFileContent = customGrammarVocabularyFile.getContent();
+
+    vocabulary = customGrammarVocabularyFileContent;  ///
+  }
+
+  return vocabulary;
+}
+
+function getTypeVocabulary() {
+  const fileName = TYPE_VOCABULARY_FILE_NAME, ///
+        vocabulary = this.getVocabulary(fileName),
+        typeVocabulary = vocabulary;  ///
+
+  return typeVocabulary;
+}
+
+function getSymbolVocabulary() {
+  const fileName = SYMBOL_VOCABULARY_FILE_NAME, ///
+        vocabulary = this.getVocabulary(fileName),
+        symbolVocabulary = vocabulary;  ///
+
+  return symbolVocabulary;
+}
+
+const vocabularyMixins =  {
+  getVocabulary,
+  getTypeVocabulary,
+  getSymbolVocabulary
+};
+
+export default vocabularyMixins;

package/src/multiplers.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const MAJOR_NUMBER_MULTIPLIER = 1e12;
+export const MINOR_NUMBER_MULTIPLIER = 1e6;
+export const PATCH_NUMBER_MULTIPLIER = 1e0;

package/src/project.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import Entries from "./entries";
+import entriesMixins from "./mixins/entries";
+
+class Project {
+  constructor(name, entries) {
+    this.name = name;
+    this.entries = entries;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getEntries() {
+    return this.entries;
+  }
+
+  toJSON() {
+    const entriesJSON = this.entries.toJSON(),
+          name = this.name,
+          entries = entriesJSON,  ///
+          json = {
+            name,
+            entries
+          };
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    let { entries } = json;
+
+    const { name } = json,
+          entriesJSON = entries;  ///
+
+    json = entriesJSON; ///
+
+    entries = Entries.fromJSON(json); ///
+
+    const project = new Project(name, entries);
+
+    return project;
+  }
+
+  static fromName(name) {
+    const entries = Entries.fromNothing(),
+          project = new Project(name, entries);
+
+    return project;
+  }
+
+  static fromNameAndEntries(name, entries) {
+    const project = new Project(name, entries);
+
+    return project;
+  }
+}
+
+Object.assign(Project.prototype, entriesMixins);
+
+export default Project;

package/src/projects.js

@@ -0,0 +1,54 @@
+"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/propertyNames.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const VERSION_PROPERTY_NAME = "version";
+export const REPOSITORY_PROPERTY_NAME = "repository";
+export const DEPENDENCIES_PROPERTY_NAME = "dependencies";