Development.Shake.Path

Documentation

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

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

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

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

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

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

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:

cmd_ "git log --pretty=" "oneline"           -- git log --pretty= oneline
cmd_ "git log --pretty=" ["oneline"]         -- git log --pretty= oneline
cmd_ "git log" ("--pretty=" ++ "oneline")    -- git log --pretty=oneline
cmd_ "git log" ("--pretty=" ++ "one line")   -- git log --pretty=one line
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
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, use cmd_.

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

IsCmdArgument CmdOption

Methods

toCmdArgument :: CmdOption -> CmdArgument

IsCmdArgument [CmdOption]

Methods

toCmdArgument :: [CmdOption] -> CmdArgument

module Path

module Path.IO