mirror of
https://github.com/10h30/odin-javascript-exercises.git
synced 2026-07-12 11:16:09 +09:00
Clean up the oopsie. Rebuild the blank exercises.
This commit is contained in:
Michael Frank
+20
-34
@@ -1,43 +1,37 @@
|
||||
'use strict';
|
||||
|
||||
var isWin = process.platform === 'win32';
|
||||
var resolveCommand = require('./util/resolveCommand');
|
||||
const isWin = process.platform === 'win32';
|
||||
|
||||
var isNode10 = process.version.indexOf('v0.10.') === 0;
|
||||
|
||||
function notFoundError(command, syscall) {
|
||||
var err;
|
||||
|
||||
err = new Error(syscall + ' ' + command + ' ENOENT');
|
||||
err.code = err.errno = 'ENOENT';
|
||||
err.syscall = syscall + ' ' + command;
|
||||
|
||||
return err;
|
||||
function notFoundError(original, syscall) {
|
||||
return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
|
||||
code: 'ENOENT',
|
||||
errno: 'ENOENT',
|
||||
syscall: `${syscall} ${original.command}`,
|
||||
path: original.command,
|
||||
spawnargs: original.args,
|
||||
});
|
||||
}
|
||||
|
||||
function hookChildProcess(cp, parsed) {
|
||||
var originalEmit;
|
||||
|
||||
if (!isWin) {
|
||||
return;
|
||||
}
|
||||
|
||||
originalEmit = cp.emit;
|
||||
cp.emit = function (name, arg1) {
|
||||
var err;
|
||||
const originalEmit = cp.emit;
|
||||
|
||||
cp.emit = function (name, arg1) {
|
||||
// If emitting "exit" event and exit code is 1, we need to check if
|
||||
// the command exists and emit an "error" instead
|
||||
// See: https://github.com/IndigoUnited/node-cross-spawn/issues/16
|
||||
// See https://github.com/IndigoUnited/node-cross-spawn/issues/16
|
||||
if (name === 'exit') {
|
||||
err = verifyENOENT(arg1, parsed, 'spawn');
|
||||
const err = verifyENOENT(arg1, parsed, 'spawn');
|
||||
|
||||
if (err) {
|
||||
return originalEmit.call(cp, 'error', err);
|
||||
}
|
||||
}
|
||||
|
||||
return originalEmit.apply(cp, arguments);
|
||||
return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
|
||||
};
|
||||
}
|
||||
|
||||
@@ -54,20 +48,12 @@ function verifyENOENTSync(status, parsed) {
|
||||
return notFoundError(parsed.original, 'spawnSync');
|
||||
}
|
||||
|
||||
// If we are in node 10, then we are using spawn-sync; if it exited
|
||||
// with -1 it probably means that the command does not exist
|
||||
if (isNode10 && status === -1) {
|
||||
parsed.file = isWin ? parsed.file : resolveCommand(parsed.original);
|
||||
|
||||
if (!parsed.file) {
|
||||
return notFoundError(parsed.original, 'spawnSync');
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
module.exports.hookChildProcess = hookChildProcess;
|
||||
module.exports.verifyENOENT = verifyENOENT;
|
||||
module.exports.verifyENOENTSync = verifyENOENTSync;
|
||||
module.exports.notFoundError = notFoundError;
|
||||
module.exports = {
|
||||
hookChildProcess,
|
||||
verifyENOENT,
|
||||
verifyENOENTSync,
|
||||
notFoundError,
|
||||
};
|
||||
|
||||
+63
-51
@@ -1,73 +1,86 @@
|
||||
'use strict';
|
||||
|
||||
var resolveCommand = require('./util/resolveCommand');
|
||||
var hasEmptyArgumentBug = require('./util/hasEmptyArgumentBug');
|
||||
var escapeArgument = require('./util/escapeArgument');
|
||||
var escapeCommand = require('./util/escapeCommand');
|
||||
var readShebang = require('./util/readShebang');
|
||||
const path = require('path');
|
||||
const niceTry = require('nice-try');
|
||||
const resolveCommand = require('./util/resolveCommand');
|
||||
const escape = require('./util/escape');
|
||||
const readShebang = require('./util/readShebang');
|
||||
const semver = require('semver');
|
||||
|
||||
var isWin = process.platform === 'win32';
|
||||
var skipShellRegExp = /\.(?:com|exe)$/i;
|
||||
const isWin = process.platform === 'win32';
|
||||
const isExecutableRegExp = /\.(?:com|exe)$/i;
|
||||
const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
|
||||
|
||||
// Supported in Node >= 6 and >= 4.8
|
||||
var supportsShellOption = parseInt(process.version.substr(1).split('.')[0], 10) >= 6 ||
|
||||
parseInt(process.version.substr(1).split('.')[0], 10) === 4 && parseInt(process.version.substr(1).split('.')[1], 10) >= 8;
|
||||
// `options.shell` is supported in Node ^4.8.0, ^5.7.0 and >= 6.0.0
|
||||
const supportsShellOption = niceTry(() => semver.satisfies(process.version, '^4.8.0 || ^5.7.0 || >= 6.0.0', true)) || false;
|
||||
|
||||
function detectShebang(parsed) {
|
||||
parsed.file = resolveCommand(parsed);
|
||||
|
||||
const shebang = parsed.file && readShebang(parsed.file);
|
||||
|
||||
if (shebang) {
|
||||
parsed.args.unshift(parsed.file);
|
||||
parsed.command = shebang;
|
||||
|
||||
return resolveCommand(parsed);
|
||||
}
|
||||
|
||||
return parsed.file;
|
||||
}
|
||||
|
||||
function parseNonShell(parsed) {
|
||||
var shebang;
|
||||
var needsShell;
|
||||
var applyQuotes;
|
||||
|
||||
if (!isWin) {
|
||||
return parsed;
|
||||
}
|
||||
|
||||
// Detect & add support for shebangs
|
||||
parsed.file = resolveCommand(parsed.command);
|
||||
parsed.file = parsed.file || resolveCommand(parsed.command, true);
|
||||
shebang = parsed.file && readShebang(parsed.file);
|
||||
const commandFile = detectShebang(parsed);
|
||||
|
||||
if (shebang) {
|
||||
parsed.args.unshift(parsed.file);
|
||||
parsed.command = shebang;
|
||||
needsShell = hasEmptyArgumentBug || !skipShellRegExp.test(resolveCommand(shebang) || resolveCommand(shebang, true));
|
||||
} else {
|
||||
needsShell = hasEmptyArgumentBug || !skipShellRegExp.test(parsed.file);
|
||||
}
|
||||
// We don't need a shell if the command filename is an executable
|
||||
const needsShell = !isExecutableRegExp.test(commandFile);
|
||||
|
||||
// If a shell is required, use cmd.exe and take care of escaping everything correctly
|
||||
if (needsShell) {
|
||||
// Escape command & arguments
|
||||
applyQuotes = (parsed.command !== 'echo'); // Do not quote arguments for the special "echo" command
|
||||
parsed.command = escapeCommand(parsed.command);
|
||||
parsed.args = parsed.args.map(function (arg) {
|
||||
return escapeArgument(arg, applyQuotes);
|
||||
});
|
||||
// Note that `forceShell` is an hidden option used only in tests
|
||||
if (parsed.options.forceShell || needsShell) {
|
||||
// Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
|
||||
// The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
|
||||
// Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
|
||||
// we need to double escape them
|
||||
const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
|
||||
|
||||
// Make use of cmd.exe
|
||||
parsed.args = ['/d', '/s', '/c', '"' + parsed.command + (parsed.args.length ? ' ' + parsed.args.join(' ') : '') + '"'];
|
||||
// Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
|
||||
// This is necessary otherwise it will always fail with ENOENT in those cases
|
||||
parsed.command = path.normalize(parsed.command);
|
||||
|
||||
// Escape command & arguments
|
||||
parsed.command = escape.command(parsed.command);
|
||||
parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
|
||||
|
||||
const shellCommand = [parsed.command].concat(parsed.args).join(' ');
|
||||
|
||||
parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
|
||||
parsed.command = process.env.comspec || 'cmd.exe';
|
||||
parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
|
||||
parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
|
||||
}
|
||||
|
||||
return parsed;
|
||||
}
|
||||
|
||||
function parseShell(parsed) {
|
||||
var shellCommand;
|
||||
|
||||
// If node supports the shell option, there's no need to mimic its behavior
|
||||
if (supportsShellOption) {
|
||||
return parsed;
|
||||
}
|
||||
|
||||
// Mimic node shell option, see: https://github.com/nodejs/node/blob/b9f6a2dc059a1062776133f3d4fd848c4da7d150/lib/child_process.js#L335
|
||||
shellCommand = [parsed.command].concat(parsed.args).join(' ');
|
||||
// Mimic node shell option
|
||||
// See https://github.com/nodejs/node/blob/b9f6a2dc059a1062776133f3d4fd848c4da7d150/lib/child_process.js#L335
|
||||
const shellCommand = [parsed.command].concat(parsed.args).join(' ');
|
||||
|
||||
if (isWin) {
|
||||
parsed.command = typeof parsed.options.shell === 'string' ? parsed.options.shell : process.env.comspec || 'cmd.exe';
|
||||
parsed.args = ['/d', '/s', '/c', '"' + shellCommand + '"'];
|
||||
parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
|
||||
parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
|
||||
parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
|
||||
} else {
|
||||
if (typeof parsed.options.shell === 'string') {
|
||||
parsed.command = parsed.options.shell;
|
||||
@@ -83,27 +96,26 @@ function parseShell(parsed) {
|
||||
return parsed;
|
||||
}
|
||||
|
||||
// ------------------------------------------------
|
||||
|
||||
function parse(command, args, options) {
|
||||
var parsed;
|
||||
|
||||
// Normalize arguments, similar to nodejs
|
||||
if (args && !Array.isArray(args)) {
|
||||
options = args;
|
||||
args = null;
|
||||
}
|
||||
|
||||
args = args ? args.slice(0) : []; // Clone array to avoid changing the original
|
||||
options = options || {};
|
||||
args = args ? args.slice(0) : []; // Clone array to avoid changing the original
|
||||
options = Object.assign({}, options); // Clone object to avoid changing the original
|
||||
|
||||
// Build our parsed object
|
||||
parsed = {
|
||||
command: command,
|
||||
args: args,
|
||||
options: options,
|
||||
const parsed = {
|
||||
command,
|
||||
args,
|
||||
options,
|
||||
file: undefined,
|
||||
original: command,
|
||||
original: {
|
||||
command,
|
||||
args,
|
||||
},
|
||||
};
|
||||
|
||||
// Delegate further parsing to shell or non-shell
|
||||
|
||||
-30
@@ -1,30 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
function escapeArgument(arg, quote) {
|
||||
// Convert to string
|
||||
arg = '' + arg;
|
||||
|
||||
// If we are not going to quote the argument,
|
||||
// escape shell metacharacters, including double and single quotes:
|
||||
if (!quote) {
|
||||
arg = arg.replace(/([()%!^<>&|;,"'\s])/g, '^$1');
|
||||
} else {
|
||||
// Sequence of backslashes followed by a double quote:
|
||||
// double up all the backslashes and escape the double quote
|
||||
arg = arg.replace(/(\\*)"/g, '$1$1\\"');
|
||||
|
||||
// Sequence of backslashes followed by the end of the string
|
||||
// (which will become a double quote later):
|
||||
// double up all the backslashes
|
||||
arg = arg.replace(/(\\*)$/, '$1$1');
|
||||
|
||||
// All other backslashes occur literally
|
||||
|
||||
// Quote the whole thing:
|
||||
arg = '"' + arg + '"';
|
||||
}
|
||||
|
||||
return arg;
|
||||
}
|
||||
|
||||
module.exports = escapeArgument;
|
||||
-12
@@ -1,12 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
var escapeArgument = require('./escapeArgument');
|
||||
|
||||
function escapeCommand(command) {
|
||||
// Do not escape if this command is not dangerous..
|
||||
// We do this so that commands like "echo" or "ifconfig" work
|
||||
// Quoting them, will make them unaccessible
|
||||
return /^[a-z0-9_-]+$/i.test(command) ? command : escapeArgument(command, true);
|
||||
}
|
||||
|
||||
module.exports = escapeCommand;
|
||||
-18
@@ -1,18 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
// See: https://github.com/IndigoUnited/node-cross-spawn/pull/34#issuecomment-221623455
|
||||
function hasEmptyArgumentBug() {
|
||||
var nodeVer;
|
||||
|
||||
if (process.platform !== 'win32') {
|
||||
return false;
|
||||
}
|
||||
|
||||
nodeVer = process.version.substr(1).split('.').map(function (num) {
|
||||
return parseInt(num, 10);
|
||||
});
|
||||
|
||||
return (nodeVer[0] === 0 && nodeVer[1] < 12);
|
||||
}
|
||||
|
||||
module.exports = hasEmptyArgumentBug();
|
||||
+16
-21
@@ -1,37 +1,32 @@
|
||||
'use strict';
|
||||
|
||||
var fs = require('fs');
|
||||
var LRU = require('lru-cache');
|
||||
var shebangCommand = require('shebang-command');
|
||||
|
||||
var shebangCache = new LRU({ max: 50, maxAge: 30 * 1000 }); // Cache just for 30sec
|
||||
const fs = require('fs');
|
||||
const shebangCommand = require('shebang-command');
|
||||
|
||||
function readShebang(command) {
|
||||
var buffer;
|
||||
var fd;
|
||||
var shebang;
|
||||
// Read the first 150 bytes from the file
|
||||
const size = 150;
|
||||
let buffer;
|
||||
|
||||
// Check if it is in the cache first
|
||||
if (shebangCache.has(command)) {
|
||||
return shebangCache.get(command);
|
||||
if (Buffer.alloc) {
|
||||
// Node.js v4.5+ / v5.10+
|
||||
buffer = Buffer.alloc(size);
|
||||
} else {
|
||||
// Old Node.js API
|
||||
buffer = new Buffer(size);
|
||||
buffer.fill(0); // zero-fill
|
||||
}
|
||||
|
||||
// Read the first 150 bytes from the file
|
||||
buffer = new Buffer(150);
|
||||
let fd;
|
||||
|
||||
try {
|
||||
fd = fs.openSync(command, 'r');
|
||||
fs.readSync(fd, buffer, 0, 150, 0);
|
||||
fs.readSync(fd, buffer, 0, size, 0);
|
||||
fs.closeSync(fd);
|
||||
} catch (e) { /* empty */ }
|
||||
} catch (e) { /* Empty */ }
|
||||
|
||||
// Attempt to extract shebang (null is returned if not a shebang)
|
||||
shebang = shebangCommand(buffer.toString());
|
||||
|
||||
// Store the shebang in the cache
|
||||
shebangCache.set(command, shebang);
|
||||
|
||||
return shebang;
|
||||
return shebangCommand(buffer.toString());
|
||||
}
|
||||
|
||||
module.exports = readShebang;
|
||||
|
||||
+35
-19
@@ -1,31 +1,47 @@
|
||||
'use strict';
|
||||
|
||||
var path = require('path');
|
||||
var which = require('which');
|
||||
var LRU = require('lru-cache');
|
||||
const path = require('path');
|
||||
const which = require('which');
|
||||
const pathKey = require('path-key')();
|
||||
|
||||
var commandCache = new LRU({ max: 50, maxAge: 30 * 1000 }); // Cache just for 30sec
|
||||
function resolveCommandAttempt(parsed, withoutPathExt) {
|
||||
const cwd = process.cwd();
|
||||
const hasCustomCwd = parsed.options.cwd != null;
|
||||
|
||||
function resolveCommand(command, noExtension) {
|
||||
var resolved;
|
||||
|
||||
noExtension = !!noExtension;
|
||||
resolved = commandCache.get(command + '!' + noExtension);
|
||||
|
||||
// Check if its resolved in the cache
|
||||
if (commandCache.has(command)) {
|
||||
return commandCache.get(command);
|
||||
// If a custom `cwd` was specified, we need to change the process cwd
|
||||
// because `which` will do stat calls but does not support a custom cwd
|
||||
if (hasCustomCwd) {
|
||||
try {
|
||||
process.chdir(parsed.options.cwd);
|
||||
} catch (err) {
|
||||
/* Empty */
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
resolved = !noExtension ?
|
||||
which.sync(command) :
|
||||
which.sync(command, { pathExt: path.delimiter + (process.env.PATHEXT || '') });
|
||||
} catch (e) { /* empty */ }
|
||||
let resolved;
|
||||
|
||||
commandCache.set(command + '!' + noExtension, resolved);
|
||||
try {
|
||||
resolved = which.sync(parsed.command, {
|
||||
path: (parsed.options.env || process.env)[pathKey],
|
||||
pathExt: withoutPathExt ? path.delimiter : undefined,
|
||||
});
|
||||
} catch (e) {
|
||||
/* Empty */
|
||||
} finally {
|
||||
process.chdir(cwd);
|
||||
}
|
||||
|
||||
// If we successfully resolved, ensure that an absolute path is returned
|
||||
// Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
|
||||
if (resolved) {
|
||||
resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
|
||||
}
|
||||
|
||||
return resolved;
|
||||
}
|
||||
|
||||
function resolveCommand(parsed) {
|
||||
return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
|
||||
}
|
||||
|
||||
module.exports = resolveCommand;
|
||||
|
||||
Reference in New Issue
Block a user