build.template

#r @"packages/build/FAKE/tools/FakeLib.dll"

open Fake
open Fake.AssemblyInfoFile
open Fake.ProcessHelper

open System
open System.IO
open System.Text.RegularExpressions

(*################################# Definitions #################################*)

type GitVersionInfo = {
  Major: int
  Minor: int
  Patch: int
  CommitsAhead : int
  IsReleaseCandidate : bool
  PreReleaseVersion: (string*int) option
  Hash: string
  Sha: string
  Branch: string
  LatestReleaseTag: string option
}

let BuildAssemblyVersion info =
  if info.CommitsAhead = 0
  then new Version(info.Major, info.Minor, info.Patch, info.CommitsAhead)
  else
    match info.Branch with
      | "release" -> new Version(info.Major, info.Minor + 1, 0, 0)
      | "hotfix" -> new Version(info.Major, info.Minor, info.Patch + 1, 0)
      | _ -> new Version(info.Major, info.Minor, info.Patch, info.CommitsAhead)

let CreateAssemblyVersion info =
  let assemblyVersion = BuildAssemblyVersion info
  sprintf "%i.%i.%i.%i" assemblyVersion.Major assemblyVersion.Minor assemblyVersion.Build assemblyVersion.Revision

let CreateSemVer info =
  let assemblyVersion = BuildAssemblyVersion info
  match info.PreReleaseVersion with
  | Some (tag, version) -> sprintf "%i.%i.%i-%s%i" assemblyVersion.Major assemblyVersion.Minor assemblyVersion.Build tag version
  | None -> sprintf "%i.%i.%i" assemblyVersion.Major assemblyVersion.Minor assemblyVersion.Build

let CreateInformationalVersion info =
  sprintf "%s+%i.Branch.%s.Sha.%s" (CreateSemVer info) info.CommitsAhead info.Branch info.Sha
  
let IsPublishAllowed info =
  (info.Branch = "master" && info.CommitsAhead = 0) || (info.Branch = "integration" && info.CommitsAhead <> 0)

let GetPreReleaseTag branch =
  match branch with
      | "master" -> None
      | "hotfix" -> Some("rc")
      | "release" -> Some("rc")
      | "develop" -> Some("beta")
      | _ -> Some("alpha")

let ApplyBranchConvention info =
  let preReleaseTag = GetPreReleaseTag info.Branch
  match preReleaseTag with
  | Some tag ->
    { info with
        IsReleaseCandidate = tag = "rc"
        PreReleaseVersion = Some(tag, info.CommitsAhead) }
  | None -> info
  
let ApplyConvention info =
  match info.LatestReleaseTag with
  | Some tag ->
    let versionRegEx = Regex.Match(tag, "(?<version>\d+\.\d+(\.\d+)?)(-(?<prerelease>[A-Za-z-]*)((?<preversion>\d+))?)?")
    if versionRegEx.Success
      then
        let version = Version.Parse versionRegEx.Groups.["version"].Value
        let preReleaseTagGroup = versionRegEx.Groups.["prerelease"]
        let preReleaseVersion =
          if preReleaseTagGroup.Success
            then
              let preReleaseVersion =
                let preReleaseVersionGroup = versionRegEx.Groups.["preversion"]
                if preReleaseVersionGroup.Success
                  then int preReleaseVersionGroup.Value
                  else info.CommitsAhead
              Some(preReleaseTagGroup.Value, preReleaseVersion) 
            else info.PreReleaseVersion
        { info with
            Major = version.Major
            Minor = version.Minor
            Patch = if version.Build < 0 then 0 else version.Build
            IsReleaseCandidate = preReleaseVersion |> Option.fold (fun _ (tag, version) -> tag = "rc") false
            PreReleaseVersion = preReleaseVersion
        }
      else ApplyBranchConvention info
  | None -> ApplyBranchConvention info

let GetVersionInfo tagPrefix =
  let sha = Git.Information.getCurrentSHA1 ""
  let latestReleaseTag = 
    Git.CommandHelper.runSimpleGitCommand "" (sprintf "describe --tags --abbrev=0 HEAD --always --match \"%s[0-9]*.[0-9]*\"" tagPrefix)
    |> (fun result -> if result <> sha then Some(result) else None)
  let branch = Git.CommandHelper.runSimpleGitCommand "" "rev-parse --abbrev-ref HEAD"
  let commitsAhead =
    if latestReleaseTag.IsSome 
      then Git.Branches.revisionsBetween "" latestReleaseTag.Value sha 
      else int (Git.CommandHelper.runSimpleGitCommand "" "rev-list HEAD --count")
  
  { Major = 0
    Minor = 0
    Patch = 0
    CommitsAhead = commitsAhead
    IsReleaseCandidate = false
    PreReleaseVersion = None
    Hash = Git.Information.getCurrentHash()
    Sha = sha
    Branch = branch
    LatestReleaseTag = latestReleaseTag }
  |> ApplyConvention
  
(*################################# Assign Variables #################################*)

let solutionFile  = "##ProjectName##.sln"
let testAssemblies = "tests/**/bin/Release/*Tests*.dll"

let versionInfo = GetVersionInfo "release/*"

let dirBuildOutput = "_build.output"
let dirTestsOutput = dirBuildOutput @@ "tests"
let dirDocOutput = dirBuildOutput @@ "docs"
let dirNuGetOutput = dirBuildOutput @@ "nuget"
let dirBinOutput = dirBuildOutput @@ "bin"

let buildConfiguration = "Release"

(*################################# Print Variables #################################*)

traceHeader "Variables"
trace <| sprintf "%A" versionInfo
traceHeader ""

(*################################# Tasks #################################*)

Target "AssemblyInfo" (fun _ ->
  
  let assemblyVersion = CreateAssemblyVersion versionInfo
  let informationalVersion = CreateInformationalVersion versionInfo

  trace <| sprintf "AssemblyVersion: %s" assemblyVersion
  trace <| sprintf "AssemblyInformationalVersion: %s" informationalVersion
  
  !! ("src/**/*Info.cs")
    |> Seq.iter(fun file ->
       (ReplaceAssemblyInfoVersions (fun f ->
          { f with
              AssemblyInformationalVersion = informationalVersion
              AssemblyVersion = assemblyVersion
              OutputFileName = file })
        
        Git.CommandHelper.fireAndForgetGitCommand "" ("update-index --assume-unchanged " + file)
        )
    )
)

Target "CopyBinaries" (fun _ ->
  !! "src/**/*.??proj"
  -- "src/**/*.shproj"
  |>  Seq.map (fun f -> ((System.IO.Path.GetDirectoryName f) </> "bin/Release", dirBuildOutput @@ "bin" </> (System.IO.Path.GetFileNameWithoutExtension f)))
  |>  Seq.iter (fun (fromDir, toDir) -> CopyDir toDir fromDir (fun _ -> true))
)

Target "Clean" (fun _ ->
  CleanDirs [dirBuildOutput]
)

Target "CleanDocs" (fun _ ->
  CleanDirs [ dirBuildOutput @@ "docs"]
)

Target "Build" (fun _ ->
  MSBuildDefaults  <- { MSBuildDefaults with Verbosity = Some(MSBuildVerbosity.Quiet) }
  sprintf "building %s -> %s" solutionFile buildConfiguration |> traceHeader
  MSBuild "" "Build" ["Configuration", buildConfiguration] [solutionFile] |> ignore
)

Target "RunTests" (fun _ ->
  let tests = !! testAssemblies
  if not (tests |> Seq.isEmpty)
  then  
    ensureDirectory dirTestsOutput
    tests
      |> NUnit (fun p -> 
        { p with
            ShowLabels = false
            ErrorLevel = DontFailBuild
            DisableShadowCopy = true
            TimeOut = (TimeSpan.FromMinutes 10.)
            Domain = MultipleDomainModel
            ProcessModel = MultipleProcessModel
            OutputFile = (dirTestsOutput @@ "nunit-report.xml")
            })
            
    PublishArtifact dirTestsOutput
)

Target "NuGet" (fun _ ->
  Paket.Pack(fun p ->
      {p with
          Version = (CreateSemVer versionInfo)
          OutputPath = dirNuGetOutput
          })
          
  PublishArtifact dirNuGetOutput
)

Target "NuGetPush" (fun _ ->
  if not (IsPublishAllowed versionInfo)
  then failwithf "Vom aktuellen Stand darf keine keine Lieferung verteilt werden. %A" versionInfo
  
  let nugetPublishUrl = environVarOrFail "NuGetPublishUrl"
  let nugetApiKey = environVarOrFail "nugetkey"
  
  Paket.Push(fun p ->
      {p with
          WorkingDir = (dirBuildOutput @@ "nuget")
          PublishUrl = nugetPublishUrl
          ApiKey = nugetApiKey
          DegreeOfParallelism = 1
          EndPoint = "api/packages"
          })
)

Target "GenerateDocs" (fun _ ->
  traceHeader "GenerateDocs"
  
  let dirDocs = "docs"
  
  let result =
    ExecProcess (fun info ->
      info.FileName <- currentDirectory @@ "packages" @@ "build" @@ "docfx.msbuild" @@ "tools" @@ "docfx.exe"
      info.Arguments <- sprintf "%s" (dirDocs @@ "docfx.json")
      ) (TimeSpan.FromMinutes 5.)

  if result <> 0 then failwithf "Error during docfx execution."
  
  let testResults = dirTestsOutput @@ "nunit-report.xml"
  if (fileExists testResults)
  then
    let result =
      ExecProcess (fun info ->
        info.FileName <- currentDirectory @@ "packages" @@ "build" @@ "NUnit2Report.Console.Runner" @@ "NUnit2Report.Console.exe"
        info.Arguments <- sprintf "--fileset=\"%s\" --todir \"%s\"" testResults (dirDocOutput @@ "testreport")
        ) (TimeSpan.FromMinutes 15.)
        
    if result <> 0 then failwithf "Error during NUnit2Report execution."
  
  PublishArtifact dirDocOutput
)

Target "?" (fun _ ->
  traceHeader "target summary"
  trace ""
  listTargets  ()
  trace ""
)

Target "Publish" DoNothing
Target "All" DoNothing

"Clean"
  ==> "AssemblyInfo"
  ==> "Build"
  ==> "CopyBinaries"
  ==> "RunTests"
  ==> "GenerateDocs"
  ==> "All"

"All"
  ==> "NuGet"
  =?> ("NuGetPush", isLocalBuild || (IsPublishAllowed versionInfo))
  ==> "Publish"

"CleanDocs"
  ==> "GenerateDocs"


RunTargetOrDefault "All"