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


-- | A simple DevOps tool which will never "reach" enterprice level.
--   
--   A simple DevOps tool which will never "reach" enterprice level. It is
--   basically a Haskell lib which you can use to create nice scripts that
--   setup you computer, via ssh bashscrip, Dockerfile, etc
@package azubi
@version 0.2.0.2


-- | Example:
--   
--   <pre>
--   import Azubi
--   
--   main :: IO ()
--   main = azubiMain $ []
--          &amp; installed (Ebuild "vim")
--          &amp; uptodate (Git "git<tt>github.com:mrVanDalo/azubi.git" "/dev/shm/azubi")
--          &amp; installed (Git "git</tt>github.com:mrVanDalo/azubi-config.git" "/dev/shm/azubi-config")
--          &amp; run (Always "touch" ["<i>dev</i>shm/run.test"])
--          &amp; link "/dev/shm/azubi.link" "/dev/shm/azubi"
--   </pre>
module Azubi

-- | The low level element to formulate a state on a machine. If the check
--   returns <a>No</a> the <a>Command</a>s will run. So the author should
--   make sure the <a>Command</a> will result in a <a>Yes</a> the next time
--   this state will run.
--   
--   All <a>Check</a>s have to return <a>Yes</a> to avoid the
--   <a>Command</a>s to be run.
--   
--   If a <a>Command</a> returns a <a>Failure</a> the following commands
--   will not be called. Same holdes for <a>States</a> if one of the states
--   fail, the following <a>State</a>s will not be <i>run</i>.
data State

-- | State contains checks and commands if one command failed the following
--   commands will not be executed.
State :: [Check] -> [Command] -> (Maybe Comment) -> State

-- | To create depended states which should stop being executed when a
--   previous state fails
States :: [Check] -> [State] -> (Maybe Comment) -> State

-- | Ebuild is a Portage package (used by Gentoo and Funtoo).
--   
--   <a>http://gentoo.org</a>
--   
--   See <a>installed</a>.
data Ebuild
Ebuild :: String -> Ebuild

-- | Git is a version control system.
--   
--   <a>http://git.scm.com</a>
--   
--   See <a>installed</a>.
data Git
Git :: RepoUrl -> Path -> [GitOption] -> Git
data GitOption
Recursive :: GitOption

-- | The way a command should be run. See <a>run</a>
data RunCommand

-- | run command every time
Always :: String -> [Argument] -> RunCommand

-- | run command and creates a file to prevent to run again
Once :: String -> [Argument] -> Path -> RunCommand

-- | install a piece of software on the system. The <i>piece</i> of
--   software should be typed of course.
installed :: Installable a => a -> State

-- | To install Software you have to instance the Installable class.
class Installable a

-- | install a piece of software on the system. The <i>piece</i> of
--   software should be typed of course.
installed :: Installable a => a -> State

-- | make sure something is installed and up to date.
uptodate :: Updatable a => a -> State

-- | Same like <a>Installable</a> but will also make sure there you have
--   the newest version.
class Updatable a

-- | make sure something is installed and up to date.
uptodate :: Updatable a => a -> State

-- | creates a <a>State</a> that will run a command of your choice.
run :: RunCommand -> State

-- | ensure there is a link file -&gt; target
--   
--   example:
--   
--   <pre>
--   link "~/file" "~/target"
--   </pre>
--   
--   will create a link at <tt>~/file/</tt> pointing to <tt>~/target/</tt>
link :: Path -> Path -> State

-- | make sure a folder exists
folderExists :: Path -> State

-- | Create a state that ensures that a file in <tt>Path</tt> will have the
--   content of the String List.
--   
--   Every String in the List will be a Line in the File.
content :: Path -> [String] -> State

-- | Creates a state out of two states. When the first State fails the
--   second State will not be checked nor enforced.
--   
--   This can also be achieved using <a>submodule</a>:
--   
--   <pre>
--   stateA <a>requires</a> stateB == <a>submodule</a> [stateB, stateA]
--   </pre>
requires :: State -> State -> State

-- | Create a state containing of sub-states, which have to be fulfilled in
--   order.
--   
--   If one state is not fulfilled, the following will be ignored.
submodule :: [State] -> State

-- | <a>State</a> combinator.
--   
--   <pre>
--   []
--   &amp; folderExists "/tmp/foo"
--   &amp; folderExists "/tmp/bar"
--   </pre>
(&) :: [State] -> State -> [State]

-- | The function you should use to get you commands running.
azubiMain :: [State] -> IO ()

-- | A command is something that will be run. In a normal case you put a
--   <a>Check</a> before using a <a>State</a>
--   
--   When a Command get executed, it will create a <a>CommandResult</a>.
--   
--   <pre>
--   command -&gt; exit code -&gt; <a>CommandResult</a>
--   </pre>
data Command
Run :: String -> [Argument] -> (Maybe Comment) -> Command
FileContent :: Path -> [String] -> Command
CreateSymlink :: Path -> Target -> Command
CreateFolder :: Path -> Command
Remove :: Path -> Command

-- | Gather information about a situation.
--   
--   <pre>
--   check -&gt; success/failure
--   check -&gt; exit code -&gt; success/failure
--   </pre>
data Check

-- | Check if command returns exit status
--   
--   <pre>
--   0 -&gt; Yes
--   _ -&gt; No
--   </pre>
Check :: String -> [Argument] -> (Maybe Comment) -> Check
AlwaysYes :: Check

-- | Opposite result of a <a>Check</a>
Not :: Check -> Check

-- | Check if <a>Path</a> has content
HasFileContent :: Path -> [String] -> Check

-- | Check if a Symbolic link exists to a specific target
SymlinkExists :: Path -> Target -> Check

-- | Check if a folder exists
FolderExists :: Path -> Check

-- | Check if something exists at path
DoesExist :: Path -> Check