Reflex.Process.Repl

• Module: Reflex.Process.Repl
• Description: Run repl-like processes in a reflex application.

Documentation

data Repl t

Output of a repl session

Constructors

Repl

Fields

• _repl_process :: Process t ByteString ByteString

  The underlying repl process, which can be used to access the process handle, the raw output, and so on.

• _repl_finished :: Event t (Map Int Cmd)

  An event of commands that the repl has finished executing and their associated output. The Int here represents the order in which commands were submitted to the repl.

• _repl_started :: Dynamic t (Int, Maybe Cmd)

  A dynamic of the currently running command, if any, and its output. The Int here represents the ordering of this command relative to the ones in _repl_finished.

• _repl_exited :: Event t ExitCode

  An event that fires when the repl exits

data Cmd

An individual command submitted to the repl, and its output

Constructors

Cmd

Fields

• _cmd_stdin :: Command
• _cmd_stdout :: Lines
• _cmd_stderr :: Lines

Instances

Eq Cmd

Defined in Reflex.Process.Repl

Methods

(==) :: Cmd -> Cmd -> Bool

(/=) :: Cmd -> Cmd -> Bool

Ord Cmd

Defined in Reflex.Process.Repl

Methods

compare :: Cmd -> Cmd -> Ordering

(<) :: Cmd -> Cmd -> Bool

(<=) :: Cmd -> Cmd -> Bool

(>) :: Cmd -> Cmd -> Bool

(>=) :: Cmd -> Cmd -> Bool

max :: Cmd -> Cmd -> Cmd

min :: Cmd -> Cmd -> Cmd

Show Cmd

Defined in Reflex.Process.Repl

Methods

showsPrec :: Int -> Cmd -> ShowS

show :: Cmd -> String

showList :: [Cmd] -> ShowS

data Accum

An accumulator used to track and combine the repl's output streams

Constructors

Accum

Fields

• _accum_stdout :: (Map Int Lines, Int, Lines)
• _accum_stderr :: (Map Int Lines, Int, Lines)

accumHandle :: (Int -> ByteString -> Bool) -> ByteString -> (Map Int Lines, Int, Lines) -> (Map Int Lines, Int, Lines)

Accumulate a handle, grouping its output by prompts

accumHandles :: (Int -> ByteString -> Bool) -> These ByteString ByteString -> Accum -> Accum

Accumulate the output of stdout and stderr, grouping the output lines of both by prompt

flushAccum :: Accum -> Accum

Take all the pending output and consider it complete.

repl

Arguments

:: forall t m. (Adjustable t m, MonadFix m, MonadHold t m, MonadIO (Performable m), MonadIO m, NotReady t m, PerformEvent t m, PostBuild t m, TriggerEvent t m)

=> CreateProcess

Command to run to enter repl

-> Event t [Command]

Commands to send to the repl

-> (Int -> ByteString -> Bool)

Test for determining whether a line is the prompt we're waiting or

-> m (Repl t)

Run a repl, feed it commands, and produce output grouped by those commands. The repl in question must be able to print its prompt on both stdout and stderr.

data Lines

Accumulator for line-based output that keeps track of any dangling, unterminated line

Constructors

Lines

Fields

• _lines_terminated :: Seq ByteString
• _lines_unterminated :: Maybe ByteString

Instances

Eq Lines

Defined in Reflex.Process.Repl

Methods

(==) :: Lines -> Lines -> Bool

(/=) :: Lines -> Lines -> Bool

Ord Lines

Defined in Reflex.Process.Repl

Methods

compare :: Lines -> Lines -> Ordering

(<) :: Lines -> Lines -> Bool

(<=) :: Lines -> Lines -> Bool

(>) :: Lines -> Lines -> Bool

(>=) :: Lines -> Lines -> Bool

max :: Lines -> Lines -> Lines

min :: Lines -> Lines -> Lines

Read Lines

Defined in Reflex.Process.Repl

Methods

readsPrec :: Int -> ReadS Lines

readList :: ReadS [Lines]

readPrec :: ReadPrec Lines

readListPrec :: ReadPrec [Lines]

Show Lines

Defined in Reflex.Process.Repl

Methods

showsPrec :: Int -> Lines -> ShowS

show :: Lines -> String

showList :: [Lines] -> ShowS

Semigroup Lines

Defined in Reflex.Process.Repl

Methods

(<>) :: Lines -> Lines -> Lines

sconcat :: NonEmpty Lines -> Lines

stimes :: Integral b => b -> Lines -> Lines

Monoid Lines

Defined in Reflex.Process.Repl

Methods

mempty :: Lines

mappend :: Lines -> Lines -> Lines

mconcat :: [Lines] -> Lines

emptyLines :: Lines

Empty output

addLines :: ByteString -> Lines -> Lines

Add some raw output to a Lines. This will chop the raw output up into lines.

linesFromBS :: ByteString -> Lines

Convert a ByteString into a Lines

unLines :: Lines -> ByteString

Convert a Lines back into a ByteString

lastWholeLine :: Lines -> Maybe ByteString

Convenience accessor for the last whole line received by a Lines. Ignores any unterminated line that may follow.

splitLinesOn :: (ByteString -> Bool) -> Lines -> Maybe (Lines, Lines)

Split lines into two. The sequence that satisfies the predicate is consumed and will not appear in either resulting Lines.

data Command

A string that will be sent to the repl for evaluation. A newline will be appended to the end of the string. Commands should not themselves contain newlines.

Instances

Eq Command

Defined in Reflex.Process.Repl

Methods

(==) :: Command -> Command -> Bool

(/=) :: Command -> Command -> Bool

Ord Command

Defined in Reflex.Process.Repl

Methods

compare :: Command -> Command -> Ordering

(<) :: Command -> Command -> Bool

(<=) :: Command -> Command -> Bool

(>) :: Command -> Command -> Bool

(>=) :: Command -> Command -> Bool

max :: Command -> Command -> Command

min :: Command -> Command -> Command

Read Command

Defined in Reflex.Process.Repl

Methods

readsPrec :: Int -> ReadS Command

readList :: ReadS [Command]

readPrec :: ReadPrec Command

readListPrec :: ReadPrec [Command]

Show Command

Defined in Reflex.Process.Repl

Methods

showsPrec :: Int -> Command -> ShowS

show :: Command -> String

showList :: [Command] -> ShowS

unsafeCommand :: ByteString -> Command

Constructs a Command without checking for newlines. If there are newlines in the input, things will not work properly.

command :: ByteString -> [Command]

Convert a ByteString into a set of Commands. Any newlines found in the input are considered Command separators.

commands :: [ByteString] -> [Command]

Convert a ByteString into a set of Commands. Any newlines found in the input are considered Command separators.

displayCommand :: Command -> ByteString

Turn a command back into a ByteString.

sendCommands :: [Command] -> Maybe (SendPipe ByteString)

Convert commands to a format that can be sent over stdin

testRepl :: IO ()

A headless repl test that runs ghci, executes some commands, and checks that the output is as expected.

mkTestCommands :: (PerformEvent t m, PostBuild t m, TriggerEvent t m, MonadIO (Performable m)) => m (Event t [Command])

Constructs some testing commands that are fed in on a timer

assertStdoutEq :: MonadIO m => String -> Maybe Cmd -> ByteString -> m Bool

Check that stdout equals the given value

assertStderrEq :: MonadIO m => String -> Maybe Cmd -> ByteString -> m Bool

Check that stderr equals the given value

assertStderr :: MonadIO m => String -> Maybe Cmd -> (Lines -> Bool) -> m Bool

Test the contents of stderr

assertStdout :: MonadIO m => String -> Maybe Cmd -> (Lines -> Bool) -> m Bool

Test the contents of stdout

assertHandleEq :: MonadIO m => (Cmd -> Lines) -> String -> Maybe Cmd -> ByteString -> m Bool

Check that a handle equals the given value

assertHandle :: MonadIO m => (Cmd -> Lines) -> String -> Maybe Cmd -> (Lines -> Bool) -> m Bool

Test the contents of a handle

assertCmd :: MonadIO m => String -> Maybe Cmd -> (Cmd -> Bool) -> m Bool

Test that a repl command and its output satisfy the predicate