smartfile/ts/smartfile.fs.ts

import plugins = require('./smartfile.plugins');
import SmartfileInterpreter = require('./smartfile.interpreter');

import { Smartfile } from './smartfile.classes.smartfile';

import * as memory from './smartfile.memory';
/*===============================================================
============================ Checks =============================
===============================================================*/

/**
 *
 * @param filePath
 * @returns {boolean}
 */
export const fileExistsSync = (filePath): boolean => {
  let fileExistsBool: boolean = false;
  try {
    plugins.fsExtra.readFileSync(filePath);
    fileExistsBool = true;
  } catch (err) {
    fileExistsBool = false;
  }
  return fileExistsBool;
};

/**
 *
 * @param filePath
 * @returns {any}
 */
export let fileExists = async (filePath): Promise<boolean> => {
  const done = plugins.smartpromise.defer<boolean>();
  plugins.fs.access(filePath, 4, err => {
    err ? done.resolve(false) : done.resolve(true);
  });
  return done.promise;
};

/**
 * Checks if given path points to an existing directory
 */
export const isDirectory = (pathArg): boolean => {
  try {
    return plugins.fsExtra.statSync(pathArg).isDirectory();
  } catch (err) {
    return false;
  }
};

/**
 * Checks if a given path points to an existing file
 */
export const isFile = (pathArg): boolean => {
  return plugins.fsExtra.statSync(pathArg).isFile();
};

/*===============================================================
============================ FS ACTIONS =========================
===============================================================*/

/**
 * copies a file from A to B on the local disk
 */
export const copy = async (fromArg: string, toArg: string): Promise<boolean> => {
  const done = plugins.smartpromise.defer<boolean>();
  plugins.fsExtra.copy(fromArg, toArg, {}, (err) => {
    if (err) {
      throw new Error(`Could not copy from ${fromArg} to ${toArg}: ${err}`);
    }
    done.resolve(true);
  });
  return done.promise;
};

/**
 * copies a file SYNCHRONOUSLY from A to B on the local disk
 */
export const copySync = (fromArg: string, toArg: string): boolean => {
  plugins.fsExtra.copySync(fromArg, toArg);
  return true;
};

/**
 * ensures that a directory is in place
 */
export let ensureDir = (dirPathArg: string) => {
  let done = plugins.smartpromise.defer();
  plugins.fsExtra.ensureDir(dirPathArg, done.resolve);
  return done.promise;
};

/**
 * ensures that a directory is in place
 */
export let ensureDirSync = (dirPathArg: string) => {
  plugins.fsExtra.ensureDirSync(dirPathArg);
};

/**
 * ensure an empty directory
 * @executes ASYNC
 */
export let ensureEmptyDir = (dirPathArg: string) => {
  let done = plugins.smartpromise.defer();
  plugins.fsExtra.ensureDir(dirPathArg, () => {
    plugins.fsExtra.emptyDir(dirPathArg, done.resolve);
  });
  return done.promise;
};

/**
 * ensure an empty directory
 * @executes SYNC
 */
export let ensureEmptyDirSync = (dirPathArg: string) => {
  plugins.fsExtra.ensureDirSync(dirPathArg);
  plugins.fsExtra.emptyDirSync(dirPathArg);
};

/**
 * ensures that a file is on disk
 * @param filePath the filePath to ensureDir
 * @param the fileContent to place into a new file in case it doesn't exist yet
 * @returns Promise<void>
 * @exec ASYNC
 */
export let ensureFile = (filePathArg, initFileStringArg): Promise<void> => {
  let done = plugins.smartpromise.defer<void>();
  ensureFileSync(filePathArg, initFileStringArg);
  done.resolve();
  return done.promise;
};

/**
 * ensures that a file is on disk
 * @param filePath the filePath to ensureDir
 * @param the fileContent to place into a new file in case it doesn't exist yet
 * @returns Promise<void>
 * @exec SYNC
 */
export let ensureFileSync = (filePathArg: string, initFileStringArg: string): void => {
  if (fileExistsSync(filePathArg)) {
    return null;
  } else {
    memory.toFsSync(initFileStringArg, filePathArg);
  }
};

/**
 * removes a file or folder from local disk
 */
export let remove = function(pathArg: string): Promise<void> {
  let done = plugins.smartpromise.defer<void>();
  plugins.fsExtra.remove(pathArg, function() {
    done.resolve();
  });
  return done.promise;
};

/**
 * removes a file SYNCHRONOUSLY from local disk
 */
export let removeSync = function(pathArg: string): boolean {
  plugins.fsExtra.removeSync(pathArg);
  return true;
};

/**
 * removes an array of filePaths from disk
 */
export let removeMany = function(filePathArrayArg: string[]) {
  let promiseArray: Promise<void>[] = [];
  for (let filePath of filePathArrayArg) {
    promiseArray.push(remove(filePath));
  }
  return Promise.all(promiseArray);
};

/**
 * like removeFilePathArray but SYNCHRONOUSLY
 */
export let removeManySync = function(filePathArrayArg: string[]): void {
  for (let filePath of filePathArrayArg) {
    removeSync(filePath);
  }
};

/*===============================================================
============================ Write/Read =========================
===============================================================*/

/**
 *
 * @param filePathArg
 * @param fileTypeArg
 * @returns {any}
 */
export let toObjectSync = function(filePathArg, fileTypeArg?) {
  const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
  let fileType;
  fileTypeArg ? (fileType = fileTypeArg) : (fileType = SmartfileInterpreter.filetype(filePathArg));
  return SmartfileInterpreter.objectFile(fileString, fileType);
};

/**
 * reads a file content to a String
 * @param filePath
 * @returns {string|Buffer|any}
 */
export const toStringSync = (filePath: string): string => {
  const fileString: string = plugins.fsExtra.readFileSync(filePath, 'utf8');
  return fileString;
};

export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: string) => {
  // handle absolute miniMatchFilter
  let dirPath: string;
  if (plugins.path.isAbsolute(miniMatchFilter)) {
    dirPath = '/';
  } else {
    dirPath = dirPathArg;
  }

  const fileTree = await listFileTree(dirPath, miniMatchFilter);
  const smartfileArray: Smartfile[] = [];
  for (let filePath of fileTree) {
    let readPath = ((): string => {
      if (!plugins.path.isAbsolute(filePath)) {
        return plugins.path.join(dirPath, filePath);
      } else {
        return filePath;
      }
    })();
    let fileContentString = toStringSync(readPath);

    // push a read file as Smartfile
    smartfileArray.push(
      new Smartfile({
        contentBuffer: Buffer.from(fileContentString),
        base: dirPath,
        path: filePath
      })
    );
  }
  return smartfileArray;
};

/**
 *
 * @param filePathArg
 * @param options
 * @returns {number}
 */
export let toVinylSync = function(filePathArg, options = {}) {
  return plugins.vinylFile.readSync(filePathArg, options);
};

/**
 * lists Folders in a directory on local disk
 * @returns Promise with an array that contains the folder names
 */
export let listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listFoldersSync(pathArg, regexFilter);
};

/**
 * lists Folders SYNCHRONOUSLY in a directory on local disk
 * @returns an array with the folder names as strings
 */
export let listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let folderArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
  });
  if (regexFilter) {
    folderArray = folderArray.filter(fileItem => {
      return regexFilter.test(fileItem);
    });
  }
  return folderArray;
};

/**
 * lists Files in a directory on local disk
 * @returns Promise
 */
export let listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listFilesSync(pathArg, regexFilter);
};

/**
 * lists Files SYNCHRONOUSLY in a directory on local disk
 * @returns an array with the folder names as strings
 */
export let listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let fileArray = plugins.fsExtra.readdirSync(pathArg).filter(file => {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
  });
  if (regexFilter) {
    fileArray = fileArray.filter(fileItem => {
      return regexFilter.test(fileItem);
    });
  }
  return fileArray;
};

/**
 * lists all items (folders AND files) in a directory on local disk
 * @returns Promise<string[]>
 */
export let listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
  return listAllItemsSync(pathArg, regexFilter);
};

/**
 * lists all items (folders AND files) in a directory on local disk
 * @returns an array with the folder names as strings
 * @executes SYNC
 */
export let listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
  let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
  });
  if (regexFilter) {
    allItmesArray = allItmesArray.filter(fileItem => {
      return regexFilter.test(fileItem);
    });
  }
  return allItmesArray;
};

/**
 * lists a file tree using a miniMatch filter
 * note: if the miniMatch Filter is an absolute path, the cwdArg will be omitted
 * @returns Promise<string[]> string array with the absolute paths of all matching files
 */
export const listFileTree = async (dirPathArg: string, miniMatchFilter: string, absolutePathsBool: boolean = false): Promise<string[]> => {
  const done = plugins.smartpromise.defer<string[]>();

  // handle absolute miniMatchFilter
  let dirPath: string;
  if (plugins.path.isAbsolute(miniMatchFilter)) {
    dirPath = '/';
  } else {
    dirPath = dirPathArg;
  }

  const options = {
    cwd: dirPath,
    nodir: true,
    dot: true
  };
  plugins.glob(miniMatchFilter, options, (err, files: string[]) => {
    if (err) {
      console.log(err);
      done.reject(err);
    }
    done.resolve(files);
  });
  
  let fileList = await done.promise;
  if (absolutePathsBool) {
    fileList = fileList.map(filePath => {
      return plugins.path.resolve(plugins.path.join(dirPath, filePath));
    });
  }

  return fileList;
};