How do I parameterise and repeat a build step - f#

Question

I'm writing a FAKE script which will basically do the following: -
1. Clean build outputs
2. Modify a configuration file with a specific value.
3. Perform a build.
4. Upload the outputs somewhere.
I've written all the individual tasks. What I now need to do is to set up a set of FAKE build steps to essentially repeat the above steps, once for each configuration value e.g. let's assume the configuration file had an attribute "colour". I want to repeat the above four build steps, and in step 2 use one of the values [ "black"; "blue"; "red"; "white" ].
What's the best way of achieving this? Should I just make one big build task that does all of this in one e.g. for loop (seems wrong)? Or create multiple build steps e.g. "Set Config to Blue" and "Set Config to Red" etc. and repeat the whole build flow for each colour (again, seems wrong)?

Answer 1

It's not very good documented, but you can create targets programmatically via TargetTemplateWithDependecies
I will add some docs.

Answer 2

You can do it like this
#r "tools/FAKE/tools/FakeLib.dll"
open Fake
Target "Clean" (fun _ ->
trace "Cleaning stuff..."
)
let config color = ignore()
Target "ConfigBlack" (fun _ ->
config "black"
)
Target "ConfigRed" (fun _ ->
config "red"
)
Target "Build" (fun _ ->
trace "Build solution"
)
Target "Upload" (fun _ ->
trace "Upload artifacts"
)
"Clean"
=?> ("ConfigBlack",hasBuildParam "black")
=?> ("ConfigRed",hasBuildParam "red")
==> "Build"
==> "Upload"
Run "Upload"
After that you will be able to call in like this build Upload black or build Upload red

Answer 3

The script below works but uses ExecutedTargets which I don't think you should use.
#I "tools/FAKE/tools"
#r "FakeLib.dll"
open Fake
let mutable value = "Foo"
Target "Clean" (fun _ ->
trace "clean target"
)
Target "Modify config file" (fun _ ->
trace (sprintf "===========> Modify config file: '%s'" value)
)
Target "Perform build" (fun _ ->
trace "Perform build"
)
Target "Default" (fun _ -> ())
"Clean"
==> "Modify config file"
==> "Perform build"
==> "Default"
["black"; "blue"; "red"; "white"]
|> List.iter(fun v ->
value <- v
Run <| getBuildParamOrDefault "target" "Default"
ExecutedTargets.Clear()
)

Answer 4

Can you use various configurations? For example:
BlueBuild:
[configsection]
[Color]Blue[/Color]
[/configsection]
RedBuild:
[configsection]
[Color]Red[/Color]
[/configsection]
See the following Articles:
How to select different app.config for several build configurations
http://www.hanselman.com/blog/managingmultipleconfigurationfileenvironmentswithprebuildevents.aspx

Answer 5

The way I've done this is to basically write a helper function which generates targets - much like the template dependency does - but also generates multiple instances of the "common" targets; each one differs based on the name of the variable element e.g.
let targets =
[ "Blue: Clean"
"Blue: Modify Config"
"Blue: Perform Build"
"Blue: Upload outputs"
"Red: Clean"
"Red: Modify Config"
"Red: Perform Build"
"Red: Upload outputs"
"Yellow: Clean"
"Yellow: Modify Config"
"Yellow: Perform Build"
"Yellow: Upload outputs" ]
You can then easily build then into a sequential chain of dependencies with e.g.
targets |> List.reduce (==>)
Whilst this is not exactly what I had hoped for, it works well enough for me and lets me see through Fake where things are.