src/index.js

   1 'use strict'
   2
   3 const debug_ = require('debug');
   4
   5 const debug = debug_('purs-loader');
   6
   7 const debugVerbose = debug_('purs-loader:verbose');
   8
   9 const loaderUtils = require('loader-utils')
  10
  11 const Promise = require('bluebird')
  12
  13 const path = require('path')
  14
  15 const PsModuleMap = require('./purs-module-map');
  16
  17 const compile = require('./compile');
  18
  19 const bundle = require('./bundle');
  20
  21 const ide = require('./ide');
  22
  23 const toJavaScript = require('./to-javascript');
  24
  25 const dargs = require('./dargs');
  26
  27 const spawn = require('cross-spawn').sync
  28
  29 const eol = require('os').EOL
  30
  31 module.exports = function purescriptLoader(source, map) {
  32   this.cacheable && this.cacheable();
  33
  34   const webpackConfig = this.options;
  35
  36   var cache = webpackConfig.purescriptLoaderCache = webpackConfig.purescriptLoaderCache || {
  37     rebuild: false,
  38     deferred: [],
  39     bundleModules: [],
  40     ideServer: null,
  41     psModuleMap: null,
  42     warnings: [],
  43     errors: [],
  44     compilationStarted: false,
  45     compilationFinished: false,
  46     installed: false,
  47     srcOption: []
  48   };
  49
  50   const callback = this.async();
  51
  52   const loaderOptions = loaderUtils.getOptions(this) || {};
  53
  54   const srcOption = (pscPackage => {
  55     const srcPath = path.join('src', '**', '*.purs');
  56
  57     const bowerPath = path.join('bower_components', 'purescript-*', 'src', '**', '*.purs');
  58
  59     if (cache.srcOption.length > 0) {
  60       return cache.srcOption;
  61     }
  62     else if (pscPackage) {
  63       const pscPackageCommand = 'psc-package';
  64
  65       const pscPackageArgs = ['sources'];
  66
  67       const loaderSrc = loaderOptions.src || [
  68         srcPath
  69       ];
  70
  71       debug('psc-package %s %o', pscPackageCommand, pscPackageArgs);
  72
  73       const cmd = spawn(pscPackageCommand, pscPackageArgs);
  74
  75       if (cmd.status !== 0) {
  76         const error = cmd.stdout.toString();
  77
  78         throw new Error(error);
  79       }
  80       else {
  81         const result = cmd.stdout.toString().split(eol).filter(v => v != '').concat(loaderSrc);
  82
  83         debug('psc-package result: %o', result);
  84
  85         cache.srcOption = result;
  86
  87         return result;
  88       }
  89     }
  90     else {
  91       const result = loaderOptions.src || [
  92         bowerPath,
  93         srcPath
  94       ];
  95
  96       cache.srcOption = result;
  97
  98       return result;
  99     }
 100   })(loaderOptions.pscPackage);
 101
 102   const options = Object.assign({
 103     context: webpackConfig.context,
 104     psc: null,
 105     pscArgs: {},
 106     pscBundle: null,
 107     pscBundleArgs: {},
 108     pscIde: false,
 109     pscIdeColors: loaderOptions.psc === 'psa',
 110     pscIdeArgs: {},
 111     pscPackage: false,
 112     bundleOutput: 'output/bundle.js',
 113     bundleNamespace: 'PS',
 114     bundle: false,
 115     warnings: true,
 116     watch: false,
 117     output: 'output',
 118     src: []
 119   }, loaderOptions, {
 120     src: srcOption
 121   });
 122
 123   if (!cache.installed) {
 124     debugVerbose('installing purs-loader with options: %O', options);
 125
 126     cache.installed = true;
 127
 128     // invalidate loader cache when bundle is marked as invalid (in watch mode)
 129     this._compiler.plugin('invalid', () => {
 130       debugVerbose('invalidating loader cache');
 131
 132       cache = webpackConfig.purescriptLoaderCache = {
 133         rebuild: options.pscIde,
 134         deferred: [],
 135         bundleModules: [],
 136         ideServer: cache.ideServer,
 137         psModuleMap: cache.psModuleMap,
 138         warnings: [],
 139         errors: [],
 140         compilationStarted: false,
 141         compilationFinished: false,
 142         installed: cache.installed,
 143         srcOption: cache.srcOption
 144       };
 145     });
 146
 147     // add psc warnings to webpack compilation warnings
 148     this._compiler.plugin('after-compile', (compilation, callback) => {
 149       cache.warnings.forEach(warning => {
 150         compilation.warnings.push(warning);
 151       });
 152
 153       cache.errors.forEach(error => {
 154         compilation.errors.push(error);
 155       });
 156
 157       callback()
 158     });
 159   }
 160
 161   const psModuleName = PsModuleMap.matchModule(source);
 162
 163   const psModule = {
 164     name: psModuleName,
 165     load: js => callback(null, js),
 166     reject: error => callback(error),
 167     srcPath: this.resourcePath,
 168     srcDir: path.dirname(this.resourcePath),
 169     jsPath: path.resolve(path.join(options.output, psModuleName, 'index.js')),
 170     options: options,
 171     cache: cache,
 172     emitWarning: warning => {
 173       if (options.warnings && warning.length) {
 174         cache.warnings.push(warning);
 175       }
 176     },
 177     emitError: error => {
 178       if (error.length) {
 179         cache.errors.push(error);
 180       }
 181     }
 182   }
 183
 184   debug('loading %s', psModule.name);
 185
 186   if (options.bundle) {
 187     cache.bundleModules.push(psModule.name);
 188   }
 189
 190   if (cache.rebuild) {
 191     const connect = () => {
 192       if (!cache.ideServer) {
 193         cache.ideServer = true;
 194
 195         return ide.connect(psModule)
 196           .then(ideServer => {
 197             cache.ideServer = ideServer;
 198             return psModule;
 199           })
 200           .then(ide.loadWithRetry)
 201           .catch(error => {
 202             if (cache.ideServer.kill) {
 203               debug('ide failed to initially load modules, stopping the ide server process');
 204
 205               cache.ideServer.kill();
 206             }
 207
 208             cache.ideServer = null;
 209
 210             return Promise.reject(error);
 211           })
 212         ;
 213       }
 214       else {
 215         return Promise.resolve(psModule);
 216       }
 217     };
 218
 219     const rebuild = () =>
 220       ide.rebuild(psModule)
 221       .then(() =>
 222         toJavaScript(psModule)
 223           .then(psModule.load)
 224           .catch(psModule.reject)
 225       )
 226       .catch(error => {
 227         if (error instanceof ide.UnknownModuleError) {
 228           // Store the modules that trigger a recompile due to an
 229           // unknown module error. We need to wait until compilation is
 230           // done before loading these files.
 231
 232           cache.deferred.push(psModule);
 233
 234           if (!cache.compilationStarted) {
 235             cache.compilationStarted = true;
 236
 237             return compile(psModule)
 238               .then(() => {
 239                 cache.compilationFinished = true;
 240               })
 241               .then(() =>
 242                 PsModuleMap.makeMap(options.src).then(map => {
 243                   debug('rebuilt module map after unknown module forced a recompilation');
 244
 245                   cache.psModuleMap = map;
 246                 })
 247               )
 248               .then(() =>
 249                 Promise.map(cache.deferred, psModule =>
 250                   ide.load(psModule)
 251                     .then(() => toJavaScript(psModule))
 252                     .then(psModule.load)
 253                 )
 254               )
 255               .catch(error => {
 256                 cache.deferred[0].reject(error);
 257
 258                 cache.deferred.slice(1).forEach(psModule => {
 259                   psModule.reject(new Error('purs-loader failed'));
 260                 })
 261               })
 262             ;
 263           }
 264           else {
 265             // The compilation has started. We must wait until it is
 266             // done in order to ensure the module map contains all of
 267             // the unknown modules.
 268           }
 269         }
 270         else {
 271           debug('ide rebuild failed due to an unhandled error: %o', error);
 272
 273           psModule.reject(error);
 274         }
 275       })
 276     ;
 277
 278     connect().then(rebuild);
 279   }
 280   else if (cache.compilationFinished) {
 281     debugVerbose('compilation is already finished, loading module %s', psModule.name);
 282
 283     toJavaScript(psModule)
 284       .then(psModule.load)
 285       .catch(psModule.reject);
 286   }
 287   else {
 288     // The compilation has not finished yet. We need to wait for
 289     // compilation to finish before the loaders run so that references
 290     // to compiled output are valid. Push the modules into the cache to
 291     // be loaded once the complation is complete.
 292
 293     cache.deferred.push(psModule);
 294
 295     if (!cache.compilationStarted) {
 296       cache.compilationStarted = true;
 297
 298       compile(psModule)
 299         .then(() => {
 300           cache.compilationFinished = true;
 301         })
 302         .then(() => {
 303           if (options.bundle) {
 304             return bundle(options, cache.bundleModules);
 305           }
 306         })
 307         .then(() =>
 308           PsModuleMap.makeMap(options.src).then(map => {
 309             debug('rebuilt module map after compilation');
 310
 311             cache.psModuleMap = map;
 312           })
 313         )
 314         .then(() =>
 315           Promise.map(cache.deferred, psModule =>
 316             toJavaScript(psModule)
 317               .then(psModule.load)
 318           )
 319         )
 320         .catch(error => {
 321           cache.deferred[0].reject(error);
 322
 323           cache.deferred.slice(1).forEach(psModule => {
 324             psModule.reject(new Error('purs-loader failed'));
 325           })
 326         })
 327       ;
 328     }
 329     else {
 330       // The complation has started. Nothing to do but wait until it is
 331       // done before loading all of the modules.
 332     }
 333   }
 334 }