lint-filter/lib/utils/git.js

Lint touched code stricter

'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var getDiffInformation = exports.getDiffInformation = function () {
  var ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
    var _ref2 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

    var _ref2$branch = _ref2.branch;
    var branch = _ref2$branch === undefined ? 'origin/master' : _ref2$branch;
    var hash = _ref2.hash;
    var diffAgainst;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.t0 = hash;

            if (_context.t0) {
              _context.next = 5;
              break;
            }

            _context.next = 4;
            return exports.spawn('git', ['merge-base', branch, 'HEAD']);

          case 4:
            _context.t0 = _context.sent;

          case 5:
            diffAgainst = _context.t0;
            _context.next = 8;
            return exports.spawn('git', ['diff', diffAgainst.trim()]);

          case 8:
            _context.t1 = _context.sent;
            return _context.abrupt('return', parseFullDiff(_context.t1));

          case 10:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function getDiffInformation(_x) {
    return ref.apply(this, arguments);
  };
}();

exports.parseDiffRanges = parseDiffRanges;
exports.parseDiffForFile = parseDiffForFile;
exports.parseFullDiff = parseFullDiff;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _child_process = require('child_process');

var _child_process2 = _interopRequireDefault(_child_process);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new _bluebird2.default(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return _bluebird2.default.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var spawn = exports.spawn = function spawn(file, args) {
  return new _bluebird2.default(function (resolve, reject) {
    var stdout = '';
    var stderr = '';

    var process = _child_process2.default.spawn(file, args);
    process.stdout.on('data', function (data) {
      stdout += data;
    });
    process.stderr.on('data', function (data) {
      stderr += data;
    });

    process.on('close', function (code) {
      if (code === 0) {
        resolve(stdout);
      } else {
        var error = new Error(file + ' ' + args.join(' ') + ' failed');
        error.stdout = stdout;
        error.stderr = stderr;
        error.code = code;
        reject(error);
      }
    });
  });
};

function parseDiffRanges(diff) {
  var matches = diff.match(/^@@ -\d+,\d+ \+(\d+),(\d+) @@/gm);
  if (!_lodash2.default.isEmpty(matches)) {
    return matches.map(function (match) {
      var _$exec$slice = /^@@ -\d+,\d+ \+(\d+),(\d+) @@/.exec(match).slice(1, 3);

      var _$exec$slice2 = _slicedToArray(_$exec$slice, 2);

      var start = _$exec$slice2[0];
      var end = _$exec$slice2[1];

      return [parseInt(start, 10), parseInt(start, 10) + parseInt(end, 10)];
    });
  }
  return [];
}

var filenameRegex = /^a\/([^\n]+) b\/[^\n]+/;
function parseDiffForFile(diff) {
  var matches = filenameRegex.exec(diff);
  if (matches === null) {
    return null;
  }
  var filename = matches[1];
  return { filename: filename, ranges: parseDiffRanges(diff) };
}

function parseFullDiff(diff) {
  return (0, _lodash2.default)(('\n' + diff).split('\ndiff --git ')).map(parseDiffForFile).filter(_lodash2.default.isObject).reduce(function (lastValue, _ref) {
    var filename = _ref.filename;
    var ranges = _ref.ranges;
    return _lodash2.default.assign({}, lastValue, _defineProperty({}, filename, lastValue[filename] ? _lodash2.default.concat(lastValue[filename], ranges) : ranges));
  }, {});
}