Ejemplo n.º 1
0
    function _matches(val, cmp) {
      var ret = false;

      switch (true) {
        case type.isString(cmp): ret = val === cmp;             break;
        case type.isRegExp(cmp): ret = cmp.test(val);           break;
        case type.isArray(cmp):  ret = cmp.indexOf(val) !== -1; break;
      }

      return ret;
    }
Ejemplo n.º 2
0
/**
 * Clones the object by traversing through it and setting up new instances of anything that can be referenced.
 * Dereferences most things, including Regular Expressions.
 * Will not dereference functions and classes, they will throw.
 * @param {object} source
 * @returns {object} dereferenced source
 * @throws {Error} Throws in the case it encounters something it cannot dereference.
 */
function dereference(source) {
	if (typeChecker.isString(source)) {
		return source.toString()
	}

	if (typeChecker.isUndefined(source)) {
		return
	}

	if (typeChecker.isNull(source)) {
		return null
	}

	if (typeChecker.isNumber(source) || typeChecker.isBoolean(source)) {
		return dereferenceJSON(source)
	}

	if (typeChecker.isPlainObject(source)) {
		const result = {}
		for (const key in source) {
			if (source.hasOwnProperty(key)) {
				const value = source[key]
				result[key] = dereference(value)
			}
		}
		return result
	}

	if (typeChecker.isArray(source)) {
		return source.map(function(item) {
			return dereference(item)
		})
	}

	if (typeChecker.isDate(source)) {
		return new Date(source.toISOString())
	}

	if (typeChecker.isRegExp(source)) {
		if (source.flags == null) {
			throw new Error(
				'extendr cannot derefence RegExps on this older version of node'
			)
		} else {
			return new RegExp(source.source, source.flags)
		}
	}

	throw new Error(
		'extendr was passed an object type that it does not know how to derefence'
	)
}
Ejemplo n.º 3
0
		safeps.openProcess(function (closeProcess) {
			// If the command is a string, then convert it into an array
			if ( typeChecker.isString(command) ) {
				command = command.split(' ')
			}

			// Prepare
			const result = {
				pid: null,
				stdout: null,
				stderr: null,
				output: null,
				error: null,
				status: null,
				signal: null
			}
			let exited = false

			// Tasks
			const tasks = new TaskGroup().done(function (err) {
				exited = true
				closeProcess()
				next(err || result.error, result.stdout, result.stderr, result.status, result.signal)
			})

			// Get correct executable path
			if ( opts.safe ) {
				tasks.addTask(function (complete) {
					safeps.getExecPath(command[0], opts, function (err, execPath) {
						if ( err )  return complete(err)
						command[0] = execPath
						complete()
					})
				})
			}

			// Spawn
			tasks.addTask(function (complete) {
				// Spawn
				result.pid = require('child_process').spawn(command[0], command.slice(1), opts)

				// Write if we want to
				// result.pid.stdin may be null of stdio is 'inherit'
				if ( opts.stdin && result.pid.stdin) {
					result.pid.stdin.write(opts.stdin)
					result.pid.stdin.end()
				}

				// Read if we want to by listening to the streams and updating our result variables
				if ( opts.read ) {
					// result.pid.stdout may be null of stdio is 'inherit'
					if ( result.pid.stdout ) {
						result.pid.stdout.on('data', function (data) {
							if ( opts.output ) {
								safeps.outputData(data, 'stdout', opts.outputPrefix)
							}
							if ( result.stdout ) {
								result.stdout = Buffer.concat([result.stdout, data])
							}
							else {
								result.stdout = data
							}
						})
					}

					// result.pid.stderr may be null of stdio is 'inherit'
					if ( result.pid.stderr ) {
						result.pid.stderr.on('data', function (data) {
							if ( opts.output) {
								safeps.outputData(data, 'stderr', opts.outputPrefix)
							}
							if ( result.stderr ) {
								result.stderr = Buffer.concat([result.stderr, data])
							}
							else {
								result.stderr = data
							}
						})
					}
				}

				// Wait
				result.pid.on('close', function (status, signal) {
					// Apply to local global
					result.status = status
					result.signal = signal

					// Check if we have already exited due to domains
					// as without this, then we will fire the completion callback twice
					// once for the domain error that will happen first
					// then again for the close error
					// if it happens the other way round, close, then error, we want to be alerted of that
					if ( exited === true )  return

					// Check result and complete
					opts.output = false
					safeps.updateExecutableResult(result, opts)
					return complete(result.error)
				})
			})

			// Run
			tasks.run()
		})
Ejemplo n.º 4
0
	* @param {Function} [next] callback
	* @param {Error} next.error
	* @param {Stream} next.stdout out stream
	* @param {Stream} next.stderr error stream
	* @param {Number} next.status node.js exit code
	* @param {String} next.signal unix style signal such as SIGKILL or SIGHUP
	* @return {Object} {error, pid, output, stdout, stderr, status, signal}
	*/
	spawnSync (command, opts, next) {
		// Prepare
		[opts, next] = extractOptsAndCallback(opts, next)
		opts = safeps.prepareExecutableOptions(opts)
		opts.sync = true

		// If the command is a string, then convert it into an array
		if ( typeChecker.isString(command) ) {
			command = command.split(' ')
		}

		// Get correct executable path
		// Only possible if sync abilities are possible (node 0.12 and up) or if it is cached
		// Otherwise, don't worry about it and output a warning to stderr
		if ( opts.safe ) {
			let wasSync = 0
			safeps.getExecPath(command[0], opts, function (err, execPath) {
				if ( err )  return
				command[0] = execPath
				wasSync = 1
			})
			if ( wasSync === 0 ) {
				process.stderr.write('safeps.spawnSync: was unable to get the executable path synchronously')