fs: move utility functions to internal/fs

PR-URL: #18777
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

Author: targos

lib/fs.js

@@ -37,14 +37,29 @@ const { Buffer } = require('buffer');
 const errors = require('internal/errors');
 const { Readable, Writable } = require('stream');
 const EventEmitter = require('events');
-const { FSReqWrap } = binding;
+const { FSReqWrap, statValues } = binding;
 const { FSEvent } = process.binding('fs_event_wrap');
 const internalFS = require('internal/fs');
 const { getPathFromURL } = require('internal/url');
 const internalUtil = require('internal/util');
 const {
-  assertEncoding,
-  stringToFlags
+  copyObject,
+  getOptions,
+  isUint32,
+  modeNum,
+  nullCheck,
+  preprocessSymlinkDestination,
+  Stats,
+  statsFromValues,
+  stringToFlags,
+  stringToSymlinkType,
+  toUnixTimestamp,
+  validateBuffer,
+  validateLen,
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+  validatePath,
+  validateUint32
 } = internalFS;
 const {
   CHAR_FORWARD_SLASH,
@@ -70,9 +85,6 @@ const errnoException = errors.errnoException;
 
 let truncateWarn = true;
 
-function isInt32(n) { return n === (n | 0); }
-function isUint32(n) { return n === (n >>> 0); }
-
 function showTruncateDeprecation() {
   if (truncateWarn) {
     process.emitWarning(
@@ -83,35 +95,6 @@ function showTruncateDeprecation() {
   }
 }
 
-function getOptions(options, defaultOptions) {
-  if (options === null || options === undefined ||
-      typeof options === 'function') {
-    return defaultOptions;
-  }
-
-  if (typeof options === 'string') {
-    defaultOptions = util._extend({}, defaultOptions);
-    defaultOptions.encoding = options;
-    options = defaultOptions;
-  } else if (typeof options !== 'object') {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                               'options',
-                               ['string', 'Object'],
-                               options);
-  }
-
-  if (options.encoding !== 'buffer')
-    assertEncoding(options.encoding);
-  return options;
-}
-
-function copyObject(source) {
-  var target = {};
-  for (var key in source)
-    target[key] = source[key];
-  return target;
-}
-
 function handleErrorFromBinding(ctx) {
   if (ctx.errno !== undefined) {  // libuv error numbers
     const err = errors.uvException(ctx);
@@ -175,117 +158,6 @@ function makeCallback(cb) {
   };
 }
 
-function validateBuffer(buffer) {
-  if (!isUint8Array(buffer)) {
-    const err = new errors.TypeError('ERR_INVALID_ARG_TYPE', 'buffer',
-                                     ['Buffer', 'Uint8Array']);
-    Error.captureStackTrace(err, validateBuffer);
-    throw err;
-  }
-}
-
-function validateLen(len) {
-  let err;
-
-  if (!isInt32(len))
-    err = new errors.TypeError('ERR_INVALID_ARG_TYPE', 'len', 'integer');
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validateLen);
-    throw err;
-  }
-}
-
-function validateOffsetLengthRead(offset, length, bufferLength) {
-  let err;
-
-  if (offset < 0 || offset >= bufferLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'offset');
-  } else if (length < 0 || offset + length > bufferLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'length');
-  }
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validateOffsetLengthRead);
-    throw err;
-  }
-}
-
-function validateOffsetLengthWrite(offset, length, byteLength) {
-  let err;
-
-  if (offset > byteLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'offset');
-  } else if (offset + length > byteLength || offset + length > kMaxLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'length');
-  }
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validateOffsetLengthWrite);
-    throw err;
-  }
-}
-
-// Check if the path contains null types if it is a string nor Uint8Array,
-// otherwise return silently.
-function nullCheck(path, propName, throwError = true) {
-  const pathIsString = typeof path === 'string';
-  const pathIsUint8Array = isUint8Array(path);
-
-  // We can only perform meaningful checks on strings and Uint8Arrays.
-  if (!pathIsString && !pathIsUint8Array) {
-    return;
-  }
-
-  if (pathIsString && path.indexOf('\u0000') === -1) {
-    return;
-  } else if (pathIsUint8Array && path.indexOf(0) === -1) {
-    return;
-  }
-
-  const err = new errors.Error(
-    'ERR_INVALID_ARG_VALUE', propName, path,
-    'must be a string or Uint8Array without null bytes');
-
-  if (throwError) {
-    Error.captureStackTrace(err, nullCheck);
-    throw err;
-  }
-  return err;
-}
-
-function validatePath(path, propName) {
-  let err;
-
-  if (propName === undefined) {
-    propName = 'path';
-  }
-
-  if (typeof path !== 'string' && !isUint8Array(path)) {
-    err = new errors.TypeError('ERR_INVALID_ARG_TYPE', propName,
-                               ['string', 'Buffer', 'URL']);
-  } else {
-    err = nullCheck(path, propName, false);
-  }
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validatePath);
-    throw err;
-  }
-}
-
-function validateUint32(value, propName) {
-  let err;
-
-  if (!isUint32(value))
-    err = new errors.TypeError('ERR_INVALID_ARG_TYPE', propName, 'integer');
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validateUint32);
-    throw err;
-  }
-}
-
 // Special case of `makeCallback()` that is specific to async `*stat()` calls as
 // an optimization, since the data passed back to the callback needs to be
 // transformed anyway.
@@ -308,85 +180,8 @@ function isFd(path) {
   return (path >>> 0) === path;
 }
 
-// Constructor for file stats.
-function Stats(
-  dev,
-  mode,
-  nlink,
-  uid,
-  gid,
-  rdev,
-  blksize,
-  ino,
-  size,
-  blocks,
-  atim_msec,
-  mtim_msec,
-  ctim_msec,
-  birthtim_msec
-) {
-  this.dev = dev;
-  this.mode = mode;
-  this.nlink = nlink;
-  this.uid = uid;
-  this.gid = gid;
-  this.rdev = rdev;
-  this.blksize = blksize;
-  this.ino = ino;
-  this.size = size;
-  this.blocks = blocks;
-  this.atimeMs = atim_msec;
-  this.mtimeMs = mtim_msec;
-  this.ctimeMs = ctim_msec;
-  this.birthtimeMs = birthtim_msec;
-  this.atime = new Date(atim_msec + 0.5);
-  this.mtime = new Date(mtim_msec + 0.5);
-  this.ctime = new Date(ctim_msec + 0.5);
-  this.birthtime = new Date(birthtim_msec + 0.5);
-}
 fs.Stats = Stats;
 
-Stats.prototype._checkModeProperty = function(property) {
-  return ((this.mode & S_IFMT) === property);
-};
-
-Stats.prototype.isDirectory = function() {
-  return this._checkModeProperty(constants.S_IFDIR);
-};
-
-Stats.prototype.isFile = function() {
-  return this._checkModeProperty(S_IFREG);
-};
-
-Stats.prototype.isBlockDevice = function() {
-  return this._checkModeProperty(constants.S_IFBLK);
-};
-
-Stats.prototype.isCharacterDevice = function() {
-  return this._checkModeProperty(constants.S_IFCHR);
-};
-
-Stats.prototype.isSymbolicLink = function() {
-  return this._checkModeProperty(S_IFLNK);
-};
-
-Stats.prototype.isFIFO = function() {
-  return this._checkModeProperty(S_IFIFO);
-};
-
-Stats.prototype.isSocket = function() {
-  return this._checkModeProperty(S_IFSOCK);
-};
-
-const statValues = binding.statValues;
-
-function statsFromValues(stats = statValues) {
-  return new Stats(stats[0], stats[1], stats[2], stats[3], stats[4], stats[5],
-                   stats[6] < 0 ? undefined : stats[6], stats[7], stats[8],
-                   stats[9] < 0 ? undefined : stats[9], stats[10], stats[11],
-                   stats[12], stats[13]);
-}
-
 // Don't allow mode to accidentally be overwritten.
 Object.defineProperties(fs, {
   F_OK: { enumerable: true, value: constants.F_OK || 0 },
@@ -760,16 +555,6 @@ fs.closeSync = function(fd) {
   handleErrorFromBinding(ctx);
 };
 
-function modeNum(m, def) {
-  if (typeof m === 'number')
-    return m;
-  if (typeof m === 'string')
-    return parseInt(m, 8);
-  if (def)
-    return modeNum(def);
-  return undefined;
-}
-
 fs.open = function(path, flags, mode, callback_) {
   var callback = makeCallback(arguments[arguments.length - 1]);
   mode = modeNum(mode, 0o666);
@@ -1162,42 +947,6 @@ fs.readlinkSync = function(path, options) {
   return result;
 };
 
-function preprocessSymlinkDestination(path, type, linkPath) {
-  if (!isWindows) {
-    // No preprocessing is needed on Unix.
-    return path;
-  } else if (type === 'junction') {
-    // Junctions paths need to be absolute and \\?\-prefixed.
-    // A relative target is relative to the link's parent directory.
-    path = pathModule.resolve(linkPath, '..', path);
-    return pathModule.toNamespacedPath(path);
-  } else {
-    // Windows symlinks don't tolerate forward slashes.
-    return ('' + path).replace(/\//g, '\\');
-  }
-}
-
-function stringToSymlinkType(type) {
-  let flags = 0;
-  if (typeof type === 'string') {
-    switch (type) {
-      case 'dir':
-        flags |= constants.UV_FS_SYMLINK_DIR;
-        break;
-      case 'junction':
-        flags |= constants.UV_FS_SYMLINK_JUNCTION;
-        break;
-      case 'file':
-        break;
-      default:
-        const err = new errors.Error('ERR_FS_INVALID_SYMLINK_TYPE', type);
-        Error.captureStackTrace(err, stringToSymlinkType);
-        throw err;
-    }
-  }
-  return flags;
-}
-
 fs.symlink = function(target, path, type_, callback_) {
   var type = (typeof type_ === 'string' ? type_ : null);
   var callback = makeCallback(arguments[arguments.length - 1]);
@@ -1421,28 +1170,6 @@ fs.chownSync = function(path, uid, gid) {
   return binding.chown(pathModule.toNamespacedPath(path), uid, gid);
 };
 
-// converts Date or number to a fractional UNIX timestamp
-function toUnixTimestamp(time, name = 'time') {
-  // eslint-disable-next-line eqeqeq
-  if (typeof time === 'string' && +time == time) {
-    return +time;
-  }
-  if (Number.isFinite(time)) {
-    if (time < 0) {
-      return Date.now() / 1000;
-    }
-    return time;
-  }
-  if (util.isDate(time)) {
-    // convert to 123.456 UNIX timestamp
-    return time.getTime() / 1000;
-  }
-  throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                             name,
-                             ['Date', 'Time in seconds'],
-                             time);
-}
-
 // exported for unit tests, not for public consumption
 fs._toUnixTimestamp = toUnixTimestamp;