Propagating option parsing errors

When an option is provided with an invalid type of value, the error is
propagated upwards as a plugin error.

Resolves #31

Author: ethul

src/Options.purs

@@ -263,18 +263,17 @@ foldPscOptions (Psc a) = mkBoolean noPreludeOpt a.noPrelude <>
                          mkBoolean noPrefixOpt a.noPrefix <>
                          mkPathArray ffiOpt a.ffi
 
-pscOptions :: Foreign -> [String]
-pscOptions opts = either (const []) foldPscOptions parsed
-  where parsed = read opts :: F Psc
+pscOptions :: Foreign -> Either ForeignError [String]
+pscOptions opts = foldPscOptions <$> (read opts :: F Psc)
 
-pscOptionsNoOutput :: Foreign -> Tuple (Maybe String) [String]
-pscOptionsNoOutput opts = either (const $ tuple2 Nothing []) fold parsed
+pscOptionsNoOutput :: Foreign -> Either ForeignError (Tuple (Maybe String) [String])
+pscOptionsNoOutput opts = fold <$> parsed
   where parsed = read opts :: F Psc
         fold (Psc a) = tuple2 (runNullOrUndefined a.output)
                               (foldPscOptions (Psc $ a { output = NullOrUndefined Nothing }))
 
-pscMakeOptions :: Foreign -> [String]
-pscMakeOptions opts = either (const []) fold parsed
+pscMakeOptions :: Foreign -> Either ForeignError [String]
+pscMakeOptions opts = fold <$> parsed
   where parsed = read opts :: F PscMake
         fold (PscMake a) = mkString outputOpt a.output <>
                            mkBoolean noPreludeOpt a.noPrelude <>
@@ -286,8 +285,8 @@ pscMakeOptions opts = either (const []) fold parsed
                            mkBoolean noPrefixOpt a.noPrefix <>
                            mkPathArray ffiOpt a.ffi
 
-pscDocsOptions :: Foreign -> [String]
-pscDocsOptions opts = either (const []) fold parsed
+pscDocsOptions :: Foreign -> Either ForeignError [String]
+pscDocsOptions opts = fold <$> parsed
   where parsed = read opts :: F PscDocs
         fold (PscDocs a) = mkFormat formatOpt a.format <>
                            mkDocgen docgenOpt a.docgen

src/Plugin.purs

@@ -12,6 +12,7 @@ import Control.Monad.Eff.Class (liftEff)
 import Control.Monad.Eff.Exception (Error())
 import Control.Monad.Error.Class (catchError, throwError)
 
+import Data.Either (Either(..), either)
 import Data.Foreign (Foreign())
 import Data.Foreign.Class (IsForeign, read, readProp)
 import Data.Maybe (Maybe(Just), maybe, fromMaybe)
@@ -72,8 +73,9 @@ foreign import cwd "var cwd = process.cwd();" :: String
 
 foreign import argv "var argv = process.argv.slice(2);" :: [String]
 
-pluginError :: forall eff. String -> Aff (Effects eff) Error
-pluginError msg = liftEff $ flip mkPluginError msg <$> (maybe "" (\(Package a) -> a.name)) <$> package
+throwPluginError :: forall eff. String -> Aff (Effects eff) _
+throwPluginError msg = liftEff (flip mkPluginError msg <$> (maybe "" (\(Package a) -> a.name))
+                                                       <$> package) >>= throwError
 
 resolve :: forall eff. String -> [String] -> Aff (Effects eff) (Tuple String [String])
 resolve cmd args = catchError primary fallback
@@ -90,9 +92,7 @@ resolve cmd args = catchError primary fallback
     fallback _ = (const $ tuple2 cmd args) <$> catchError (which cmd) mapError
 
     mapError :: Error -> Aff (Effects eff) String
-    mapError _ = pluginError ( "Failed to find " ++ cmd ++ ". " ++
-                               "Please ensure it is available on your system."
-                             ) >>= throwError
+    mapError _ = throwPluginError ("Failed to find " ++ cmd ++ ". " ++ "Please ensure it is available on your system.")
 
 execute :: forall eff. String -> [String] -> Aff (Effects eff) String
 execute cmd args = do
@@ -103,30 +103,35 @@ execute cmd args = do
 pathsStream :: forall eff. Eff (through2 :: Through2 | eff) (Stream File [String])
 pathsStream = accStream run
   where run i = if fileIsStream i
-                   then pluginError "Streaming is not supported" >>= throwError
+                   then throwPluginError "Streaming is not supported"
                    else pure $ filePath i
 
 psc :: forall eff. Foreign -> Eff (Effects eff) (Stream File File)
 psc opts = multipipe2 <$> pathsStream <*> objStream run
   where run i = case pscOptionsNoOutput opts of
-                     Tuple out opt ->
+                     Left e -> throwPluginError (show e)
+                     Right (Tuple out opt) ->
                      mkFile (fromMaybe pscOutputDefault out) <$> mkBufferFromString
                                                              <$> execute pscCommand (i <> opt)
 
 pscMake :: forall eff. Foreign -> Eff (Effects eff) (Stream File Unit)
 pscMake opts = multipipe2 <$> pathsStream <*> objStream run
-  where run i = do output <- execute pscMakeCommand (i <> pscMakeOptions opts)
+  where run i = do output <- either (throwPluginError <<< show)
+                                    (\a -> execute pscMakeCommand (i <> a))
+                                    (pscMakeOptions opts)
                    if isVerbose
                       then liftEff $ info $ pscMakeCommand ++ "\n" ++ output
                       else pure unit
 
 pscDocs :: forall eff. Foreign -> Eff (Effects eff) (Stream File File)
 pscDocs opts = multipipe2 <$> pathsStream <*> objStream run
-  where run i = mkFile "." <$> mkBufferFromString
-                           <$> execute pscDocsCommand (pscDocsOptions opts <> i)
+  where run i = case pscDocsOptions opts of
+                     Left e -> throwPluginError (show e)
+                     Right a-> mkFile "." <$> mkBufferFromString
+                                          <$> execute pscDocsCommand (a <> i)
 
 dotPsci :: forall eff. Eff (Effects eff) (Stream File Unit)
 dotPsci = multipipe2 <$> objStream run <*> createWriteStream psciFilename
   where run i = if fileIsStream i
-                   then pluginError "Streaming is not supported" >>= throwError
+                   then throwPluginError "Streaming is not supported"
                    else pure $ psciLoadCommand ++ " " ++ relative cwd (filePath i) ++ "\n"

test.js

@@ -2,6 +2,8 @@
 
 var fs = require('fs');
 
+var path = require('path');
+
 var test = require('tape');
 
 var gulp = require('gulp');
@@ -58,6 +60,21 @@ test('psc - failure', function(t){
   });
 });
 
+test('psc - invalid option type', function(t){
+  t.plan(2);
+
+  var fixture = 'Fixture1.purs';
+
+  var moduleName = path.basename(fixture, '.purs');
+
+  var stream  = purescript.psc({noPrelude: true, module: moduleName});
+
+  gulp.src(fixture).pipe(stream).
+                    on('error', function(e){
+    t.ok(/type mismatch/i.test(e.message), 'should have a failure message');
+    t.equal('Error', e.name);
+  });
+});
 
 test('psci - basic', function(t){
   t.plan(1);
@@ -111,3 +128,17 @@ test('psc-make - error', function(t){
     t.equal('Error', e.name);
   });
 });
+
+test('psc-make - invalid option type', function(t){
+  t.plan(2);
+
+  var stream = purescript.pscMake({noPrelude: 'invalid'});
+
+  var fixture = 'Fixture1.purs';
+
+  gulp.src(fixture).pipe(stream).
+                    on('error', function(e){
+    t.ok(/type mismatch/i.test(e.message), 'should have a failure message');
+    t.equal('Error', e.name);
+  });
+});