module HaskellCI.Config.Jobs where

import HaskellCI.Prelude

import qualified Distribution.Compat.CharParsing as C
import qualified Distribution.Parsec             as C
import qualified Distribution.Pretty             as C
import qualified Text.PrettyPrint                as PP

-- | Jobs
--
-- * @N:M@ - @N@ ghcs (cabal -j), @M@ threads (ghc -j)
--
-- >>> let parseJobs = C.simpleParsec :: String -> Maybe Jobs
-- >>> parseJobs "2:2"
-- Just (BothJobs 2 2)
--
-- >>> parseJobs ":2"
-- Just (GhcJobs 2)
--
-- >>> parseJobs "2"
-- Just (CabalJobs 2)
--
-- >>> parseJobs "garbage"
-- Nothing
--
data Jobs
    = CabalJobs Int
    | GhcJobs Int
    | BothJobs Int Int
  deriving (Int -> Jobs -> ShowS
[Jobs] -> ShowS
Jobs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Jobs] -> ShowS
$cshowList :: [Jobs] -> ShowS
show :: Jobs -> String
$cshow :: Jobs -> String
showsPrec :: Int -> Jobs -> ShowS
$cshowsPrec :: Int -> Jobs -> ShowS
Show)

cabalJobs :: Jobs -> Maybe Int
cabalJobs :: Jobs -> Maybe Int
cabalJobs (CabalJobs Int
n)  = forall a. a -> Maybe a
Just Int
n
cabalJobs (GhcJobs Int
_)    = forall a. Maybe a
Nothing
cabalJobs (BothJobs Int
n Int
_) = forall a. a -> Maybe a
Just Int
n

ghcJobs :: Jobs -> Maybe Int
ghcJobs :: Jobs -> Maybe Int
ghcJobs (CabalJobs Int
_)  = forall a. Maybe a
Nothing
ghcJobs (GhcJobs Int
m)    = forall a. a -> Maybe a
Just Int
m
ghcJobs (BothJobs Int
_ Int
m) = forall a. a -> Maybe a
Just Int
m

instance C.Parsec Jobs where
    parsec :: forall (m :: * -> *). CabalParsing m => m Jobs
parsec = m Jobs
ghc forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Jobs
rest where
        ghc :: m Jobs
ghc  = forall (m :: * -> *). CharParsing m => Char -> m Char
C.char Char
':' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Int -> Jobs
GhcJobs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. (CharParsing m, Integral a) => m a
C.integral)
        rest :: m Jobs
rest = do
            Int
n <- forall (m :: * -> *) a. (CharParsing m, Integral a) => m a
C.integral
            Maybe Int
m' <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
C.optional (forall (m :: * -> *). CharParsing m => Char -> m Char
C.char Char
':' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. (CharParsing m, Integral a) => m a
C.integral)
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case Maybe Int
m' of
                Maybe Int
Nothing -> Int -> Jobs
CabalJobs Int
n
                Just Int
m  -> Int -> Int -> Jobs
BothJobs Int
n Int
m

instance C.Pretty Jobs where
    pretty :: Jobs -> Doc
pretty (BothJobs Int
n Int
m) = Int -> Doc
PP.int Int
n Doc -> Doc -> Doc
PP.<> Doc
PP.colon Doc -> Doc -> Doc
PP.<> Int -> Doc
PP.int Int
m
    pretty (CabalJobs Int
n)  = Int -> Doc
PP.int Int
n
    pretty (GhcJobs Int
m)    = Doc
PP.colon Doc -> Doc -> Doc
PP.<> Int -> Doc
PP.int Int
m