Add hlint makefile target.

[hath.git] / src / Main.hs

diff --git a/src/Main.hs b/src/Main.hs
index eeee9f6b6fe07f4ae40b580e093c818042b253c9..12511b61463b6d04a721434cbb7e7d8b09db15e8 100644 (file)
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -1,5 +1,8 @@
-import Data.List ((\\), intercalate, intersperse)
-import System.Exit (ExitCode(..), exitWith)
+import Control.Monad (unless, when)
+import Data.List ((\\), intercalate)
+import Data.Maybe (catMaybes, isNothing)
+import Data.String.Utils (splitWs)
+import System.Exit (ExitCode(..), exitSuccess, exitWith)
 import System.IO (stderr, hPutStrLn)
 
 import Cidr (Cidr(..),
@@ -20,39 +23,32 @@ import CommandLine (help_set,
                     Mode(..),
                     parse_errors,
                     parse_mode)
-    
+
+import ExitCodes
 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.
+-- | A regular expression that matches a non-address character.
 non_addr_char :: String
 non_addr_char = "[^\\.0-9]"
 
 
--- Add non_addr_chars on either side of the given String. This
--- prevents (for example) the regex '127.0.0.1' from matching
--- '127.0.0.100'.
+-- | Add non_addr_chars on either side of the given String. This
+--   prevents (for example) the regex '127.0.0.1' from matching
+--   '127.0.0.100'.
 addr_barrier :: String -> String
 addr_barrier x = non_addr_char ++ x ++ non_addr_char
 
 
--- The magic happens here. We take a CIDR String as an argument, and
--- return the equivalent regular expression. We do this as follows:
+-- | The magic happens here. We take a CIDR String as an argument, and
+--   return the equivalent regular expression. We do this as follows:
 --
--- 1. Compute the minimum possible value of each octet.
--- 2. Compute the maximum possible value of each octet.
--- 3. Generate a regex matching every value between those min and
---    max values.
--- 4. Join the regexes from step 3 with regexes matching periods.
--- 5. Stick an address boundary on either side of the result.
---cidr_to_regex :: String -> String
+--   1. Compute the minimum possible value of each octet.
+--   2. Compute the maximum possible value of each octet.
+--   3. Generate a regex matching every value between those min and
+--      max values.
+--   4. Join the regexes from step 3 with regexes matching periods.
+--   5. Stick an address boundary on either side of the result.
 cidr_to_regex :: Cidr.Cidr -> String
 cidr_to_regex cidr =
     addr_barrier (intercalate "\\." [range1, range2, range3, range4])
@@ -72,14 +68,14 @@ cidr_to_regex cidr =
 
 
 
--- Take a list of Strings, and return a regular expression matching
--- any of them.
+-- | Take a list of Strings, and return a regular expression matching
+--   any of them.
 alternate :: [String] -> String
-alternate terms = "(" ++ (concat (intersperse "|" terms)) ++ ")"
+alternate terms = "(" ++ (intercalate "|" terms) ++ ")"
 
 
--- Take two Ints as parameters, and return a regex matching any
--- integer between them (inclusive).
+-- | Take two Ints as parameters, and return a regex matching any
+--   integer between them (inclusive).
 numeric_range :: Int -> Int -> String
 numeric_range x y =
     alternate (map show [lower..upper])
@@ -93,47 +89,53 @@ 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
-      hPutStrLn stderr (concat errors)
-      putStrLn CommandLine.help_text
-      exitWith (ExitFailure exit_args_parse_failed)
-    else do -- Nothing
+  unless (null errors) $ do
+    hPutStrLn stderr (concat errors)
+    putStrLn CommandLine.help_text
+    exitWith (ExitFailure exit_args_parse_failed)
 
   -- 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
+  when help_opt_set $ do
+    putStrLn CommandLine.help_text
+    exitSuccess
 
   -- The input function we receive here should know what to read.
   inputfunc <- (CommandLine.input_function)
   input <- inputfunc
 
-  let cidr_strings = lines input
-  let cidrs = map Cidr.cidr_from_string cidr_strings
+  let cidr_strings = splitWs input
+  let cidrs = map cidr_from_string cidr_strings
+
+  when (any isNothing cidrs) $ do
+    putStrLn "Error: not valid CIDR notation."
+    exitWith (ExitFailure exit_invalid_cidr)
 
-  if (any (== Cidr.None) 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 cidrs
-        putStrLn $ alternate regexes
+      let regexes = map cidr_to_regex valid_cidrs
+      putStrLn $ alternate regexes
     Reduce -> do
-        mapM (putStrLn . show) (combine_all cidrs)
-        return ()
+      _ <- mapM print (combine_all valid_cidrs)
+      return ()
     Dupe -> do
-         mapM (putStrLn . show) dupes
-         return ()
-         where
-           dupes = cidrs \\ (combine_all cidrs)
+       _ <- mapM print 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