fluentnode/target/src/node-native/fs.js

Fluent apis for node (based on the concepts used in C#'s FluentSharp

// Generated by CoffeeScript 1.12.7
(function() {
  var fs;

  require('./path');

  fs = require('fs');

  String.prototype.create_Parent_Folder = function() {
    this.valueOf().parent_Folder().folder_Create();
    return this;
  };

  String.prototype.folder_Create = function() {
    var target;
    target = this.valueOf();
    if (target.folder_Not_Exists()) {
      target.parent_Folder().folder_Create();
      fs.mkdirSync(target);
    }
    return target.realPath();
  };

  String.prototype.folder_Delete = function() {
    var folder;
    folder = this.toString();
    if (fs.existsSync(folder)) {
      fs.rmdirSync(folder);
    }
    return folder.not_Exists();
  };

  String.prototype.delete_Folder = String.prototype.folder_Delete;

  String.prototype.folder_Delete_Recursive = function() {
    var file, folder, i, j, len, len1, ref, ref1, subFolder;
    folder = this.toString();
    if (folder.exists()) {
      ref = folder.files();
      for (i = 0, len = ref.length; i < len; i++) {
        file = ref[i];
        file.file_Delete();
      }
      ref1 = folder.folders();
      for (j = 0, len1 = ref1.length; j < len1; j++) {
        subFolder = ref1[j];
        subFolder.folder_Delete_Recursive();
      }
      folder.folder_Delete();
    }
    return folder.not_Exists();
  };

  String.prototype.file_Append = function(contents, callback) {
    var file_Path;
    file_Path = this.real_Path();
    if (file_Path.file_Exists() && contents) {
      if (callback) {
        fs.appendFile(file_Path, contents, (function(_this) {
          return function(err) {
            return callback(err || file_Path);
          };
        })(this));
      } else {
        fs.appendFileSync(file_Path, contents);
      }
    }
    return this;
  };

  String.prototype.file_Copy = function(target) {
    var content;
    if (!target) {
      return null;
    }
    if (this.valueOf().file_Not_Exists()) {
      return null;
    }
    if (target.folder_Exists()) {
      target = target.path_Combine(this.valueOf().file_Name());
    } else {
      target.parent_Folder().folder_Create();
    }
    content = fs.readFileSync(this.valueOf());
    fs.writeFileSync(target, content);
    return target;
  };

  String.prototype.file_Create = function(contents) {
    var path;
    path = this.toString();
    if (path.not_Exists()) {
      fs.writeFileSync(path, contents || '');
    }
    return path.realPath();
  };

  String.prototype.file_Delete = function() {
    var file;
    file = this.toString().realPath();
    if (!file) {
      return true;
    }
    fs.unlinkSync(file);
    return file.file_Not_Exists();
  };

  String.prototype.file_Contents = function() {
    var file;
    file = this.valueOf().realPath();
    try {
      return fs.readFileSync(file, "utf8");
    } catch (error) {
      return null;
    }
  };

  String.prototype.file_Exists = function() {
    return fs.existsSync(this.valueOf());
  };

  String.prototype.exists = String.prototype.file_Exists;

  String.prototype.file_Lines = function() {
    var file_Contents;
    file_Contents = this.file_Contents();
    if (file_Contents !== null) {
      return file_Contents.lines();
    } else {
      return [];
    }
  };

  String.prototype.file_Write = function(content) {
    content.saveAs(this._str());
    return this;
  };

  String.prototype.file_Not_Exists = function() {
    return (fs.existsSync(this.valueOf())) === false;
  };

  String.prototype.files_And_Folders = function() {
    var i, item, len, path, ref, results;
    path = this.valueOf();
    try {
      ref = fs.readdirSync(path);
      results = [];
      for (i = 0, len = ref.length; i < len; i++) {
        item = ref[i];
        results.push(path.path_Combine(item).realPath());
      }
      return results;
    } catch (error) {
      return [];
    }
  };

  String.prototype.files = function(extension) {
    var file, files, item;
    files = (function() {
      var i, len, ref, results;
      ref = this.files_And_Folders();
      results = [];
      for (i = 0, len = ref.length; i < len; i++) {
        item = ref[i];
        if (item.is_File()) {
          results.push(item);
        }
      }
      return results;
    }).call(this);
    if (extension) {
      return (function() {
        var i, len, results;
        results = [];
        for (i = 0, len = files.length; i < len; i++) {
          file = files[i];
          if (file.file_Extension() === extension) {
            results.push(file);
          }
        }
        return results;
      })();
    }
    return files;
  };

  String.prototype.files_Recursive = function(extension) {
    var files, i, item, len, ref;
    files = [];
    ref = this._str().files_And_Folders();
    for (i = 0, len = ref.length; i < len; i++) {
      item = ref[i];
      if (item.is_Folder()) {
        files = files.concat(item.files_Recursive(extension));
      } else {
        if (!extension || item.file_Extension() === extension) {
          files.push(item);
        }
      }
    }
    return files;
  };

  String.prototype.folders = function() {
    var folders, i, item, len, ref;
    folders = [];
    ref = this.files_And_Folders();
    for (i = 0, len = ref.length; i < len; i++) {
      item = ref[i];
      if (item != null ? item.is_Folder() : void 0) {
        folders.push(item);
      }
    }
    return folders;
  };

  String.prototype.folders_Recursive = function() {
    var folders, i, item, len, ref;
    folders = [];
    ref = this._str().folders();
    for (i = 0, len = ref.length; i < len; i++) {
      item = ref[i];
      folders = folders.concat(item.folders_Recursive());
      folders.push(item);
    }
    return folders;
  };

  String.prototype.is_Folder = function() {
    try {
      return fs.lstatSync(this.valueOf()).isDirectory();
    } catch (error) {
      return false;
    }
  };

  String.prototype.is_Not_Folder = function() {
    return this.is_Folder() === false;
  };

  String.prototype.is_File = function() {
    try {
      return fs.lstatSync(this.valueOf()).isFile();
    } catch (error) {
      return false;
    }
  };

  String.prototype.realPath = function() {
    try {
      return fs.realpathSync(this.valueOf());
    } catch (error) {
      return null;
    }
  };

  String.prototype.temp_File = function(contents) {
    if (this.is_Folder()) {
      return this.temp_Name_In_Folder().file_Write(contents || '').valueOf();
    } else {
      return null;
    }
  };

  String.prototype.temp_Name_In_Folder = function() {
    return this.valueOf().realPath().path_Combine("_tmp_".add_Random_String(10));
  };

  String.prototype.save_As = function(targetFile) {
    var contents;
    if (targetFile === null || targetFile.length > 255) {
      return false;
    }
    contents = this.valueOf();
    if (targetFile.exists()) {
      targetFile.file_Delete();
    }
    fs.writeFileSync(targetFile, contents);
    if (targetFile.real_Path().exists()) {
      return targetFile.real_Path();
    }
  };

  String.prototype.saveAs = String.prototype.save_As;

  String.prototype.create_Dir = String.prototype.folder_Create;

  String.prototype.delete_File = String.prototype.file_Delete;

  String.prototype.folder_Exists = String.prototype.is_Folder;

  String.prototype.folder_Not_Exists = String.prototype.is_Not_Folder;

  String.prototype.fullPath = String.prototype.realPath;

  String.prototype.real_Path = String.prototype.realPath;

  String.prototype.is_Directory = String.prototype.is_Folder;

  String.prototype.touch = String.prototype.file_Create;

  String.prototype.not_Exists = String.prototype.file_Not_Exists;

}).call(this);