-- | The CommandLine module handles parsing of the command-line -- options. It should more or less be a black box, providing Main -- with only the information it requires. module CommandLine ( get_cfg, help_set, help_text, parse_errors, parse_usernames ) where import Data.Maybe (fromJust, isJust, isNothing) import System.Console.GetOpt import System.Directory (doesFileExist) import System.Environment (getArgs) import Configuration (Cfg(..)) -- | A record containing values for all available options. data Options = Options { opt_heartbeat :: Maybe Int, opt_help :: Bool, opt_ignore_replies :: Bool, opt_ignore_retweets :: Bool, opt_sendmail_path :: FilePath, opt_from :: Maybe String, opt_to :: Maybe String, opt_verbose :: Bool } -- | Constructs an instance of Options, with each of its members set -- to default values. default_options :: Options default_options = Options { opt_heartbeat = Just 600, opt_help = False, opt_ignore_replies = False, opt_ignore_retweets = False, opt_sendmail_path = "/usr/sbin/sendmail", opt_from = Nothing, opt_to = Nothing, opt_verbose = False } -- | The options list that we construct associates a function with -- each option. This function is responsible for updating an Options -- record with the appropriate value. -- -- For more information and an example of this idiom, see, -- -- -- options :: [OptDescr (Options -> IO Options)] options = [ Option ['h']["help"] (NoArg set_help) "Prints this help message.", Option ['n']["heartbeat"] (ReqArg set_heartbeat "heartbeat") "How many seconds to wait between polling.", Option ['t']["to"] (ReqArg set_to "email_address") "Send tweets TO email_address.", Option ['f']["from"] (ReqArg set_from "email_address") "Send tweets FROM email_address.", Option ['s']["sendmail_path"] (ReqArg set_sendmail_path "sendmail_path") "Use sendmail_path to send mail", Option ['i']["ignore-replies"] (NoArg set_ignore_replies) "Ignore replies.", Option ['I']["ignore-retweets"] (NoArg set_ignore_retweets) "Ignore retweets.", Option ['v']["verbose"] (NoArg set_verbose) "Be verbose about stuff." ] -- | Attempt to parse an 'Int' from a 'String'. This is just a 'Maybe' -- wrapper around 'reads'. parse_int :: String -> Maybe Int parse_int s = case (reads s) of [(n,_)] -> Just n _ -> Nothing set_heartbeat :: String -> Options -> IO Options set_heartbeat arg opts = do let new_heartbeat = parse_int arg return opts { opt_heartbeat = new_heartbeat } set_help :: Options -> IO Options set_help opts = do return opts { opt_help = True } set_ignore_retweets :: Options -> IO Options set_ignore_retweets opts = return opts { opt_ignore_retweets = True } set_ignore_replies :: Options -> IO Options set_ignore_replies opts = return opts { opt_ignore_replies = True } set_verbose :: Options -> IO Options set_verbose opts = return opts { opt_verbose = True } set_sendmail_path :: String -> Options -> IO Options set_sendmail_path arg opts = do return opts { opt_sendmail_path = arg } set_to :: String -> Options -> IO Options set_to arg opts = do return opts { opt_to = Just arg } set_from :: String -> Options -> IO Options set_from arg opts = do return opts { opt_from = Just arg } -- | The usage header. usage :: String usage = "Usage: twat [-n heartbeat] [-t to_address] [-f from_address] [-s path-to-sendmail] [username2, [username3]...]" -- | Was the help option passed? help_set :: IO Bool help_set = do opts <- parse_options return (opt_help opts) -- | The usage header, and all available flags (as generated by GetOpt) help_text :: String help_text = usageInfo usage options -- | Return a list of options. parse_options :: IO Options parse_options = do argv <- getArgs let (actions, _, _) = getOpt Permute options argv -- This will execute each of the functions contained in our options -- list, one after another, on a default_options record. The end -- result should be an Options instance with all of its members set -- correctly. opts <- foldl (>>=) (return default_options) actions return opts -- | A list of parse errors relating to the heartbeat. heartbeat_errors :: IO [String] heartbeat_errors = do hb <- parse_heartbeat if (isNothing hb) then return ["\"heartbeat\" does not appear to be an integer."] else return [] -- | Parse errors relating to the list of usernames. username_errors :: IO [String] username_errors = do argv <- getArgs let (_, usernames, _) = getOpt Permute options argv if (null usernames) then return ["no usernames provided."] else return [] -- | Parse errors relating to the "To" address. to_errors :: IO [String] to_errors = do toaddr <- parse_to_address fromaddr <- parse_from_address if (isNothing toaddr) && (isJust fromaddr) then return ["\"from\" address specified without \"to\" address."] else return [] -- | Errors for the sendmail path argument. sendmail_path_errors :: IO [String] sendmail_path_errors = do sendmail <- parse_sendmail_path exists <- doesFileExist sendmail if (not exists) then return ["sendmail path does not exist"] else return [] -- | Parse errors relating to the "From" address. from_errors :: IO [String] from_errors = do toaddr <- parse_to_address fromaddr <- parse_from_address if (isJust toaddr) && (isNothing fromaddr) then return ["\"to\" address specified without \"from\" address."] else return [] -- | Format an error message for printing. format_error :: String -> String format_error err = "ERROR: " ++ err ++ "\n" -- | Return a list of all parse errors. parse_errors :: IO [String] parse_errors = do argv <- getArgs let (_, _, errors) = getOpt Permute options argv errs_heartbeat <- heartbeat_errors errs_username <- username_errors errs_to <- to_errors errs_from <- from_errors errs_sendmail <- sendmail_path_errors return $ map format_error (errors ++ errs_heartbeat ++ errs_username ++ errs_sendmail ++ errs_to ++ errs_from) -- | What's the heartbeat? parse_heartbeat :: IO (Maybe Int) parse_heartbeat = do opts <- parse_options return (opt_heartbeat opts) -- | What "To" address was given on the command line? parse_to_address :: IO (Maybe String) parse_to_address = do opts <- parse_options return (opt_to opts) -- | What sendmail path was given on the command line? parse_sendmail_path :: IO FilePath parse_sendmail_path = do opts <- parse_options return (opt_sendmail_path opts) -- | What "From" address was given on the command line? parse_from_address :: IO (Maybe String) parse_from_address = do opts <- parse_options return (opt_from opts) -- | What usernames were passed on the command line? parse_usernames :: IO [String] parse_usernames = do argv <- getArgs let (_, usernames, _) = getOpt Permute options argv return usernames -- | Construct a Cfg object from the command line options assuming -- there are no errors. get_cfg :: IO Cfg get_cfg = do opts <- parse_options return Cfg { heartbeat = fromJust $ opt_heartbeat opts, ignore_replies = opt_ignore_replies opts, ignore_retweets = opt_ignore_retweets opts, sendmail_path = opt_sendmail_path opts, from_address = opt_from opts, to_address = opt_to opts, verbose = opt_verbose opts }