saxon/js/sync.js

// Generated by CoffeeScript 2.3.2
var S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, chmodSync, copyFile, copyTree, errno, follow, fs, getMode, lstatSync, mkdirSync, os, path, readFileSync, readdirSync, readlinkSync, removeTree, renameSync, resolve, rmdirSync, statSync, symlinkSync, uhoh, unlinkSync, utimesSync, writeFileSync;

({chmodSync, lstatSync, mkdirSync, readdirSync, readlinkSync, readFileSync, renameSync, rmdirSync, statSync, symlinkSync, unlinkSync, utimesSync, writeFileSync} = require('fs'));

({S_IFMT, S_IFREG, S_IFDIR, S_IFLNK} = require('fs').constants);

errno = require('./errno');

path = require('path');

os = require('os');

fs = exports;

fs.stat = function(name) {
  return statSync(resolve(name));
};

fs.lstat = function(name) {
  return lstatSync(resolve(name));
};

fs.read = function(name, enc) {
  var mode;
  name = resolve(name);
  if (!(mode = getMode(name))) {
    uhoh(`Path does not exist: '${name}'`, 'NOT_REAL');
  }
  if (mode === S_IFDIR) {
    uhoh(`Path is not readable: '${name}'`, 'NOT_FILE');
  }
  if (enc === void 0) {
    enc = "utf8";
  }
  return readFileSync(name, enc);
};

fs.readJson = function(name) {
  return JSON.parse(fs.read(name));
};

fs.list = function(name) {
  var mode;
  name = resolve(name);
  if (!(mode = getMode(name))) {
    uhoh(`Path does not exist: '${name}'`, 'NOT_REAL');
  }
  if (mode !== S_IFDIR) {
    uhoh(`Path is not a directory: '${name}'`, 'NOT_DIR');
  }
  return readdirSync(name);
};

fs.follow = function(name, recursive) {
  var mode;
  name = resolve(name);
  if (!(mode = getMode(name))) {
    uhoh(`Path does not exist: '${name}'`, 'NOT_REAL');
  }
  if (mode === S_IFLNK) {
    return follow(name, recursive);
  } else {
    return name;
  }
};

fs.exists = function(name) {
  return getMode(resolve(name)) !== null;
};

fs.isFile = function(name) {
  return getMode(resolve(name)) === S_IFREG;
};

fs.isDir = function(name) {
  return getMode(resolve(name)) === S_IFDIR;
};

fs.isLink = function(name) {
  return getMode(resolve(name)) === S_IFLNK;
};

fs.readPerms = function(name) {
  return '0' + (fs.stat(name).mode & parseInt('777', 8)).toString(8);
};

fs.touch = function(name) {
  var time;
  name = resolve(name);
  if (getMode(name) === null) {
    return writeFileSync(name, '');
  }
  time = Date.now() / 1000;
  return utimesSync(name, time, time);
};

fs.chmod = function(name, mode) {
  name = resolve(name);
  if (!(mode = getMode(name))) {
    uhoh(`Path does not exist: '${name}'`, 'NOT_REAL');
  }
  if (mode === S_IFDIR) {
    uhoh(`Path is a directory: '${name}'`, 'NOT_FILE');
  }
  return chmodSync(name, mode);
};

fs.link = function(name, target) {
  name = resolve(name);
  if (getMode(name) === null) {
    return symlinkSync(target, name);
  }
  return uhoh(`Path already exists: '${name}'`, 'PATH_EXISTS');
};

fs.write = function(name, content) {
  name = resolve(name);
  if (getMode(name) !== S_IFDIR) {
    return writeFileSync(name, content);
  }
  return uhoh(`Path is a directory: '${name}'`, 'NOT_FILE');
};

fs.mkdir = function(name) {
  var mode;
  name = resolve(name);
  if (!(mode = getMode(name))) {
    fs.mkdir(path.dirname(name));
    return mkdirSync(name);
  }
  if (mode === S_IFLNK) {
    mode = getMode(follow(name, true));
  }
  if (mode !== S_IFDIR) {
    return uhoh(`Path already exists: '${name}'`, 'PATH_EXISTS');
  }
};

fs.rename = function(src, dest) {
  var mode;
  src = resolve(src);
  if (!(mode = getMode(src))) {
    uhoh(`Path does not exist: '${src}'`, 'NOT_REAL');
  }
  dest = resolve(dest);
  if (getMode(dest)) {
    uhoh(`Path already exists: '${dest}'`, 'PATH_EXISTS');
  }
  fs.mkdir(path.dirname(dest));
  return renameSync(src, dest);
};

fs.remove = function(name, recursive) {
  var mode;
  name = resolve(name);
  if (mode = getMode(name)) {
    if (mode === S_IFDIR) {
      if (recursive) {
        return removeTree(name);
      } else {
        return rmdirSync(name);
      }
    } else {
      return unlinkSync(name);
    }
  }
};

fs.copy = function(srcPath, destPath) {
  var destMode, mode;
  srcPath = resolve(srcPath);
  destPath = resolve(destPath);
  if (!(mode = getMode(srcPath))) {
    uhoh(`Cannot \`copy\` non-existent path: '${srcPath}'`, 'NOT_REAL');
  }
  if (mode === S_IFDIR) {
    return copyTree(srcPath, destPath);
  }
  destMode = getMode(destPath);
  if (destMode === S_IFDIR) {
    destPath = path.join(destPath, path.basename(srcPath));
    destMode = getMode(destPath);
  }
  if (destMode) {
    if (destMode === S_IFDIR) {
      uhoh(`Cannot overwrite directory path: '${destPath}'`, 'PATH_EXISTS');
    } else {
      unlinkSync(destPath);
    }
  }
  // Create missing parent directories.
  fs.mkdir(path.dirname(destPath));
  if (mode === S_IFLNK) {
    return symlinkSync(readlinkSync(srcPath), destPath);
  } else {
    return writeFileSync(destPath, readFileSync(srcPath));
  }
};


// Internal

uhoh = function(msg, why) {
  var err;
  err = Error(msg);
  err.code = errno[why] || 0;
  Error.captureStackTrace(err, uhoh);
  throw err;
};

resolve = function(name) {
  if (name[0] === '~') {
    return os.homedir() + name.slice(1);
  } else {
    return path.resolve(name);
  }
};

getMode = function(name) {
  var e;
  try {
    return lstatSync(name).mode & S_IFMT;
  } catch (error) {
    e = error;
    return null;
  }
};

// Recursive symlink resolution
follow = function(link, recursive) {
  var mode, name, prev, reads, validate;
  name = link;
  reads = 0;
  if (typeof recursive === 'function') {
    validate = recursive;
    recursive = true;
  }
  while (++reads) {
    prev = name;
    name = readlinkSync(prev);
    if (!path.isAbsolute(name)) {
      name = path.resolve(path.dirname(prev), name);
    }
    if (validate && !validate(name)) {
      return prev;
    }
    if (!recursive) {
      return name;
    }
    if (!(mode = getMode(name))) {
      uhoh(`Symlink leads nowhere: '${link}'`, 'NOT_REAL');
    }
    if (mode !== S_IFLNK) {
      return name;
    }
    if (reads === 10) {
      uhoh(`Too many symlinks: '${link}'`, 'LINK_LIMIT');
    }
  }
};

// Overwrite the `destPath` with contents of the `srcPath`.
copyFile = function(srcPath, destPath) {
  var destMode, mode;
  mode = getMode(srcPath);
  if (mode === S_IFDIR) {
    return copyTree(srcPath, destPath);
  }
  if (destMode = getMode(destPath)) {
    if (destMode === S_IFDIR) {
      removeTree(destPath);
    } else {
      unlinkSync(destPath);
    }
  }
  // Create missing parent directories.
  fs.mkdir(path.dirname(destPath));
  if (mode === S_IFLNK) {
    return symlinkSync(readlinkSync(srcPath), destPath);
  } else {
    return writeFileSync(destPath, readFileSync(srcPath));
  }
};

// Recursive tree copies.
copyTree = function(srcPath, destPath) {
  var destMode;
  destMode = getMode(destPath);
  // Remove the file under our new path, if needed.
  if (destMode && destMode !== S_IFDIR) {
    unlinkSync(destPath);
  }
  // Create the directory, if needed.
  if (destMode !== S_IFDIR) {
    fs.mkdir(destPath);
  }
  return readdirSync(srcPath).forEach(function(file) {
    return copyFile(path.join(srcPath, file), path.join(destPath, file));
  });
};

// Recursive tree deletion.
removeTree = function(name) {
  var child, i, len, ref;
  ref = readdirSync(name);
  for (i = 0, len = ref.length; i < len; i++) {
    child = ref[i];
    child = path.join(name, child);
    if (getMode(child) === S_IFDIR) {
      removeTree(child);
    } else {
      unlinkSync(child);
    }
  }
  return rmdirSync(name);
};

(function() {  // Expose error codes.
  var def, des, why;
  def = Object.defineProperty;
  des = {
    value: 0
  };
  for (why in errno) {
    des.value = errno[why];
    def(fs, why, des);
  }
})();