Safe Haskell	None
Language	Haskell2010

Development.Shake.Path

Synopsis

Documentation

getHashedShakeVersionP :: [Path r File] -> IO String Source #

needP :: [Path r File] -> Action () Source #

wantP :: [Path r File] -> Rules () Source #

($%>) :: Path r File -> Action () -> Rules () Source #

($&%>) :: [Path r File] -> Action () -> Rules () Source #

orderOnlyP :: [Path r File] -> Action () Source #

cmd :: CmdArguments args => (:->) args (Action r) #

Execute a system command. Before running cmd make sure you need any files that are used by the command.

String arguments are treated as whitespace separated arguments.
[String] arguments are treated as literal arguments.
CmdOption arguments are used as options.

As some examples, here are some calls, and the resulting command string:

unit $ cmd "git log --pretty=" "oneline"           -- git log --pretty= oneline
unit $ cmd "git log --pretty=" ["oneline"]         -- git log --pretty= oneline
unit $ cmd "git log" ("--pretty=" ++ "oneline")    -- git log --pretty=oneline
unit $ cmd "git log" ("--pretty=" ++ "one line")   -- git log --pretty=one line
unit $ cmd "git log" ["--pretty=" ++ "one line"]   -- git log "--pretty=one line"

More examples, including return values, see this translation of the examples given for the command function:

() <- cmd "gcc -c myfile.c"                                  -- compile a file, throwing an exception on failure
unit $ cmd "gcc -c myfile.c"                                 -- alternative to () <- binding.
Exit c <- cmd "gcc -c" [myfile]                              -- run a command, recording the exit code
(Exit c, Stderr err) <- cmd "gcc -c myfile.c"                -- run a command, recording the exit code and error output
Stdout out <- cmd "gcc -MM myfile.c"                         -- run a command, recording the output
cmd (Cwd "generated") "gcc -c" [myfile] :: Action ()         -- run a command in a directory

When passing file arguments we use [myfile] so that if the myfile variable contains spaces they are properly escaped.

If you use cmd inside a do block and do not use the result, you may get a compile-time error about being unable to deduce CmdResult. To avoid this error, bind the result to (), or include a type signature, or use the unit function.

The cmd function can also be run in the IO monad, but then Traced is ignored and command lines are not echoed. As an example:

cmd (Cwd "generated") Shell "gcc -c myfile.c" :: IO ()

liftIO :: MonadIO m => forall a. IO a -> m a #

Lift a computation from the IO monad.

data CmdOption :: * #

Options passed to command or cmd to control how processes are executed.

Constructors

Cwd FilePath	Change the current directory in the spawned process. By default uses this processes current directory.
Env [(String, String)]	Change the environment variables in the spawned process. By default uses this processes environment.
AddEnv String String	Add an environment variable in the child process.
RemEnv String	Remove an environment variable from the child process.
AddPath [String] [String]	Add some items to the prefix and suffix of the `$PATH` variable.
Stdin String	Given as the `stdin` of the spawned process. By default the `stdin` is inherited.
StdinBS ByteString	Given as the `stdin` of the spawned process.
FileStdin FilePath	Take the `stdin` from a file.
Shell	Pass the command to the shell without escaping - any arguments will be joined with spaces. By default arguments are escaped properly.
BinaryPipes	Treat the `stdin`/`stdout`/`stderr` messages as binary. By default `String` results use text encoding and `ByteString` results use binary encoding.
Traced String	Name to use with `traced`, or `""` for no tracing. By default traces using the name of the executable.
Timeout Double	Abort the computation after N seconds, will raise a failure exit code. Calls `interruptProcessGroupOf` and `terminateProcess`, but may sometimes fail to abort the process and not timeout.
WithStdout Bool	Should I include the `stdout` in the exception if the command fails? Defaults to `False`.
WithStderr Bool	Should I include the `stderr` in the exception if the command fails? Defaults to `True`.
EchoStdout Bool	Should I echo the `stdout`? Defaults to `True` unless a `Stdout` result is required or you use `FileStdout`.
EchoStderr Bool	Should I echo the `stderr`? Defaults to `True` unless a `Stderr` result is required or you use `FileStderr`.
FileStdout FilePath	Should I put the `stdout` to a file.
FileStderr FilePath	Should I put the `stderr` to a file.
AutoDeps	Compute dependencies automatically.

Instances

Eq CmdOption
Methods (==) :: CmdOption -> CmdOption -> Bool # (/=) :: CmdOption -> CmdOption -> Bool #
Data CmdOption
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CmdOption -> c CmdOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CmdOption # toConstr :: CmdOption -> Constr # dataTypeOf :: CmdOption -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c CmdOption) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CmdOption) # gmapT :: (forall b. Data b => b -> b) -> CmdOption -> CmdOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CmdOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CmdOption -> r # gmapQ :: (forall d. Data d => d -> u) -> CmdOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CmdOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CmdOption -> m CmdOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CmdOption -> m CmdOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CmdOption -> m CmdOption #
Ord CmdOption
Methods compare :: CmdOption -> CmdOption -> Ordering # (<) :: CmdOption -> CmdOption -> Bool # (<=) :: CmdOption -> CmdOption -> Bool # (>) :: CmdOption -> CmdOption -> Bool # (>=) :: CmdOption -> CmdOption -> Bool # max :: CmdOption -> CmdOption -> CmdOption # min :: CmdOption -> CmdOption -> CmdOption #
Show CmdOption
Methods showsPrec :: Int -> CmdOption -> ShowS # show :: CmdOption -> String # showList :: [CmdOption] -> ShowS #
Arg CmdOption
Methods arg :: CmdOption -> [Either CmdOption String]
Arg [CmdOption]
Methods arg :: [CmdOption] -> [Either CmdOption String]
CmdArguments [Either CmdOption String]
Methods cmdArguments :: [Either CmdOption String] -> [Either CmdOption String]

module Path

module Path.IO