Development.Cake3

Documentation

data Variable

The representation of Makefile variable

Instances

Eq Variable

Data Variable

Ord Variable

Show Variable

Typeable Variable

MonadAction a m => RefInput a m Variable

data Recipe

Recipe answers to the question 'How to build the targets'. Internally, it contains sets of targets and prerequisites, as well as shell commands required to build former from latter

Instances

Eq Recipe

Data Recipe

Ord Recipe

Show Recipe

Typeable Recipe

MonadAction a m => RefInput a m Recipe

(MonadAction a m, MonadMake a) => RefInput a m (Make Recipe)

Monad m => MonadState Recipe (A' m)

class MonadAction a m => RefInput a m x where

Class of things which may be referenced using '$(expr)' from inside of quasy-quoted shell expressions

Methods

refInput :: x -> a Command

Register the input item, return it's shell-script representation

Instances

MonadAction a m => RefInput a m CakeString

MonadAction a m => RefInput a m Variable

MonadAction a m => RefInput a m Recipe

MonadAction a m => RefInput a m File

MonadAction a m => RefInput a m UWExe

MonadAction a m => RefInput a m UWLib

RefInput a m x => RefInput a m (Maybe x)

(RefInput a m x, MonadMake a) => RefInput a m (Make x)

(MonadAction a m, MonadMake a) => RefInput a m (Make Recipe)

(MonadIO a, RefInput a m x) => RefInput a m (IO x)

MonadAction a m => RefInput a m (Set File)

RefInput a m x => RefInput a m [x]

class Monad m => RefOutput m x where

Class of things which may be referenced using '@(expr)' syntax of the quasi-quoted shell expressions.

Methods

refOutput :: x -> A' m Command

Register the output item, return it's shell-command representation. Files are rendered using space protection quotation, variables are wrapped into $(VAR) syntax, item lists are converted into space-separated lists.

Instances

Monad m => RefOutput m File

RefOutput m x => RefOutput m (Maybe x)

Monad m => RefOutput m (Set File)

Monad m => RefOutput m [File]

data CakeString

Simple wrapper for strings, a target for various typeclass instances.

Instances

Eq CakeString

Ord CakeString

Show CakeString

MonadAction a m => RefInput a m CakeString

string :: String -> CakeString

An alias to CakeString constructor

type A a = A' (Make' IO) a

Verison of Action monad with fixed parents

type Make a = Make' IO a

buildMake :: MakeState -> Either String String

Render the Makefile. Return either the content (Right), or error messages (Left).

runMake :: Make a -> IO String

A General Make runner. Executes the monad, returns the Makefile as a String. Errors go to stdout. fail is possible.

writeMake

Arguments

:: File

Output file

-> Make a

Makefile builder

-> IO ()

Execute the Make monad, build the Makefile, write it to the output file. Also note, that errors (if any) go to the stderr. fail will be executed in such cases

includeMakefile :: Foldable t => t File -> Make ()

Add 'include ...' directive to the final Makefile for each input file.

class Monad m => MonadMake m where

A Monad providing access to MakeState. TODO: not mention IO here.

Methods

liftMake :: Make' IO a -> m a

Instances

MonadMake m => MonadMake (A' m)

MonadMake (Make' IO)

MonadMake m => MonadMake (UrpGen m)

MonadMake m => MonadMake (StateT s m)

rule

Arguments

:: A a

Rule builder

-> Make a

Version of rule2 which places it's recipe above all other recipies.

 let c = file "main.c"

Declare a rule to build main.o out of main.c and CFLAGS variable

 rule $ shell [cmd| gcc -c $(extvar "CFLAGS") -o @(c.="o") $c |]

rule2 :: MonadMake m => A a -> m (Recipe, a)

rule' :: MonadMake m => A a -> m a

Version of rule2, without Make monad set explicitly

phony :: String -> A ()

Adds the phony target for a rule. Typical usage:

 rule $ do
  phony "clean"
  unsafeShell [cmd|rm $elf $os $d|]

depend

Arguments

:: RefInput a m x

=> x

File or [File] or (Set File) or other form of dependency.

-> a ()

Add it's argument to the list of dependencies (prerequsites) of a current recipe under construction

produce

Arguments

:: RefOutput m x

=> x

File or [File] or other form of target.

-> A' m ()

Declare that current recipe produces some producable item.

ignoreDepends :: Monad m => A' m a -> A' m a

Modifie the recipe builder: ignore all the dependencies

prebuild :: MonadMake m => CommandGen -> m ()

Add prebuild command

postbuild :: MonadMake m => CommandGen -> m ()

Add prebuild command

class FileLike a where

Methods

combine :: a -> String -> a

takeDirectory :: a -> a

takeBaseName :: a -> String

takeFileName :: a -> String

makeRelative :: a -> a -> a

replaceExtension :: a -> String -> a

takeExtension :: a -> String

takeExtensions :: a -> String

dropExtensions :: a -> a

Instances

FileLike FilePath

FileLike a => FileLike (FileT a)

type File = FileT FilePath

Simple wrapper for FilePath.

file' :: ProjectLocation -> String -> File

(.=) :: FileLike a => a -> String -> a

Alias for replaceExtension

(</>) :: FileLike a => a -> String -> a

Redefine standard / operator to work with Files

toFilePath :: FileT FilePath -> FilePath

Convert File back to FilePath

readFileForMake

Arguments

:: MonadMake m

=> File

File to read contents of

-> m ByteString

Obtain the contents of a File. Note, that this generally means, that Makefile should be regenerated each time the File is changed.

prerequisites :: (Applicative m, Monad m) => A' m (Set File)

Get a list of prerequisites added so far

shell

Arguments

:: Monad m

=> CommandGen' m

Command builder as returned by cmd quasi-quoter

-> A' m [File]

Apply the recipe builder to the current recipe state. Return the list of targets of the current Recipe under construction

unsafeShell :: Monad m => CommandGen' m -> A' m [File]

Version of shell which doesn't track it's dependencies

cmd :: QuasiQuoter

Has effect of a function QQ -> CommandGen where QQ is a string supporting the following syntax:

• $(expr) evaluates to expr and adds it to the list of dependencies (prerequsites)
• @(expr) evaluates to expr and adds it to the list of targets
• $$ and @@ evaluates to $ and @

Example

 [cmd|gcc $flags -o @file|]

is equivalent to

   return $ CommandGen $ do
     s1 <- refInput "gcc "
     s2 <- refInput (flags :: Variable)
     s3 <- refInput " -o "
     s4 <- refOutput (file :: File)
     return (s1 ++ s2 ++ s3 ++ s4)

Later, this command may be examined or passed to the shell function to apply it to the recipe

makevar

Arguments

:: String

Variable name

-> String

Default value

-> Variable

Declare the variable which is defined in the current Makefile and has it's default value

extvar :: String -> Variable

Declare the variable which is not defined in the target Makefile

newtype CommandGen' m

CommandGen is a recipe-builder packed in the newtype to prevent partial expantion of it's commands

Constructors

CommandGen'

Fields

unCommand :: A' m Command

make :: Variable

Special variable $(MAKE)

data ProjectLocation

Constructors

ProjectLocation

Fields

root :: FilePath

off :: FilePath

Instances

Eq ProjectLocation

Ord ProjectLocation

Show ProjectLocation

currentDirLocation :: MonadIO m => m ProjectLocation

module Data.String

module Control.Monad

module Control.Applicative