--- /dev/null
+/*!
+ * Tmp
+ *
+ * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
+ *
+ * MIT Licensed
+ */
+
+/*
+ * Module dependencies.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const osTmpDir = require('os-tmpdir');
+const _c = process.binding('constants');
+
+/*
+ * The working inner variables.
+ */
+const
+ /**
+ * The temporary directory.
+ * @type {string}
+ */
+ tmpDir = osTmpDir(),
+
+ // the random characters to choose from
+ RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+
+ TEMPLATE_PATTERN = /XXXXXX/,
+
+ DEFAULT_TRIES = 3,
+
+ CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR),
+
+ EBADF = _c.EBADF || _c.os.errno.EBADF,
+ ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
+
+ DIR_MODE = 448 /* 0o700 */,
+ FILE_MODE = 384 /* 0o600 */,
+
+ // this will hold the objects need to be removed on exit
+ _removeObjects = [];
+
+var
+ _gracefulCleanup = false,
+ _uncaughtException = false;
+
+/**
+ * Random name generator based on crypto.
+ * Adapted from http://blog.tompawlak.org/how-to-generate-random-values-nodejs-javascript
+ *
+ * @param {number} howMany
+ * @returns {string} the generated random name
+ * @private
+ */
+function _randomChars(howMany) {
+ var
+ value = [],
+ rnd = null;
+
+ // make sure that we do not fail because we ran out of entropy
+ try {
+ rnd = crypto.randomBytes(howMany);
+ } catch (e) {
+ rnd = crypto.pseudoRandomBytes(howMany);
+ }
+
+ for (var i = 0; i < howMany; i++) {
+ value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
+ }
+
+ return value.join('');
+}
+
+/**
+ * Checks whether the `obj` parameter is defined or not.
+ *
+ * @param {Object} obj
+ * @returns {boolean} true if the object is undefined
+ * @private
+ */
+function _isUndefined(obj) {
+ return typeof obj === 'undefined';
+}
+
+/**
+ * Parses the function arguments.
+ *
+ * This function helps to have optional arguments.
+ *
+ * @param {(Options|Function)} options
+ * @param {Function} callback
+ * @returns {Array} parsed arguments
+ * @private
+ */
+function _parseArguments(options, callback) {
+ if (typeof options == 'function') {
+ return [callback || {}, options];
+ }
+
+ if (_isUndefined(options)) {
+ return [{}, callback];
+ }
+
+ return [options, callback];
+}
+
+/**
+ * Generates a new temporary name.
+ *
+ * @param {Object} opts
+ * @returns {string} the new random name according to opts
+ * @private
+ */
+function _generateTmpName(opts) {
+ if (opts.name) {
+ return path.join(opts.dir || tmpDir, opts.name);
+ }
+
+ // mkstemps like template
+ if (opts.template) {
+ return opts.template.replace(TEMPLATE_PATTERN, _randomChars(6));
+ }
+
+ // prefix and postfix
+ const name = [
+ opts.prefix || 'tmp-',
+ process.pid,
+ _randomChars(12),
+ opts.postfix || ''
+ ].join('');
+
+ return path.join(opts.dir || tmpDir, name);
+}
+
+/**
+ * Gets a temporary file name.
+ *
+ * @param {(Options|tmpNameCallback)} options options or callback
+ * @param {?tmpNameCallback} callback the callback function
+ */
+function tmpName(options, callback) {
+ var
+ args = _parseArguments(options, callback),
+ opts = args[0],
+ cb = args[1],
+ tries = opts.name ? 1 : opts.tries || DEFAULT_TRIES;
+
+ if (isNaN(tries) || tries < 0)
+ return cb(new Error('Invalid tries'));
+
+ if (opts.template && !opts.template.match(TEMPLATE_PATTERN))
+ return cb(new Error('Invalid template provided'));
+
+ (function _getUniqueName() {
+ const name = _generateTmpName(opts);
+
+ // check whether the path exists then retry if needed
+ fs.stat(name, function (err) {
+ if (!err) {
+ if (tries-- > 0) return _getUniqueName();
+
+ return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
+ }
+
+ cb(null, name);
+ });
+ }());
+}
+
+/**
+ * Synchronous version of tmpName.
+ *
+ * @param {Object} options
+ * @returns {string} the generated random name
+ * @throws {Error} if the options are invalid or could not generate a filename
+ */
+function tmpNameSync(options) {
+ var
+ args = _parseArguments(options),
+ opts = args[0],
+ tries = opts.name ? 1 : opts.tries || DEFAULT_TRIES;
+
+ if (isNaN(tries) || tries < 0)
+ throw new Error('Invalid tries');
+
+ if (opts.template && !opts.template.match(TEMPLATE_PATTERN))
+ throw new Error('Invalid template provided');
+
+ do {
+ const name = _generateTmpName(opts);
+ try {
+ fs.statSync(name);
+ } catch (e) {
+ return name;
+ }
+ } while (tries-- > 0);
+
+ throw new Error('Could not get a unique tmp filename, max tries reached');
+}
+
+/**
+ * Creates and opens a temporary file.
+ *
+ * @param {(Options|fileCallback)} options the config options or the callback function
+ * @param {?fileCallback} callback
+ */
+function file(options, callback) {
+ var
+ args = _parseArguments(options, callback),
+ opts = args[0],
+ cb = args[1];
+
+ opts.postfix = (_isUndefined(opts.postfix)) ? '.tmp' : opts.postfix;
+
+ // gets a temporary filename
+ tmpName(opts, function _tmpNameCreated(err, name) {
+ if (err) return cb(err);
+
+ // create and open the file
+ fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
+ if (err) return cb(err);
+
+ if (opts.discardDescriptor) {
+ return fs.close(fd, function _discardCallback(err) {
+ if (err) {
+ // Low probability, and the file exists, so this could be
+ // ignored. If it isn't we certainly need to unlink the
+ // file, and if that fails too its error is more
+ // important.
+ try {
+ fs.unlinkSync(name);
+ } catch (e) {
+ if (!isENOENT(e)) {
+ err = e;
+ }
+ }
+ return cb(err);
+ }
+ cb(null, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts));
+ });
+ }
+ if (opts.detachDescriptor) {
+ return cb(null, name, fd, _prepareTmpFileRemoveCallback(name, -1, opts));
+ }
+ cb(null, name, fd, _prepareTmpFileRemoveCallback(name, fd, opts));
+ });
+ });
+}
+
+/**
+ * Synchronous version of file.
+ *
+ * @param {Options} options
+ * @returns {FileSyncObject} object consists of name, fd and removeCallback
+ * @throws {Error} if cannot create a file
+ */
+function fileSync(options) {
+ var
+ args = _parseArguments(options),
+ opts = args[0];
+
+ opts.postfix = opts.postfix || '.tmp';
+
+ const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+ const name = tmpNameSync(opts);
+ var fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+ if (opts.discardDescriptor) {
+ fs.closeSync(fd);
+ fd = undefined;
+ }
+
+ return {
+ name: name,
+ fd: fd,
+ removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts)
+ };
+}
+
+/**
+ * Removes files and folders in a directory recursively.
+ *
+ * @param {string} root
+ * @private
+ */
+function _rmdirRecursiveSync(root) {
+ const dirs = [root];
+
+ do {
+ var
+ dir = dirs.pop(),
+ deferred = false,
+ files = fs.readdirSync(dir);
+
+ for (var i = 0, length = files.length; i < length; i++) {
+ var
+ file = path.join(dir, files[i]),
+ stat = fs.lstatSync(file); // lstat so we don't recurse into symlinked directories
+
+ if (stat.isDirectory()) {
+ if (!deferred) {
+ deferred = true;
+ dirs.push(dir);
+ }
+ dirs.push(file);
+ } else {
+ fs.unlinkSync(file);
+ }
+ }
+
+ if (!deferred) {
+ fs.rmdirSync(dir);
+ }
+ } while (dirs.length !== 0);
+}
+
+/**
+ * Creates a temporary directory.
+ *
+ * @param {(Options|dirCallback)} options the options or the callback function
+ * @param {?dirCallback} callback
+ */
+function dir(options, callback) {
+ var
+ args = _parseArguments(options, callback),
+ opts = args[0],
+ cb = args[1];
+
+ // gets a temporary filename
+ tmpName(opts, function _tmpNameCreated(err, name) {
+ if (err) return cb(err);
+
+ // create the directory
+ fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
+ if (err) return cb(err);
+
+ cb(null, name, _prepareTmpDirRemoveCallback(name, opts));
+ });
+ });
+}
+
+/**
+ * Synchronous version of dir.
+ *
+ * @param {Options} options
+ * @returns {DirSyncObject} object consists of name and removeCallback
+ * @throws {Error} if it cannot create a directory
+ */
+function dirSync(options) {
+ var
+ args = _parseArguments(options),
+ opts = args[0];
+
+ const name = tmpNameSync(opts);
+ fs.mkdirSync(name, opts.mode || DIR_MODE);
+
+ return {
+ name: name,
+ removeCallback: _prepareTmpDirRemoveCallback(name, opts)
+ };
+}
+
+/**
+ * Prepares the callback for removal of the temporary file.
+ *
+ * @param {string} name the path of the file
+ * @param {number} fd file descriptor
+ * @param {Object} opts
+ * @returns {fileCallback}
+ * @private
+ */
+function _prepareTmpFileRemoveCallback(name, fd, opts) {
+ const removeCallback = _prepareRemoveCallback(function _removeCallback(fdPath) {
+ try {
+ if (0 <= fdPath[0]) {
+ fs.closeSync(fdPath[0]);
+ }
+ }
+ catch (e) {
+ // under some node/windows related circumstances, a temporary file
+ // may have not be created as expected or the file was already closed
+ // by the user, in which case we will simply ignore the error
+ if (!isEBADF(e) && !isENOENT(e)) {
+ // reraise any unanticipated error
+ throw e;
+ }
+ }
+ try {
+ fs.unlinkSync(fdPath[1]);
+ }
+ catch (e) {
+ if (!isENOENT(e)) {
+ // reraise any unanticipated error
+ throw e;
+ }
+ }
+ }, [fd, name]);
+
+ if (!opts.keep) {
+ _removeObjects.unshift(removeCallback);
+ }
+
+ return removeCallback;
+}
+
+/**
+ * Prepares the callback for removal of the temporary directory.
+ *
+ * @param {string} name
+ * @param {Object} opts
+ * @returns {Function} the callback
+ * @private
+ */
+function _prepareTmpDirRemoveCallback(name, opts) {
+ const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs.rmdirSync.bind(fs);
+ const removeCallback = _prepareRemoveCallback(removeFunction, name);
+
+ if (!opts.keep) {
+ _removeObjects.unshift(removeCallback);
+ }
+
+ return removeCallback;
+}
+
+/**
+ * Creates a guarded function wrapping the removeFunction call.
+ *
+ * @param {Function} removeFunction
+ * @param {Object} arg
+ * @returns {Function}
+ * @private
+ */
+function _prepareRemoveCallback(removeFunction, arg) {
+ var called = false;
+
+ return function _cleanupCallback(next) {
+ if (!called) {
+ const index = _removeObjects.indexOf(_cleanupCallback);
+ if (index >= 0) {
+ _removeObjects.splice(index, 1);
+ }
+
+ called = true;
+ removeFunction(arg);
+ }
+
+ if (next) next(null);
+ };
+}
+
+/**
+ * The garbage collector.
+ *
+ * @private
+ */
+function _garbageCollector() {
+ if (_uncaughtException && !_gracefulCleanup) {
+ return;
+ }
+
+ // the function being called removes itself from _removeObjects,
+ // loop until _removeObjects is empty
+ while (_removeObjects.length) {
+ try {
+ _removeObjects[0].call(null);
+ } catch (e) {
+ // already removed?
+ }
+ }
+}
+
+/**
+ * Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
+ */
+function isEBADF(error) {
+ return isExpectedError(error, -EBADF, 'EBADF');
+}
+
+/**
+ * Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
+ */
+function isENOENT(error) {
+ return isExpectedError(error, -ENOENT, 'ENOENT');
+}
+
+/**
+ * Helper to determine whether the expected error code matches the actual code and errno,
+ * which will differ between the supported node versions.
+ *
+ * - Node >= 7.0:
+ * error.code {String}
+ * error.errno {String|Number} any numerical value will be negated
+ *
+ * - Node >= 6.0 < 7.0:
+ * error.code {String}
+ * error.errno {Number} negated
+ *
+ * - Node >= 4.0 < 6.0: introduces SystemError
+ * error.code {String}
+ * error.errno {Number} negated
+ *
+ * - Node >= 0.10 < 4.0:
+ * error.code {Number} negated
+ * error.errno n/a
+ */
+function isExpectedError(error, code, errno) {
+ return error.code == code || error.code == errno;
+}
+
+/**
+ * Sets the graceful cleanup.
+ *
+ * Also removes the created files and directories when an uncaught exception occurs.
+ */
+function setGracefulCleanup() {
+ _gracefulCleanup = true;
+}
+
+const version = process.versions.node.split('.').map(function (value) {
+ return parseInt(value, 10);
+});
+
+if (version[0] === 0 && (version[1] < 9 || version[1] === 9 && version[2] < 5)) {
+ process.addListener('uncaughtException', function _uncaughtExceptionThrown(err) {
+ _uncaughtException = true;
+ _garbageCollector();
+
+ throw err;
+ });
+}
+
+process.addListener('exit', function _exit(code) {
+ if (code) _uncaughtException = true;
+ _garbageCollector();
+});
+
+/**
+ * Configuration options.
+ *
+ * @typedef {Object} Options
+ * @property {?number} tries the number of tries before give up the name generation
+ * @property {?string} template the "mkstemp" like filename template
+ * @property {?string} name fix name
+ * @property {?string} dir the tmp directory to use
+ * @property {?string} prefix prefix for the generated name
+ * @property {?string} postfix postfix for the generated name
+ */
+
+/**
+ * @typedef {Object} FileSyncObject
+ * @property {string} name the name of the file
+ * @property {string} fd the file descriptor
+ * @property {fileCallback} removeCallback the callback function to remove the file
+ */
+
+/**
+ * @typedef {Object} DirSyncObject
+ * @property {string} name the name of the directory
+ * @property {fileCallback} removeCallback the callback function to remove the directory
+ */
+
+/**
+ * @callback tmpNameCallback
+ * @param {?Error} err the error object if anything goes wrong
+ * @param {string} name the temporary file name
+ */
+
+/**
+ * @callback fileCallback
+ * @param {?Error} err the error object if anything goes wrong
+ * @param {string} name the temporary file name
+ * @param {number} fd the file descriptor
+ * @param {cleanupCallback} fn the cleanup callback function
+ */
+
+/**
+ * @callback dirCallback
+ * @param {?Error} err the error object if anything goes wrong
+ * @param {string} name the temporary file name
+ * @param {cleanupCallback} fn the cleanup callback function
+ */
+
+/**
+ * Removes the temporary created file or directory.
+ *
+ * @callback cleanupCallback
+ * @param {simpleCallback} [next] function to call after entry was removed
+ */
+
+/**
+ * Callback function for function composition.
+ * @see {@link https://github.com/raszi/node-tmp/issues/57|raszi/node-tmp#57}
+ *
+ * @callback simpleCallback
+ */
+
+// exporting all the needed methods
+module.exports.tmpdir = tmpDir;
+
+module.exports.dir = dir;
+module.exports.dirSync = dirSync;
+
+module.exports.file = file;
+module.exports.fileSync = fileSync;
+
+module.exports.tmpName = tmpName;
+module.exports.tmpNameSync = tmpNameSync;
+
+module.exports.setGracefulCleanup = setGracefulCleanup;
projects / dotfiles / .git / blobdiff