Fix a few hlint suggestions.
[dead/halcyon.git] / src / CommandLine.hs
1 -- | The CommandLine module handles parsing of the command-line
2 -- options. It should more or less be a black box, providing Main
3 -- with only the information it requires.
4 module CommandLine
5 ( get_cfg,
6 help_set,
7 help_text,
8 parse_errors,
9 parse_usernames
10 ) where
11
12 import Data.Maybe (fromJust, isJust, isNothing)
13 import System.Console.GetOpt
14 import System.Directory (doesFileExist)
15 import System.Environment (getArgs)
16
17 import Configuration (Cfg(..))
18
19 -- | A record containing values for all available options.
20 data Options = Options { opt_consumer_key :: Maybe String,
21 opt_consumer_secret :: Maybe String,
22 opt_access_token :: Maybe String,
23 opt_access_secret :: Maybe String,
24 opt_heartbeat :: Maybe Int,
25 opt_help :: Bool,
26 opt_ignore_replies :: Bool,
27 opt_ignore_retweets :: Bool,
28 opt_sendmail_path :: FilePath,
29 opt_from :: Maybe String,
30 opt_to :: Maybe String,
31 opt_verbose :: Bool }
32
33
34 -- | Constructs an instance of Options, with each of its members set
35 -- to default values.
36 default_options :: Options
37 default_options = Options { opt_access_token = Nothing,
38 opt_access_secret = Nothing,
39 opt_consumer_key = Nothing,
40 opt_consumer_secret = Nothing,
41 opt_heartbeat = Just 600,
42 opt_help = False,
43 opt_ignore_replies = False,
44 opt_ignore_retweets = False,
45 opt_sendmail_path = "/usr/sbin/sendmail",
46 opt_from = Nothing,
47 opt_to = Nothing,
48 opt_verbose = False }
49
50
51 -- | The options list that we construct associates a function with
52 -- each option. This function is responsible for updating an Options
53 -- record with the appropriate value.
54 --
55 -- For more information and an example of this idiom, see,
56 --
57 -- <http://www.haskell.org/haskellwiki/High-level_option_handling_with_GetOpt>
58 --
59 options :: [OptDescr (Options -> IO Options)]
60 options =
61 [ Option
62 "" ["consumer-key"]
63 (ReqArg set_consumer_key "consumer-key")
64 "Your Twitter API consumer key.",
65
66 Option
67 "" ["consumer-secret"]
68 (ReqArg set_consumer_secret "consumer-secret")
69 "Your Twitter API consumer secret.",
70
71 Option
72 "" ["access-token"]
73 (ReqArg set_access_token "access-token")
74 "Your Twitter API access token.",
75
76 Option
77 "" ["access-secret"]
78 (ReqArg set_access_secret "access-secret")
79 "Your Twitter API access secret.",
80
81 Option
82 "h" ["help"]
83 (NoArg set_help)
84 "Prints this help message.",
85
86 Option
87 "n" ["heartbeat"]
88 (ReqArg set_heartbeat "heartbeat")
89 "How many seconds to wait between polling.",
90
91 Option
92 "t" ["to"]
93 (ReqArg set_to "email_address")
94 "Send tweets TO email_address.",
95
96 Option
97 "f" ["from"]
98 (ReqArg set_from "email_address")
99 "Send tweets FROM email_address.",
100
101 Option
102 "s" ["sendmail_path"]
103 (ReqArg set_sendmail_path "sendmail_path")
104 "Use sendmail_path to send mail",
105
106 Option
107 "i" ["ignore-replies"]
108 (NoArg set_ignore_replies)
109 "Ignore replies.",
110
111 Option
112 "I" ["ignore-retweets"]
113 (NoArg set_ignore_retweets)
114 "Ignore retweets.",
115
116 Option
117 "v" ["verbose"]
118 (NoArg set_verbose)
119 "Be verbose about stuff."
120 ]
121
122
123 -- | Attempt to parse an 'Int' from a 'String'. This is just a 'Maybe'
124 -- wrapper around 'reads'.
125 parse_int :: String -> Maybe Int
126 parse_int s =
127 case (reads s) of
128 [(n,_)] -> Just n
129 _ -> Nothing
130
131 set_consumer_key :: String -> Options -> IO Options
132 set_consumer_key arg opts =
133 return opts { opt_consumer_key = Just arg }
134
135 set_consumer_secret :: String -> Options -> IO Options
136 set_consumer_secret arg opts =
137 return opts { opt_consumer_secret = Just arg }
138
139 set_access_token :: String -> Options -> IO Options
140 set_access_token arg opts =
141 return opts { opt_access_token = Just arg }
142
143 set_access_secret :: String -> Options -> IO Options
144 set_access_secret arg opts =
145 return opts { opt_access_secret = Just arg }
146
147 set_heartbeat :: String -> Options -> IO Options
148 set_heartbeat arg opts = do
149 let new_heartbeat = parse_int arg
150 return opts { opt_heartbeat = new_heartbeat }
151
152 set_help :: Options -> IO Options
153 set_help opts = do
154 return opts { opt_help = True }
155
156 set_ignore_retweets :: Options -> IO Options
157 set_ignore_retweets opts =
158 return opts { opt_ignore_retweets = True }
159
160 set_ignore_replies :: Options -> IO Options
161 set_ignore_replies opts =
162 return opts { opt_ignore_replies = True }
163
164 set_verbose :: Options -> IO Options
165 set_verbose opts =
166 return opts { opt_verbose = True }
167
168 set_sendmail_path :: String -> Options -> IO Options
169 set_sendmail_path arg opts =
170 return opts { opt_sendmail_path = arg }
171
172 set_to :: String -> Options -> IO Options
173 set_to arg opts =
174 return opts { opt_to = Just arg }
175
176 set_from :: String -> Options -> IO Options
177 set_from arg opts =
178 return opts { opt_from = Just arg }
179
180
181 -- | The usage header.
182 usage :: String
183 usage = "Usage: twat --consumer-key=<key> --consumer-secret=<secret> --access-token=<key> --access-secret=<secret> [-n heartbeat] [-t to_address] [-f from_address] [-s path-to-sendmail] <username1> [username2, [username3]...]"
184
185
186 -- | Was the help option passed?
187 help_set :: IO Bool
188 help_set = do
189 opts <- parse_options
190 return (opt_help opts)
191
192 -- | The usage header, and all available flags (as generated by GetOpt)
193 help_text :: String
194 help_text = usageInfo usage options
195
196
197 -- | Return a list of options.
198 parse_options :: IO Options
199 parse_options = do
200 argv <- getArgs
201 let (actions, _, _) = getOpt Permute options argv
202
203 -- This will execute each of the functions contained in our options
204 -- list, one after another, on a default_options record. The end
205 -- result should be an Options instance with all of its members set
206 -- correctly.
207 foldl (>>=) (return default_options) actions
208
209
210 -- | A list of parse errors relating to the heartbeat.
211 heartbeat_errors :: IO [String]
212 heartbeat_errors = do
213 hb <- parse_heartbeat
214 if (isNothing hb)
215 then return ["\"heartbeat\" does not appear to be an integer."]
216 else return []
217
218 -- | Parse errors relating to the list of usernames.
219 username_errors :: IO [String]
220 username_errors = do
221 argv <- getArgs
222 let (_, usernames, _) = getOpt Permute options argv
223
224 if (null usernames)
225 then return ["no usernames provided."]
226 else return []
227
228
229 -- | Parse errors relating to the "To" address.
230 to_errors :: IO [String]
231 to_errors = do
232 toaddr <- parse_to_address
233 fromaddr <- parse_from_address
234 if (isNothing toaddr) && (isJust fromaddr)
235 then return ["\"from\" address specified without \"to\" address."]
236 else return []
237
238
239 -- | Errors for the sendmail path argument.
240 sendmail_path_errors :: IO [String]
241 sendmail_path_errors = do
242 sendmail <- parse_sendmail_path
243 exists <- doesFileExist sendmail
244 if (not exists)
245 then return ["sendmail path does not exist"]
246 else return []
247
248
249 -- | Parse errors relating to the "From" address.
250 from_errors :: IO [String]
251 from_errors = do
252 toaddr <- parse_to_address
253 fromaddr <- parse_from_address
254 if (isJust toaddr) && (isNothing fromaddr)
255 then return ["\"to\" address specified without \"from\" address."]
256 else return []
257
258
259 -- | Format an error message for printing.
260 format_error :: String -> String
261 format_error err = "ERROR: " ++ err ++ "\n"
262
263
264 -- | Return a list of all parse errors.
265 parse_errors :: IO [String]
266 parse_errors = do
267 argv <- getArgs
268 let (_, _, errors) = getOpt Permute options argv
269 errs_heartbeat <- heartbeat_errors
270 errs_username <- username_errors
271 errs_to <- to_errors
272 errs_from <- from_errors
273 errs_sendmail <- sendmail_path_errors
274 return $ map format_error (errors ++
275 errs_heartbeat ++
276 errs_username ++
277 errs_sendmail ++
278 errs_to ++
279 errs_from)
280
281 -- | What's the heartbeat?
282 parse_heartbeat :: IO (Maybe Int)
283 parse_heartbeat = do
284 opts <- parse_options
285 return (opt_heartbeat opts)
286
287 -- | What "To" address was given on the command line?
288 parse_to_address :: IO (Maybe String)
289 parse_to_address = do
290 opts <- parse_options
291 return (opt_to opts)
292
293 -- | What sendmail path was given on the command line?
294 parse_sendmail_path :: IO FilePath
295 parse_sendmail_path = do
296 opts <- parse_options
297 return (opt_sendmail_path opts)
298
299 -- | What "From" address was given on the command line?
300 parse_from_address :: IO (Maybe String)
301 parse_from_address = do
302 opts <- parse_options
303 return (opt_from opts)
304
305
306 -- | What usernames were passed on the command line?
307 parse_usernames :: IO [String]
308 parse_usernames = do
309 argv <- getArgs
310 let (_, usernames, _) = getOpt Permute options argv
311 return usernames
312
313
314
315 -- | Construct a Cfg object from the command line options assuming
316 -- there are no errors.
317 get_cfg :: IO Cfg
318 get_cfg = do
319 opts <- parse_options
320 return Cfg { consumer_key = fromJust $ opt_consumer_key opts,
321 consumer_secret = fromJust $ opt_consumer_secret opts,
322 access_token = fromJust $ opt_access_token opts,
323 access_secret = fromJust $ opt_access_secret opts,
324 heartbeat = fromJust $ opt_heartbeat opts,
325 ignore_replies = opt_ignore_replies opts,
326 ignore_retweets = opt_ignore_retweets opts,
327 sendmail_path = opt_sendmail_path opts,
328 from_address = opt_from opts,
329 to_address = opt_to opts,
330 verbose = opt_verbose opts }