occam-server 2.0.0 → 7.0.4

package/src/utilities/fileSystem.js

@@ -0,0 +1,364 @@
+"use strict";
+
+import { arrayUtilities, pathUtilities, fileSystemUtilities } from "necessary";
+import { File, Files, Entries, Project, Release, Projects, Releases, Directory, filePathUtilities } from "occam-model";
+
+import { isNameHiddenName } from "../utilities/name";
+
+const { first } = arrayUtilities,
+      { isFilePathRecognisedFilePath } = filePathUtilities,
+      { concatenatePaths, topmostDirectoryNameFromPath } = pathUtilities,
+      { readFile,
+        writeFile,
+        isEntryFile,
+        readDirectory,
+        isEntryDirectory,
+        checkEntryExists,
+        checkEntryExists: checkFileExists } = fileSystemUtilities;
+
+export function loadFile(path, projectsDirectoryPath) {
+  let file = null;
+
+  try {
+    const topmostDirectoryName = topmostDirectoryNameFromPath(path);
+
+    if (topmostDirectoryName !== null) {
+      const absolutePath = concatenatePaths(projectsDirectoryPath, topmostDirectoryName),
+            entryDirectory = isEntryDirectory(absolutePath);
+
+      file = entryDirectory ?
+               fileFromProject(path, projectsDirectoryPath) :
+                 fileFromRelease(path, projectsDirectoryPath);
+    }
+  } catch (error) {
+    ///
+  }
+
+  return file;
+}
+
+export function saveFile(file, projectsDirectoryPath) {
+  let success = false;
+
+  const filePath = file.getPath(),
+        absoluteFilePath = concatenatePaths(projectsDirectoryPath, filePath),
+        fileExists = checkFileExists(absoluteFilePath);
+
+  if (fileExists) {
+    const filePath = absoluteFilePath,  ///
+          content = file.getContent();
+
+    try {
+      writeFile(filePath, content);
+    } catch (error) {
+      ///
+    }
+
+    success = true;
+  }
+
+  return success;
+}
+
+export function loadFiles(paths, projectsDirectoryPath) {
+  let files;
+
+  try {
+    files = Files.fromNothing();
+
+    const pathsLength = paths.length;
+
+    if (pathsLength > 0) {
+      const firstPath = first(paths),
+            path = firstPath, ///
+            topmostDirectoryName = topmostDirectoryNameFromPath(path);
+
+      if (topmostDirectoryName !== null) {
+        const absolutePath = concatenatePaths(projectsDirectoryPath, topmostDirectoryName),
+              entryExists = checkEntryExists(absolutePath);
+
+        if (entryExists) {
+          const entryDirectory = isEntryDirectory(absolutePath);
+
+          files = entryDirectory ?
+                    filesFromProject(paths, projectsDirectoryPath) :
+                      filesFromRelease(paths, projectsDirectoryPath);
+        }
+      }
+    }
+  } catch (error) {
+    files = null;
+  }
+
+  return files;
+}
+
+export function loadRelease(releaseName, projectsDirectoryPath) {
+  let release = null;
+
+  try {
+    const name = releaseName, ///
+          topmostFileName = releaseName,  ///
+          absolutePath = concatenatePaths(projectsDirectoryPath, topmostFileName),
+          entryFile = isEntryFile(absolutePath);
+
+    if (entryFile) {
+      let json,
+          entries;
+
+      const content = readFile(absolutePath);
+
+      json = JSON.parse(content);
+
+      ({ entries } = json);
+
+      json  = entries;  ///
+
+      entries = Entries.fromJSON(json);
+
+      release = Release.fromNameAndEntries(name, entries);
+    }
+  } catch (error) {
+    ///
+  }
+
+  return release;
+}
+
+export function loadProject(projectName, projectsDirectoryPath, loadOnlyRecognisedFiles) {
+  let project = null;
+
+  try {
+    const name = projectName,  ///
+          topmostDirectoryName = projectName, ///
+          entries = loadEntries(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles);
+
+    project = Project.fromNameAndEntries(name, entries);
+  } catch (error) {
+    ///
+  }
+
+  return project;
+}
+
+export function loadReleases(projectsDirectoryPath) {
+  let releases;
+
+  try {
+    releases = Releases.fromNothing();
+
+    const topmostFileNames = topmostFileNamesFromProjectsDirectoryPath(projectsDirectoryPath),
+          releaseNames = topmostFileNames;  ///
+
+    releaseNames.forEach((releaseName) => {
+      const release = loadRelease(releaseName, projectsDirectoryPath);
+
+      if (release !== null) {
+        releases.addRelease(release);
+      }
+    });
+  } catch (error) {
+    releases = null;
+  }
+
+  return releases;
+}
+
+export function loadProjects(projectsDirectoryPath, loadOnlyRecognisedFiles) {
+  let projects;
+
+  try {
+    projects = Projects.fromNothing();
+
+    const topmostDirectoryNames = topmostDirectoryNamesFromProjectsDirectoryPath(projectsDirectoryPath),
+          projectNames = topmostDirectoryNames; ///
+
+    projectNames.forEach((projectName) => {
+      const project = loadProject(projectName, projectsDirectoryPath, loadOnlyRecognisedFiles);
+
+      if (project !== null) {
+        projects.addProject(project);
+      }
+    });
+  } catch (error) {
+    projects = null;
+  }
+
+  return projects;
+}
+
+export default {
+  loadFile,
+  saveFile,
+  loadFiles,
+  loadRelease,
+  loadProject,
+  loadReleases,
+  loadProjects
+};
+
+function loadEntries(topmostDirectoryName, projectsDirectoryPath, loadOnlyRecognisedFiles) {
+  const entries = Entries.fromNothing(),
+        relativeDirectoryPath = topmostDirectoryName;  ///
+
+  entriesFromRelativeDirectoryPath(entries, relativeDirectoryPath, projectsDirectoryPath, loadOnlyRecognisedFiles);
+
+  return entries;
+}
+
+function loadDirectory(path, projectsDirectoryPath) {
+  const absolutePath = concatenatePaths(projectsDirectoryPath, path),
+        entryDirectory = isEntryDirectory(absolutePath),
+        directory = entryDirectory ?
+                      Directory.fromPath(path) :
+                        null;
+
+  return directory;
+}
+
+function fileFromProject(path, projectsDirectoryPath) {
+  let file = null;
+
+  const absolutePath = concatenatePaths(projectsDirectoryPath, path),
+        entryFile = isEntryFile(absolutePath);
+
+  if (entryFile) {
+    const released = false,
+          content = readFile(absolutePath);
+
+    file = File.fromPathContentAndReleased(path, content, released);
+  }
+
+  return file;
+}
+
+function fileFromRelease(path, projectsDirectoryPath) {
+  const topmostDirectoryName = topmostDirectoryNameFromPath(path),
+        topmostFileName = topmostDirectoryName, ///
+        filePath = path,  ///
+        release = loadRelease(topmostFileName, projectsDirectoryPath),
+        file = release.findFile(filePath);
+
+  return file;
+}
+
+function filesFromProject(paths, projectsDirectoryPath) {
+  const files = Files.fromNothing();
+
+  paths.forEach((path) => {
+    const file = fileFromProject(path, projectsDirectoryPath);
+
+    files.addFile(file);
+  });
+
+  return files;
+}
+
+function filesFromRelease(paths, projectsDirectoryPath) {
+  const files = Files.fromNothing(),
+        pathsLength = paths.length;
+
+  if (pathsLength > 0) {
+    const firstPath = first(paths),
+          path = firstPath, ///
+          topmostDirectoryName = topmostDirectoryNameFromPath(path),
+          topmostFileName = topmostDirectoryName, ///
+          release = loadRelease(topmostFileName, projectsDirectoryPath);
+
+    paths.forEach((path) => {
+      const filePath = path,  ///
+            file = release.findFile(filePath);
+
+      files.addFile(file);
+    });
+  }
+
+  return files;
+}
+
+function entriesFromRelativeDirectoryPath(entries, relativeDirectoryPath, projectsDirectoryPath, loadOnlyRecognisedFiles) {
+  const absoluteDirectoryPath = concatenatePaths(projectsDirectoryPath, relativeDirectoryPath),
+        subEntryNames = readDirectory(absoluteDirectoryPath);
+
+  subEntryNames.forEach((subEntryName) => {
+    const subEntryNameHiddenName = isNameHiddenName(subEntryName),
+          loadUnrecognisedFilesAndDirectories = !loadOnlyRecognisedFiles;
+
+    if (!subEntryNameHiddenName) {
+      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); ///
+      } 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);
+
+    if (!subEntryNameHiddenName) {
+      const subEntryFile = isEntryFile(absoluteSubEntryPath);
+
+      if (subEntryFile) {
+        const topmostFileName = subEntryName;  ///
+
+        topmostFileNames.push(topmostFileName)
+      }
+    }
+
+    return topmostFileNames;
+  }, []);
+
+  return topmostFileNames;
+}
+
+function topmostDirectoryNamesFromProjectsDirectoryPath(projectsDirectoryPath) {
+  let topmostDirectoryNames;
+
+  const subEntryNames = readDirectory(projectsDirectoryPath);
+
+  topmostDirectoryNames = subEntryNames.reduce((topmostDirectoryNames, subEntryName) => {
+    const absoluteSubEntryPath = concatenatePaths(projectsDirectoryPath, subEntryName),
+          subEntryNameHiddenName = isNameHiddenName(subEntryName);
+
+    if (!subEntryNameHiddenName) {
+      const subEntryDirectory = isEntryDirectory(absoluteSubEntryPath);
+
+      if (subEntryDirectory) {
+        const topmostDirectoryName = subEntryName;  ///
+
+        topmostDirectoryNames.push(topmostDirectoryName)
+      }
+    }
+
+    return topmostDirectoryNames;
+  }, []);
+
+  return topmostDirectoryNames;
+}

package/src/utilities/http.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { Readable } from "stream";
+
+import { methods, headers, contentTypes, statusCodes, requestUtilities } from "necessary";
+
+import { END, DATA, EMPTY_STRING } from "../constants";
+
+const { POST_METHOD } = methods,
+      { createRequest } = requestUtilities,
+      { OK_200_STATUS_CODE } = statusCodes,
+      { ACCEPT_HEADER, CONTENT_TYPE_HEADER } = headers,
+      { APPLICATION_JSON_CHARSET_UTF_8_CONTENT_TYPE } = contentTypes;
+
+export function post(host, uri, query, json, callback) {
+	const content = JSON.stringify(json),	///
+				method = POST_METHOD,
+				headers = {
+          [ACCEPT_HEADER]: APPLICATION_JSON_CHARSET_UTF_8_CONTENT_TYPE,
+          [CONTENT_TYPE_HEADER]: APPLICATION_JSON_CHARSET_UTF_8_CONTENT_TYPE
+        };
+
+	const request = createRequest(host, uri, query, method, headers, (error, response) => {
+					if (response === null) {
+						error = true;
+					} else {
+						const { statusCode } = response;
+
+						if (statusCode !== OK_200_STATUS_CODE) {
+							error = true;
+						}
+					}
+
+					if (error) {
+						const json = null;
+
+						callback(json);
+
+						return;
+					}
+
+					contentFromResponse(response, (content) => {
+						let json = null;
+
+						try {
+							json = JSON.parse(content);
+						} catch (error) {}	///
+
+						callback(json);
+					});
+				}),
+				readable = Readable.from(content);
+
+	readable.pipe(request);
+}
+
+export default {
+	post
+};
+
+function contentFromResponse(response, callback) {
+	let content = EMPTY_STRING;
+
+	response.on(DATA, (data) => {
+		content += data;
+	});
+
+	response.on(END, () => {
+		callback(content);
+	});
+}

package/src/utilities/name.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export function isNameHiddenName(name) {
+  const nameHiddenName = /^\..+/.test(name);
+
+  return nameHiddenName;
+}

package/src/utilities/pathMap.js

@@ -0,0 +1,39 @@
+"use strict";
+
+export function nullifyEntryPaths(pathMap) {
+  const sourceEntryPath = null,
+        targetEntryPath = null;
+
+  Object.assign(pathMap, {
+    sourceEntryPath,
+    targetEntryPath
+  });
+}
+
+export function nullifySourceEntryPath(pathMap) {
+  const sourceEntryPath = null;
+
+  Object.assign(pathMap, {
+    sourceEntryPath
+  });
+}
+
+export function nullifyTargetEntryPath(pathMap) {
+  const targetEntryPath = null;
+
+  Object.assign(pathMap, {
+    targetEntryPath
+  });
+}
+
+export function nullifySourceEntryPaths(pathMaps) {
+  pathMaps.forEach((pathMap) => {
+    nullifySourceEntryPath(pathMap);
+  });
+}
+
+export function nullifyTargetEntryPaths(pathMaps) {
+  pathMaps.forEach((pathMap) => {
+    nullifyTargetEntryPath(pathMap);
+  });
+}

package/es6/handler/importProject.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { importProject } = filesystem;
-
-function importProjectHandler(request, response, next) {
-  const { query, } = request,
-        { url } = query;
-
-  importProject(url, function(project) {
-    const projectJSON = project.toJSON(),
-          responseJSON = projectJSON; ///
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = importProjectHandler;

package/es6/handler/loadFile.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { loadFile } = filesystem;
-
-function loadFileHandler(request, response, next) {
-  const { query, body } = request,
-        { filePath } = body,
-        { projectsDirectoryPath } = query,
-        path = filePath;  ///
-
-  loadFile(projectsDirectoryPath, path, function(file) {
-    const fileJSON = (file !== null) ?  ///
-                        file.toJSON() :
-                          null,
-          responseJSON = fileJSON;  ///
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = loadFileHandler;

package/es6/handler/loadFiles.js

@@ -1,25 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { loadFiles } = filesystem;
-
-function loadFilesHandler(request, response, next) {
-  const { query, body } = request,
-        { filePaths } = body,
-        { projectsDirectoryPath } = query,
-        paths = filePaths;  ///
-
-  loadFiles(projectsDirectoryPath, paths, function(files) {
-    const filesJSON = files.toJSON(),
-          responseJSON = filesJSON; ///
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = loadFilesHandler;

package/es6/handler/loadProjects.js

@@ -1,29 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse'),
-      queryUtilities = require('../utilities/query');
-
-const { toBoolean } = queryUtilities,
-      { loadProjects } = filesystem;
-
-function loadProjectsHandler(request, response, next) {
-  const { query } = request,
-        { projectsDirectoryPath } = query;
-
-  let { doNotLoadHiddenFilesAndDirectories } = query;
-
-  doNotLoadHiddenFilesAndDirectories = toBoolean(doNotLoadHiddenFilesAndDirectories); ///
-
-  loadProjects(projectsDirectoryPath, doNotLoadHiddenFilesAndDirectories, function(projects) {
-    const projectsJSON = projects.toJSON(),
-          responseJSON = projectsJSON;  ///
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = loadProjectsHandler;

package/es6/handler/moveProjectEntries.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { moveProjectEntries } = filesystem;
-
-function moveProjectEntriesHandler(request, response, next) {
-  const { query, body } = request,
-        { pathMaps } = body,
-        { projectsDirectoryPath } = query;
-
-  moveProjectEntries(projectsDirectoryPath, pathMaps, function(targetPaths) {
-    const targetPathsJSON = targetPaths,  ///
-          responseJSON = targetPathsJSON;  ///
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = moveProjectEntriesHandler;

package/es6/handler/removeProjectEntries.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { removeProjectEntries } = filesystem;
-
-function removeProjectEntriesHandler(request, response, next) {
-  const { query, body } = request,
-        { pathMaps } = body,
-        { projectsDirectoryPath } = query;
-
-  removeProjectEntries(projectsDirectoryPath, pathMaps, function(targetPaths) {
-    const targetPathsJSON = targetPaths,  ///
-          responseJSON = targetPathsJSON;  ///
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = removeProjectEntriesHandler;

package/es6/handler/saveFile.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { saveFile } = filesystem;
-
-function saveFileHandler(request, response, next) {
-  const { query, body } = request,
-        { projectsDirectoryPath } = query,
-        json = body; ///
-
-  saveFile(projectsDirectoryPath, json, function(success) {
-    const responseJSON = {};
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = saveFileHandler;

package/es6/handler/saveFiles.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const filesystem = require('occam-file-system');  ///
-
-const httpResponse = require('../httpResponse');
-
-const { saveFiles } = filesystem;
-
-function saveFilesHandler(request, response, next) {
-  const { query, body } = request,
-        { projectsDirectoryPath } = query,
-        json = body; ///
-
-  saveFiles(projectsDirectoryPath, json, function(success) {
-    const responseJSON = {};
-
-    httpResponse.json(response, responseJSON);
-
-    next();
-  });
-}
-
-module.exports = saveFilesHandler;