src/PscIde.js

   1 'use strict';
   2
   3 const path = require('path');
   4
   5 const Promise = require('bluebird');
   6
   7 const fs = Promise.promisifyAll(require('fs'));
   8
   9 const retryPromise = require('promise-retry');
  10
  11 const spawn = require('cross-spawn');
  12
  13 const colors = require('chalk');
  14
  15 const debug = require('debug')('purs-loader');
  16
  17 const dargs = require('./dargs');
  18
  19 const Psc = require('./Psc');
  20
  21 const PsModuleMap = require('./PsModuleMap');
  22
  23 function connect(psModule) {
  24   const options = psModule.options
  25   const cache = psModule.cache
  26
  27   if (cache.ideServer) return Promise.resolve(psModule)
  28
  29   cache.ideServer = true
  30
  31   const connect_ = () => new Promise((resolve, reject) => {
  32     const args = dargs(options.pscIdeArgs)
  33
  34     debug('attempting to connect to psc-ide-server', args)
  35
  36     const ideClient = spawn('psc-ide-client', args)
  37
  38     ideClient.stderr.on('data', data => {
  39       debug(data.toString())
  40       cache.ideServer = false
  41       reject(new Error('psc-ide-client failed'))
  42     })
  43     ideClient.stdout.once('data', data => {
  44       debug(data.toString())
  45       if (data.toString()[0] === '{') {
  46         const res = JSON.parse(data.toString())
  47         if (res.resultType === 'success') {
  48           cache.ideServer = ideServer
  49           resolve(psModule)
  50         } else {
  51           cache.ideServer = ideServer
  52           reject(new Error('psc-ide-client failed'))
  53         }
  54       } else {
  55         cache.ideServer = false
  56         reject(new Error('psc-ide-client failed'))
  57       }
  58     })
  59     ideClient.stdin.resume()
  60     ideClient.stdin.write(JSON.stringify({ command: 'load' }))
  61     ideClient.stdin.write('\n')
  62   })
  63
  64   const serverArgs = dargs(Object.assign({
  65     outputDirectory: options.output,
  66     '_': options.src
  67   }, options.pscIdeServerArgs))
  68
  69   debug('attempting to start psc-ide-server', serverArgs)
  70
  71   const ideServer = cache.ideServer = spawn('psc-ide-server', serverArgs)
  72
  73   ideServer.stdout.on('data', data => {
  74     debug('psc-ide-server stdout: %s', data.toString());
  75   });
  76
  77   ideServer.stderr.on('data', data => {
  78     debug('psc-ide-server stderr: %s', data.toString());
  79   });
  80
  81   ideServer.on('error', error => {
  82     debug('psc-ide-server error: %o', error);
  83   });
  84
  85   ideServer.on('close', (code, signal) => {
  86     debug('psc-ide-server close: %s %s', code, signal);
  87   });
  88
  89   return retryPromise((retry, number) => {
  90     return connect_().catch(error => {
  91       if (!cache.ideServer && number === 9) {
  92         debug(error)
  93
  94         console.warn('Failed to connect to or start psc-ide-server. A full compilation will occur on rebuild');
  95
  96         return Promise.resolve(psModule)
  97       }
  98
  99       return retry(error)
 100     })
 101   }, {
 102     retries: 9,
 103     factor: 1,
 104     minTimeout: 333,
 105     maxTimeout: 333,
 106   })
 107 }
 108 module.exports.connect = connect;
 109
 110 function rebuild(psModule) {
 111   const options = psModule.options
 112   const cache = psModule.cache
 113
 114   debug('attempting rebuild with psc-ide-client %s', psModule.srcPath)
 115
 116   const request = (body) => new Promise((resolve, reject) => {
 117     const args = dargs(options.pscIdeArgs)
 118     const ideClient = spawn('psc-ide-client', args)
 119
 120     var stdout = ''
 121     var stderr = ''
 122
 123     ideClient.stdout.on('data', data => {
 124       stdout = stdout + data.toString()
 125     })
 126
 127     ideClient.stderr.on('data', data => {
 128       stderr = stderr + data.toString()
 129     })
 130
 131     ideClient.on('close', code => {
 132       if (code !== 0) {
 133         const error = stderr === '' ? 'Failed to spawn psc-ide-client' : stderr
 134         return reject(new Error(error))
 135       }
 136
 137       let res = null
 138
 139       try {
 140         res = JSON.parse(stdout.toString())
 141         debug(res)
 142       } catch (err) {
 143         return reject(err)
 144       }
 145
 146       if (res && !Array.isArray(res.result)) {
 147         return resolve(psModule);
 148       }
 149
 150       Promise.map(res.result, (item, i) => {
 151         debug(item)
 152         return formatIdeResult(item, options, i, res.result.length)
 153       })
 154       .then(compileMessages => {
 155         if (res.resultType === 'error') {
 156           if (res.result.some(item => {
 157             const isModuleNotFound = item.errorCode === 'ModuleNotFound';
 158
 159             const isUnknownModule = item.errorCode === 'UnknownModule';
 160
 161             const isUnknownModuleImport = item.errorCode === 'UnknownName' && /Unknown module/.test(item.message);
 162
 163             return isModuleNotFound || isUnknownModule || isUnknownModuleImport;
 164           })) {
 165             debug('unknown module, attempting full recompile')
 166             return Psc.compile(psModule)
 167               .then(() => PsModuleMap.makeMap(options.src).then(map => {
 168                 debug('rebuilt module map after unknown module forced a recompile');
 169                 cache.psModuleMap = map;
 170               }))
 171               .then(() => request({ command: 'load' }))
 172               .then(resolve)
 173               .catch(() => resolve(psModule))
 174           }
 175           const errorMessage = compileMessages.join('\n');
 176           if (errorMessage.length) {
 177             psModule.emitError(errorMessage);
 178           }
 179           resolve(psModule);
 180         } else {
 181           const warningMessage = compileMessages.join('\n');
 182           if (options.warnings && warningMessage.length) {
 183             psModule.emitWarning(warningMessage);
 184           }
 185           resolve(psModule);
 186         }
 187       })
 188     })
 189
 190     debug('psc-ide-client stdin: %o', body);
 191
 192     ideClient.stdin.write(JSON.stringify(body))
 193     ideClient.stdin.write('\n')
 194   })
 195
 196   return request({
 197     command: 'rebuild',
 198     params: {
 199       file: psModule.srcPath,
 200     }
 201   })
 202 }
 203 module.exports.rebuild = rebuild;
 204
 205 function formatIdeResult(result, options, index, length) {
 206   let numAndErr = `[${index+1}/${length} ${result.errorCode}]`
 207   numAndErr = options.pscIdeColors ? colors.yellow(numAndErr) : numAndErr
 208
 209   function makeResult() {
 210     return Promise.resolve(`\n${numAndErr} ${result.message}`)
 211   }
 212
 213   function makeResultSnippet(filename, pos) {
 214     const srcPath = path.relative(options.context, filename);
 215     const fileAndPos = `${srcPath}:${pos.startLine}:${pos.startColumn}`
 216
 217     return fs.readFileAsync(filename, 'utf8').then(source => {
 218       const lines = source.split('\n').slice(pos.startLine - 1, pos.endLine)
 219       const endsOnNewline = pos.endColumn === 1 && pos.startLine !== pos.endLine
 220       const up = options.pscIdeColors ? colors.red('^') : '^'
 221       const down = options.pscIdeColors ? colors.red('v') : 'v'
 222       let trimmed = lines.slice(0)
 223
 224       if (endsOnNewline) {
 225         lines.splice(lines.length - 1, 1)
 226         pos.endLine = pos.endLine - 1
 227         pos.endColumn = lines[lines.length - 1].length || 1
 228       }
 229
 230       // strip newlines at the end
 231       if (endsOnNewline) {
 232         trimmed = lines.reverse().reduce((trimmed, line, i) => {
 233           if (i === 0 && line === '') trimmed.trimming = true
 234           if (!trimmed.trimming) trimmed.push(line)
 235           if (trimmed.trimming && line !== '') {
 236             trimmed.trimming = false
 237             trimmed.push(line)
 238           }
 239           return trimmed
 240         }, []).reverse()
 241         pos.endLine = pos.endLine - (lines.length - trimmed.length)
 242         pos.endColumn = trimmed[trimmed.length - 1].length || 1
 243       }
 244
 245       const spaces = ' '.repeat(String(pos.endLine).length)
 246       let snippet = trimmed.map((line, i) => {
 247         return `  ${pos.startLine + i}  ${line}`
 248       }).join('\n')
 249
 250       if (trimmed.length === 1) {
 251         snippet += `\n  ${spaces}  ${' '.repeat(pos.startColumn - 1)}${up.repeat(pos.endColumn - pos.startColumn + 1)}`
 252       } else {
 253         snippet = `  ${spaces}  ${' '.repeat(pos.startColumn - 1)}${down}\n${snippet}`
 254         snippet += `\n  ${spaces}  ${' '.repeat(pos.endColumn - 1)}${up}`
 255       }
 256
 257       return Promise.resolve(`\n${numAndErr} ${fileAndPos}\n\n${snippet}\n\n${result.message}`)
 258     })
 259   }
 260
 261   return result.filename && result.position ? makeResultSnippet(result.filename, result.position) : makeResult();
 262 }