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

📦🐈 Fast, reliable, and secure dependency management.

'use strict';

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

var _asyncToGenerator2;

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

let list = (() => {
  var _ref = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (config, reporter, flags, args) {
    let readCacheMetadata = (() => {
      var _ref2 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (parentDir = config.cacheFolder) {
        const folders = yield (_fs || _load_fs()).readdir(parentDir);
        const packagesMetadata = [];

        for (var _iterator = folders, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
          var _ref3;

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

          const folder = _ref3;

          if (folder[0] === '.') {
            continue;
          }

          const loc = path.join(parentDir, folder);
          // Check if this is a scoped package
          if (folder.indexOf('@') > -1) {
            // If so, recurrently read scoped packages metadata
            packagesMetadata.push(...(yield readCacheMetadata(loc)));
          } else {
            var _ref4 = yield config.readPackageMetadata(loc);

            const registry = _ref4.registry,
                  manifest = _ref4.package,
                  remote = _ref4.remote;

            if (flags.pattern && !micromatch.contains(manifest.name, flags.pattern)) {
              continue;
            }
            packagesMetadata.push([manifest.name, manifest.version, registry, remote && remote.resolved || '']);
          }
        }

        return packagesMetadata;
      });

      return function readCacheMetadata() {
        return _ref2.apply(this, arguments);
      };
    })();

    const body = yield readCacheMetadata();

    reporter.table(['Name', 'Version', 'Registry', 'Resolved'], body);
  });

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

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

var _buildSubCommands2;

function _load_buildSubCommands() {
  return _buildSubCommands2 = _interopRequireDefault(require('./_build-sub-commands.js'));
}

var _fs;

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

var _constants;

function _load_constants() {
  return _constants = require('../../constants');
}

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 path = require('path');

const micromatch = require('micromatch');

function hasWrapper(flags, args) {
  return args[0] !== 'dir';
}

var _buildSubCommands = (0, (_buildSubCommands2 || _load_buildSubCommands()).default)('cache', {
  ls(config, reporter, flags, args) {
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      reporter.warn(`\`yarn cache ls\` is deprecated. Please use \`yarn cache list\`.`);
      yield list(config, reporter, flags, args);
    })();
  },

  list,

  dir(config, reporter) {
    reporter.log(config.cacheFolder, { force: true });
  },

  clean(config, reporter, flags, args) {
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      let getPackageCachefolders = (() => {
        var _ref5 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (packageName, parentDir = config.cacheFolder, metadataFile = (_constants || _load_constants()).METADATA_FILENAME) {
          const folders = yield (_fs || _load_fs()).readdir(parentDir);
          const packageFolders = [];

          for (var _iterator2 = folders, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref6;

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

            const folder = _ref6;

            if (folder[0] === '.') {
              continue;
            }

            const loc = path.join(config.cacheFolder, parentDir.replace(config.cacheFolder, ''), folder);
            // Check if this is a scoped package
            if (!(yield (_fs || _load_fs()).exists(path.join(loc, metadataFile)))) {
              // If so, recurrently read scoped packages metadata
              packageFolders.push(...(yield getPackageCachefolders(packageName, loc)));
            } else {
              var _ref7 = yield config.readPackageMetadata(loc);

              const manifest = _ref7.package;

              if (packageName === manifest.name) {
                packageFolders.push(loc);
              }
            }
          }

          return packageFolders;
        });

        return function getPackageCachefolders(_x5) {
          return _ref5.apply(this, arguments);
        };
      })();

      if (config.cacheFolder) {
        const activity = reporter.activity();

        if (args.length > 0) {
          for (var _iterator3 = args, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref8;

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

            const arg = _ref8;

            // Clear named package from cache
            const folders = yield getPackageCachefolders(arg);

            if (folders.length === 0) {
              activity.end();
              reporter.warn(reporter.lang('couldntClearPackageFromCache', arg));
              continue;
            }

            for (var _iterator4 = folders, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
              var _ref9;

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

              const folder = _ref9;

              yield (_fs || _load_fs()).unlink(folder);
            }
            activity.end();
            reporter.success(reporter.lang('clearedPackageFromCache', arg));
          }
        } else {
          // Clear all cache
          yield (_fs || _load_fs()).unlink(config._cacheRootFolder);
          yield (_fs || _load_fs()).mkdirp(config.cacheFolder);
          activity.end();
          reporter.success(reporter.lang('clearedCache'));
        }
      }
    })();
  }
});

const run = _buildSubCommands.run,
      _setFlags = _buildSubCommands.setFlags,
      examples = _buildSubCommands.examples;
exports.run = run;
exports.examples = examples;
function setFlags(commander) {
  _setFlags(commander);
  commander.description('Yarn cache list will print out every cached package.');
  commander.option('--pattern [pattern]', 'filter cached packages by pattern');
}