astx/cjs/util/formatMatches.js

super powerful structural search and replace for JavaScript and TypeScript to automate your refactoring

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = formatMatches;
exports.formatIpcMatches = formatIpcMatches;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _chalk = _interopRequireDefault(require("chalk"));

var _countLines = _interopRequireDefault(require("./countLines"));

var captureColors = [_chalk["default"].green, _chalk["default"].yellow, _chalk["default"].blue, _chalk["default"].cyan, _chalk["default"].magenta, _chalk["default"].red];

function deriveLineAndColumn(source, index) {
  var rx = /\r\n?|\n/gm;
  var lastIndex = 0;
  var line = 1;

  while (lastIndex < index) {
    rx.lastIndex = lastIndex + 1;
    var match = rx.exec(source);
    if (!match) break;
    line++;
    lastIndex = match.index;
  }

  return {
    startLine: line,
    startColumn: index - lastIndex
  };
}

function formatMatch(backend, source, match, lineCount) {
  var lineNumberLength = String(lineCount).length;
  if (match.type === 'nodes' && !match.nodes.length) return "".concat(' '.repeat(lineNumberLength), " | (zero statements)");

  var _backend$location = backend.location(match.nodes[0]),
      nodeStart = _backend$location.start;

  var _backend$location2 = backend.location(match.nodes[match.nodes.length - 1]),
      nodeEnd = _backend$location2.end;

  if (nodeStart == null || nodeEnd == null) {
    throw new Error('failed to get match location');
  }

  var _backend$location3 = backend.location(match.nodes[0]),
      startLine = _backend$location3.startLine,
      startCol = _backend$location3.startColumn;

  if (startLine == null || startCol == null) {
    ;

    var _deriveLineAndColumn = deriveLineAndColumn(source, nodeStart);

    startLine = _deriveLineAndColumn.startLine;
    startCol = _deriveLineAndColumn.startColumn;
  }

  var captures = match.captures,
      arrayCaptures = match.arrayCaptures;
  var start = nodeStart - startCol;
  var eolRegex = /\r\n?|\n/gm;
  eolRegex.lastIndex = nodeEnd;
  var eolMatch = eolRegex.exec(source);
  var end = eolMatch ? eolMatch.index : nodeEnd;
  var captureColor = 0;
  var captureRanges = [];

  if (captures) {
    for (var _i = 0, _Object$entries = Object.entries(captures); _i < _Object$entries.length; _i++) {
      var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
          key = _Object$entries$_i[0],
          _node = _Object$entries$_i[1];

      var _backend$location4 = backend.location(_node),
          _start = _backend$location4.start,
          _end = _backend$location4.end;

      if (_start != null && _end != null) {
        captureRanges.push({
          key: key,
          start: _start,
          end: _end,
          color: captureColors[captureColor++] || _chalk["default"].gray
        });
      }
    }
  }

  if (arrayCaptures) {
    for (var _i2 = 0, _Object$entries2 = Object.entries(arrayCaptures); _i2 < _Object$entries2.length; _i2++) {
      var _Object$entries2$_i = (0, _slicedToArray2["default"])(_Object$entries2[_i2], 2),
          _key = _Object$entries2$_i[0],
          nodes = _Object$entries2$_i[1];

      var first = nodes[0];
      var last = nodes[nodes.length - 1];
      if (!first || !last) continue;

      var _backend$location5 = backend.location(first),
          _start2 = _backend$location5.start;

      var _backend$location6 = backend.location(last),
          _end2 = _backend$location6.end;

      if (_start2 != null && _end2 != null) {
        captureRanges.push({
          key: _key,
          start: _start2,
          end: _end2,
          color: captureColors[captureColor++] || _chalk["default"].gray
        });
      }
    }
  }

  captureRanges.sort(function (a, b) {
    return a.start - b.start;
  });
  var lastIndex = nodeStart;
  var parts = [];

  for (var _i3 = 0, _captureRanges = captureRanges; _i3 < _captureRanges.length; _i3++) {
    var _captureRanges$_i = _captureRanges[_i3],
        _start3 = _captureRanges$_i.start,
        _end3 = _captureRanges$_i.end,
        color = _captureRanges$_i.color;
    if (_start3 < lastIndex) continue;
    parts.push(source.substring(lastIndex, _start3));
    parts.push(color(source.substring(_start3, _end3)));
    lastIndex = _end3;
  }

  parts.push(source.substring(lastIndex, nodeEnd));
  var bolded = source.substring(start, nodeStart) + _chalk["default"].bold(parts.join('')) + source.substring(nodeEnd, end);
  var lines = bolded.split(/\r\n?|\n/gm);
  var line = startLine;
  var result = lines.map(function (l) {
    return "".concat(String(line++).padStart(lineNumberLength, ' '), " | ").concat(l);
  }).join('\n');
  return captureRanges.length ? "".concat(' '.repeat(lineNumberLength), " | ").concat(captureRanges.map(function (_ref) {
    var key = _ref.key,
        color = _ref.color;
    return color(key);
  }).join(' '), "\n").concat(result) : result;
}

function formatMatches(backend, source, matches) {
  var result = [];
  var lineCount = (0, _countLines["default"])(source);

  for (var i = 0; i < matches.length; i++) {
    var match = matches[i];
    if (i > 0) result.push(' '.repeat(String(lineCount).length + 1) + '|');
    result.push(formatMatch(backend, source, match, lineCount));
  }

  return result.join('\n');
}

function formatIpcMatches(source, matches) {
  return formatMatches({
    location: function location(node) {
      return node.location;
    }
  }, source, matches);
}