FAKE build setup with external build properties file setup

build.fsx

#r "./FAKE/tools/FakeLib.dll"
#r "System.Xml"
#load "initializeProperties.fsx"
open InitializeProperties
open Fake
open System
open System.IO
open System.Configuration
open System.Xml

let getOutputDirs =
    let dirs = [BUILD_OUTPUT; TEST_OUTPUT; DEPLOY_OUTPUT]
    dirs |> Seq.map (fun dir ->
                        match dir with
                        | null -> Option<string>.None
                        | x -> Some(x))
         |> Seq.filter Option.isSome
         |> Seq.map (fun x -> x.Value)

Target "Clean" (fun _ -> 
    DeleteDirs getOutputDirs
)

Target "Purge" (fun _ -> 
    DeleteDirs getOutputDirs
    DeleteDir <| PACKAGE_OUTPUT
)

Target "RestorePackages" (fun _ -> 
     PACKAGE_CONFIG_PATH
     |> RestorePackage (fun p ->
         { p with
            ToolPath = NUGET_PATH
            OutputPath = PACKAGE_OUTPUT
            Retries = 4 })
)

Target "Build" (fun _ ->
    let setParams defaults = 
        {defaults with
            Targets = ["Build"];
            Verbosity = Some(Quiet);
            ToolsVersion = Some "12.0";
            Properties = [
                            "Configuration", BUILD_CONFIGURATION
                            "OutputPath", BUILD_OUTPUT
            ]
        }
    build setParams WEB_PROJECT_PATH
)

Target "Test" (fun _ ->
    trace "nothing to test here yet"
)

Target "Package" (fun _ ->
    let setParams defaults = 
        {defaults with
            Targets = ["Package"];
            Verbosity = Some(Quiet);
            ToolsVersion = Some "12.0";
            Properties = [
                            "Configuration", BUILD_CONFIGURATION
                            "OutputPath", BUILD_OUTPUT
                            "CreatePackageOnPublish", "False"
                            "DeployOnBuild", "False"
                            "VSToolsPath", VS_TOOLS_PATH
                            "IsDesktopBuild", "False"
                            "PackageLocation", DEPLOY_OUTPUT
            ]
        }
    build setParams WEB_PROJECT_PATH
)

"Clean"
    ==> "RestorePackages"
    ==> "Build"
    ==> "Test"
    ==> "Package"
// start build
trace VS_TOOLS_PATH
trace <| "Running build for " + environVar "ENV"
RunTargetOrDefault "RestorePackages"

default.properties.cmd

REM set BUILD_SCRIPT_PATH=%~dp0
REM set PROJECT_PATH=%BUILD_SCRIPT_PATH%\..\
REM FOR /F "delims=" %%F IN ("%PROJECT_PATH%") DO SET "PROJECT_PATH=%%~fF"
REM 
REM set NUGET_PATH=%PROJECT_PATH%tools/nuget.exe
REM set PACKAGE_CONFIG_PATH=%PROJECT_PATH%packages.config
REM set PACKAGE_OUTPUT=%PROJECT_PATH%_packages
REM set BUILD_OUTPUT=%PROJECT_PATH%_buildoutput
REM set TEST_OUTPUT=%PROJECT_PATH%_testoutput
REM set DEPLOY_OUTPUT=%PROJECT_PATH%_deployoutput

go.cmd

@echo off
cls
if not defined ENV (set ENV=%COMPUTERNAME%)
echo Beginning build... %ENV%

if not exist "%~dp0FAKE\tools\Fake.exe" (
	echo FAKE is missing
	echo Installing FAKE...
	"..\tools\NuGet.exe" "Install" "FAKE" "-ExcludeVersion"
)

if exist ".\FAKE\tools\Fake.exe" (
    call ".\includeProperties.cmd" "%~dp0/default.properties.cmd"
    call ".\includeProperties.cmd" "%~dp0/%ENV%.properties.cmd"
	call ".\FAKE\tools\Fake.exe" %*
) else (
	echo Error: Could not locate FAKE
    exit /b 1
)
exit /b %errorlevel%

includeProperties.cmd

if exist %~f1 (
    echo Running %~f1
    call %~f1
)

initializeProperties.fsx

#r "./FAKE/tools/FakeLib.dll"
open Fake
open System
open System.IO

let setEnvVarIfNotExist (varName:string) (varValue:string) =
    match environVarOrNone varName with
    | None -> setEnvironVar varName varValue
    | Some(v) -> ()


let BUILD_SCRIPT_PATH = environVarOrDefault "BUILD_SCRIPT_PATH" __SOURCE_DIRECTORY__
let PROJECT_PATH = environVarOrDefault "PROJECT_PATH" <| Path.GetFullPath(BUILD_SCRIPT_PATH + @"\..\")
let WEB_SLN_PATH = environVarOrDefault "WEB_SLN_PATH" <| PROJECT_PATH + @"Zoo.sln"
let WEB_PROJECT_PATH = environVarOrDefault "WEB_SLN_PATH" <| PROJECT_PATH + @"src\WebZoo\WebZoo.fsproj"
let TOOLS_PATH = environVarOrDefault "TOOLS_PATH" <| PROJECT_PATH + @"tools\"
let VS_TOOLS_PATH = environVarOrDefault "VS_TOOLS_PATH" <| TOOLS_PATH + @"VS_tools"
let NUGET_PATH = environVarOrDefault "NUGET_PATH" <| TOOLS_PATH + @"nuget.exe"
let PACKAGE_CONFIG_PATH = environVarOrDefault "PACKAGE_CONFIG_PATH" <| PROJECT_PATH + @"packages.config"
let PACKAGE_OUTPUT = environVarOrDefault "PACKAGE_OUTPUT" <| PROJECT_PATH + @"_packages"
let BUILD_OUTPUT = environVarOrDefault "BUILD_OUTPUT" <| PROJECT_PATH + @"_build"
let TEST_OUTPUT = environVarOrDefault "TEST_OUTPUT" <| PROJECT_PATH + @"_test"
let DEPLOY_OUTPUT = environVarOrDefault "DEPLOY_OUTPUT" <| PROJECT_PATH + @"_deploy"

let BUILD_CONFIGURATION = environVarOrDefault "BUILD_CONFIGURATION" "Release"

So, the go.cmd is where it all begins

go.cmd loads up and runs the "default.properties.cmd" and "[machineName].properties.cmd" files. Any environment variables can be set here. Build servers should have an easier time with the environment variables

go.cmd then runs build.fsx which in turn loads includeProperties.fsx

includeProperties.fsx file just sets up FSharp variables for those environment variables so that we can get intellisense. "Calculated proeprties" can also be formulated here. Most properties should be calculated properties based on one or more static properties set at start of execution. Ideally, these would be functions that are fetching these values, but that decision can be left up to preference and if the values for those calculated properties change dynamically at runtime

Any feedback is very much appreciated