@hygiene/cli/dist/command/run.js

Keep your TODOs and FIXMEs healthy

"use strict";

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

var _fs = require("fs");

var _util = require("util");

var _path = require("path");

var _ignore = _interopRequireDefault(require("ignore"));

var _pick = _interopRequireDefault(require("lodash/pick"));

var _flow = _interopRequireDefault(require("lodash/flow"));

var _core = require("@hygiene/core");

var reporters = _interopRequireWildcard(require("../reporter"));

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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

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

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var readFileAsync = (0, _util.promisify)(_fs.readFile);
var existsAsync = (0, _util.promisify)(_fs.exists);

var createFilter =
/*#__PURE__*/
function () {
  var _ref2 = _asyncToGenerator(function* (_ref) {
    var ignorePattern = _ref.ignorePattern,
        ignorePath = _ref.ignorePath,
        cwd = _ref.cwd;
    var blacklist = (0, _ignore.default)();

    if (ignorePath) {
      if (yield existsAsync(ignorePath)) {
        // TODO: Verbose logging
        blacklist.add((yield readFileAsync(ignorePath, "utf8")));
      } else {// TODO: Verbose logging
      }
    }

    if (ignorePattern) {
      // TODO: Verbose logging
      blacklist.add(ignorePattern);
    } // https://www.npmjs.com/package/ignore#1-pathname-should-be-a-pathrelative-d-pathname


    return (0, _flow.default)(function (path) {
      return (0, _path.relative)(cwd, path);
    }, function (path) {
      try {
        return !blacklist.ignores(path);
      } catch (e) {
        if (e.message.includes("relative")) {
          return true;
        }

        throw e;
      }
    });
  });

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

exports.createFilter = createFilter;

var run = function run(_ref3) {
  var plugins = _ref3.plugins;
  return (
    /*#__PURE__*/
    function () {
      var _ref4 = _asyncToGenerator(function* (argv) {
        var glob = argv.glob,
            json = argv.json,
            ignore = argv.ignore,
            ignorePattern = argv.ignorePattern,
            ignorePath = argv.ignorePath;

        var bodyParser = _core.combineParsers.apply(void 0, _toConsumableArray(plugins));

        var report = json ? reporters.json : reporters.text;
        var filter = ignore ? yield createFilter({
          ignorePattern: ignorePattern,
          ignorePath: ignorePath,
          cwd: process.cwd()
        }) : function () {
          return true;
        };
        var pluginConfigs = plugins.map(function (plugin) {
          return (0, _pick.default)(argv, Object.keys(plugin.getConfigDefinition()));
        });
        var comments = yield (0, _core.parseFiles)(glob, bodyParser, {
          filter: filter
        });
        var expiredComments = yield (0, _core.filterExpired)(comments, plugins, pluginConfigs);
        return report(expiredComments, plugins, pluginConfigs);
      });

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

exports.run = run;