The shellout package

[ Tags: bsd3, library, program, system ] [ Propose Tags ]

Please see the README on Github at https://github.com/loganmac/shellout#readme


[Skip to Readme]

Properties

Versions 0.1.0.0
Change log ChangeLog.md
Dependencies async, base (>=4.7 && <5), shellout, stm, text, typed-process [details]
License BSD3
Copyright 2018 Logan McPhail
Author Logan McPhail
Maintainer logan.airnomad@gmail.com
Category System
Home page https://github.com/loganmac/shellout#readme
Bug tracker https://github.com/loganmac/shellout/issues
Source repo head: git clone https://github.com/loganmac/shellout
Uploaded Mon Feb 5 01:28:15 UTC 2018 by loganmac
Distributions NixOS:0.1.0.0
Executables example
Downloads 28 total (28 in the last 30 days)
Rating (no votes yet) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2018-02-05 [all 1 reports]
Hackage Matrix CI

Modules

[Index]

Downloads

Maintainer's Corner

For package maintainers and hackage trustees


Readme for shellout-0.1.0.0

[back to package description]

shellout

A simple library for running standard processes in a threaded manager , and responding to/doing things with stdout, stderr, and exits as they happen.

This was mainly built out of frustration that most libraries wait for a task to complete before giving output.

Just initialize with a driver and off you go!

Example

Here's a short annotated example on how to use this:

{-# LANGUAGE OverloadedStrings #-}
module Main where

import qualified Shellout

import           Control.Concurrent (threadDelay)
import           Data.Monoid        ((<>))
import           Data.Text          (Text)
import qualified Data.Text.IO       as T

-- create a type to hold data that will be passed between all of your handlers,
-- where you could store things like the task name, a spinner's position
-- and last spin time, etc.
newtype Task = Task {name :: Text}

main :: IO ()
main = do
  -- create a 'driver', with functions that handle each type of output
  let driver = Shellout.Driver
        -- (optionally) do something with the task name, and initialize
        -- data that will be passed between your handlers. you could store
        -- things like the task name, a spinner's position and last spin time, etc.
        { Shellout.initialState =
          \taskName -> Task {name = taskName}

        -- what to do when polling returns `Nothing`, so it's waiting on
        -- more output from the task, but the task still hasn't exited.
        -- In this example, we just sleep.
        , Shellout.handleNothing =
          \task -> threadDelay 1000 >> pure task

        -- what to do on stdout from the shell command. You could colorize it,
        -- append it to list of output (you could keep a list of them in the `Task`), etc.
        , Shellout.handleOut =
          \task txt -> T.putStrLn (name task <> ": " <> txt) >> pure task

        -- what to do on stderr. Same things go as stdout.
        , Shellout.handleErr =
          \task txt -> T.putStrLn (name task <> ": " <> txt) >> pure task

        -- what to do when a task completes successfully
        , Shellout.handleSuccess =
          \task -> T.putStrLn $ (name task) <> " complete."

        -- what to do when a task doesn't complete successfully
        , Shellout.handleFailure =
          \task -> T.putStrLn $ (name task) <> " failed."
        }

  shell <- Shellout.new driver

  shell "listing directory" "ls"

  shell "listing hidden files" "ls -lah"