System.Unix.Progress

Control the progress reporting and output of subprocesses.

The Progress Monad

type Progress m a = MonadIO m => StateT ProgressState m a

A monad for controlling progress reporting of subprocesses.

data ProgressFlag

The flags that control what type of output will be sent to stdout and stderr. Also, the ExceptionOnFail flag controls whether an exception will be thrown if the ExitCode is not ExitSuccess.

Constructors

Echo

Dots

All

Errors

Result

EchoOnFail

AllOnFail

ErrorsOnFail

ResultOnFail

ExceptionOnFail

Instances

Eq ProgressFlag

Ord ProgressFlag

quietnessLevels :: [Set ProgressFlag] -> Int -> Set ProgressFlag

Create a function that returns the flags used for a given quietness level.

runProgress

Arguments

:: MonadIO m

=> (Int -> Set ProgressFlag)

-> Progress m a

The progress task to be run

-> m a

Run the Progress monad with the given flags. The flag set is compute from the current quietness level, <= 0 the most verbose and >= 3 the least.

Process launching

lazyCommandP :: MonadIO m => (Int -> Set ProgressFlag) -> String -> ByteString -> m [Output]

lazyProcessP :: MonadIO m => (Int -> Set ProgressFlag) -> FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> ByteString -> m [Output]

Quietness control

defaultQuietness :: MonadIO m => m Int

Look for occurrences of -v and -q in the command line arguments and the current values of environment variables VERBOSITY and QUIETNESS to compute a new value for QUIETNESS. If you want to ignore the current QUIETNESS value say setQuietness 0 >> computeQuietness.

modQuietness :: MonadIO m => (Int -> Int) -> m a -> m a

Perform a task with the given quietness level.

quieter :: MonadIO m => Int -> m a -> m a

Do an IO task with additional -v or -q arguments so that the progress reporting becomes more or less verbose.

Output stream processing

timeTask :: MonadIO m => m a -> m (a, NominalDiffTime)

Run a task and return the elapsed time along with its result.

showElapsed :: MonadIO m => String -> m a -> m a

Perform a task, print the elapsed time it took, and return the result.

ePutStr :: MonadIO m => String -> m ()

Send a string to stderr.

ePutStrLn :: MonadIO m => String -> m ()

ePutStr with a terminating newline.

qPutStr :: MonadIO m => String -> m ()

If the current quietness level is less than one print a message. Control the quietness level using quieter.

qPutStrLn :: MonadIO m => String -> m ()

qPutStr with a terminating newline.

eMessage :: MonadIO m => String -> a -> m a

Print a message and return the second argument unevaluated.

eMessageLn :: MonadIO m => String -> a -> m a

eMessage with a terminating newline.

qMessage :: MonadIO m => String -> a -> m a

eMessage controlled by the quietness level.

qMessageLn :: MonadIO m => String -> a -> m a

qMessage with a terminating newline.

Unit tests

tests :: [Test]

Unit tests.

A set of lazyCommand functions for an example set of verbosity levels

defaultLevels :: [Set ProgressFlag]

lazyCommandV :: MonadIO m => String -> ByteString -> m [Output]

lazyProcessV :: MonadIO m => FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> ByteString -> m [Output]

lazyCommandF :: MonadIO m => String -> ByteString -> m [Output]

lazyProcessF :: MonadIO m => FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> ByteString -> m [Output]

lazyCommandE :: MonadIO m => String -> ByteString -> m [Output]

lazyProcessE :: MonadIO m => FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> ByteString -> m [Output]

lazyCommandEF :: MonadIO m => String -> ByteString -> m [Output]

lazyProcessEF :: MonadIO m => FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> ByteString -> m [Output]

lazyCommandD :: MonadIO m => String -> ByteString -> m [Output]

lazyCommandQ :: MonadIO m => String -> ByteString -> m [Output]

lazyCommandS :: MonadIO m => String -> ByteString -> m [Output]

lazyCommandSF :: MonadIO m => String -> ByteString -> m [Output]