Splitting PSC functionality into a separate plugin

The loader creates shim modules that reference their corresponding
PureScript module that is bundled by the PureScript webpack plugin,
which invokes `psc` and `psc-bundle`.

Resolves #31 and resolves #32

1 files changed, 20 insertions, 112 deletions

diff --git a/src/PursLoader/Options.purs b/src/PursLoader/Options.purs
index 3657d1a..132096c 100644
--- a/src/PursLoader/Options.purs
+++ b/src/PursLoader/Options.purs
@@ -1,122 +1,30 @@
 module PursLoader.Options
-  ( pscOptions
-  , loaderSrcOption
-  , loaderFFIOption
-  , Options()
-  , output
+  ( Options()
+  , runOptions
   ) where
 
-import Prelude ((<>), (<$>), (<<<), (++), (<*>), ($), const, id)
+import Prelude ((<$>), (<<<), id)
 
-import Data.Array (concat)
-import Data.Either (either)
+import Data.Foreign.Class (IsForeign, readProp)
+import Data.Foreign.NullOrUndefined (runNullOrUndefined)
+import Data.Maybe (maybe)
 
-import Data.Foreign (Foreign())
-import Data.Foreign.Class (IsForeign, read, readProp)
-import Data.Foreign.NullOrUndefined (NullOrUndefined(..), runNullOrUndefined)
+import PursLoader.Path (joinPath)
 
-import Data.Maybe (Maybe(..), maybe, fromMaybe)
+newtype Options = Options { pscBundle :: String }
 
-noPreludeOpt :: String
-noPreludeOpt = "no-prelude"
+type Options_ = { pscBundle :: String }
 
-noOptsOpt :: String
-noOptsOpt = "no-opts"
-
-noMagicDoOpt :: String
-noMagicDoOpt = "no-magic-do"
-
-noTcoOpt :: String
-noTcoOpt = "no-tco"
-
-verboseErrorsOpt :: String
-verboseErrorsOpt = "verbose-errors"
-
-outputOpt :: String
-outputOpt = "output"
-
-commentsOpt :: String
-commentsOpt = "comments"
-
-noPrefixOpt :: String
-noPrefixOpt = "no-prefix"
-
-requirePathOpt :: String
-requirePathOpt = "require-path"
-
-srcOpt :: String
-srcOpt = "src"
-
-ffiOpt :: String
-ffiOpt = "ffi"
-
-newtype Options
-  = Options { noPrelude :: NullOrUndefined Boolean
-            , noOpts :: NullOrUndefined Boolean
-            , noMagicDo :: NullOrUndefined Boolean
-            , noTco :: NullOrUndefined Boolean
-            , verboseErrors :: NullOrUndefined Boolean
-            , comments :: NullOrUndefined Boolean
-            , output :: String
-            , noPrefix :: NullOrUndefined Boolean
-            , requirePath :: String
-            , src :: NullOrUndefined (Array String)
-            , ffi :: NullOrUndefined (Array String)
-            }
-
-output :: Options -> String
-output (Options o) = o.output
+runOptions :: Options -> Options_
+runOptions (Options options) = options
 
 instance isForeignOptions :: IsForeign Options where
-  read obj = Options <$> ({ noPrelude: _
-                          , noOpts: _
-                          , noMagicDo: _
-                          , noTco: _
-                          , verboseErrors: _
-                          , comments: _
-                          , output: _
-                          , noPrefix: _
-                          , requirePath: "../"
-                          , src: _
-                          , ffi: _
-                          } <$> readProp noPreludeOpt obj
-                            <*> readProp noOptsOpt obj
-                            <*> readProp noMagicDoOpt obj
-                            <*> readProp noTcoOpt obj
-                            <*> readProp verboseErrorsOpt obj
-                            <*> readProp commentsOpt obj
-                            <*> (maybe "output" id <<< runNullOrUndefined <$> readProp outputOpt obj)
-                            <*> readProp noPrefixOpt obj
-                            <*> readProp srcOpt obj
-                            <*> readProp ffiOpt obj)
-
-class LoaderOption a where
-  opt :: String -> NullOrUndefined a -> Array String
-
-instance booleanLoaderOption :: LoaderOption Boolean where
-  opt key val = maybe [] (\a -> if a then ["--" ++ key] else []) (runNullOrUndefined val)
-
-instance stringLoaderOption :: LoaderOption String where
-  opt key val = maybe [] (\a -> ["--" ++ key ++ "=" ++ a]) (runNullOrUndefined val)
-
-instance arrayLoaderOption :: (LoaderOption a) => LoaderOption (Array a) where
-  opt key val = concat (opt key <$> (NullOrUndefined <<< Just)
-                                <$> (fromMaybe [] (runNullOrUndefined val)))
-
-pscOptions :: Options -> Array String
-pscOptions (Options a) = opt noPreludeOpt a.noPrelude <>
-                         opt noOptsOpt a.noOpts <>
-                         opt noMagicDoOpt a.noMagicDo <>
-                         opt noTcoOpt a.noTco <>
-                         opt verboseErrorsOpt a.verboseErrors <>
-                         opt commentsOpt a.comments <>
-                         opt outputOpt (NullOrUndefined $ Just a.output) <>
-                         opt noPrefixOpt a.noPrefix <>
-                         opt requirePathOpt (NullOrUndefined $ Just a.requirePath) <>
-                         opt ffiOpt a.ffi
-
-loaderSrcOption :: Foreign -> Maybe (Array String)
-loaderSrcOption query = either (const Nothing) (\(Options a) -> runNullOrUndefined a.src) (read query)
-
-loaderFFIOption :: Foreign -> Maybe (Array String)
-loaderFFIOption query = either (const Nothing) (\(Options a) -> runNullOrUndefined a.ffi) (read query)
+  read obj =
+    Options <$> ({ pscBundle: _ }
+            <$> (maybe pscBundleDefault id <<< runNullOrUndefined <$> readProp pscBundle obj))
+    where
+    pscBundle :: String
+    pscBundle = "pscBundle"
+
+    pscBundleDefault :: String
+    pscBundleDefault = joinPath "output" "bundle.js"