Format source code

src/Constraint.hs

@@ -1,9 +1,9 @@
 module Constraint where
 
-data Constraint = Constraint {
-  lower :: Int,
-  upper :: Int
-} deriving (Show, Eq)
+data Constraint = Constraint
+  { lower :: Int
+  , upper :: Int
+  } deriving (Show, Eq)
 
 makeRangeFromNumber :: Int -> Constraint
 makeRangeFromNumber x = Constraint x x

src/Field.hs

@@ -1,18 +1,25 @@
 module Field where
 
-import Data.Char (isDigit)
-import Data.Maybe
+import           Constraint
+import           Data.Char  (isDigit)
+import           Data.Maybe
+import           Helper
 
-import Constraint
-import Helper
-
-data Range = All | Range Int Int | Sequence [Int]
+data Range
+  = All
+  | Range Int
+          Int
+  | Sequence [Int]
   deriving (Eq, Show)
 
-data Step = Every | Step Int
+data Step
+  = Every
+  | Step Int
   deriving (Eq, Show)
 
-data Field = Field Range Step
+data Field =
+  Field Range
+        Step
   deriving (Eq, Show)
 
 parseField :: String -> Constraint -> Maybe Field
@@ -64,7 +71,9 @@ parseRange text constraint
     isAllNumbers = all isNumber pieces
     start = read (head pieces) :: Int
     end = read (pieces !! 1) :: Int
-    isValid = isTwo && isAllNumbers && start <= start && (start, end) `inside` constraint
+    isValid =
+      isTwo &&
+      isAllNumbers && start <= start && (start, end) `inside` constraint
 
 parseSequence :: String -> Constraint -> Maybe [Int]
 parseSequence text constraint
@@ -79,17 +88,19 @@ parseSequence text constraint
 
 parseFieldStep :: String -> Maybe Step
 parseFieldStep "" = Just Every
-parseFieldStep text | isNumber text = Just (Step (read text))
+parseFieldStep text
+  | isNumber text = Just (Step (read text))
 parseFieldStep _ = Nothing
 
 matchField :: Field -> Int -> Bool
-matchField (Field range step) n = matchFieldRange range n && matchFieldStep step n
+matchField (Field range step) n =
+  matchFieldRange range n && matchFieldStep step n
 
 matchFieldRange :: Range -> Int -> Bool
-matchFieldRange All _ = True
-matchFieldRange (Range x y) n = n >= x && n <= y
+matchFieldRange All _           = True
+matchFieldRange (Range x y) n   = n >= x && n <= y
 matchFieldRange (Sequence xs) n = n `elem` xs
 
 matchFieldStep :: Step -> Int -> Bool
-matchFieldStep Every _ = True
+matchFieldStep Every _    = True
 matchFieldStep (Step x) n = n `mod` x == 0

src/Pattern.hs

@@ -1,53 +1,55 @@
 module Pattern
-    ( Pattern(..),
-      match,
-      safeMatch,
-      parse,
-      check,
-      createParts,
-      parseField
-    ) where
+  ( Pattern(..)
+  , match
+  , safeMatch
+  , parse
+  , check
+  , createParts
+  , parseField
+  ) where
 
-import Data.Dates
-import Data.Maybe
+import           Constraint
+import           Data.Dates
+import           Data.Maybe
+import           Field
 
-import Field
-import Constraint
-
-data Pattern = Pattern {
-    cminute :: Field,
-    chour :: Field,
-    cday :: Field,
-    cmonth :: Field,
-    cweek :: Field,
-    cyear :: Field
-}
+data Pattern = Pattern
+  { cminute :: Field
+  , chour   :: Field
+  , cday    :: Field
+  , cmonth  :: Field
+  , cweek   :: Field
+  , cyear   :: Field
+  }
 
 match :: String -> DateTime -> Bool
-match s d =  case parse s of
-    Just p -> check p d
+match s d =
+  case parse s of
+    Just p  -> check p d
     Nothing -> error "Parse error"
 
 safeMatch :: String -> DateTime -> Maybe Bool
-safeMatch s d = case parse s of
-    Just p -> Just (check p d)
+safeMatch s d =
+  case parse s of
+    Just p  -> Just (check p d)
     Nothing -> Nothing
 
 parse :: String -> Maybe Pattern
 parse s
-    | isInvalid = Nothing
-    | otherwise = Just (createPattern $ catMaybes parts)
-    where
-        parts = createParts s
-        isInvalid = not (checkParts parts)
-        createPattern xs = Pattern {
-            cminute = head xs,
-            chour = xs !! 1,
-            cday = xs !! 2,
-            cmonth = xs !! 3,
-            cweek = xs !! 4,
-            cyear = xs !! 5
-        }
+  | isInvalid = Nothing
+  | otherwise = Just (createPattern $ catMaybes parts)
+  where
+    parts = createParts s
+    isInvalid = not (checkParts parts)
+    createPattern xs =
+      Pattern
+      { cminute = head xs
+      , chour = xs !! 1
+      , cday = xs !! 2
+      , cmonth = xs !! 3
+      , cweek = xs !! 4
+      , cyear = xs !! 5
+      }
 
 createParts s = zipWith (curry f) parsers (words s)
   where
@@ -55,18 +57,23 @@ createParts s = zipWith (curry f) parsers (words s)
 
 checkParts :: [Maybe Field] -> Bool
 checkParts xs
-    | length xs /= 6 = False
-    | any isNothing xs = False
-    | otherwise = True
+  | length xs /= 6 = False
+  | any isNothing xs = False
+  | otherwise = True
 
 parseFieldAdapter :: Constraint -> String -> Maybe Field
 parseFieldAdapter c t = parseField t c
 
 parseMinute = parseFieldAdapter (Constraint 0 59)
+
 parseHour = parseFieldAdapter (Constraint 0 59)
+
 parseDay = parseFieldAdapter (Constraint 1 31)
+
 parseMonth = parseFieldAdapter (Constraint 1 12)
+
 parseWeek = parseFieldAdapter (Constraint 1 7)
+
 parseYear = parseFieldAdapter (Constraint 0 9999)
 
 parsers = [parseMinute, parseHour, parseDay, parseMonth, parseWeek, parseYear]
@@ -74,11 +81,12 @@ parsers = [parseMinute, parseHour, parseDay, parseMonth, parseWeek, parseYear]
 check :: Pattern -> DateTime -> Bool
 check ptn date = all isRight pairs
   where
-    pairs = [ (cminute ptn, minute date),
-              (chour ptn, hour date),
-              (cday ptn, day date),
-              (cmonth ptn, month date),
-              (cweek ptn, weekdayNumber $ dateWeekDay date),
-              (cyear ptn, year date)
-            ]
+    pairs =
+      [ (cminute ptn, minute date)
+      , (chour ptn, hour date)
+      , (cday ptn, day date)
+      , (cmonth ptn, month date)
+      , (cweek ptn, weekdayNumber $ dateWeekDay date)
+      , (cyear ptn, year date)
+      ]
     isRight (p, value) = matchField p value