{-# LANGUAGE DeriveGeneric #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Distribution.Verbosity
-- Copyright   :  Ian Lynagh 2007
-- License     :  BSD3
--
-- Maintainer  :  cabal-devel@haskell.org
-- Portability :  portable
--
-- A 'Verbosity' type with associated utilities.
--
-- There are 4 standard verbosity levels from 'silent', 'normal',
-- 'verbose' up to 'deafening'. This is used for deciding what logging
-- messages to print.
--
-- Verbosity also is equipped with some internal settings which can be
-- used to control at a fine granularity the verbosity of specific
-- settings (e.g., so that you can trace only particular things you
-- are interested in.)  It's important to note that the instances
-- for 'Verbosity' assume that this does not exist.

-- Verbosity for Cabal functions.

module Distribution.Verbosity (
  -- * Verbosity
  Verbosity,
  silent, normal, verbose, deafening,
  moreVerbose, lessVerbose, isVerboseQuiet,
  intToVerbosity, flagToVerbosity,
  showForCabal, showForGHC,
  verboseNoFlags, verboseHasFlags,
  modifyVerbosity,

  -- * Call stacks
  verboseCallSite, verboseCallStack,
  isVerboseCallSite, isVerboseCallStack,

  -- * Output markets
  verboseMarkOutput, isVerboseMarkOutput,
  verboseUnmarkOutput,

  -- * line-wrapping
  verboseNoWrap, isVerboseNoWrap,

  -- * timestamps
  verboseTimestamp, isVerboseTimestamp,
  verboseNoTimestamp,
  ) where

import Prelude ()
import Distribution.Compat.Prelude

import Distribution.ReadE

import Data.List (elemIndex)
import Data.Set (Set)
import Distribution.Parsec

import qualified Data.Set as Set
import qualified Distribution.Compat.CharParsing as P

data Verbosity = Verbosity {
    Verbosity -> VerbosityLevel
vLevel :: VerbosityLevel,
    Verbosity -> Set VerbosityFlag
vFlags :: Set VerbosityFlag,
    Verbosity -> Bool
vQuiet :: Bool
  } deriving ((forall x. Verbosity -> Rep Verbosity x)
-> (forall x. Rep Verbosity x -> Verbosity) -> Generic Verbosity
forall x. Rep Verbosity x -> Verbosity
forall x. Verbosity -> Rep Verbosity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Verbosity x -> Verbosity
$cfrom :: forall x. Verbosity -> Rep Verbosity x
Generic)

mkVerbosity :: VerbosityLevel -> Verbosity
mkVerbosity :: VerbosityLevel -> Verbosity
mkVerbosity l :: VerbosityLevel
l = Verbosity :: VerbosityLevel -> Set VerbosityFlag -> Bool -> Verbosity
Verbosity { vLevel :: VerbosityLevel
vLevel = VerbosityLevel
l, vFlags :: Set VerbosityFlag
vFlags = Set VerbosityFlag
forall a. Set a
Set.empty, vQuiet :: Bool
vQuiet = Bool
False }

instance Show Verbosity where
    showsPrec :: Int -> Verbosity -> ShowS
showsPrec n :: Int
n = Int -> VerbosityLevel -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
n (VerbosityLevel -> ShowS)
-> (Verbosity -> VerbosityLevel) -> Verbosity -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verbosity -> VerbosityLevel
vLevel

instance Read Verbosity where
    readsPrec :: Int -> ReadS Verbosity
readsPrec n :: Int
n s :: String
s = ((VerbosityLevel, String) -> (Verbosity, String))
-> [(VerbosityLevel, String)] -> [(Verbosity, String)]
forall a b. (a -> b) -> [a] -> [b]
map (\(x :: VerbosityLevel
x,y :: String
y) -> (VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
x,String
y)) (Int -> ReadS VerbosityLevel
forall a. Read a => Int -> ReadS a
readsPrec Int
n String
s)

instance Eq Verbosity where
    x :: Verbosity
x == :: Verbosity -> Verbosity -> Bool
== y :: Verbosity
y = Verbosity -> VerbosityLevel
vLevel Verbosity
x VerbosityLevel -> VerbosityLevel -> Bool
forall a. Eq a => a -> a -> Bool
== Verbosity -> VerbosityLevel
vLevel Verbosity
y

instance Ord Verbosity where
    compare :: Verbosity -> Verbosity -> Ordering
compare x :: Verbosity
x y :: Verbosity
y = VerbosityLevel -> VerbosityLevel -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Verbosity -> VerbosityLevel
vLevel Verbosity
x) (Verbosity -> VerbosityLevel
vLevel Verbosity
y)

instance Enum Verbosity where
    toEnum :: Int -> Verbosity
toEnum = VerbosityLevel -> Verbosity
mkVerbosity (VerbosityLevel -> Verbosity)
-> (Int -> VerbosityLevel) -> Int -> Verbosity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> VerbosityLevel
forall a. Enum a => Int -> a
toEnum
    fromEnum :: Verbosity -> Int
fromEnum = VerbosityLevel -> Int
forall a. Enum a => a -> Int
fromEnum (VerbosityLevel -> Int)
-> (Verbosity -> VerbosityLevel) -> Verbosity -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verbosity -> VerbosityLevel
vLevel

instance Bounded Verbosity where
    minBound :: Verbosity
minBound = VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
forall a. Bounded a => a
minBound
    maxBound :: Verbosity
maxBound = VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
forall a. Bounded a => a
maxBound

instance Binary Verbosity

data VerbosityLevel = Silent | Normal | Verbose | Deafening
    deriving ((forall x. VerbosityLevel -> Rep VerbosityLevel x)
-> (forall x. Rep VerbosityLevel x -> VerbosityLevel)
-> Generic VerbosityLevel
forall x. Rep VerbosityLevel x -> VerbosityLevel
forall x. VerbosityLevel -> Rep VerbosityLevel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VerbosityLevel x -> VerbosityLevel
$cfrom :: forall x. VerbosityLevel -> Rep VerbosityLevel x
Generic, Int -> VerbosityLevel -> ShowS
[VerbosityLevel] -> ShowS
VerbosityLevel -> String
(Int -> VerbosityLevel -> ShowS)
-> (VerbosityLevel -> String)
-> ([VerbosityLevel] -> ShowS)
-> Show VerbosityLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VerbosityLevel] -> ShowS
$cshowList :: [VerbosityLevel] -> ShowS
show :: VerbosityLevel -> String
$cshow :: VerbosityLevel -> String
showsPrec :: Int -> VerbosityLevel -> ShowS
$cshowsPrec :: Int -> VerbosityLevel -> ShowS
Show, ReadPrec [VerbosityLevel]
ReadPrec VerbosityLevel
Int -> ReadS VerbosityLevel
ReadS [VerbosityLevel]
(Int -> ReadS VerbosityLevel)
-> ReadS [VerbosityLevel]
-> ReadPrec VerbosityLevel
-> ReadPrec [VerbosityLevel]
-> Read VerbosityLevel
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VerbosityLevel]
$creadListPrec :: ReadPrec [VerbosityLevel]
readPrec :: ReadPrec VerbosityLevel
$creadPrec :: ReadPrec VerbosityLevel
readList :: ReadS [VerbosityLevel]
$creadList :: ReadS [VerbosityLevel]
readsPrec :: Int -> ReadS VerbosityLevel
$creadsPrec :: Int -> ReadS VerbosityLevel
Read, VerbosityLevel -> VerbosityLevel -> Bool
(VerbosityLevel -> VerbosityLevel -> Bool)
-> (VerbosityLevel -> VerbosityLevel -> Bool) -> Eq VerbosityLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VerbosityLevel -> VerbosityLevel -> Bool
$c/= :: VerbosityLevel -> VerbosityLevel -> Bool
== :: VerbosityLevel -> VerbosityLevel -> Bool
$c== :: VerbosityLevel -> VerbosityLevel -> Bool
Eq, Eq VerbosityLevel
Eq VerbosityLevel =>
(VerbosityLevel -> VerbosityLevel -> Ordering)
-> (VerbosityLevel -> VerbosityLevel -> Bool)
-> (VerbosityLevel -> VerbosityLevel -> Bool)
-> (VerbosityLevel -> VerbosityLevel -> Bool)
-> (VerbosityLevel -> VerbosityLevel -> Bool)
-> (VerbosityLevel -> VerbosityLevel -> VerbosityLevel)
-> (VerbosityLevel -> VerbosityLevel -> VerbosityLevel)
-> Ord VerbosityLevel
VerbosityLevel -> VerbosityLevel -> Bool
VerbosityLevel -> VerbosityLevel -> Ordering
VerbosityLevel -> VerbosityLevel -> VerbosityLevel
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VerbosityLevel -> VerbosityLevel -> VerbosityLevel
$cmin :: VerbosityLevel -> VerbosityLevel -> VerbosityLevel
max :: VerbosityLevel -> VerbosityLevel -> VerbosityLevel
$cmax :: VerbosityLevel -> VerbosityLevel -> VerbosityLevel
>= :: VerbosityLevel -> VerbosityLevel -> Bool
$c>= :: VerbosityLevel -> VerbosityLevel -> Bool
> :: VerbosityLevel -> VerbosityLevel -> Bool
$c> :: VerbosityLevel -> VerbosityLevel -> Bool
<= :: VerbosityLevel -> VerbosityLevel -> Bool
$c<= :: VerbosityLevel -> VerbosityLevel -> Bool
< :: VerbosityLevel -> VerbosityLevel -> Bool
$c< :: VerbosityLevel -> VerbosityLevel -> Bool
compare :: VerbosityLevel -> VerbosityLevel -> Ordering
$ccompare :: VerbosityLevel -> VerbosityLevel -> Ordering
$cp1Ord :: Eq VerbosityLevel
Ord, Int -> VerbosityLevel
VerbosityLevel -> Int
VerbosityLevel -> [VerbosityLevel]
VerbosityLevel -> VerbosityLevel
VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
VerbosityLevel
-> VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
(VerbosityLevel -> VerbosityLevel)
-> (VerbosityLevel -> VerbosityLevel)
-> (Int -> VerbosityLevel)
-> (VerbosityLevel -> Int)
-> (VerbosityLevel -> [VerbosityLevel])
-> (VerbosityLevel -> VerbosityLevel -> [VerbosityLevel])
-> (VerbosityLevel -> VerbosityLevel -> [VerbosityLevel])
-> (VerbosityLevel
    -> VerbosityLevel -> VerbosityLevel -> [VerbosityLevel])
-> Enum VerbosityLevel
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VerbosityLevel
-> VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
$cenumFromThenTo :: VerbosityLevel
-> VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
enumFromTo :: VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
$cenumFromTo :: VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
enumFromThen :: VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
$cenumFromThen :: VerbosityLevel -> VerbosityLevel -> [VerbosityLevel]
enumFrom :: VerbosityLevel -> [VerbosityLevel]
$cenumFrom :: VerbosityLevel -> [VerbosityLevel]
fromEnum :: VerbosityLevel -> Int
$cfromEnum :: VerbosityLevel -> Int
toEnum :: Int -> VerbosityLevel
$ctoEnum :: Int -> VerbosityLevel
pred :: VerbosityLevel -> VerbosityLevel
$cpred :: VerbosityLevel -> VerbosityLevel
succ :: VerbosityLevel -> VerbosityLevel
$csucc :: VerbosityLevel -> VerbosityLevel
Enum, VerbosityLevel
VerbosityLevel -> VerbosityLevel -> Bounded VerbosityLevel
forall a. a -> a -> Bounded a
maxBound :: VerbosityLevel
$cmaxBound :: VerbosityLevel
minBound :: VerbosityLevel
$cminBound :: VerbosityLevel
Bounded)

instance Binary VerbosityLevel

-- We shouldn't print /anything/ unless an error occurs in silent mode
silent :: Verbosity
silent :: Verbosity
silent = VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Silent

-- Print stuff we want to see by default
normal :: Verbosity
normal :: Verbosity
normal = VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Normal

-- Be more verbose about what's going on
verbose :: Verbosity
verbose :: Verbosity
verbose = VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Verbose

-- Not only are we verbose ourselves (perhaps even noisier than when
-- being "verbose"), but we tell everything we run to be verbose too
deafening :: Verbosity
deafening :: Verbosity
deafening = VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Deafening

moreVerbose :: Verbosity -> Verbosity
moreVerbose :: Verbosity -> Verbosity
moreVerbose v :: Verbosity
v =
    case Verbosity -> VerbosityLevel
vLevel Verbosity
v of
        Silent    -> Verbosity
v -- silent should stay silent
        Normal    -> Verbosity
v { vLevel :: VerbosityLevel
vLevel = VerbosityLevel
Verbose }
        Verbose   -> Verbosity
v { vLevel :: VerbosityLevel
vLevel = VerbosityLevel
Deafening }
        Deafening -> Verbosity
v

lessVerbose :: Verbosity -> Verbosity
lessVerbose :: Verbosity -> Verbosity
lessVerbose v :: Verbosity
v =
    Verbosity -> Verbosity
verboseQuiet (Verbosity -> Verbosity) -> Verbosity -> Verbosity
forall a b. (a -> b) -> a -> b
$
    case Verbosity -> VerbosityLevel
vLevel Verbosity
v of
        Deafening -> Verbosity
v -- deafening stays deafening
        Verbose   -> Verbosity
v { vLevel :: VerbosityLevel
vLevel = VerbosityLevel
Normal }
        Normal    -> Verbosity
v { vLevel :: VerbosityLevel
vLevel = VerbosityLevel
Silent }
        Silent    -> Verbosity
v

-- | Combinator for transforming verbosity level while retaining the
-- original hidden state.
--
-- For instance, the following property holds
--
-- prop> isVerboseNoWrap (modifyVerbosity (max verbose) v) == isVerboseNoWrap v
--
-- __Note__: you can use @modifyVerbosity (const v1) v0@ to overwrite
-- @v1@'s flags with @v0@'s flags.
--
-- @since 2.0.1.0
modifyVerbosity :: (Verbosity -> Verbosity) -> Verbosity -> Verbosity
modifyVerbosity :: (Verbosity -> Verbosity) -> Verbosity -> Verbosity
modifyVerbosity f :: Verbosity -> Verbosity
f v :: Verbosity
v = Verbosity
v { vLevel :: VerbosityLevel
vLevel = Verbosity -> VerbosityLevel
vLevel (Verbosity -> Verbosity
f Verbosity
v) }

intToVerbosity :: Int -> Maybe Verbosity
intToVerbosity :: Int -> Maybe Verbosity
intToVerbosity 0 = Verbosity -> Maybe Verbosity
forall a. a -> Maybe a
Just (VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Silent)
intToVerbosity 1 = Verbosity -> Maybe Verbosity
forall a. a -> Maybe a
Just (VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Normal)
intToVerbosity 2 = Verbosity -> Maybe Verbosity
forall a. a -> Maybe a
Just (VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Verbose)
intToVerbosity 3 = Verbosity -> Maybe Verbosity
forall a. a -> Maybe a
Just (VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
Deafening)
intToVerbosity _ = Maybe Verbosity
forall a. Maybe a
Nothing

parsecVerbosity :: CabalParsing m => m (Either Int Verbosity)
parsecVerbosity :: m (Either Int Verbosity)
parsecVerbosity = m (Either Int Verbosity)
forall b. m (Either Int b)
parseIntVerbosity m (Either Int Verbosity)
-> m (Either Int Verbosity) -> m (Either Int Verbosity)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Either Int Verbosity)
forall a. m (Either a Verbosity)
parseStringVerbosity
  where
    parseIntVerbosity :: m (Either Int b)
parseIntVerbosity = (Int -> Either Int b) -> m Int -> m (Either Int b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Either Int b
forall a b. a -> Either a b
Left m Int
forall (m :: * -> *) a. (CharParsing m, Integral a) => m a
P.integral
    parseStringVerbosity :: m (Either a Verbosity)
parseStringVerbosity = (Verbosity -> Either a Verbosity)
-> m Verbosity -> m (Either a Verbosity)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Verbosity -> Either a Verbosity
forall a b. b -> Either a b
Right (m Verbosity -> m (Either a Verbosity))
-> m Verbosity -> m (Either a Verbosity)
forall a b. (a -> b) -> a -> b
$ do
        VerbosityLevel
level <- m VerbosityLevel
parseVerbosityLevel
        ()
_ <- m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces
        [Verbosity -> Verbosity]
extras <- m (Verbosity -> Verbosity) -> m () -> m [Verbosity -> Verbosity]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
P.sepBy m (Verbosity -> Verbosity)
parseExtra m ()
forall (m :: * -> *). CharParsing m => m ()
P.skipSpaces1
        Verbosity -> m Verbosity
forall (m :: * -> *) a. Monad m => a -> m a
return (((Verbosity -> Verbosity)
 -> (Verbosity -> Verbosity) -> Verbosity -> Verbosity)
-> (Verbosity -> Verbosity)
-> [Verbosity -> Verbosity]
-> Verbosity
-> Verbosity
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Verbosity -> Verbosity)
-> (Verbosity -> Verbosity) -> Verbosity -> Verbosity
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) Verbosity -> Verbosity
forall a. a -> a
id [Verbosity -> Verbosity]
extras (VerbosityLevel -> Verbosity
mkVerbosity VerbosityLevel
level))
    parseVerbosityLevel :: m VerbosityLevel
parseVerbosityLevel = [m VerbosityLevel] -> m VerbosityLevel
forall (m :: * -> *) a. Alternative m => [m a] -> m a
P.choice
        [ String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "silent" m String -> m VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a. Monad m => a -> m a
return VerbosityLevel
Silent
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "normal" m String -> m VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a. Monad m => a -> m a
return VerbosityLevel
Normal
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "verbose" m String -> m VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a. Monad m => a -> m a
return VerbosityLevel
Verbose
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "debug"  m String -> m VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a. Monad m => a -> m a
return VerbosityLevel
Deafening
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "deafening" m String -> m VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VerbosityLevel -> m VerbosityLevel
forall (m :: * -> *) a. Monad m => a -> m a
return VerbosityLevel
Deafening
        ]
    parseExtra :: m (Verbosity -> Verbosity)
parseExtra = Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char '+' m Char -> m (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [m (Verbosity -> Verbosity)] -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a. Alternative m => [m a] -> m a
P.choice
        [ String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "callsite"  m String
-> m (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity -> Verbosity
verboseCallSite
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "callstack" m String
-> m (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity -> Verbosity
verboseCallStack
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "nowrap"    m String
-> m (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity -> Verbosity
verboseNoWrap
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "markoutput" m String
-> m (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity -> Verbosity
verboseMarkOutput
        , String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string "timestamp" m String
-> m (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity -> Verbosity
verboseTimestamp
        ]

flagToVerbosity :: ReadE Verbosity
flagToVerbosity :: ReadE Verbosity
flagToVerbosity = ShowS -> ParsecParser Verbosity -> ReadE Verbosity
forall a. ShowS -> ParsecParser a -> ReadE a
parsecToReadE ShowS
forall a. a -> a
id (ParsecParser Verbosity -> ReadE Verbosity)
-> ParsecParser Verbosity -> ReadE Verbosity
forall a b. (a -> b) -> a -> b
$ do
    Either Int Verbosity
e <- ParsecParser (Either Int Verbosity)
forall (m :: * -> *). CabalParsing m => m (Either Int Verbosity)
parsecVerbosity
    case Either Int Verbosity
e of
       Right v :: Verbosity
v -> Verbosity -> ParsecParser Verbosity
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity
v
       Left i :: Int
i -> case Int -> Maybe Verbosity
intToVerbosity Int
i of
           Just v :: Verbosity
v  -> Verbosity -> ParsecParser Verbosity
forall (m :: * -> *) a. Monad m => a -> m a
return Verbosity
v
           Nothing -> String -> ParsecParser Verbosity
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> ParsecParser Verbosity)
-> String -> ParsecParser Verbosity
forall a b. (a -> b) -> a -> b
$ "Bad verbosity: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ ". Valid values are 0..3"

showForCabal, showForGHC :: Verbosity -> String

showForCabal :: Verbosity -> String
showForCabal v :: Verbosity
v
    | Set VerbosityFlag -> Bool
forall a. Set a -> Bool
Set.null (Verbosity -> Set VerbosityFlag
vFlags Verbosity
v)
    = String -> (Int -> String) -> Maybe Int -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ShowS
forall a. HasCallStack => String -> a
error "unknown verbosity") Int -> String
forall a. Show a => a -> String
show (Maybe Int -> String) -> Maybe Int -> String
forall a b. (a -> b) -> a -> b
$
        Verbosity -> [Verbosity] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex Verbosity
v [Verbosity
silent,Verbosity
normal,Verbosity
verbose,Verbosity
deafening]
    | Bool
otherwise
    = [String] -> String
unwords ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ (case Verbosity -> VerbosityLevel
vLevel Verbosity
v of
                    Silent -> "silent"
                    Normal -> "normal"
                    Verbose -> "verbose"
                    Deafening -> "debug")
              String -> [String] -> [String]
forall a. a -> [a] -> [a]
: (VerbosityFlag -> [String]) -> [VerbosityFlag] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap VerbosityFlag -> [String]
showFlag (Set VerbosityFlag -> [VerbosityFlag]
forall a. Set a -> [a]
Set.toList (Verbosity -> Set VerbosityFlag
vFlags Verbosity
v))
  where
    showFlag :: VerbosityFlag -> [String]
showFlag VCallSite   = ["+callsite"]
    showFlag VCallStack  = ["+callstack"]
    showFlag VNoWrap     = ["+nowrap"]
    showFlag VMarkOutput = ["+markoutput"]
    showFlag VTimestamp  = ["+timestamp"]
showForGHC :: Verbosity -> String
showForGHC   v :: Verbosity
v = String -> (Int -> String) -> Maybe Int -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ShowS
forall a. HasCallStack => String -> a
error "unknown verbosity") Int -> String
forall a. Show a => a -> String
show (Maybe Int -> String) -> Maybe Int -> String
forall a b. (a -> b) -> a -> b
$
    Verbosity -> [Verbosity] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex Verbosity
v [Verbosity
silent,Verbosity
normal,Verbosity
__,Verbosity
verbose,Verbosity
deafening]
        where __ :: Verbosity
__ = Verbosity
silent -- this will be always ignored by elemIndex

data VerbosityFlag
    = VCallStack
    | VCallSite
    | VNoWrap
    | VMarkOutput
    | VTimestamp
    deriving ((forall x. VerbosityFlag -> Rep VerbosityFlag x)
-> (forall x. Rep VerbosityFlag x -> VerbosityFlag)
-> Generic VerbosityFlag
forall x. Rep VerbosityFlag x -> VerbosityFlag
forall x. VerbosityFlag -> Rep VerbosityFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VerbosityFlag x -> VerbosityFlag
$cfrom :: forall x. VerbosityFlag -> Rep VerbosityFlag x
Generic, Int -> VerbosityFlag -> ShowS
[VerbosityFlag] -> ShowS
VerbosityFlag -> String
(Int -> VerbosityFlag -> ShowS)
-> (VerbosityFlag -> String)
-> ([VerbosityFlag] -> ShowS)
-> Show VerbosityFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VerbosityFlag] -> ShowS
$cshowList :: [VerbosityFlag] -> ShowS
show :: VerbosityFlag -> String
$cshow :: VerbosityFlag -> String
showsPrec :: Int -> VerbosityFlag -> ShowS
$cshowsPrec :: Int -> VerbosityFlag -> ShowS
Show, ReadPrec [VerbosityFlag]
ReadPrec VerbosityFlag
Int -> ReadS VerbosityFlag
ReadS [VerbosityFlag]
(Int -> ReadS VerbosityFlag)
-> ReadS [VerbosityFlag]
-> ReadPrec VerbosityFlag
-> ReadPrec [VerbosityFlag]
-> Read VerbosityFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VerbosityFlag]
$creadListPrec :: ReadPrec [VerbosityFlag]
readPrec :: ReadPrec VerbosityFlag
$creadPrec :: ReadPrec VerbosityFlag
readList :: ReadS [VerbosityFlag]
$creadList :: ReadS [VerbosityFlag]
readsPrec :: Int -> ReadS VerbosityFlag
$creadsPrec :: Int -> ReadS VerbosityFlag
Read, VerbosityFlag -> VerbosityFlag -> Bool
(VerbosityFlag -> VerbosityFlag -> Bool)
-> (VerbosityFlag -> VerbosityFlag -> Bool) -> Eq VerbosityFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VerbosityFlag -> VerbosityFlag -> Bool
$c/= :: VerbosityFlag -> VerbosityFlag -> Bool
== :: VerbosityFlag -> VerbosityFlag -> Bool
$c== :: VerbosityFlag -> VerbosityFlag -> Bool
Eq, Eq VerbosityFlag
Eq VerbosityFlag =>
(VerbosityFlag -> VerbosityFlag -> Ordering)
-> (VerbosityFlag -> VerbosityFlag -> Bool)
-> (VerbosityFlag -> VerbosityFlag -> Bool)
-> (VerbosityFlag -> VerbosityFlag -> Bool)
-> (VerbosityFlag -> VerbosityFlag -> Bool)
-> (VerbosityFlag -> VerbosityFlag -> VerbosityFlag)
-> (VerbosityFlag -> VerbosityFlag -> VerbosityFlag)
-> Ord VerbosityFlag
VerbosityFlag -> VerbosityFlag -> Bool
VerbosityFlag -> VerbosityFlag -> Ordering
VerbosityFlag -> VerbosityFlag -> VerbosityFlag
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VerbosityFlag -> VerbosityFlag -> VerbosityFlag
$cmin :: VerbosityFlag -> VerbosityFlag -> VerbosityFlag
max :: VerbosityFlag -> VerbosityFlag -> VerbosityFlag
$cmax :: VerbosityFlag -> VerbosityFlag -> VerbosityFlag
>= :: VerbosityFlag -> VerbosityFlag -> Bool
$c>= :: VerbosityFlag -> VerbosityFlag -> Bool
> :: VerbosityFlag -> VerbosityFlag -> Bool
$c> :: VerbosityFlag -> VerbosityFlag -> Bool
<= :: VerbosityFlag -> VerbosityFlag -> Bool
$c<= :: VerbosityFlag -> VerbosityFlag -> Bool
< :: VerbosityFlag -> VerbosityFlag -> Bool
$c< :: VerbosityFlag -> VerbosityFlag -> Bool
compare :: VerbosityFlag -> VerbosityFlag -> Ordering
$ccompare :: VerbosityFlag -> VerbosityFlag -> Ordering
$cp1Ord :: Eq VerbosityFlag
Ord, Int -> VerbosityFlag
VerbosityFlag -> Int
VerbosityFlag -> [VerbosityFlag]
VerbosityFlag -> VerbosityFlag
VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
VerbosityFlag -> VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
(VerbosityFlag -> VerbosityFlag)
-> (VerbosityFlag -> VerbosityFlag)
-> (Int -> VerbosityFlag)
-> (VerbosityFlag -> Int)
-> (VerbosityFlag -> [VerbosityFlag])
-> (VerbosityFlag -> VerbosityFlag -> [VerbosityFlag])
-> (VerbosityFlag -> VerbosityFlag -> [VerbosityFlag])
-> (VerbosityFlag
    -> VerbosityFlag -> VerbosityFlag -> [VerbosityFlag])
-> Enum VerbosityFlag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VerbosityFlag -> VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
$cenumFromThenTo :: VerbosityFlag -> VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
enumFromTo :: VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
$cenumFromTo :: VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
enumFromThen :: VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
$cenumFromThen :: VerbosityFlag -> VerbosityFlag -> [VerbosityFlag]
enumFrom :: VerbosityFlag -> [VerbosityFlag]
$cenumFrom :: VerbosityFlag -> [VerbosityFlag]
fromEnum :: VerbosityFlag -> Int
$cfromEnum :: VerbosityFlag -> Int
toEnum :: Int -> VerbosityFlag
$ctoEnum :: Int -> VerbosityFlag
pred :: VerbosityFlag -> VerbosityFlag
$cpred :: VerbosityFlag -> VerbosityFlag
succ :: VerbosityFlag -> VerbosityFlag
$csucc :: VerbosityFlag -> VerbosityFlag
Enum, VerbosityFlag
VerbosityFlag -> VerbosityFlag -> Bounded VerbosityFlag
forall a. a -> a -> Bounded a
maxBound :: VerbosityFlag
$cmaxBound :: VerbosityFlag
minBound :: VerbosityFlag
$cminBound :: VerbosityFlag
Bounded)

instance Binary VerbosityFlag

-- | Turn on verbose call-site printing when we log.
verboseCallSite :: Verbosity -> Verbosity
verboseCallSite :: Verbosity -> Verbosity
verboseCallSite = VerbosityFlag -> Verbosity -> Verbosity
verboseFlag VerbosityFlag
VCallSite

-- | Turn on verbose call-stack printing when we log.
verboseCallStack :: Verbosity -> Verbosity
verboseCallStack :: Verbosity -> Verbosity
verboseCallStack = VerbosityFlag -> Verbosity -> Verbosity
verboseFlag VerbosityFlag
VCallStack

-- | Turn on @-----BEGIN CABAL OUTPUT-----@ markers for output
-- from Cabal (as opposed to GHC, or system dependent).
verboseMarkOutput :: Verbosity -> Verbosity
verboseMarkOutput :: Verbosity -> Verbosity
verboseMarkOutput = VerbosityFlag -> Verbosity -> Verbosity
verboseFlag VerbosityFlag
VMarkOutput

-- | Turn off marking; useful for suppressing nondeterministic output.
verboseUnmarkOutput :: Verbosity -> Verbosity
verboseUnmarkOutput :: Verbosity -> Verbosity
verboseUnmarkOutput = VerbosityFlag -> Verbosity -> Verbosity
verboseNoFlag VerbosityFlag
VMarkOutput

-- | Disable line-wrapping for log messages.
verboseNoWrap :: Verbosity -> Verbosity
verboseNoWrap :: Verbosity -> Verbosity
verboseNoWrap = VerbosityFlag -> Verbosity -> Verbosity
verboseFlag VerbosityFlag
VNoWrap

-- | Mark the verbosity as quiet
verboseQuiet :: Verbosity -> Verbosity
verboseQuiet :: Verbosity -> Verbosity
verboseQuiet v :: Verbosity
v = Verbosity
v { vQuiet :: Bool
vQuiet = Bool
True }

-- | Turn on timestamps for log messages.
verboseTimestamp :: Verbosity -> Verbosity
verboseTimestamp :: Verbosity -> Verbosity
verboseTimestamp = VerbosityFlag -> Verbosity -> Verbosity
verboseFlag VerbosityFlag
VTimestamp

-- | Turn off timestamps for log messages.
verboseNoTimestamp :: Verbosity -> Verbosity
verboseNoTimestamp :: Verbosity -> Verbosity
verboseNoTimestamp = VerbosityFlag -> Verbosity -> Verbosity
verboseNoFlag VerbosityFlag
VTimestamp

-- | Helper function for flag enabling functions
verboseFlag :: VerbosityFlag -> (Verbosity -> Verbosity)
verboseFlag :: VerbosityFlag -> Verbosity -> Verbosity
verboseFlag flag :: VerbosityFlag
flag v :: Verbosity
v = Verbosity
v { vFlags :: Set VerbosityFlag
vFlags = VerbosityFlag -> Set VerbosityFlag -> Set VerbosityFlag
forall a. Ord a => a -> Set a -> Set a
Set.insert VerbosityFlag
flag (Verbosity -> Set VerbosityFlag
vFlags Verbosity
v) }

-- | Helper function for flag disabling functions
verboseNoFlag :: VerbosityFlag -> (Verbosity -> Verbosity)
verboseNoFlag :: VerbosityFlag -> Verbosity -> Verbosity
verboseNoFlag flag :: VerbosityFlag
flag v :: Verbosity
v = Verbosity
v { vFlags :: Set VerbosityFlag
vFlags = VerbosityFlag -> Set VerbosityFlag -> Set VerbosityFlag
forall a. Ord a => a -> Set a -> Set a
Set.delete VerbosityFlag
flag (Verbosity -> Set VerbosityFlag
vFlags Verbosity
v) }

-- | Turn off all flags
verboseNoFlags :: Verbosity -> Verbosity
verboseNoFlags :: Verbosity -> Verbosity
verboseNoFlags v :: Verbosity
v = Verbosity
v { vFlags :: Set VerbosityFlag
vFlags = Set VerbosityFlag
forall a. Set a
Set.empty }

verboseHasFlags :: Verbosity -> Bool
verboseHasFlags :: Verbosity -> Bool
verboseHasFlags = Bool -> Bool
not (Bool -> Bool) -> (Verbosity -> Bool) -> Verbosity -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set VerbosityFlag -> Bool
forall a. Set a -> Bool
Set.null (Set VerbosityFlag -> Bool)
-> (Verbosity -> Set VerbosityFlag) -> Verbosity -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verbosity -> Set VerbosityFlag
vFlags

-- | Test if we should output call sites when we log.
isVerboseCallSite :: Verbosity -> Bool
isVerboseCallSite :: Verbosity -> Bool
isVerboseCallSite = VerbosityFlag -> Verbosity -> Bool
isVerboseFlag VerbosityFlag
VCallSite

-- | Test if we should output call stacks when we log.
isVerboseCallStack :: Verbosity -> Bool
isVerboseCallStack :: Verbosity -> Bool
isVerboseCallStack = VerbosityFlag -> Verbosity -> Bool
isVerboseFlag VerbosityFlag
VCallStack

-- | Test if we should output markets.
isVerboseMarkOutput :: Verbosity -> Bool
isVerboseMarkOutput :: Verbosity -> Bool
isVerboseMarkOutput = VerbosityFlag -> Verbosity -> Bool
isVerboseFlag VerbosityFlag
VMarkOutput

-- | Test if line-wrapping is disabled for log messages.
isVerboseNoWrap :: Verbosity -> Bool
isVerboseNoWrap :: Verbosity -> Bool
isVerboseNoWrap = VerbosityFlag -> Verbosity -> Bool
isVerboseFlag VerbosityFlag
VNoWrap

-- | Test if we had called 'lessVerbose' on the verbosity
isVerboseQuiet :: Verbosity -> Bool
isVerboseQuiet :: Verbosity -> Bool
isVerboseQuiet = Verbosity -> Bool
vQuiet

-- | Test if if we should output timestamps when we log.
isVerboseTimestamp :: Verbosity -> Bool
isVerboseTimestamp :: Verbosity -> Bool
isVerboseTimestamp = VerbosityFlag -> Verbosity -> Bool
isVerboseFlag VerbosityFlag
VTimestamp

-- | Helper function for flag testing functions.
isVerboseFlag :: VerbosityFlag -> Verbosity -> Bool
isVerboseFlag :: VerbosityFlag -> Verbosity -> Bool
isVerboseFlag flag :: VerbosityFlag
flag = (VerbosityFlag -> Set VerbosityFlag -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member VerbosityFlag
flag) (Set VerbosityFlag -> Bool)
-> (Verbosity -> Set VerbosityFlag) -> Verbosity -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verbosity -> Set VerbosityFlag
vFlags

-- $setup
-- >>> import Test.QuickCheck (Arbitrary (..), arbitraryBoundedEnum)
-- >>> instance Arbitrary VerbosityLevel where arbitrary = arbitraryBoundedEnum
-- >>> instance Arbitrary Verbosity where arbitrary = fmap mkVerbosity arbitrary