@dependabot/yarn-lib/lib/cli/commands/run.js

📦🐈 Fast, reliable, and secure dependency management.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.run = undefined;

var _asyncToGenerator2;

function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}

let run = exports.run = (() => {
  var _ref = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (config, reporter, flags, args) {
    let runCommand = (() => {
      var _ref4 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (args) {
        const action = args.shift();

        // build up list of commands
        const cmds = [];

        if (pkgScripts && action in pkgScripts) {
          const preAction = `pre${action}`;
          if (preAction in pkgScripts) {
            cmds.push([preAction, pkgScripts[preAction]]);
          }

          cmds.push([action, scripts[action]]);

          const postAction = `post${action}`;
          if (postAction in pkgScripts) {
            cmds.push([postAction, pkgScripts[postAction]]);
          }
        } else if (scripts[action]) {
          cmds.push([action, scripts[action]]);
        }

        if (cmds.length) {
          // Disable wrapper in executed commands
          process.env.YARN_WRAP_OUTPUT = 'false';
          for (var _iterator3 = cmds, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref6;

            if (_isArray3) {
              if (_i3 >= _iterator3.length) break;
              _ref6 = _iterator3[_i3++];
            } else {
              _i3 = _iterator3.next();
              if (_i3.done) break;
              _ref6 = _i3.value;
            }

            const _ref5 = _ref6;
            const stage = _ref5[0];
            const cmd = _ref5[1];

            // only tack on trailing arguments for default script, ignore for pre and post - #1595
            const cmdWithArgs = stage === action ? sh`${unquoted(cmd)} ${args}` : cmd;
            const customShell = config.getOption('script-shell');
            if (customShell) {
              yield (0, (_executeLifecycleScript || _load_executeLifecycleScript()).execCommand)(stage, config, cmdWithArgs, config.cwd, String(customShell));
            } else {
              yield (0, (_executeLifecycleScript || _load_executeLifecycleScript()).execCommand)(stage, config, cmdWithArgs, config.cwd);
            }
          }
        } else if (action === 'env') {
          reporter.log(JSON.stringify((yield (0, (_executeLifecycleScript || _load_executeLifecycleScript()).makeEnv)('env', config.cwd, config)), null, 2), { force: true });
        } else {
          let suggestion;

          for (const commandName in scripts) {
            const steps = leven(commandName, action);
            if (steps < 2) {
              suggestion = commandName;
            }
          }

          let msg = `Command ${JSON.stringify(action)} not found.`;
          if (suggestion) {
            msg += ` Did you mean ${JSON.stringify(suggestion)}?`;
          }
          throw new (_errors || _load_errors()).MessageError(msg);
        }
      });

      return function runCommand(_x5) {
        return _ref4.apply(this, arguments);
      };
    })();

    // list possible scripts if none specified


    // build up a list of possible scripts
    const pkg = yield config.readManifest(config.cwd);
    const scripts = (0, (_map || _load_map()).default)();
    const binCommands = [];
    const visitedBinFolders = new Set();
    let pkgCommands = [];
    for (var _iterator = Object.keys((_index || _load_index()).registries), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
      var _ref2;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref2 = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref2 = _i.value;
      }

      const registry = _ref2;

      const binFolder = path.join(config.cwd, config.registries[registry].folder, '.bin');
      if (!visitedBinFolders.has(binFolder)) {
        if (yield (_fs || _load_fs()).exists(binFolder)) {
          for (var _iterator4 = yield (_fs || _load_fs()).readdir(binFolder), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref7;

            if (_isArray4) {
              if (_i4 >= _iterator4.length) break;
              _ref7 = _iterator4[_i4++];
            } else {
              _i4 = _iterator4.next();
              if (_i4.done) break;
              _ref7 = _i4.value;
            }

            const name = _ref7;

            binCommands.push(name);
            scripts[name] = quoteForShell(path.join(binFolder, name));
          }
        }
        visitedBinFolders.add(binFolder);
      }
    }
    const pkgScripts = pkg.scripts;
    const cmdHints = {};
    if (pkgScripts) {
      // inherit `scripts` from manifest
      pkgCommands = Object.keys(pkgScripts).sort();

      // add command hints (what the actual yarn command will do)
      for (var _iterator2 = pkgCommands, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
        var _ref3;

        if (_isArray2) {
          if (_i2 >= _iterator2.length) break;
          _ref3 = _iterator2[_i2++];
        } else {
          _i2 = _iterator2.next();
          if (_i2.done) break;
          _ref3 = _i2.value;
        }

        const cmd = _ref3;

        cmdHints[cmd] = pkgScripts[cmd] || '';
      }

      Object.assign(scripts, pkgScripts);
    }

    if (args.length === 0) {
      reporter.error(reporter.lang('commandNotSpecified'));

      if (binCommands.length) {
        reporter.info(`${reporter.lang('binCommands') + binCommands.join(', ')}`);
      } else {
        reporter.error(reporter.lang('noBinAvailable'));
      }

      if (pkgCommands.length) {
        reporter.info(`${reporter.lang('possibleCommands')}`);
        reporter.list('possibleCommands', pkgCommands, cmdHints);
        yield reporter.question(reporter.lang('commandQuestion')).then(function (answer) {
          return runCommand(answer.split(' '));
        }, function () {
          return reporter.error(reporter.lang('commandNotSpecified'));
        });
      } else {
        reporter.error(reporter.lang('noScriptsAvailable'));
      }
      return Promise.resolve();
    } else {
      return runCommand(args);
    }
  });

  return function run(_x, _x2, _x3, _x4) {
    return _ref.apply(this, arguments);
  };
})();

exports.setFlags = setFlags;
exports.hasWrapper = hasWrapper;

var _executeLifecycleScript;

function _load_executeLifecycleScript() {
  return _executeLifecycleScript = require('../../util/execute-lifecycle-script.js');
}

var _errors;

function _load_errors() {
  return _errors = require('../../errors.js');
}

var _index;

function _load_index() {
  return _index = require('../../resolvers/index.js');
}

var _fs;

function _load_fs() {
  return _fs = _interopRequireWildcard(require('../../util/fs.js'));
}

var _map;

function _load_map() {
  return _map = _interopRequireDefault(require('../../util/map.js'));
}

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const leven = require('leven');

const path = require('path');

var _require = require('puka');

const quoteForShell = _require.quoteForShell,
      sh = _require.sh,
      unquoted = _require.unquoted;
function setFlags(commander) {
  commander.description('Runs a defined package script.');
}

function hasWrapper(commander, args) {
  return true;
}