Rewrite everything to use Maybe instead of None constructors.

[hath.git] / src / Main.hs

diff --git a/src/Main.hs b/src/Main.hs
index c87520951088c46f095f334bd90e78587b98c53d..b2fc64b5eb71a441226f7772b2ed8e591afb9ca3 100644 (file)
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -1,17 +1,35 @@
-import Data.List (intercalate, intersperse)
-import System.Exit (exitFailure)
-import Text.Regex.Posix
-
-import Cidr (Cidr,
-             from_string,
-             min_first_octet,
-             min_second_octet,
-             min_third_octet,
-             min_fourth_octet,
-             max_first_octet,
-             max_second_octet,
-             max_third_octet,
-             max_fourth_octet)
+import Data.List ((\\), intercalate, intersperse)
+import Data.Maybe (catMaybes, isNothing)
+import System.Exit (ExitCode(..), exitWith)
+import System.IO (stderr, hPutStrLn)
+
+import Cidr (Cidr(..),
+             cidr_from_string,
+             combine_all,
+             max_octet1,
+             max_octet2,
+             max_octet3,
+             max_octet4,
+             min_octet1,
+             min_octet2,
+             min_octet3,
+             min_octet4 )
+
+import CommandLine (help_set,
+                    help_text,
+                    input_function,
+                    Mode(..),
+                    parse_errors,
+                    parse_mode)
+    
+import Octet
+    
+-- Some exit codes, used in the ExitFailure constructor.
+exit_invalid_cidr :: Int
+exit_invalid_cidr = 1
+
+exit_args_parse_failed :: Int
+exit_args_parse_failed = 2
 
 
 -- A regular expression that matches a non-address character.
@@ -44,21 +62,16 @@ cidr_to_regex cidr =
       range2 = numeric_range min2 max2
       range3 = numeric_range min3 max3
       range4 = numeric_range min4 max4
-      min1   = min_first_octet cidr
-      min2   = min_second_octet cidr
-      min3   = min_third_octet cidr
-      min4   = min_fourth_octet cidr
-      max1   = max_first_octet cidr
-      max2   = max_second_octet cidr
-      max3   = max_third_octet cidr
-      max4   = max_fourth_octet cidr
+      min1   = octet_to_int (min_octet1 cidr)
+      min2   = octet_to_int (min_octet2 cidr)
+      min3   = octet_to_int (min_octet3 cidr)
+      min4   = octet_to_int (min_octet4 cidr)
+      max1   = octet_to_int (max_octet1 cidr)
+      max2   = octet_to_int (max_octet2 cidr)
+      max3   = octet_to_int (max_octet3 cidr)
+      max4   = octet_to_int (max_octet4 cidr)
 
 
--- Will return True if the passed String is in CIDR notation, False
--- otherwise.
-is_valid_cidr :: String -> Bool
-is_valid_cidr cidr = cidr =~ "([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}"
-
 
 -- Take a list of Strings, and return a regular expression matching
 -- any of them.
@@ -76,23 +89,64 @@ numeric_range x y =
        upper = maximum [x,y]
 
 
--- Take a CIDR String, and exitFailure if it's invalid.
-validate_or_die :: String -> IO ()
-validate_or_die cidr = do
-  if (is_valid_cidr cidr)
+main :: IO ()
+main = do
+  -- First, check for any errors that occurred while parsing
+  -- the command line options.
+  errors <- CommandLine.parse_errors
+  if not (null errors)
     then do
-      return ()
-    else do
-        putStrLn "Error: not valid CIDR notation."
-        exitFailure
+      hPutStrLn stderr (concat errors)
+      putStrLn CommandLine.help_text
+      exitWith (ExitFailure exit_args_parse_failed)
+    else do -- Nothing
+
+  -- Next, check to see if the 'help' option was passed to the
+  -- program. If it was, display the help, and exit successfully.
+  help_opt_set <- CommandLine.help_set
+  if help_opt_set
+    then do
+      putStrLn CommandLine.help_text
+      exitWith ExitSuccess
+    else do -- Nothing
 
+  -- The input function we receive here should know what to read.
+  inputfunc <- (CommandLine.input_function)
+  input <- inputfunc
 
-main :: IO ()
-main = do
-  input <- getContents
   let cidr_strings = lines input
-  mapM validate_or_die cidr_strings
-  let cidrs = map Cidr.from_string cidr_strings
-  let regexes = map cidr_to_regex cidrs
-  putStrLn $ alternate regexes
+  let cidrs = map cidr_from_string cidr_strings
 
+  if (any isNothing cidrs)
+    then do
+      putStrLn "Error: not valid CIDR notation."
+      exitWith (ExitFailure exit_invalid_cidr)
+    else do -- Nothing
+
+  -- Filter out only the valid ones.
+  let valid_cidrs = catMaybes cidrs
+
+  -- Get the mode of operation.
+  mode <- CommandLine.parse_mode
+
+  case mode of
+    Regex -> do
+      let regexes = map cidr_to_regex valid_cidrs
+      putStrLn $ alternate regexes
+    Reduce -> do
+      _ <- mapM (putStrLn . show) (combine_all valid_cidrs)
+      return ()
+    Dupe -> do
+       _ <- mapM (putStrLn . show) dupes
+       return ()
+       where
+         dupes = valid_cidrs \\ (combine_all valid_cidrs)
+    Diff -> do
+       _ <- mapM putStrLn deletions
+       _ <- mapM putStrLn additions
+       return ()
+       where
+         dupes = valid_cidrs \\ (combine_all valid_cidrs)
+         deletions = map (\s -> "-" ++ (show s)) dupes
+         newcidrs = (combine_all valid_cidrs) \\ valid_cidrs
+         additions = map (\s -> "+" ++ (show s)) newcidrs