projen 0.91.16 → 0.91.18

package/node_modules/shelljs/src/dirs.js

@@ -16,7 +16,7 @@ common.register('popd', _popd, {
 var _dirStack = [];
 
 function _isStackIndex(index) {
-  return (/^[\-+]\d+$/).test(index);
+  return (/^[-+]\d+$/).test(index);
 }
 
 function _parseStackIndex(index) {
@@ -40,7 +40,7 @@ function _actualDirStack() {
 //@ Available options:
 //@
 //@ + `-n`: Suppresses the normal change of directory when adding directories to the stack, so that only the stack is manipulated.
-//@ + `-q`: Supresses output to the console.
+//@ + `-q`: Suppresses output to the console.
 //@
 //@ Arguments:
 //@
@@ -81,12 +81,10 @@ function _pushd(options, dir) {
   } else if (_isStackIndex(dir)) {
     var n = _parseStackIndex(dir);
     dirs = dirs.slice(n).concat(dirs.slice(0, n));
+  } else if (options['no-cd']) {
+    dirs.splice(1, 0, dir);
   } else {
-    if (options['no-cd']) {
-      dirs.splice(1, 0, dir);
-    } else {
-      dirs.unshift(dir);
-    }
+    dirs.unshift(dir);
   }
 
   if (options['no-cd']) {
@@ -108,7 +106,7 @@ exports.pushd = _pushd;
 //@ Available options:
 //@
 //@ + `-n`: Suppress the normal directory change when removing directories from the stack, so that only the stack is manipulated.
-//@ + `-q`: Supresses output to the console.
+//@ + `-q`: Suppresses output to the console.
 //@
 //@ Arguments:
 //@
@@ -162,7 +160,7 @@ exports.popd = _popd;
 //@ Available options:
 //@
 //@ + `-c`: Clears the directory stack by deleting all of the elements.
-//@ + `-q`: Supresses output to the console.
+//@ + `-q`: Suppresses output to the console.
 //@
 //@ Arguments:
 //@

package/node_modules/shelljs/src/echo.js

@@ -22,8 +22,7 @@ common.register('echo', _echo, {
 //@ echo('-n', 'no newline at end');
 //@ ```
 //@
-//@ Prints `string` to stdout, and returns string with additional utility methods
-//@ like `.to()`.
+//@ Prints `string` to stdout, and returns a [ShellString](#shellstringstr).
 function _echo(opts) {
   // allow strings starting with '-', see issue #20
   var messages = [].slice.call(arguments, opts ? 0 : 1);

package/node_modules/shelljs/src/errorCode.js

@@ -0,0 +1,10 @@
+var common = require('./common');
+
+//@
+//@ ### errorCode()
+//@
+//@ Returns the error code from the last command.
+function errorCode() {
+  return common.state.errorCode;
+}
+module.exports = errorCode;

package/node_modules/shelljs/src/exec-child.js

@@ -1,39 +1,71 @@
-if (require.main !== module) {
-  throw new Error('This file should not be required');
-}
-
 var childProcess = require('child_process');
 var fs = require('fs');
 
-var paramFilePath = process.argv[2];
+function main() {
+  var paramFilePath = process.argv[2];
+
+  var serializedParams = fs.readFileSync(paramFilePath, 'utf8');
+  var params = JSON.parse(serializedParams);
+
+  var cmd = params.command;
+  var execOptions = params.execOptions;
+  var pipe = params.pipe;
+  var stdoutFile = params.stdoutFile;
+  var stderrFile = params.stderrFile;
 
-var serializedParams = fs.readFileSync(paramFilePath, 'utf8');
-var params = JSON.parse(serializedParams);
+  function isMaxBufferError(err) {
+    var maxBufferErrorPattern = /^.*\bmaxBuffer\b.*exceeded.*$/;
+    if (err instanceof Error && err.message &&
+          err.message.match(maxBufferErrorPattern)) {
+      // < v10
+      // Error: stdout maxBuffer exceeded
+      return true;
+    } else if (err instanceof RangeError && err.message &&
+          err.message.match(maxBufferErrorPattern)) {
+      // >= v10
+      // RangeError [ERR_CHILD_PROCESS_STDIO_MAXBUFFER]: stdout maxBuffer length
+      // exceeded
+      return true;
+    }
+    return false;
+  }
 
-var cmd = params.command;
-var execOptions = params.execOptions;
-var pipe = params.pipe;
-var stdoutFile = params.stdoutFile;
-var stderrFile = params.stderrFile;
+  var stdoutStream = fs.createWriteStream(stdoutFile);
+  var stderrStream = fs.createWriteStream(stderrFile);
 
-var c = childProcess.exec(cmd, execOptions, function (err) {
-  if (!err) {
-    process.exitCode = 0;
-  } else if (err.code === undefined) {
-    process.exitCode = 1;
-  } else {
-    process.exitCode = err.code;
+  function appendError(message, code) {
+    stderrStream.write(message);
+    process.exitCode = code;
   }
-});
 
-var stdoutStream = fs.createWriteStream(stdoutFile);
-var stderrStream = fs.createWriteStream(stderrFile);
+  var c = childProcess.exec(cmd, execOptions, function (err) {
+    if (!err) {
+      process.exitCode = 0;
+    } else if (isMaxBufferError(err)) {
+      appendError('maxBuffer exceeded', 1);
+    } else if (err.code === undefined && err.message) {
+      /* istanbul ignore next */
+      appendError(err.message, 1);
+    } else if (err.code === undefined) {
+      /* istanbul ignore next */
+      appendError('Unknown issue', 1);
+    } else {
+      process.exitCode = err.code;
+    }
+  });
+
+  c.stdout.pipe(stdoutStream);
+  c.stderr.pipe(stderrStream);
+  c.stdout.pipe(process.stdout);
+  c.stderr.pipe(process.stderr);
 
-c.stdout.pipe(stdoutStream);
-c.stderr.pipe(stderrStream);
-c.stdout.pipe(process.stdout);
-c.stderr.pipe(process.stderr);
+  if (pipe) {
+    c.stdin.end(pipe);
+  }
+}
 
-if (pipe) {
-  c.stdin.end(pipe);
+// This file should only be executed. This module does not export anything.
+/* istanbul ignore else */
+if (require.main === module) {
+  main();
 }

package/node_modules/shelljs/src/exec.js

@@ -12,22 +12,32 @@ common.register('exec', _exec, {
   unix: false,
   canReceivePipe: true,
   wrapOutput: false,
+  handlesFatalDynamically: true,
 });
 
 // We use this function to run `exec` synchronously while also providing realtime
 // output.
 function execSync(cmd, opts, pipe) {
   if (!common.config.execPath) {
-    common.error('Unable to find a path to the node binary. Please manually set config.execPath');
+    try {
+        common.error('Unable to find a path to the node binary. Please manually set config.execPath');
+    } catch (e) {
+      if (opts.fatal) {
+        throw e;
+      }
+
+      return;
+    }
   }
 
   var tempDir = _tempDir();
-  var paramsFile = path.resolve(tempDir + '/' + common.randomFileName());
-  var stderrFile = path.resolve(tempDir + '/' + common.randomFileName());
-  var stdoutFile = path.resolve(tempDir + '/' + common.randomFileName());
+  var paramsFile = path.join(tempDir, common.randomFileName());
+  var stderrFile = path.join(tempDir, common.randomFileName());
+  var stdoutFile = path.join(tempDir, common.randomFileName());
 
   opts = common.extend({
     silent: common.config.silent,
+    fatal: common.config.fatal, // TODO(nfischer): this and the line above are probably unnecessary
     cwd: _pwd().toString(),
     env: process.env,
     maxBuffer: DEFAULT_MAXBUFFER_SIZE,
@@ -117,7 +127,7 @@ function execSync(cmd, opts, pipe) {
     // Note: `silent` should be unconditionally true to avoid double-printing
     // the command's stderr, and to avoid printing any stderr when the user has
     // set `shell.config.silent`.
-    common.error(stderr, code, { continue: true, silent: true });
+    common.error(stderr, code, { continue: true, silent: true, fatal: opts.fatal });
   }
   var obj = common.ShellString(stdout, stderr, code);
   return obj;
@@ -127,6 +137,7 @@ function execSync(cmd, opts, pipe) {
 function execAsync(cmd, opts, pipe, callback) {
   opts = common.extend({
     silent: common.config.silent,
+    fatal: common.config.fatal, // TODO(nfischer): this and the line above are probably unnecessary
     cwd: _pwd().toString(),
     env: process.env,
     maxBuffer: DEFAULT_MAXBUFFER_SIZE,
@@ -164,6 +175,7 @@ function execAsync(cmd, opts, pipe, callback) {
 //@
 //@ + `async`: Asynchronous execution. If a callback is provided, it will be set to
 //@   `true`, regardless of the passed value (default: `false`).
+//@ + `fatal`: Exit upon error (default: `false`).
 //@ + `silent`: Do not echo program output to console (default: `false`).
 //@ + `encoding`: Character encoding to use. Affects the values returned to stdout and stderr, and
 //@   what is written to stdout and stderr when not in silent mode (default: `'utf8'`).
@@ -187,17 +199,21 @@ function execAsync(cmd, opts, pipe, callback) {
 //@ });
 //@ ```
 //@
-//@ Executes the given `command` _synchronously_, unless otherwise specified.  When in synchronous
-//@ mode, this returns a `ShellString` (compatible with ShellJS v0.6.x, which returns an object
-//@ of the form `{ code:..., stdout:... , stderr:... }`). Otherwise, this returns the child process
-//@ object, and the `callback` receives the arguments `(code, stdout, stderr)`.
+//@ Executes the given `command` _synchronously_, unless otherwise specified.
+//@ When in synchronous mode, this returns a [ShellString](#shellstringstr).
+//@ Otherwise, this returns the child process object, and the `callback`
+//@ receives the arguments `(code, stdout, stderr)`.
 //@
 //@ Not seeing the behavior you want? `exec()` runs everything through `sh`
 //@ by default (or `cmd.exe` on Windows), which differs from `bash`. If you
 //@ need bash-specific behavior, try out the `{shell: 'path/to/bash'}` option.
+//@
+//@ **Security note:** as `shell.exec()` executes an arbitrary string in the
+//@ system shell, it is **critical** to properly sanitize user input to avoid
+//@ **command injection**. For more context, consult the [Security
+//@ Guidelines](https://github.com/shelljs/shelljs/wiki/Security-guidelines).
 function _exec(command, options, callback) {
   options = options || {};
-  if (!command) common.error('must specify command');
 
   var pipe = common.readFromPipe();
 
@@ -214,9 +230,22 @@ function _exec(command, options, callback) {
 
   options = common.extend({
     silent: common.config.silent,
+    fatal: common.config.fatal,
     async: false,
   }, options);
 
+  if (!command) {
+    try {
+      common.error('must specify command');
+    } catch (e) {
+      if (options.fatal) {
+        throw e;
+      }
+
+      return;
+    }
+  }
+
   if (options.async) {
     return execAsync(command, options, pipe, callback);
   } else {

package/node_modules/shelljs/src/find.js

@@ -2,7 +2,11 @@ var path = require('path');
 var common = require('./common');
 var _ls = require('./ls');
 
-common.register('find', _find, {});
+common.register('find', _find, {
+  cmdOptions: {
+    'L': 'link',
+  },
+});
 
 //@
 //@ ### find(path [, path ...])
@@ -16,7 +20,8 @@ common.register('find', _find, {});
 //@ find('.').filter(function(file) { return file.match(/\.js$/); });
 //@ ```
 //@
-//@ Returns array of all files (however deep) in the given paths.
+//@ Returns a [ShellString](#shellstringstr) (with array-like properties) of all
+//@ files (however deep) in the given paths.
 //@
 //@ The main difference from `ls('-R', path)` is that the resulting file names
 //@ include the base directories (e.g., `lib/resources/file1` instead of just `file1`).
@@ -50,7 +55,7 @@ function _find(options, paths) {
     pushFile(file);
 
     if (stat.isDirectory()) {
-      _ls({ recursive: true, all: true }, file).forEach(function (subfile) {
+      _ls({ recursive: true, all: true, link: options.link }, file).forEach(function (subfile) {
         pushFile(path.join(file, subfile));
       });
     }

package/node_modules/shelljs/src/grep.js

@@ -8,6 +8,7 @@ common.register('grep', _grep, {
     'v': 'inverse',
     'l': 'nameOnly',
     'i': 'ignoreCase',
+    'n': 'lineNumber',
   },
 });
 
@@ -20,6 +21,7 @@ common.register('grep', _grep, {
 //@ + `-v`: Invert `regex_filter` (only print non-matching lines).
 //@ + `-l`: Print only filenames of matching files.
 //@ + `-i`: Ignore case.
+//@ + `-n`: Print line numbers.
 //@
 //@ Examples:
 //@
@@ -28,8 +30,9 @@ common.register('grep', _grep, {
 //@ grep('GLOBAL_VARIABLE', '*.js');
 //@ ```
 //@
-//@ Reads input string from given files and returns a string containing all lines of the
-//@ file that match the given `regex_filter`.
+//@ Reads input string from given files and returns a
+//@ [ShellString](#shellstringstr) containing all lines of the @ file that match
+//@ the given `regex_filter`.
 function _grep(options, regex, files) {
   // Check if this is coming from a pipe
   var pipe = common.readFromPipe();
@@ -59,15 +62,23 @@ function _grep(options, regex, files) {
       }
     } else {
       var lines = contents.split('\n');
-      lines.forEach(function (line) {
+      lines.forEach(function (line, index) {
         var matched = line.match(regex);
         if ((options.inverse && !matched) || (!options.inverse && matched)) {
-          grep.push(line);
+          var result = line;
+          if (options.lineNumber) {
+            result = '' + (index + 1) + ':' + line;
+          }
+          grep.push(result);
         }
       });
     }
   });
 
+  if (grep.length === 0 && common.state.errorCode !== 2) {
+    // We didn't hit the error above, but pattern didn't match
+    common.error('', { silent: true });
+  }
   return grep.join('\n') + '\n';
 }
 module.exports = _grep;

package/node_modules/shelljs/src/head.js

@@ -46,7 +46,7 @@ function readSomeLines(file, numLines) {
 //@ var str = head(['file1', 'file2']); // same as above
 //@ ```
 //@
-//@ Read the start of a file.
+//@ Read the start of a `file`. Returns a [ShellString](#shellstringstr).
 function _head(options, files) {
   var head = [];
   var pipe = common.readFromPipe();

package/node_modules/shelljs/src/ln.js

@@ -24,7 +24,9 @@ common.register('ln', _ln, {
 //@ ln('-sf', 'file', 'existing');
 //@ ```
 //@
-//@ Links `source` to `dest`. Use `-f` to force the link, should `dest` already exist.
+//@ Links `source` to `dest`. Use `-f` to force the link, should `dest` already
+//@ exist. Returns a [ShellString](#shellstringstr) indicating success or
+//@ failure.
 function _ln(options, source, dest) {
   if (!source || !dest) {
     common.error('Missing <source> and/or <dest>');

package/node_modules/shelljs/src/ls.js

@@ -1,9 +1,10 @@
 var path = require('path');
 var fs = require('fs');
 var common = require('./common');
-var glob = require('glob');
+var glob = require('fast-glob');
 
-var globPatternRecursive = path.sep + '**';
+// glob patterns use the UNIX path seperator
+var globPatternRecursive = '/**';
 
 common.register('ls', _ls, {
   cmdOptions: {
@@ -26,22 +27,28 @@ common.register('ls', _ls, {
 //@ + `-A`: all files (include files beginning with `.`, except for `.` and `..`)
 //@ + `-L`: follow symlinks
 //@ + `-d`: list directories themselves, not their contents
-//@ + `-l`: list objects representing each file, each with fields containing `ls
-//@         -l` output fields. See
-//@         [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats)
-//@         for more info
+//@ + `-l`: provides more details for each file. Specifically, each file is
+//@         represented by a structured object with separate fields for file
+//@         metadata (see
+//@         [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats)). The
+//@         return value also overrides `.toString()` to resemble `ls -l`'s
+//@         output format for human readability, but programmatic usage should
+//@         depend on the stable object format rather than the `.toString()`
+//@         representation.
 //@
 //@ Examples:
 //@
 //@ ```javascript
 //@ ls('projs/*.js');
+//@ ls('projs/**/*.js'); // Find all js files recursively in projs
 //@ ls('-R', '/users/me', '/tmp');
 //@ ls('-R', ['/users/me', '/tmp']); // same as above
 //@ ls('-l', 'file.txt'); // { name: 'file.txt', mode: 33188, nlink: 1, ...}
 //@ ```
 //@
-//@ Returns array of files in the given `path`, or files in
-//@ the current directory if no `path` is  provided.
+//@ Returns a [ShellString](#shellstringstr) (with array-like properties) of all
+//@ the files in the given `path`, or files in the current directory if no
+//@ `path` is  provided.
 function _ls(options, paths) {
   if (options.all_deprecated) {
     // We won't support the -a option as it's hard to image why it's useful
@@ -99,13 +106,20 @@ function _ls(options, paths) {
     if (stat.isDirectory() && !options.directory) {
       if (options.recursive) {
         // use glob, because it's simple
-        glob.sync(p + globPatternRecursive, { dot: options.all, follow: options.link })
-          .forEach(function (item) {
-            // Glob pattern returns the directory itself and needs to be filtered out.
-            if (path.relative(p, item)) {
-              pushFile(item, path.relative(p, item));
-            }
-          });
+        glob.sync(p + globPatternRecursive, {
+          // These options are just to make fast-glob be compatible with POSIX
+          // (bash) wildcard behavior.
+          onlyFiles: false,
+
+          // These options depend on the cmdOptions provided to ls.
+          dot: options.all,
+          followSymbolicLinks: options.link,
+        }).forEach(function (item) {
+          // Glob pattern returns the directory itself and needs to be filtered out.
+          if (path.relative(p, item)) {
+            pushFile(item, path.relative(p, item));
+          }
+        });
       } else if (options.all) {
         // use fs.readdirSync, because it's fast
         fs.readdirSync(p).forEach(function (item) {

package/node_modules/shelljs/src/mkdir.js

@@ -19,17 +19,18 @@ function mkdirSyncRecursive(dir) {
     common.error('dirname() failed: [' + dir + ']');
   }
 
-  // Base dir exists, no recursion necessary
-  if (fs.existsSync(baseDir)) {
-    fs.mkdirSync(dir, parseInt('0777', 8));
-    return;
-  }
-
   // Base dir does not exist, go recursive
-  mkdirSyncRecursive(baseDir);
+  if (!fs.existsSync(baseDir)) {
+    mkdirSyncRecursive(baseDir);
+  }
 
-  // Base dir created, can create dir
-  fs.mkdirSync(dir, parseInt('0777', 8));
+  try {
+    // Base dir created, can create dir
+    fs.mkdirSync(dir, parseInt('0777', 8));
+  } catch (e) {
+    // swallow error if dir already exists
+    if (e.code !== 'EEXIST' || common.statNoFollowLinks(dir).isFile()) { throw e; }
+  }
 }
 
 //@
@@ -47,7 +48,8 @@ function mkdirSyncRecursive(dir) {
 //@ mkdir('-p', ['/tmp/a/b/c/d', '/tmp/e/f/g']); // same as above
 //@ ```
 //@
-//@ Creates directories.
+//@ Creates directories. Returns a [ShellString](#shellstringstr) indicating
+//@ success or failure.
 function _mkdir(options, dirs) {
   if (!dirs) common.error('no paths given');
 
@@ -96,5 +98,5 @@ function _mkdir(options, dirs) {
     }
   });
   return '';
-} // mkdir
+} // man arraykdir
 module.exports = _mkdir;

package/node_modules/shelljs/src/mv.js

@@ -36,7 +36,8 @@ function checkRecentCreated(sources, index) {
 //@ mv(['file1', 'file2'], 'dir/'); // same as above
 //@ ```
 //@
-//@ Moves `source` file(s) to `dest`.
+//@ Moves `source` file(s) to `dest`. Returns a [ShellString](#shellstringstr)
+//@ indicating success or failure.
 function _mv(options, sources, dest) {
   // Get sources, dest
   if (arguments.length < 3) {
@@ -108,8 +109,8 @@ function _mv(options, sources, dest) {
         // to perform a copy and then clean up the original file. If either the
         // copy or the rm fails with an exception, we should allow this
         // exception to pass up to the top level.
-        cp('-r', src, thisDest);
-        rm('-rf', src);
+        cp({ recursive: true }, src, thisDest);
+        rm({ recursive: true, force: true }, src);
       }
     }
   }); // forEach(src)

package/node_modules/shelljs/src/pwd.js

@@ -8,7 +8,7 @@ common.register('pwd', _pwd, {
 //@
 //@ ### pwd()
 //@
-//@ Returns the current directory.
+//@ Returns the current directory as a [ShellString](#shellstringstr).
 function _pwd() {
   var pwd = path.resolve(process.cwd());
   return pwd;

package/node_modules/shelljs/src/rm.js

@@ -29,16 +29,15 @@ function rmdirSyncRecursive(dir, force, fromSymlink) {
 
     if (currFile.isDirectory()) { // Recursive function back to the beginning
       rmdirSyncRecursive(file, force);
-    } else { // Assume it's a file - perhaps a try/catch belongs here?
-      if (force || isWriteable(file)) {
-        try {
-          common.unlinkSync(file);
-        } catch (e) {
-          /* istanbul ignore next */
-          common.error('could not remove file (code ' + e.code + '): ' + file, {
-            continue: true,
-          });
-        }
+    } else if (force || isWriteable(file)) {
+      // Assume it's a file - perhaps a try/catch belongs here?
+      try {
+        common.unlinkSync(file);
+      } catch (e) {
+        /* istanbul ignore next */
+        common.error('could not remove file (code ' + e.code + '): ' + file, {
+          continue: true,
+        });
       }
     }
   }
@@ -163,7 +162,8 @@ function handleFIFO(file) {
 //@ rm(['some_file.txt', 'another_file.txt']); // same as above
 //@ ```
 //@
-//@ Removes files.
+//@ Removes files. Returns a [ShellString](#shellstringstr) indicating success
+//@ or failure.
 function _rm(options, files) {
   if (!files) common.error('no paths given');
 

package/node_modules/shelljs/src/sed.js

@@ -21,11 +21,11 @@ common.register('sed', _sed, {
 //@
 //@ ```javascript
 //@ sed('-i', 'PROGRAM_VERSION', 'v0.1.3', 'source.js');
-//@ sed(/.*DELETE_THIS_LINE.*\n/, '', 'source.js');
 //@ ```
 //@
-//@ Reads an input string from `file`s, and performs a JavaScript `replace()` on the input
-//@ using the given `search_regex` and `replacement` string or function. Returns the new string after replacement.
+//@ Reads an input string from `file`s, line by line, and performs a JavaScript `replace()` on
+//@ each of the lines from the input string using the given `search_regex` and `replacement` string or
+//@ function. Returns the new [ShellString](#shellstringstr) after replacement.
 //@
 //@ Note:
 //@
@@ -35,6 +35,10 @@ common.register('sed', _sed, {
 //@ ```javascript
 //@ sed(/(\w+)\s(\w+)/, '$2, $1', 'file.txt');
 //@ ```
+//@
+//@ Also, like unix `sed`, ShellJS `sed` runs replacements on each line from the input file
+//@ (split by '\n') separately, so `search_regex`es that span more than one line (or include '\n')
+//@ will not match anything and nothing will be replaced.
 function _sed(options, regex, replacement, files) {
   // Check if this is coming from a pipe
   var pipe = common.readFromPipe();
@@ -82,6 +86,10 @@ function _sed(options, regex, replacement, files) {
     }
   });
 
-  return sed.join('\n');
+  if (options.inplace) {
+    return '';
+  } else {
+    return sed.join('\n');
+  }
 }
 module.exports = _sed;

package/node_modules/shelljs/src/set.js

@@ -51,6 +51,5 @@ function _set(options) {
       common.config[key] = options[key];
     }
   });
-  return;
 }
 module.exports = _set;

package/node_modules/shelljs/src/sort.js

@@ -54,8 +54,9 @@ function numericalCmp(a, b) {
 //@ sort('-r', 'foo.txt');
 //@ ```
 //@
-//@ Return the contents of the `file`s, sorted line-by-line. Sorting multiple
-//@ files mixes their content (just as unix `sort` does).
+//@ Return the contents of the `file`s, sorted line-by-line as a
+//@ [ShellString](#shellstringstr). Sorting multiple files mixes their content
+//@ (just as unix `sort` does).
 function _sort(options, files) {
   // Check if this is coming from a pipe
   var pipe = common.readFromPipe();