X-Git-Url: http://gitweb.michael.orlitzky.com/?p=dead%2Fhalcyon.git;a=blobdiff_plain;f=src%2FCommandLine.hs;h=db3b12da2039c6de2d046bf04e22782849b32649;hp=c5ddb4b48a002213631cbdb32d0f91596a399db1;hb=dd6cea3dc5e830691b1da442fcf91602e4cf94aa;hpb=17dd116706c4a971e1f5c68daa1656af5eff5cd2 diff --git a/src/CommandLine.hs b/src/CommandLine.hs index c5ddb4b..db3b12d 100644 --- a/src/CommandLine.hs +++ b/src/CommandLine.hs @@ -1,76 +1,200 @@ --- 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. - +-- | 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 -( help_set, +( get_cfg, + help_set, help_text, - from_email_address, - to_email_address, parse_errors, parse_usernames ) where -import Data.Maybe (isJust, isNothing) +import Data.Maybe (fromJust, isJust, isNothing) import System.Console.GetOpt +import System.Directory (doesFileExist) import System.Environment (getArgs) - - --- A record containing values for all available options. -data Options = Options { opt_help :: Bool, +import Configuration (Cfg(..)) + +-- | A record containing values for all available options. +data Options = Options { opt_consumer_key :: Maybe String, + opt_consumer_secret :: Maybe String, + opt_access_token :: Maybe String, + opt_access_secret :: Maybe String, + 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_to :: Maybe String, + opt_verbose :: Bool } --- This constructs an instance of Options, with each of its members --- set to default values. +-- | Constructs an instance of Options, with each of its members set +-- to default values. default_options :: Options -default_options = Options { opt_help = False, +default_options = Options { opt_access_token = Nothing, + opt_access_secret = Nothing, + opt_consumer_key = Nothing, + opt_consumer_secret = Nothing, + 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_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. +-- | 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, +-- For more information and an example of this idiom, see, -- --- http://www.haskell.org/haskellwiki/High-level_option_handling_with_GetOpt +-- -- options :: [OptDescr (Options -> IO Options)] options = - [ Option ['h'][] (NoArg set_help) "Prints this help message.", - Option ['t'][] (ReqArg set_to "email_address") "Send tweets TO email_address.", - Option ['f'][] (ReqArg set_from "email_address") "Send tweets FROM email_address." + [ Option + "" ["consumer-key"] + (ReqArg set_consumer_key "consumer-key") + "Your Twitter API consumer key.", + + Option + "" ["consumer-secret"] + (ReqArg set_consumer_secret "consumer-secret") + "Your Twitter API consumer secret.", + + Option + "" ["access-token"] + (ReqArg set_access_token "access-token") + "Your Twitter API access token.", + + Option + "" ["access-secret"] + (ReqArg set_access_secret "access-secret") + "Your Twitter API access secret.", + + 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_consumer_key :: String -> Options -> IO Options +set_consumer_key arg opts = + return opts { opt_consumer_key = Just arg } + +set_consumer_secret :: String -> Options -> IO Options +set_consumer_secret arg opts = + return opts { opt_consumer_secret = Just arg } + +set_access_token :: String -> Options -> IO Options +set_access_token arg opts = + return opts { opt_access_token = Just arg } + +set_access_secret :: String -> Options -> IO Options +set_access_secret arg opts = + return opts { opt_access_secret = Just arg } + +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 = + return opts { opt_sendmail_path = arg } + set_to :: String -> Options -> IO Options -set_to arg opts = do +set_to arg opts = return opts { opt_to = Just arg } set_from :: String -> Options -> IO Options -set_from arg opts = do +set_from arg opts = return opts { opt_from = Just arg } - --- The usage header. + +-- | The usage header. usage :: String -usage = "Usage: twat [-t to_address] [-f from_address] [username2, [username3]...]" +usage = "Usage: twat --consumer-key= --consumer-secret= --access-token= --access-secret= [-n heartbeat] [-t to_address] [-f from_address] [-s path-to-sendmail] [username2, [username3]...]" --- The usage header, and all available flags (as generated by GetOpt) +-- | 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. +-- | Return a list of options. parse_options :: IO Options parse_options = do argv <- getArgs @@ -80,72 +204,127 @@ parse_options = do -- 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 + 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."] + then return ["no usernames provided."] else return [] +-- | Parse errors relating to the "To" address. to_errors :: IO [String] to_errors = do - toaddr <- to_email_address - fromaddr <- from_email_address + toaddr <- parse_to_address + fromaddr <- parse_from_address if (isNothing toaddr) && (isJust fromaddr) - then return ["\"From\" address specified without \"To\" address."] + 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 <- to_email_address - fromaddr <- from_email_address + toaddr <- parse_to_address + fromaddr <- parse_from_address if (isJust toaddr) && (isNothing fromaddr) - then return ["\"To\" address specified without \"From\" address."] + 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 errors. +-- | Return a list of all parse errors. parse_errors :: IO [String] parse_errors = do argv <- getArgs - let (_, _, errors) = getOpt Permute options argv + let (_, _, errors) = getOpt Permute options argv + errs_heartbeat <- heartbeat_errors errs_username <- username_errors errs_to <- to_errors errs_from <- from_errors - return $ map format_error (errors ++ errs_username ++ errs_to ++ errs_from) - --- Is the help option set? -help_set :: IO Bool -help_set = do - opts <- parse_options - return (opt_help opts) - - -to_email_address :: IO (Maybe String) -to_email_address = do - opts <- parse_options - return (opt_to opts) - -from_email_address :: IO (Maybe String) -from_email_address = do - opts <- parse_options - return (opt_from opts) - - + 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 { consumer_key = fromJust $ opt_consumer_key opts, + consumer_secret = fromJust $ opt_consumer_secret opts, + access_token = fromJust $ opt_access_token opts, + access_secret = fromJust $ opt_access_secret opts, + 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 }