Refactoring promises to streams

Migrating back to a stream implementation for the tasks to allow
conventient piping with other streams such as `gulp.dest`.

Author: ethul

README.md

@@ -21,10 +21,10 @@ var gulp = require('gulp');
 
 var purescript = require('gulp-purescript');
 
-gulp.task('purescript', function(){
-  return gulp.src('src/**/*.purs').
-         pipe(purescript.psc({noPrelude: true})).
-         pipe(gulp.dest('build'));
+gulp.task('psc', function(){
+  return purescript.psc({
+    src: 'src/*.purs'
+  });
 });
 ```
 
@@ -38,11 +38,11 @@ Invokes the `psc` command. The following options are supported.
 
 ###### `src` (String or String Array)
 
-The location of the source files to compile. Glob syntax is supported.
+Files to compile. Glob syntax is supported.
 
 ###### `ffi` (String or String Array)
 
-Sets one or more `--ffi=<string>` that specifies files for code that is included with a `foreign import` in the PureScript source.
+Files for code that is included with a `foreign import` in the PureScript source. Glob syntax is supported.
 
 ###### `noTco` (Boolean)
 
@@ -78,7 +78,7 @@ Invokes the `psc-bundle` command. The following options are supported.
 
 ###### `src` (String or String Array)
 
-The location of the `psc`-produced javascript source files to bundle. Glob syntax is supported.
+The `psc`-produced JavaScript source files to bundle. Glob syntax is supported.
 
 ###### `output` (String)
 
@@ -98,7 +98,11 @@ Sets `--browser-namespace=<string>` that specifies the namespace that PureScript
 
 ### `purescript.pscDocs(options)`
 
-Invokes the `pscDocs` command. The following options are supported.
+Invokes the `psc-docs` command. The following options are supported.
+
+###### `src` (String or String Array)
+
+Files to be used for generating the documentation. Glob syntax is supported.
 
 ###### `format` (markdown | etags | ctags)
 
@@ -110,11 +114,19 @@ Sets `--docgen=...` that can be used to filter the modules documentation is gene
 
 - If a string value is provided, the documentation for that single module will be generated.
 - If a list of strings is provided, the documentation for all listed modules will be generated.
-- If an object with module name/filename pairs (for example, `{ Module: "docs/Module.md" }`) is provided, files will be written for each of the modules. In this mode, the task requires no `dest` as no value is returned.
+- If an object with module name/filename pairs (for example, `{ Module: 'docs/Module.md' }`) is provided, files will be written for each of the modules. In this mode, the task requires no `dest` as no value is returned.
+
+### `purescript.psci(options)`
+
+Generates a `.psci` file.
 
-### `purescript.dotPsci()`
+###### `src` (String or String Array)
+
+Files added to the `.psci` file with the `:m` command. Glob syntax is supported.
+
+###### `ffi` (String or String Array)
 
-Generates a `.psci` file in the current directory. Each source file is added with the `:m` command.
+Files added to the `.psci` file with the `:f` command. Glob syntax is supported.
 
 ## Command line arguments
 

entry.js

@@ -2,38 +2,20 @@
 
 var gulpPurescript = require('GulpPurescript.Plugin');
 
-var Promise = require('promise');
-
-function promisify(aff) {
-  return new Promise(function(resolve, reject){
-    var errback = function(error){
-      return function(){
-        reject(error);
-      };
-    };
-    var callback = function(result){
-      return function(){
-        resolve(result);
-      };
-    };
-    aff(errback)(callback)();
-  });
-}
-
 function psc(options) {
-  return promisify(gulpPurescript.psc(options));
+  return gulpPurescript.psc(options)();
 }
 
 function pscBundle(options) {
-  return promisify(gulpPurescript.pscBundle(options));
+  return gulpPurescript.pscBundle(options)();
 }
 
 function pscDocs(options) {
-  return promisify(gulpPurescript.pscDocs(options));
+  return gulpPurescript.pscDocs(options)();
 }
 
 function psci(options) {
-  return promisify(gulpPurescript.psci(options));
+  return gulpPurescript.psci(options)();
 }
 
 module.exports.psc = psc;

package.json

@@ -35,7 +35,6 @@
     "gulp-util": "^3.0.4",
     "logalot": "^2.1.0",
     "minimist": "^1.1.1",
-    "promise": "^7.0.3",
     "resolve-bin": "^0.3.0",
     "which": "^1.0.9"
   },

src/FS.purs

@@ -8,7 +8,7 @@ module GulpPurescript.Plugin
   , psci
   ) where
 
-import Control.Monad.Aff (Aff(), runAff)
+import Control.Monad.Aff (Aff())
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Class (liftEff)
 import Control.Monad.Eff.Exception (Error())
@@ -26,7 +26,6 @@ import Data.Tuple.Nested (tuple2)
 
 import GulpPurescript.Buffer (Buffer(), mkBufferFromString)
 import GulpPurescript.ChildProcess (ChildProcess(), spawn)
-import GulpPurescript.FS (FS(), writeFile)
 import GulpPurescript.Glob (Glob(), globAll)
 import GulpPurescript.GulpUtil (File(), mkFile, mkPluginError)
 import GulpPurescript.Logalot (Logalot(), info)
@@ -36,7 +35,7 @@ import GulpPurescript.Options (Psci(..), pscOptions, pscBundleOptions, pscDocsOp
 import GulpPurescript.Package (Pkg(), Package(..), package)
 import GulpPurescript.Path (relative)
 import GulpPurescript.ResolveBin (ResolveBin(), resolveBin)
-import GulpPurescript.Stream (Stream(), ReadableStream(), mkReadableStreamFromBuffer)
+import GulpPurescript.Stream (Stream(), ReadableStream(), mkReadableStreamFromAff)
 import GulpPurescript.Which (Which(), which)
 
 newtype Argv = Argv { verbose :: Boolean }
@@ -46,7 +45,6 @@ instance isForeignArgv :: IsForeign Argv where
 
 type Effects eff =
   ( cp :: ChildProcess
-  , fs :: FS
   , glob :: Glob
   , logalot :: Logalot
   , os :: OS
@@ -110,42 +108,41 @@ execute cmd args = do
   result <- spawn cmd' args'
   return result
 
-psc :: forall eff. Foreign -> Errorback eff -> Callback eff Unit -> Eff (Effects eff) Unit
-psc opts eb cb = runAff eb cb $ do
+psc :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream Unit)
+psc opts = mkReadableStreamFromAff $ do
   output <- either (throwPluginError <<< show)
                    (execute pscCommand)
                    (pscOptions opts)
   if isVerbose
     then liftEff $ info $ pscCommand ++ "\n" ++ output
     else pure unit
 
-pscBundle :: forall eff. Foreign -> Errorback eff -> Callback eff (ReadableStream Buffer) -> Eff (Effects eff) Unit
-pscBundle opts eb cb = runAff eb cb (either (throwPluginError <<< show) run (pscBundleOptions opts))
+pscBundle :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
+pscBundle opts = mkReadableStreamFromAff (either (throwPluginError <<< show) run (pscBundleOptions opts))
   where
-    run :: [String] -> Aff (Effects eff) (ReadableStream Buffer)
-    run args = do
-      bundle <- execute pscBundleCommand args
-      liftEff (mkReadableStreamFromBuffer (mkBufferFromString bundle))
+    run :: [String] -> Aff (Effects eff) File
+    run args = mkFile "." <$> mkBufferFromString
+                          <$> execute pscBundleCommand args
 
-pscDocs :: forall eff. Foreign -> Errorback eff -> Callback eff File -> Eff (Effects eff) Unit
-pscDocs opts eb cb = runAff eb cb (either (throwPluginError <<< show) run (pscDocsOptions opts))
+pscDocs :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
+pscDocs opts = mkReadableStreamFromAff (either (throwPluginError <<< show) run (pscDocsOptions opts))
   where
     run :: [String] -> Aff (Effects eff) File
     run args = mkFile "." <$> mkBufferFromString
                           <$> execute pscDocsCommand args
 
-psci :: forall eff. Foreign -> Errorback eff -> Callback eff Unit -> Eff (Effects eff) Unit
-psci opts eb cb = runAff eb cb (either (throwPluginError <<< show) write (read opts))
+psci :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
+psci opts = mkReadableStreamFromAff (either (throwPluginError <<< show) run (read opts))
   where
-    write :: Psci -> Aff (Effects eff) Unit
-    write (Psci a) = do
+    run :: Psci -> Aff (Effects eff) File
+    run (Psci a) = do
       srcs <- globAll (either pure id a.src)
       ffis <- globAll (either pure id (fromMaybe (Right []) (runNullOrUndefined a.ffi)))
 
-      let srcLines = joinWith "\n" (loadModule <$> concat srcs)
-          ffiLines = joinWith "\n" (loadForeign <$> concat ffis)
+      let lines = (loadModule <$> concat srcs) <> (loadForeign <$> concat ffis)
+          buffer = mkBufferFromString (joinWith "\n" lines)
 
-      writeFile psciFilename (srcLines ++ ffiLines)
+      return (mkFile psciFilename buffer)
 
     loadModule :: String -> String
     loadModule a = psciLoadModuleCommand ++ " " ++ relative cwd a

src/Plugin.purs

@@ -1,30 +1,56 @@
 module GulpPurescript.Stream
   ( Stream()
   , ReadableStream()
-  , mkReadableStreamFromBuffer
+  , mkReadableStreamFromAff
   ) where
 
+import Control.Monad.Aff (Aff(), runAff)
 import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Exception (Error())
 
-import GulpPurescript.Buffer (Buffer())
+import Data.Function
 
 foreign import data Stream :: !
 
-data ReadableStream o
+data ReadableStream out
 
-foreign import mkReadableStreamFromBuffer """
-function mkReadableStreamFromBuffer(buffer) {
+type RunAff eff a = (Error -> Eff eff Unit) -> (a -> Eff eff Unit) -> Aff eff a -> Eff eff Unit
+
+mkReadableStreamFromAff :: forall eff1 eff2 out. Aff eff1 out -> Eff (stream :: Stream | eff2) (ReadableStream out)
+mkReadableStreamFromAff = runFn2 mkReadableStreamFromAffFn runAff
+
+foreign import mkReadableStreamFromAffFn """
+function mkReadableStreamFromAffFn(runAff, aff) {
   return function(){
-    var Readable = require('stream').Readable;
+    var stream = require('stream');
 
-    var stream = Readable();
+    var objectMode = true;
 
-    stream._read = function(){
-      stream.push(buffer);
-      return stream.push(null);
+    var readable = new stream.Readable({objectMode: objectMode});
+
+    readable._read = function(){
     };
 
-    return stream;
+    function onError(e) {
+      return function(){
+        readable.emit('error', e);
+      };
+    }
+
+    function onSuccess(a) {
+      return function(){
+        readable.push(a);
+        readable.push(null);
+      };
+    }
+
+    var eff = runAff(onError)(onSuccess)(aff);
+
+    eff();
+
+    return readable;
   };
 }
-""" :: forall eff. Buffer -> Eff (stream :: Stream | eff) (ReadableStream Buffer)
+""" :: forall eff1 eff2 out. Fn2 (RunAff eff1 out)
+                                 (Aff eff1 out)
+                                 (Eff (stream :: Stream | eff2) (ReadableStream out))