-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell CLI framework
--   
--   Haskell CLI framework. See <a>README.md</a> for more details.
@package iris
@version 0.0.0.0


-- | Implements a function that opens a given file in a browser.
module Iris.Browse

-- | Open a given file in a browser. The function has the following
--   algorithm:
--   
--   <ul>
--   <li>Check the <tt>BROWSER</tt> environment variable</li>
--   <li>If it's not set, try to guess browser depending on OS</li>
--   <li>If unsuccsessful, print a message</li>
--   </ul>
--   
--   <b>Throws:</b> <a>BrowseException</a> if can't find a browser.
openInBrowser :: FilePath -> IO ()

-- | Exception thrown by <a>openInBrowser</a>.
newtype BrowseException

-- | Can't find a browser application. Stores the current OS inside.
BrowserNotFoundException :: String -> BrowseException
instance GHC.Exception.Type.Exception Iris.Browse.BrowseException
instance GHC.Classes.Eq Iris.Browse.BrowseException
instance GHC.Show.Show Iris.Browse.BrowseException


-- | CLI options parsing for <tt>--browse</tt> and
--   <tt>--browse=<a>FILE_PATH</a></tt>.
module Iris.Cli.Browse

-- | A CLI option parser yields a boolean value if a file needs to be open
--   in a browser.
--   
--   Use <a>openInBrowser</a> to open the file of your choice in a browser.
browseP :: String -> Parser Bool

-- | A CLI option parser for a <a>FilePath</a> that needs to be open with a
--   browser.
--   
--   Use <a>openInBrowser</a> to open the passed file in a browser.
browseFileP :: String -> Parser FilePath


-- | Interative mode datatype and CLI parser.
module Iris.Cli.Interactive
data InteractiveMode

Interactive :: InteractiveMode

NonInteractive :: InteractiveMode

-- | A CLI option parser for switching to non-interactive mode if the flag
--   is passed.
interactiveModeP :: Parser InteractiveMode
instance GHC.Classes.Eq Iris.Cli.Interactive.InteractiveMode
instance GHC.Show.Show Iris.Cli.Interactive.InteractiveMode


-- | CLI options parsing for <tt>--version</tt> and
--   <tt>--numeric-version</tt>
--   
--   <b>Enabled with config</b>
module Iris.Cli.Version

data VersionSettings
VersionSettings :: Version -> (String -> String) -> VersionSettings

[versionSettingsVersion] :: VersionSettings -> Version

[versionSettingsMkDesc] :: VersionSettings -> String -> String

defaultVersionSettings :: Version -> VersionSettings

fullVersionP :: VersionSettings -> Parser (a -> a)

mkVersionParser :: Maybe VersionSettings -> Parser (a -> a)


-- | CLI options parsing.
module Iris.Cli


-- | The <a>ColourMode</a> data type that allows disabling and enabling of
--   colouring.
module Iris.Colour.Mode

-- | Data type that tells whether the colouring is enabled or disabled. Its
--   value is detected automatically on application start and stored in
--   <a>CliEnv</a>.
data ColourMode

DisableColour :: ColourMode

EnableColour :: ColourMode

-- | Returns <a>ColourMode</a> of a <a>Handle</a>. You can use this
--   function on output <a>Handle</a>s to find out whether they support
--   colouring or not.
--   
--   Use a function like this to check whether you can print with colour to
--   terminal:
--   
--   <pre>
--   <a>handleColourMode</a> <a>stdout</a>
--   </pre>
handleColourMode :: Handle -> IO ColourMode
instance GHC.Enum.Bounded Iris.Colour.Mode.ColourMode
instance GHC.Enum.Enum Iris.Colour.Mode.ColourMode
instance GHC.Classes.Ord Iris.Colour.Mode.ColourMode
instance GHC.Classes.Eq Iris.Colour.Mode.ColourMode
instance GHC.Show.Show Iris.Colour.Mode.ColourMode


-- | Utilities to check required tools and their minimal version for a CLI
--   app.
module Iris.Tool

data Tool cmd
Tool :: Text -> Maybe (ToolSelector cmd) -> Tool cmd

[toolName] :: Tool cmd -> Text

[toolSelector] :: Tool cmd -> Maybe (ToolSelector cmd)

data ToolSelector cmd
ToolSelector :: (cmd -> Text -> Bool) -> Maybe Text -> ToolSelector cmd

[toolSelectorFunction] :: ToolSelector cmd -> cmd -> Text -> Bool

[toolSelectorVersionArg] :: ToolSelector cmd -> Maybe Text

defaultToolSelector :: ToolSelector cmd

data ToolCheckResult

ToolNotFound :: Text -> ToolCheckResult

ToolWrongVersion :: Text -> ToolCheckResult

ToolOk :: ToolCheckResult

checkTool :: cmd -> Tool cmd -> IO ToolCheckResult
instance GHC.Classes.Eq Iris.Tool.ToolCheckResult
instance GHC.Show.Show Iris.Tool.ToolCheckResult
instance Data.String.IsString (Iris.Tool.Tool cmd)


-- | Environment of a CLI app.
module Iris.Env

data CliEnvSettings (cmd :: Type) (appEnv :: Type)
CliEnvSettings :: Parser cmd -> appEnv -> String -> String -> Maybe VersionSettings -> [Tool cmd] -> CliEnvSettings (cmd :: Type) (appEnv :: Type)

[cliEnvSettingsCmdParser] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> Parser cmd

[cliEnvSettingsAppEnv] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> appEnv

[cliEnvSettingsHeaderDesc] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> String

[cliEnvSettingsProgDesc] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> String

[cliEnvSettingsVersionSettings] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> Maybe VersionSettings

[cliEnvSettingsRequiredTools] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> [Tool cmd]

defaultCliEnvSettings :: CliEnvSettings () ()

-- | CLI application environment. It contains default settings for every
--   CLI app and parameter
--   
--   Has the following type parameters:
--   
--   <ul>
--   <li><tt>cmd</tt> — application commands</li>
--   <li><tt>appEnv</tt> — application-specific environment; use
--   <tt>()</tt> if you don't have custom app environment</li>
--   </ul>
data CliEnv (cmd :: Type) (appEnv :: Type)
CliEnv :: cmd -> ColourMode -> ColourMode -> appEnv -> InteractiveMode -> CliEnv (cmd :: Type) (appEnv :: Type)

[cliEnvCmd] :: CliEnv (cmd :: Type) (appEnv :: Type) -> cmd

[cliEnvStdoutColourMode] :: CliEnv (cmd :: Type) (appEnv :: Type) -> ColourMode

[cliEnvStderrColourMode] :: CliEnv (cmd :: Type) (appEnv :: Type) -> ColourMode

[cliEnvAppEnv] :: CliEnv (cmd :: Type) (appEnv :: Type) -> appEnv

[cliEnvInteractiveMode] :: CliEnv (cmd :: Type) (appEnv :: Type) -> InteractiveMode

newtype CliEnvException
CliEnvException :: CliEnvError -> CliEnvException
[unCliEnvException] :: CliEnvException -> CliEnvError

newtype CliEnvError

CliEnvToolError :: ToolCheckResult -> CliEnvError

-- | <b>Throws:</b> <a>CliEnvException</a>
mkCliEnv :: forall cmd appEnv. CliEnvSettings cmd appEnv -> IO (CliEnv cmd appEnv)

-- | Get a field from the global environment <a>CliEnv</a>.
asksCliEnv :: MonadReader (CliEnv cmd appEnv) m => (CliEnv cmd appEnv -> field) -> m field

-- | Get a field from custom application-specific environment
--   <tt>appEnv</tt>.
asksAppEnv :: MonadReader (CliEnv cmd appEnv) m => (appEnv -> field) -> m field
instance GHC.Classes.Eq Iris.Env.CliEnvError
instance GHC.Show.Show Iris.Env.CliEnvError
instance GHC.Exception.Type.Exception Iris.Env.CliEnvException
instance GHC.Classes.Eq Iris.Env.CliEnvException
instance GHC.Show.Show Iris.Env.CliEnvException


-- | Helper functions to print with colouring.
module Iris.Colour.Formatting

-- | Print <a>ByteString</a> to <a>stdout</a> by providing a custom
--   formatting function.
--   
--   This works especially well with the <tt>colourista</tt> package:
--   
--   <pre>
--   <a>putStdoutColouredLn</a>
--       (Colourista.formatWith [Colourista.bold, Colourista.green])
--       "my message"
--   </pre>
putStdoutColouredLn :: (MonadReader (CliEnv cmd appEnv) m, MonadIO m) => (ByteString -> ByteString) -> ByteString -> m ()

-- | Print <a>ByteString</a> to <a>stderr</a> by providing a custom
--   formatting function.
--   
--   This works especially well with the <tt>colourista</tt> package:
--   
--   <pre>
--   <a>putStderrColouredLn</a>
--       (Colourista.formatWith [Colourista.bold, Colourista.green])
--       "my message"
--   </pre>
putStderrColouredLn :: (MonadReader (CliEnv cmd appEnv) m, MonadIO m) => (ByteString -> ByteString) -> ByteString -> m ()


-- | Functions to handle colouring of the output to terminal.
module Iris.Colour


-- | Haskell CLI framework
module Iris.App

-- | Main monad for your CLI application.
newtype CliApp cmd appEnv a
CliApp :: (CliEnv cmd appEnv -> IO a) -> CliApp cmd appEnv a
[unCliApp] :: CliApp cmd appEnv a -> CliEnv cmd appEnv -> IO a

-- | Run application with settings.
runCliApp :: CliEnvSettings cmd appEnv -> CliApp cmd appEnv a -> IO a

-- | Run application by constructing <a>CliEnv</a> settings manually.
runCliAppManually :: CliEnv cmd appEnv -> CliApp cmd appEnv a -> IO a
instance Control.Monad.IO.Unlift.MonadUnliftIO (Iris.App.CliApp cmd appEnv)
instance Control.Monad.Reader.Class.MonadReader (Iris.Env.CliEnv cmd appEnv) (Iris.App.CliApp cmd appEnv)
instance Control.Monad.IO.Class.MonadIO (Iris.App.CliApp cmd appEnv)
instance GHC.Base.Monad (Iris.App.CliApp cmd appEnv)
instance GHC.Base.Applicative (Iris.App.CliApp cmd appEnv)
instance GHC.Base.Functor (Iris.App.CliApp cmd appEnv)


-- | <b>Iris</b> is a Haskell CLI framework. It contains batteries for
--   bulding CLI applications in Haskell by following best-practices.
--   
--   The library is designed for <b>qualified</b> imports. To use it,
--   import like this:
--   
--   <pre>
--   <b>import qualified</b> <a>Iris</a>
--   </pre>
--   
--   To create an CLI application with <b>Iris</b>, you need to do the
--   following steps:
--   
--   <ol>
--   <li>Create settings for your applications by constructing a value of
--   type <a>CliEnvSettings</a>.</li>
--   <li>Define a monad for your application with the help of <a>CliApp</a>
--   by using either <b>type</b> or <b>newtype</b>.</li>
--   </ol>
--   
--   That's all! Now, you can write your CLI app by having access to all
--   capabilities provided by <b>Iris</b> 🎉
module Iris