path: root/lib/ide.js

'use strict';

var path = require('path');

var Promise = require('bluebird');

var fs = Promise.promisifyAll(require('fs'));

var retryPromise = require('promise-retry');

var spawn = require('cross-spawn');

var colors = require('chalk');

var debug_ = require('debug');

var debug = debug_('purs-loader');

var debugVerbose = debug_('purs-loader:verbose');

var dargs = require('./dargs');

var compile = require('./compile');

var PsModuleMap = require('./purs-module-map');

function UnknownModuleError() {
  this.name = 'UnknownModuleError';
  this.stack = new Error().stack;
}

UnknownModuleError.prototype = Object.create(Error.prototype);

UnknownModuleError.prototype.constructor = UnknownModuleError;

module.exports.UnknownModuleError = UnknownModuleError;

function spawnIdeClient(body, options) {
  var ideClientCommand = options.pscIdeClient || 'purs';

  var ideClientArgs = (options.pscIdeClient ? [] : ['ide', 'client']).concat(dargs(options.pscIdeClientArgs));

  var stderr = [];

  var stdout = [];

  debug('ide client %s %o %O', ideClientCommand, ideClientArgs, body);

  return new Promise(function (resolve, reject) {
    var ideClient = spawn(ideClientCommand, ideClientArgs);

    ideClient.stderr.on('data', function (data) {
      stderr.push(data.toString());
    });

    ideClient.stdout.on('data', function (data) {
      stdout.push(data.toString());
    });

    ideClient.on('close', function (code) {
      if (code !== 0) {
        var errorMessage = stderr.join('');

        reject(new Error('ide client failed: ' + errorMessage));
      } else {
        var result = stdout.join('');

        resolve(result);
      }
    });

    ideClient.stdin.resume();

    ideClient.stdin.write(JSON.stringify(body));

    ideClient.stdin.write('\n');
  });
}

function formatIdeResult(result, options, index, length) {
  var numAndErr = '[' + (index + 1) + '/' + length + ' ' + result.errorCode + ']';
  numAndErr = options.pscIdeColors ? colors.yellow(numAndErr) : numAndErr;

  function makeResult() {
    return Promise.resolve('\n' + numAndErr + ' ' + result.message);
  }

  function makeResultSnippet(filename, pos) {
    var srcPath = path.relative(options.context, filename);
    var fileAndPos = srcPath + ':' + pos.startLine + ':' + pos.startColumn;

    return fs.readFileAsync(filename, 'utf8').then(function (source) {
      var lines = source.split('\n').slice(pos.startLine - 1, pos.endLine);
      var endsOnNewline = pos.endColumn === 1 && pos.startLine !== pos.endLine;
      var up = options.pscIdeColors ? colors.red('^') : '^';
      var down = options.pscIdeColors ? colors.red('v') : 'v';
      var trimmed = lines.slice(0);

      if (endsOnNewline) {
        lines.splice(lines.length - 1, 1);
        pos.endLine = pos.endLine - 1;
        pos.endColumn = lines[lines.length - 1].length || 1;
      }

      // strip newlines at the end
      if (endsOnNewline) {
        trimmed = lines.reverse().reduce(function (trimmed, line, i) {
          if (i === 0 && line === '') trimmed.trimming = true;
          if (!trimmed.trimming) trimmed.push(line);
          if (trimmed.trimming && line !== '') {
            trimmed.trimming = false;
            trimmed.push(line);
          }
          return trimmed;
        }, []).reverse();
        pos.endLine = pos.endLine - (lines.length - trimmed.length);
        pos.endColumn = trimmed[trimmed.length - 1].length || 1;
      }

      var spaces = ' '.repeat(String(pos.endLine).length);
      var snippet = trimmed.map(function (line, i) {
        return '  ' + (pos.startLine + i) + '  ' + line;
      }).join('\n');

      if (trimmed.length === 1) {
        snippet += '\n  ' + spaces + '  ' + ' '.repeat(pos.startColumn - 1) + up.repeat(pos.endColumn - pos.startColumn + 1);
      } else {
        snippet = '  ' + spaces + '  ' + ' '.repeat(pos.startColumn - 1) + down + '\n' + snippet;
        snippet += '\n  ' + spaces + '  ' + ' '.repeat(pos.endColumn - 1) + up;
      }

      return Promise.resolve('\n' + numAndErr + ' ' + fileAndPos + '\n\n' + snippet + '\n\n' + result.message);
    }).catch(function (error) {
      debug('failed to format ide result: %o', error);

      return Promise.resolve('');
    });
  }

  return result.filename && result.position ? makeResultSnippet(result.filename, result.position) : makeResult();
}

module.exports.connect = function connect(psModule) {
  var options = psModule.options;

  var serverCommand = options.pscIdeServer || 'purs';

  var serverArgs = (options.pscIdeServer ? [] : ['ide', 'server']).concat(dargs(Object.assign({
    outputDirectory: options.output,
    '_': options.src
  }, options.pscIdeServerArgs)));

  debug('ide server: %s %o', serverCommand, serverArgs);

  var ideServer = spawn(serverCommand, serverArgs);

  ideServer.stdout.on('data', function (data) {
    debugVerbose('ide server stdout: %s', data.toString());
  });

  ideServer.stderr.on('data', function (data) {
    debugVerbose('ide server stderr: %s', data.toString());
  });

  ideServer.on('error', function (error) {
    debugVerbose('ide server error: %o', error);
  });

  ideServer.on('close', function (code, signal) {
    debugVerbose('ide server close: %s %s', code, signal);
  });

  return Promise.resolve(ideServer);
};

module.exports.load = function load(psModule) {
  var options = psModule.options;

  var body = { command: 'load' };

  return spawnIdeClient(body, options);
};

module.exports.loadWithRetry = function loadWithRetry(psModule) {
  var retries = 9;

  return retryPromise(function (retry, number) {
    debugVerbose('attempting to load modules (%d out of %d attempts)', number, retries);

    return module.exports.load(psModule).catch(retry);
  }, {
    retries: retries,
    factor: 1,
    minTimeout: 333,
    maxTimeout: 333
  }).then(function () {
    return psModule;
  });
};

module.exports.rebuild = function rebuild(psModule) {
  var options = psModule.options;

  var body = {
    command: 'rebuild',
    params: {
      file: psModule.srcPath
    }
  };

  var parseResponse = function parseResponse(response) {
    try {
      var parsed = JSON.parse(response);

      debugVerbose('parsed JSON response: %O', parsed);

      return Promise.resolve(parsed);
    } catch (error) {
      return Promise.reject(error);
    }
  };

  var formatResponse = function formatResponse(parsed) {
    var result = Array.isArray(parsed.result) ? parsed.result : [];

    return Promise.map(result, function (item, i) {
      debugVerbose('formatting result %O', item);

      return formatIdeResult(item, options, i, result.length);
    }).then(function (formatted) {
      return {
        parsed: parsed,
        formatted: formatted,
        formattedMessage: formatted.join('\n')
      };
    });
  };

  return spawnIdeClient(body, options).then(parseResponse).then(formatResponse).then(function (_ref) {
    var parsed = _ref.parsed,
        formatted = _ref.formatted,
        formattedMessage = _ref.formattedMessage;

    if (parsed.resultType === 'success') {
      if (options.warnings && formattedMessage.length) {
        psModule.emitWarning(formattedMessage);
      }

      return psModule;
    } else if ((parsed.result || []).some(function (item) {
      var isModuleNotFound = item.errorCode === 'ModuleNotFound';

      var isUnknownModule = item.errorCode === 'UnknownModule';

      var isUnknownModuleImport = item.errorCode === 'UnknownName' && /Unknown module/.test(item.message);

      return isModuleNotFound || isUnknownModule || isUnknownModuleImport;
    })) {
      debug('module %s was not rebuilt because the module is unknown', psModule.name);

      return Promise.reject(new UnknownModuleError());
    } else {
      if (formattedMessage.length) {
        psModule.emitError(formattedMessage);
      }

      return psModule;
    }
  });
};