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 => {
 143             const isUnknownModule = item.errorCode === 'UnknownModule';
 144
 145             const isUnknownModuleImport = item.errorCode === 'UnknownName' && /Unknown module/.test(item.message);
 146
 147             return isUnknownModule || isUnknownModuleImport;
 148           })) {
 149             debug('unknown module, attempting full recompile')
 150             return Psc.compile(psModule)
 151               .then(() => PsModuleMap.makeMap(options.src).then(map => {
 152                 debug('rebuilt module map');
 153                 cache.psModuleMap = map;
 154               }))
 155               .then(() => request({ command: 'load' }))
 156               .then(resolve)
 157               .catch(() => resolve(psModule))
 158           }
 159           const errorMessage = compileMessages.join('\n');
 160           if (errorMessage.length) {
 161             psModule.emitError(errorMessage);
 162           }
 163           resolve(psModule);
 164         } else {
 165           const warningMessage = compileMessages.join('\n');
 166           if (options.warnings && warningMessage.length) {
 167             psModule.emitWarning(warningMessage);
 168           }
 169           resolve(psModule);
 170         }
 171       })
 172     })
 173
 174     ideClient.stdin.write(JSON.stringify(body))
 175     ideClient.stdin.write('\n')
 176   })
 177
 178   return request({
 179     command: 'rebuild',
 180     params: {
 181       file: psModule.srcPath,
 182     }
 183   })
 184 }
 185 module.exports.rebuild = rebuild;
 186
 187 function formatIdeResult(result, options, index, length) {
 188   let numAndErr = `[${index+1}/${length} ${result.errorCode}]`
 189   numAndErr = options.pscIdeColors ? colors.yellow(numAndErr) : numAndErr
 190
 191   function makeResult() {
 192     return Promise.resolve(`\n${numAndErr} ${result.message}`)
 193   }
 194
 195   function makeResultSnippet(filename, pos) {
 196     const srcPath = path.relative(options.context, filename);
 197     const fileAndPos = `${srcPath}:${pos.startLine}:${pos.startColumn}`
 198
 199     return fs.readFileAsync(filename, 'utf8').then(source => {
 200       const lines = source.split('\n').slice(pos.startLine - 1, pos.endLine)
 201       const endsOnNewline = pos.endColumn === 1 && pos.startLine !== pos.endLine
 202       const up = options.pscIdeColors ? colors.red('^') : '^'
 203       const down = options.pscIdeColors ? colors.red('v') : 'v'
 204       let trimmed = lines.slice(0)
 205
 206       if (endsOnNewline) {
 207         lines.splice(lines.length - 1, 1)
 208         pos.endLine = pos.endLine - 1
 209         pos.endColumn = lines[lines.length - 1].length || 1
 210       }
 211
 212       // strip newlines at the end
 213       if (endsOnNewline) {
 214         trimmed = lines.reverse().reduce((trimmed, line, i) => {
 215           if (i === 0 && line === '') trimmed.trimming = true
 216           if (!trimmed.trimming) trimmed.push(line)
 217           if (trimmed.trimming && line !== '') {
 218             trimmed.trimming = false
 219             trimmed.push(line)
 220           }
 221           return trimmed
 222         }, []).reverse()
 223         pos.endLine = pos.endLine - (lines.length - trimmed.length)
 224         pos.endColumn = trimmed[trimmed.length - 1].length || 1
 225       }
 226
 227       const spaces = ' '.repeat(String(pos.endLine).length)
 228       let snippet = trimmed.map((line, i) => {
 229         return `  ${pos.startLine + i}  ${line}`
 230       }).join('\n')
 231
 232       if (trimmed.length === 1) {
 233         snippet += `\n  ${spaces}  ${' '.repeat(pos.startColumn - 1)}${up.repeat(pos.endColumn - pos.startColumn + 1)}`
 234       } else {
 235         snippet = `  ${spaces}  ${' '.repeat(pos.startColumn - 1)}${down}\n${snippet}`
 236         snippet += `\n  ${spaces}  ${' '.repeat(pos.endColumn - 1)}${up}`
 237       }
 238
 239       return Promise.resolve(`\n${numAndErr} ${fileAndPos}\n\n${snippet}\n\n${result.message}`)
 240     })
 241   }
 242
 243   return result.filename && result.position ? makeResultSnippet(result.filename, result.position) : makeResult();
 244 }