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