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   ideServer.stderr.on('data', data => {
  73     debug(data.toString())
  74   })
  75
  76   return retryPromise((retry, number) => {
  77     return connect_().catch(error => {
  78       if (!cache.ideServer && number === 9) {
  79         debug(error)
  80
  81         console.warn('Failed to connect to or start psc-ide-server. A full compilation will occur on rebuild');
  82
  83         return Promise.resolve(psModule)
  84       }
  85
  86       return retry(error)
  87     })
  88   }, {
  89     retries: 9,
  90     factor: 1,
  91     minTimeout: 333,
  92     maxTimeout: 333,
  93   })
  94 }
  95 module.exports.connect = connect;
  96
  97 function rebuild(psModule) {
  98   const options = psModule.options
  99   const cache = psModule.cache
 100
 101   debug('attempting rebuild with psc-ide-client %s', psModule.srcPath)
 102
 103   const request = (body) => new Promise((resolve, reject) => {
 104     const args = dargs(options.pscIdeArgs)
 105     const ideClient = spawn('psc-ide-client', args)
 106
 107     var stdout = ''
 108     var stderr = ''
 109
 110     ideClient.stdout.on('data', data => {
 111       stdout = stdout + data.toString()
 112     })
 113
 114     ideClient.stderr.on('data', data => {
 115       stderr = stderr + data.toString()
 116     })
 117
 118     ideClient.on('close', code => {
 119       if (code !== 0) {
 120         const error = stderr === '' ? 'Failed to spawn psc-ide-client' : stderr
 121         return reject(new Error(error))
 122       }
 123
 124       let res = null
 125
 126       try {
 127         res = JSON.parse(stdout.toString())
 128         debug(res)
 129       } catch (err) {
 130         return reject(err)
 131       }
 132
 133       if (res && !Array.isArray(res.result)) {
 134         return resolve(psModule);
 135       }
 136
 137       Promise.map(res.result, (item, i) => {
 138         debug(item)
 139         return formatIdeResult(item, options, i, res.result.length)
 140       })
 141       .then(compileMessages => {
 142         if (res.resultType === 'error') {
 143           if (res.result.some(item => {
 144             const isUnknownModule = item.errorCode === 'UnknownModule';
 145
 146             const isUnknownModuleImport = item.errorCode === 'UnknownName' && /Unknown module/.test(item.message);
 147
 148             return isUnknownModule || isUnknownModuleImport;
 149           })) {
 150             debug('unknown module, attempting full recompile')
 151             return Psc.compile(psModule)
 152               .then(() => PsModuleMap.makeMap(options.src).then(map => {
 153                 debug('rebuilt module map');
 154                 cache.psModuleMap = map;
 155               }))
 156               .then(() => request({ command: 'load' }))
 157               .then(resolve)
 158               .catch(() => resolve(psModule))
 159           }
 160           const errorMessage = compileMessages.join('\n');
 161           if (errorMessage.length) {
 162             psModule.emitError(errorMessage);
 163           }
 164           resolve(psModule);
 165         } else {
 166           const warningMessage = compileMessages.join('\n');
 167           if (options.warnings && warningMessage.length) {
 168             psModule.emitWarning(warningMessage);
 169           }
 170           resolve(psModule);
 171         }
 172       })
 173     })
 174
 175     ideClient.stdin.write(JSON.stringify(body))
 176     ideClient.stdin.write('\n')
 177   })
 178
 179   return request({
 180     command: 'rebuild',
 181     params: {
 182       file: psModule.srcPath,
 183     }
 184   })
 185 }
 186 module.exports.rebuild = rebuild;
 187
 188 function formatIdeResult(result, options, index, length) {
 189   let numAndErr = `[${index+1}/${length} ${result.errorCode}]`
 190   numAndErr = options.pscIdeColors ? colors.yellow(numAndErr) : numAndErr
 191
 192   function makeResult() {
 193     return Promise.resolve(`\n${numAndErr} ${result.message}`)
 194   }
 195
 196   function makeResultSnippet(filename, pos) {
 197     const srcPath = path.relative(options.context, filename);
 198     const fileAndPos = `${srcPath}:${pos.startLine}:${pos.startColumn}`
 199
 200     return fs.readFileAsync(filename, 'utf8').then(source => {
 201       const lines = source.split('\n').slice(pos.startLine - 1, pos.endLine)
 202       const endsOnNewline = pos.endColumn === 1 && pos.startLine !== pos.endLine
 203       const up = options.pscIdeColors ? colors.red('^') : '^'
 204       const down = options.pscIdeColors ? colors.red('v') : 'v'
 205       let trimmed = lines.slice(0)
 206
 207       if (endsOnNewline) {
 208         lines.splice(lines.length - 1, 1)
 209         pos.endLine = pos.endLine - 1
 210         pos.endColumn = lines[lines.length - 1].length || 1
 211       }
 212
 213       // strip newlines at the end
 214       if (endsOnNewline) {
 215         trimmed = lines.reverse().reduce((trimmed, line, i) => {
 216           if (i === 0 && line === '') trimmed.trimming = true
 217           if (!trimmed.trimming) trimmed.push(line)
 218           if (trimmed.trimming && line !== '') {
 219             trimmed.trimming = false
 220             trimmed.push(line)
 221           }
 222           return trimmed
 223         }, []).reverse()
 224         pos.endLine = pos.endLine - (lines.length - trimmed.length)
 225         pos.endColumn = trimmed[trimmed.length - 1].length || 1
 226       }
 227
 228       const spaces = ' '.repeat(String(pos.endLine).length)
 229       let snippet = trimmed.map((line, i) => {
 230         return `  ${pos.startLine + i}  ${line}`
 231       }).join('\n')
 232
 233       if (trimmed.length === 1) {
 234         snippet += `\n  ${spaces}  ${' '.repeat(pos.startColumn - 1)}${up.repeat(pos.endColumn - pos.startColumn + 1)}`
 235       } else {
 236         snippet = `  ${spaces}  ${' '.repeat(pos.startColumn - 1)}${down}\n${snippet}`
 237         snippet += `\n  ${spaces}  ${' '.repeat(pos.endColumn - 1)}${up}`
 238       }
 239
 240       return Promise.resolve(`\n${numAndErr} ${fileAndPos}\n\n${snippet}\n\n${result.message}`)
 241     })
 242   }
 243
 244   return result.filename && result.position ? makeResultSnippet(result.filename, result.position) : makeResult();
 245 }