5 files changed, 190 insertions, 71 deletions

diff --git a/src/PsModuleMap.js b/src/PsModuleMap.js
index 2193f02..0ae687c 100644
--- a/src/PsModuleMap.js
+++ b/src/PsModuleMap.js
@@ -8,15 +8,23 @@ const fs = Promise.promisifyAll(require('fs'));
 
 const globby = require('globby');
 
-const debug = require('debug')('purs-loader')
+const debug = require('debug')('purs-loader');
 
-const srcModuleRegex = /(?:^|\n)module\s+([\w\.]+)/i
+const srcModuleRegex = /(?:^|\n)module\s+([\w\.]+)/i;
 
-function match(str) {
+const importModuleRegex = /(?:^|\n)\s*import\s+([\w\.]+)/ig;
+
+function matchModule(str) {
   const matches = str.match(srcModuleRegex);
   return matches && matches[1];
 }
-module.exports.match = match;
+module.exports.match = matchModule;
+
+function matchImports(str) {
+  const matches = str.match(importModuleRegex);
+  return (matches || []).map(a => a.replace(/\n?\s*import\s+/i, ''));
+}
+module.exports.matchImports = matchImports;
 
 function makeMapEntry(filePurs) {
   const dirname = path.dirname(filePurs);
@@ -33,7 +41,9 @@ function makeMapEntry(filePurs) {
 
     const sourceJs = fileMap.fileJs;
 
-    const moduleName = match(sourcePurs);
+    const moduleName = matchModule(sourcePurs);
+
+    const imports = matchImports(sourcePurs);
 
     const map = {};
 
@@ -41,6 +51,8 @@ function makeMapEntry(filePurs) {
 
     map[moduleName].src = path.resolve(filePurs);
 
+    map[moduleName].imports = imports;
+
     if (sourceJs) {
       map[moduleName].ffi = path.resolve(fileJs);
     }
diff --git a/src/Psc.js b/src/Psc.js
index 4991d5f..ffa32b7 100644
--- a/src/Psc.js
+++ b/src/Psc.js
@@ -45,7 +45,12 @@ function compile(psModule) {
         if (errorMessage.length) {
           psModule.emitError(errorMessage);
         }
-        reject(new Error('compilation failed'))
+        if (options.watch) {
+          resolve(psModule);
+        }
+        else {
+          reject(new Error('compilation failed'))
+        }
       } else {
         const warningMessage = stderr.join('');
         if (options.warnings && warningMessage.length) {
diff --git a/src/PscIde.js b/src/PscIde.js
index 8a0e823..b164dc2 100644
--- a/src/PscIde.js
+++ b/src/PscIde.js
@@ -63,15 +63,28 @@ function connect(psModule) {
 
   const serverArgs = dargs(Object.assign({
     outputDirectory: options.output,
-    "_": options.src
+    '_': options.src
   }, options.pscIdeServerArgs))
 
   debug('attempting to start psc-ide-server', serverArgs)
 
   const ideServer = cache.ideServer = spawn('psc-ide-server', serverArgs)
+
+  ideServer.stdout.on('data', data => {
+    debug('psc-ide-server stdout: %s', data.toString());
+  });
+
   ideServer.stderr.on('data', data => {
-    debug(data.toString())
-  })
+    debug('psc-ide-server stderr: %s', data.toString());
+  });
+
+  ideServer.on('error', error => {
+    debug('psc-ide-server error: %o', error);
+  });
+
+  ideServer.on('close', (code, signal) => {
+    debug('psc-ide-server close: %s %s', code, signal);
+  });
 
   return retryPromise((retry, number) => {
     return connect_().catch(error => {
@@ -150,7 +163,7 @@ function rebuild(psModule) {
             debug('unknown module, attempting full recompile')
             return Psc.compile(psModule)
               .then(() => PsModuleMap.makeMap(options.src).then(map => {
-                debug('rebuilt module map');
+                debug('rebuilt module map after unknown module forced a recompile');
                 cache.psModuleMap = map;
               }))
               .then(() => request({ command: 'load' }))
@@ -172,6 +185,8 @@ function rebuild(psModule) {
       })
     })
 
+    debug('psc-ide-client stdin: %o', body);
+
     ideClient.stdin.write(JSON.stringify(body))
     ideClient.stdin.write('\n')
   })
diff --git a/src/index.js b/src/index.js
index 249f472..6fb2fce 100644
--- a/src/index.js
+++ b/src/index.js
@@ -3,18 +3,15 @@
 const debug = require('debug')('purs-loader')
 const loaderUtils = require('loader-utils')
 const Promise = require('bluebird')
-const fs = Promise.promisifyAll(require('fs'))
 const path = require('path')
-const jsStringEscape = require('js-string-escape')
 const PsModuleMap = require('./PsModuleMap');
 const Psc = require('./Psc');
 const PscIde = require('./PscIde');
+const toJavaScript = require('./to-javascript');
 const dargs = require('./dargs');
 const spawn = require('cross-spawn').sync
 const eol = require('os').EOL
 
-const requireRegex = /require\(['"]\.\.\/([\w\.]+)['"]\)/g
-
 module.exports = function purescriptLoader(source, map) {
   const callback = this.async()
   const config = this.options
@@ -49,6 +46,7 @@ module.exports = function purescriptLoader(source, map) {
     bundleNamespace: 'PS',
     bundle: false,
     warnings: true,
+    watch: false,
     output: 'output',
     src: [
       path.join('src', '**', '*.purs'),
@@ -151,7 +149,7 @@ module.exports = function purescriptLoader(source, map) {
   if (!cache.compilationStarted) {
     return Psc.compile(psModule)
        .then(() => PsModuleMap.makeMap(options.src).then(map => {
-         debug('rebuilt module map');
+         debug('rebuilt module map after compile');
          cache.psModuleMap = map;
        }))
       .then(() => Promise.map(cache.deferred, psModule => {
@@ -164,59 +162,3 @@ module.exports = function purescriptLoader(source, map) {
       })
   }
 }
-
-function updatePsModuleMap(psModule) {
-  const options = psModule.options
-  const cache = psModule.cache
-  const filePurs = psModule.srcPath
-  if (!cache.psModuleMap) {
-    debug('module mapping does not exist');
-    return PsModuleMap.makeMap(options.src).then(map => {
-      cache.psModuleMap = map;
-      return cache.psModuleMap;
-    });
-  }
-  else {
-    return PsModuleMap.makeMapEntry(filePurs).then(result => {
-      const map = Object.assign(cache.psModuleMap, result)
-      cache.psModuleMap = map;
-      return cache.psModuleMap;
-    });
-  }
-}
-
-// The actual loader is executed *after* purescript compilation.
-function toJavaScript(psModule) {
-  const options = psModule.options
-  const cache = psModule.cache
-  const bundlePath = path.resolve(options.bundleOutput)
-  const jsPath = cache.bundle ? bundlePath : psModule.jsPath
-
-  debug('loading JavaScript for', psModule.name)
-
-  return Promise.props({
-    js: fs.readFileAsync(jsPath, 'utf8'),
-    psModuleMap: updatePsModuleMap(psModule)
-  }).then(result => {
-    let js = ''
-
-    if (options.bundle) {
-      // if bundling, return a reference to the bundle
-      js = 'module.exports = require("'
-             + jsStringEscape(path.relative(psModule.srcDir, options.bundleOutput))
-             + '")["' + psModule.name + '"]'
-    } else {
-      // replace require paths to output files generated by psc with paths
-      // to purescript sources, which are then also run through this loader.
-      js = result.js
-        .replace(requireRegex, (m, p1) => {
-          return 'require("' + jsStringEscape(result.psModuleMap[p1].src) + '")'
-        })
-        .replace(/require\(['"]\.\/foreign['"]\)/g, (m, p1) => {
-          return 'require("' + jsStringEscape(result.psModuleMap[psModule.name].ffi) + '")'
-        })
-    }
-
-    return js
-  })
-}
diff --git a/src/to-javascript.js b/src/to-javascript.js
new file mode 100644
index 0000000..b402ad4
--- /dev/null
+++ b/src/to-javascript.js
@@ -0,0 +1,145 @@
+'use strict';
+
+const Promise = require('bluebird');
+
+const fs = Promise.promisifyAll(require('fs'));
+
+const path = require('path');
+
+const jsStringEscape = require('js-string-escape');
+
+const difference = require('lodash.difference');
+
+const debug = require('debug')('purs-loader');
+
+const PsModuleMap = require('./PsModuleMap');
+
+function updatePsModuleMap(psModule) {
+  const options = psModule.options;
+
+  const cache = psModule.cache;
+
+  const filePurs = psModule.srcPath;
+
+  if (!cache.psModuleMap) {
+    debug('module mapping does not exist');
+
+    return PsModuleMap.makeMap(options.src).then(map => {
+      cache.psModuleMap = map;
+      return cache.psModuleMap;
+    });
+  }
+  else {
+    return PsModuleMap.makeMapEntry(filePurs).then(result => {
+      const map = Object.assign(cache.psModuleMap, result);
+
+      cache.psModuleMap = map;
+
+      return cache.psModuleMap;
+    });
+  }
+}
+
+ // Reference the bundle.
+function makeBundleJS(psModule) {
+  const bundleOutput = psModule.options.bundleOutput;
+
+  const name = psModule.name;
+
+  const srcDir = psModule.srcDir;
+
+  const escaped = jsStringEscape(path.relative(srcDir, bundleOutput));
+
+  const result = `module.exports = require("${escaped}")["${name}"]`;
+
+  return result;
+}
+
+// Replace require paths to output files generated by psc with paths
+// to purescript sources, which are then also run through this loader.
+// Additionally, the imports replaced are tracked so that in the event
+// the compiler fails to compile the PureScript source, we can tack on
+// any new imports in order to allow webpack to watch the new files
+// before they have been successfully compiled.
+function makeJS(psModule, psModuleMap, js) {
+  const requireRE = /require\(['"]\.\.\/([\w\.]+)['"]\)/g;
+
+  const foreignRE = /require\(['"]\.\/foreign['"]\)/g;
+
+  const name = psModule.name;
+
+  const imports = psModuleMap[name].imports;
+
+  var replacedImports = [];
+
+  const result = js
+    .replace(requireRE, (m, p1) => {
+      const moduleValue = psModuleMap[p1];
+
+      if (!moduleValue) {
+        debug('module %s was not found in the map, replacing require with null', p1);
+
+        return 'null';
+      }
+      else {
+        const escapedPath = jsStringEscape(moduleValue.src);
+
+        replacedImports.push(p1);
+
+        return `require("${escapedPath}")`;
+      }
+    })
+    .replace(foreignRE, () => {
+      const escapedPath = jsStringEscape(psModuleMap[name].ffi);
+
+      return `require("${escapedPath}")`;
+    })
+  ;
+
+  const additionalImports = difference(imports, replacedImports);
+
+  if (additionalImports.length) {
+    debug('additional imports for %s: %o', name, additionalImports);
+  }
+
+  const additionalImportsResult = additionalImports.map(import_ => {
+    const moduleValue = psModuleMap[import_];
+
+    if (!moduleValue) {
+      debug('module %s was not found in the map, skipping require', import_);
+
+      return null;
+    }
+    else {
+      const escapedPath = jsStringEscape(moduleValue.src);
+
+      return `var ${import_.replace(/\./g, '_')} = require("${escapedPath}")`;
+    }
+  }).filter(a => a !== null).join('\n');
+
+  const result_ = result + (additionalImports.length ? '\n' + additionalImportsResult : '');
+
+  return result_;
+}
+
+module.exports = function toJavaScript(psModule) {
+  const options = psModule.options;
+
+  const cache = psModule.cache;
+
+  const bundlePath = path.resolve(options.bundleOutput);
+
+  const jsPath = cache.bundle ? bundlePath : psModule.jsPath;
+
+  const js = fs.readFileAsync(jsPath, 'utf8').catch(() => '');
+
+  const psModuleMap = updatePsModuleMap(psModule);
+
+  debug('loading JavaScript for %s', psModule.name);
+
+  return Promise.props({js: js, psModuleMap: psModuleMap}).then(result =>
+    options.bundle ?
+      makeBundleJS(psModule) :
+      makeJS(psModule, result.psModuleMap, result.js)
+  );
+};