aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/Options.purs
blob: 51e9be53cbecaaee4730caf7e1096ddb026afcb4 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
module PursLoader.Options
  ( pscOptions
  , loaderSrcOption
  , loaderFFIOption
  ) where

import Data.Array (concat)
import Data.Either (either)

import Data.Foreign (Foreign(), F())
import Data.Foreign.Class (IsForeign, read, readProp)
import Data.Foreign.NullOrUndefined (NullOrUndefined(..), runNullOrUndefined)

import Data.Maybe (Maybe(..), maybe, fromMaybe)

noPreludeOpt = "no-prelude"

noOptsOpt = "no-opts"

noMagicDoOpt = "no-magic-do"

noTcoOpt = "no-tco"

verboseErrorsOpt = "verbose-errors"

outputOpt = "output"

commentsOpt = "comments"

noPrefixOpt = "no-prefix"

requirePathOpt = "require-path"

srcOpt = "src"

ffiOpt = "ffi"

newtype Options
  = Options { noPrelude :: NullOrUndefined Boolean
            , noOpts :: NullOrUndefined Boolean
            , noMagicDo :: NullOrUndefined Boolean
            , noTco :: NullOrUndefined Boolean
            , verboseErrors :: NullOrUndefined Boolean
            , comments :: NullOrUndefined Boolean
            , output :: NullOrUndefined String
            , noPrefix :: NullOrUndefined Boolean
            , requirePath :: NullOrUndefined String
            , src :: NullOrUndefined [String]
            , ffi :: NullOrUndefined [String]
            }

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
                            <*> readProp outputOpt obj
                            <*> readProp noPrefixOpt obj
                            <*> readProp requirePathOpt obj
                            <*> readProp srcOpt obj
                            <*> readProp ffiOpt obj)

class LoaderOption a where
  opt :: String -> NullOrUndefined a -> [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 [a] where
  opt key val = concat (opt key <$> (NullOrUndefined <<< Just)
                                <$> (fromMaybe [] (runNullOrUndefined val)))

pscOptions :: Foreign -> [String]
pscOptions query = either (const []) fold parsed
  where parsed = read query :: F Options
        fold (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 a.output <>
                           opt noPrefixOpt a.noPrefix <>
                           opt requirePathOpt a.requirePath <>
                           opt ffiOpt a.ffi

loaderSrcOption :: Foreign -> Maybe [String]
loaderSrcOption query = either (const Nothing) (\(Options a) -> runNullOrUndefined a.src) (read query)

loaderFFIOption :: Foreign -> Maybe [String]
loaderFFIOption query = either (const Nothing) (\(Options a) -> runNullOrUndefined a.ffi) (read query)