occam-file-system 5.0.13 → 5.0.15

package/src/releases.js

@@ -0,0 +1,66 @@
+"use strict";
+
+import { asynchronousUtilities } from "necessary";
+
+import Release from "./release";
+
+const { forEach } = asynchronousUtilities;
+
+export default class Releases {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() {
+    return this.array.length;
+  }
+
+  addRelease(release) {
+    this.array.push(release);
+  }
+
+  mapRelease(callback) {
+    return this.array.map(callback);
+  }
+
+  reduceRelease(callback, initialValue) {
+    return this.array.reduce(callback, initialValue);
+  }
+
+  forEachRelease(callback) {
+    this.array.forEach(callback);
+  }
+
+  asynchronousForEachRelease(callback, done) {
+    forEach(this.array, callback, done);
+  }
+
+  toJSON() {
+    const json = this.array.map((release) => {
+      const releaseJSON = release.toJSON();
+
+      return releaseJSON;
+    });
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const array = json.map((json) => {  ///
+            const release = Release.fromJSON(json);
+
+            return release;
+          }),
+          releases = new Releases(array);
+
+    return releases;
+  }
+
+  static fromNothing() {
+    const array = [],
+          releases = new Releases(array);
+
+    return releases;
+  }
+}
+

package/src/shortenedVersion.js

@@ -0,0 +1,109 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { second } = arrayUtilities;
+
+export default class ShortenedVersion {
+  constructor(majorNumber, minorNumber) {
+    this.majorNumber = majorNumber;
+    this.minorNumber = minorNumber;
+  }
+
+  getMajorNumber() {
+    return this.majorNumber;
+  }
+
+  getMinorNumber() {
+    return this.minorNumber;
+  }
+
+  toString() {
+    const string = `${this.majorNumber}.${this.minorNumber}`;
+
+    return string;
+  }
+
+  asNumber() {
+    const number = this.majorNumber * 1e12 + this.minorNumber * 1e6; ///
+
+    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),
+          shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+
+    return shortenedVersion;
+  }
+
+  static fromVersionNumber(versionNumber) {
+    const number = versionNumber, ///
+          majorNumber = majorNumberFromNumber(number),
+          minorNumber = minorNumberFromNumber(number),
+          shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+
+    return shortenedVersion;
+  }
+}
+
+function majorNumberFromNumber(number) {
+  const majorNumber = (number !== null) ?
+                        Math.floor(number / 1e12) :
+                          0;  ///
+
+  return majorNumber;
+}
+
+function minorNumberFromNumber(number) {
+  const minorNumber = (number !== null) ?
+                        Math.floor(number / 1e6) :
+                          0;  ///
+
+  return minorNumber;
+}
+
+function majorNumberFromString(string) {
+  let majorNumber = 0;
+
+  if (string) {
+    const matches = string.match(/^(\d+)\.\d+$/),
+          secondMatch = second(matches);
+
+    majorNumber = secondMatch;  ///
+  }
+
+  return majorNumber;
+}
+
+function minorNumberFromString(string) {
+  let minorNumber = 0;
+
+  if (string) {
+    const matches = string.match(/^\d+\.(\d+)$/),
+          secondMatch = second(matches);
+
+    minorNumber = secondMatch;  ///
+  }
+
+  return minorNumber;
+}

package/src/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export const FILE_TYPE = "File";
+export const DIRECTORY_TYPE = "Directory";

package/src/utilities/content.js

@@ -0,0 +1,12 @@
+"use strict";
+
+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/filePath.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const readmeFilePathPattern = "^(?:[^\\/]+\\/){1}README\\.md$",
+      florenceFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.fls$",
+      metaJSONFilePathPattern = "^(?:[^\\/]+\\/){1}meta\\.json$",
+      customGrammarBNFFilePathPattern = "^(?:[^\\/]+\\/){1}(term|statement|metastatement)\\.bnf$",
+      customGrammarPatternFilePathPattern = "^(?:[^\\/]+\\/){1}(type|symbol|operator)\\.ptn$",
+      recognisedFilePathPattern = `${readmeFilePathPattern}|${florenceFilePathPattern}|${metaJSONFilePathPattern}|${customGrammarBNFFilePathPattern}|${customGrammarPatternFilePathPattern}`;
+
+const readmeFilePathRegularExpression = new RegExp(readmeFilePathPattern),
+      florenceFilePathRegularExpression = new RegExp(florenceFilePathPattern),
+      metaJSONFilePathRegularExpression = new RegExp(metaJSONFilePathPattern),
+      recognisedFilePathRegularExpression = new RegExp(recognisedFilePathPattern),
+      customGrammarBNFFilePathRegularExpression = new RegExp(customGrammarBNFFilePathPattern),
+      customGrammarPatternFilePathRegularExpression = new RegExp(customGrammarPatternFilePathPattern);
+
+export function isFilePathReadmeFilePath(filePath) { return readmeFilePathRegularExpression.test(filePath); }
+
+export function isFilePathFlorenceFilePath(filePath) { return florenceFilePathRegularExpression.test(filePath); }
+
+export function isFilePathMetaJSONFilePath(filePath) { return metaJSONFilePathRegularExpression.test(filePath); }
+
+export function isFilePathRecognisedFilePath(filePath) { return recognisedFilePathRegularExpression.test(filePath); }
+
+export function isFilePathCustomGrammarBNFFilePath(filePath) { return customGrammarBNFFilePathRegularExpression.test(filePath); }
+
+export function isFilePathCustomGrammarPatternFilePath(filePath) { return customGrammarPatternFilePathRegularExpression.test(filePath); }
+
+export default {
+  isFilePathReadmeFilePath,
+  isFilePathFlorenceFilePath,
+  isFilePathMetaJSONFilePath,
+  isFilePathRecognisedFilePath,
+  isFilePathCustomGrammarBNFFilePath,
+  isFilePathCustomGrammarPatternFilePath
+};

package/src/utilities/fileSystem.js

@@ -2,15 +2,30 @@
 
 import mkdirp from "mkdirp";
 
+import { MetaJSONLexer, MetaJSONParser } from "occam-grammars";
 import { pathUtilities, fileSystemUtilities } from "necessary";
-import { File, Files, Project, Projects, nameUtilities, entriesUtilities, contentUtilities } from "occam-open-cli";
 
-const { isNameHiddenName } = nameUtilities,
-      { convertContentTabsToWhitespace } = contentUtilities,
-      { entriesFromTopmostDirectoryName } = entriesUtilities,
-      { concatenatePaths, topmostDirectoryPathFromPath } = pathUtilities,
+import File from "../file";
+import Files from "../files";
+import Entries from "../entries";
+import Project from "../project";
+import Projects from "../projects";
+import Releases from "../releases";
+import Directory from "../directory";
+
+import { PERIOD } from "../constants";
+import { isNameHiddenName } from "../utilities/name";
+import { isFilePathRecognisedFilePath } from "../utilities/filePath";
+import { convertContentTabsToWhitespace } from "../utilities/content";
+import { metaJSONFileFromFiles, readmeFileFromFiles } from "../utilities/files";
+import { versionFromNode, repositoryFromNode, dependenciesFromNode } from "./metaJSON";
+
+const { concatenatePaths, topmostDirectoryPathFromPath } = pathUtilities,
       { readFile, writeFile, isEntryFile, readDirectory, isEntryDirectory } = fileSystemUtilities;
 
+const metaJSONLexer = MetaJSONLexer.fromNothing(),
+      metaJSONParser = MetaJSONParser.fromNothing();
+
 export function loadFile(path, projectsDirectoryPath) {
   let file = null;
 
@@ -23,7 +38,7 @@ export function loadFile(path, projectsDirectoryPath) {
 
       content = convertContentTabsToWhitespace(content);  ///
 
-      file = new File(path, content);
+      file = File.fromPathAndContent(path, content);
     }
   } catch (error) {
     ///
@@ -44,8 +59,7 @@ export function saveFile(file, projectsDirectoryPath) {
 }
 
 export function loadFiles(paths, projectsDirectoryPath) {
-  const array = [],
-        files = new Files(array);
+  const files = Files.fromNothing();
 
   paths.forEach((path) => {
     const file = loadFile(path, projectsDirectoryPath);
@@ -62,23 +76,89 @@ export function saveFiles(files, projectsDirectoryPath) {
   });
 }
 
+export function loadEntries(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories) {
+  const entries = Entries.fromNothing(),
+        relativeDirectoryPath = topmostDirectoryName;  ///
+
+  entriesFromRelativeDirectoryPath(entries, relativeDirectoryPath, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories);
+
+  return entries;
+}
+
+export function loadRelease(topmostDirectoryName, projectsDirectoryPath = PERIOD) {
+  let release = null;
+
+  const name = topmostDirectoryName,  ///
+        loadOnlyRecognisedFiles = true,
+        doNotLoadHiddenFilesAndDirectories = true,
+        entries = loadEntries(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories),
+        files = entries.getFiles(),
+        readmeFile = readmeFileFromFiles(files),
+        metaJSONFile = metaJSONFileFromFiles(files);
+
+  if ((readmeFile !== null) && (metaJSONFile !== null)) {
+    const metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile);
+
+    if (metaJSONNode !== null) {
+      const node = metaJSONNode,  ///
+            version = versionFromNode(node),
+            repository = repositoryFromNode(node),
+            dependencies = dependenciesFromNode(node);
+
+      release = Release.fromNameEntriesVersionRepositoryAndDependencies(name, entries, version, repository, dependencies);
+    }
+  }
+
+  return release;
+}
+
 export function loadProject(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories) {
   const name = topmostDirectoryName,  ///
-        entries = entriesFromTopmostDirectoryName(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories),
-        project = new Project(name, entries);
+        entries = loadEntries(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories),
+        files = entries.getFiles(),
+        metaJSONFile = metaJSONFileFromFiles(files);
+
+  let repository = null,
+      dependencies = [];
+
+  if (metaJSONFile !== null) {
+    const metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),
+          node = metaJSONNode;
+
+    repository = repositoryFromNode(node);
+    dependencies = dependenciesFromNode(node);
+  }
+
+  const project = Project.fromNameEntriesRepositoryAndDependencies(name, entries, repository, dependencies);
 
   return project;
 }
 
-export function loadProjects(projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories) {
-  let projects;
+export function loadReleases(projectsDirectoryPath) {
+  let releases;
 
   try {
-    const array = [];
+    const releases = Releases.fromNothing(),
+          topmostFileNames = topmostFileNamesFromProjectsDirectoryPath(projectsDirectoryPath);
+
+    topmostFileNames.forEach((topmostFileName) => {
+      const release = loadRelease(topmostFileName, projectsDirectoryPath);
 
-    projects = new Projects(array);
+      releases.addRelease(release);
+    });
+  } catch (error) {
+    releases = null;
+  }
+
+  return releases;
+}
+
+export function loadProjects(projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories) {
+  let projects;
 
-    const topmostDirectoryNames = topmostDirectoryNamesFromProjectsDirectoryPath(projectsDirectoryPath, doNotLoadHiddenFilesAndDirectories);
+  try {
+    const projects = Projects.fromNothing(),
+          topmostDirectoryNames = topmostDirectoryNamesFromProjectsDirectoryPath(projectsDirectoryPath, doNotLoadHiddenFilesAndDirectories);
 
     topmostDirectoryNames.forEach((topmostDirectoryName) => {
       const project = loadProject(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories);
@@ -92,6 +172,97 @@ export function loadProjects(projectsDirectoryPath, loadOnlyRecognisedFiles, doN
   return projects;
 }
 
+export function loadDirectory(path, projectsDirectoryPath) {
+  let directory = null;
+
+  try {
+    const absolutePath = concatenatePaths(projectsDirectoryPath, path),
+          entryDirectory = isEntryDirectory(absolutePath);
+
+    if (entryDirectory) {
+      directory = Directory.fromPath(path);
+    }
+  } catch (error) {
+    ///
+  }
+
+  return directory;
+}
+
+function metaJSONNodeFromMetaJSONFile(metaJSONFile) {
+  const content = metaJSONFile.getContent(),
+        tokens = metaJSONLexer.tokenise(content),
+        node = metaJSONParser.parse(tokens),
+        metaJSONNode = node;  ///
+
+  return metaJSONNode;
+}
+
+function entriesFromRelativeDirectoryPath(entries, relativeDirectoryPath, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories) {
+  const absoluteDirectoryPath = concatenatePaths(projectsDirectoryPath, relativeDirectoryPath),
+        subEntryNames = readDirectory(absoluteDirectoryPath);
+
+  subEntryNames.forEach((subEntryName) => {
+    const subEntryNameHiddenName = isNameHiddenName(subEntryName),
+          subEntryNameNotHiddenName = !subEntryNameHiddenName,
+          loadHiddenFilesAndDirectories = !doNotLoadHiddenFilesAndDirectories,
+          loadUnrecognisedFilesAndDirectories = !loadOnlyRecognisedFiles;
+
+    if (subEntryNameNotHiddenName || loadHiddenFilesAndDirectories) {
+      const path = concatenatePaths(relativeDirectoryPath, subEntryName),
+            directory = loadDirectory(path, projectsDirectoryPath);
+
+      if (directory !== null) {
+        const directoryPath = path; ///
+
+        if (loadUnrecognisedFilesAndDirectories) {
+          entries.addDirectory(directory);
+        }
+
+        entriesFromRelativeDirectoryPath(entries, directoryPath, projectsDirectoryPath, loadOnlyRecognisedFiles, doNotLoadHiddenFilesAndDirectories); ///
+      } else {
+        const file = loadFile(path, projectsDirectoryPath);
+
+        if (file !== null) {
+          const filePath = file.getPath(),
+                filePathRecognisedFilePath = isFilePathRecognisedFilePath(filePath),
+                fileRecognisedFile = filePathRecognisedFilePath;  ///
+
+          if (fileRecognisedFile || loadUnrecognisedFilesAndDirectories) {
+            entries.addFile(file);
+          }
+        }
+      }
+    }
+  });
+}
+
+function topmostFileNamesFromProjectsDirectoryPath(projectsDirectoryPath) {
+  let topmostFileNames;
+
+  const subEntryNames = readDirectory(projectsDirectoryPath);
+
+  topmostFileNames = subEntryNames.reduce((topmostFileNames, subEntryName) => {
+    const absoluteSubEntryPath = concatenatePaths(projectsDirectoryPath, subEntryName),
+          subEntryNameHiddenName = isNameHiddenName(subEntryName),
+          subEntryNameNotHiddenName = !subEntryNameHiddenName;
+
+    if (subEntryNameNotHiddenName) {
+      const subEntryFile = isEntryFile(absoluteSubEntryPath);
+
+      if (subEntryFile) {
+        const topmostFileName = subEntryName;  ///
+
+        topmostFileNames.push(topmostFileName)
+      }
+    }
+
+    return topmostFileNames;
+  }, []);
+
+  return topmostFileNames;
+}
+
 function topmostDirectoryNamesFromProjectsDirectoryPath(projectsDirectoryPath, doNotLoadHiddenFilesAndDirectories) {
   let topmostDirectoryNames;
 

package/src/utilities/files.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import { isFilePathReadmeFilePath,
+         isFilePathFlorenceFilePath,
+         isFilePathMetaJSONFilePath,
+         isFilePathCustomGrammarBNFFilePath,
+         isFilePathCustomGrammarPatternFilePath } from "../utilities/filePath";
+
+export function readmeFileFromFiles(files) {
+  let readmeFile = null;
+
+  files.someFile((file) => {
+    const filePath = file.getPath(),
+          filePathReadmeFilePath = isFilePathReadmeFilePath(filePath);
+
+    if (filePathReadmeFilePath) {
+      readmeFile = file;  ///
+
+      return true;
+    }
+  });
+
+  return readmeFile;
+}
+
+export function metaJSONFileFromFiles(files) {
+  let metaJSONFile = null;
+
+  files.someFile((file) => {
+    const filePath = file.getPath(),
+          filePathMetaJSONFilePath = isFilePathMetaJSONFilePath(filePath);
+
+    if (filePathMetaJSONFilePath) {
+      metaJSONFile = file;  ///
+
+      return true;
+    }
+  });
+
+  return metaJSONFile;
+}
+
+export 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;
+}
+
+export 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;
+}
+
+export 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,9 +1,26 @@
 "use strict";
 
+import { pathUtilities } from "necessary";
+
 const hiddenNameRegularExpression = /^\..+/;
 
+const { bottommostNameFromPath } = pathUtilities;
+
 export function isNameHiddenName(name) {
   const nameHiddenName = hiddenNameRegularExpression.test(name);
 
   return nameHiddenName;
 }
+
+export function fileNameFromFilePath(filePath) {
+  const path = filePath,  ///
+        bottommostName = bottommostNameFromPath(path),
+        fileName = bottommostName;  //
+
+  return fileName;
+}
+
+export default {
+  isNameHiddenName,
+  fileNameFromFilePath
+};