build.fsx

//  __  __       _   _       _   _ ______ _______
// |  \/  |     | | | |     | \ | |  ____|__   __|
// | \  / | __ _| |_| |__   |  \| | |__     | |
// | |\/| |/ _` | __| '_ \  | . ` |  __|    | |
// | |  | | (_| | |_| | | |_| |\  | |____   | |
// |_|  |_|\__,_|\__|_| |_(_)_| \_|______|  |_|
//
// Math.NET Spatial - https://spatial.mathdotnet.com
// Copyright (c) Math.NET - Open Source MIT/X11 License
//
// FAKE build script, see http://fsharp.github.io/FAKE
//

// --------------------------------------------------------------------------------------
// PRELUDE
// --------------------------------------------------------------------------------------

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

open Fake
open Fake.DocuHelper
open System
open System.IO

#load "build/build-framework.fsx"
open BuildFramework


// --------------------------------------------------------------------------------------
// PROJECT INFO
// --------------------------------------------------------------------------------------

// VERSION OVERVIEW

let spatialRelease = release "spatial" "Math.NET Spatial" "RELEASENOTES.md"
let releases = [ spatialRelease ]
traceHeader releases


// SPATIAL PACKAGES

let spatialZipPackage = zipPackage "MathNet.Spatial" "Math.NET Spatial" spatialRelease
let spatialStrongNameZipPackage = zipPackage "MathNet.Spatial.Signed" "Math.NET Spatial" spatialRelease

let spatialNuGetPackage = nugetPackage "MathNet.Spatial" spatialRelease
let spatialStrongNameNuGetPackage = nugetPackage "MathNet.Spatial.Signed" spatialRelease

let spatialProject = project "MathNet.Spatial" "src/Spatial/Spatial.csproj" [spatialNuGetPackage]
let spatialStrongNameProject = project "MathNet.Spatial" "src/Spatial/Spatial.Signed.csproj" [spatialStrongNameNuGetPackage]

let spatialSolution = solution "Spatial" "MathNet.Spatial.sln" [spatialProject] [spatialZipPackage]
let spatialStrongNameSolution = solution "Spatial" "MathNet.Spatial.Signed.sln" [spatialStrongNameProject] [spatialStrongNameZipPackage]


// ALL

let allSolutions = [spatialSolution; spatialStrongNameSolution]
let allProjects = allSolutions |> List.collect (fun s -> s.Projects) |> List.distinct


// --------------------------------------------------------------------------------------
// PREPARE
// --------------------------------------------------------------------------------------

Target "Start" DoNothing

Target "Clean" (fun _ ->
    DeleteDirs (!! "src/**/obj/" ++ "src/**/bin/" )
    CleanDirs [ "out/api"; "out/docs" ]
    allSolutions |> List.iter (fun solution -> CleanDirs [ solution.OutputZipDir; solution.OutputNuGetDir; solution.OutputLibDir; solution.OutputLibStrongNameDir ]))

Target "ApplyVersion" (fun _ ->
    allProjects |> List.iter patchVersionInProjectFile
    patchVersionInAssemblyInfo "src/Spatial.Tests" spatialRelease)

Target "Restore" (fun _ -> allSolutions |> List.iter restoreWeak)
"Start"
  =?> ("Clean", not (hasBuildParam "incremental"))
  ==> "Restore"

Target "Prepare" DoNothing
"Start"
  =?> ("Clean", not (hasBuildParam "incremental"))
  ==> "ApplyVersion"
  ==> "Prepare"


// --------------------------------------------------------------------------------------
// BUILD, SIGN, COLLECT
// --------------------------------------------------------------------------------------

let fingerprint = "490408de3618bed0a28e68dc5face46e5a3a97dd"
let timeserver = "http://time.certum.pl/"

Target "Build" (fun _ ->

    // Strong Name Build (with strong name, without certificate signature)
    if hasBuildParam "strongname" then
        CleanDirs (!! "src/**/obj/" ++ "src/**/bin/" )
        restoreStrong spatialStrongNameSolution
        buildStrong spatialStrongNameSolution
        if isWindows && hasBuildParam "sign" then sign fingerprint timeserver spatialStrongNameSolution
        collectBinariesSN spatialStrongNameSolution
        zip spatialStrongNameZipPackage spatialStrongNameSolution.OutputZipDir spatialStrongNameSolution.OutputLibStrongNameDir (fun f -> f.Contains("MathNet.Spatial.") || f.Contains("MathNet.Numerics."))
        if isWindows then
            packStrong spatialStrongNameSolution
            collectNuGetPackages spatialStrongNameSolution

    // Normal Build (without strong name, with certificate signature)
    CleanDirs (!! "src/**/obj/" ++ "src/**/bin/" )
    restoreWeak spatialSolution
    buildWeak spatialSolution
    if isWindows && hasBuildParam "sign" then sign fingerprint timeserver spatialSolution
    collectBinaries spatialSolution
    zip spatialZipPackage spatialSolution.OutputZipDir spatialSolution.OutputLibDir (fun f -> f.Contains("MathNet.Spatial.") || f.Contains("MathNet.Numerics."))
    if isWindows then
        packWeak spatialSolution
        collectNuGetPackages spatialSolution

    // NuGet Sign (all or nothing)
    if isWindows && hasBuildParam "sign" then signNuGet fingerprint timeserver [spatialSolution; spatialStrongNameSolution]

    )
"Prepare" ==> "Build"


// --------------------------------------------------------------------------------------
// TEST
// --------------------------------------------------------------------------------------
let testSpatial framework = test "src/Spatial.Tests" "Spatial.Tests.csproj" framework
Target "TestSpatial" DoNothing
Target "TestSpatialCore3.1" (fun _ -> testSpatial "netcoreapp3.1")
Target "TestSpatialNET461" (fun _ -> testSpatial "net461")
Target "TestSpatialNET47"  (fun _ -> testSpatial "net47")
"Build" ==> "TestSpatialCore3.1" ==> "TestSpatial"
"Build" =?> ("TestSpatialNET461", isWindows) ==> "TestSpatial"
"Build" =?> ("TestSpatialNET47", isWindows)
Target "Test" DoNothing
"TestSpatial" ==> "Test"


// --------------------------------------------------------------------------------------
// BENCHMARKS
// --------------------------------------------------------------------------------------

//let dotnetBuild configuration solution = DotNetCli.Build (fun p ->
//    let defaultArgs = ["--no-restore"]
//    { p with
//        Project = solution
//        Configuration = configuration
//        AdditionalArgs = defaultArgs})

//let CopyBenchmarks target source framework =
//    Directory.GetFiles(source, "*.md", SearchOption.TopDirectoryOnly)
//    |> Seq.iter (fun file ->
//           let fi =
//               file
//               |> replaceFirst source ""
//               |> replaceFirst "\Spatial.Benchmarks." ""
//               |> replaceFirst "Benchmarks-report-github" (sprintf ".%s" framework)
//               |> trimSeparator
//           trace fi
//           let newFile = target @@ fi
//           logVerbosefn "%s => %s" file newFile
//           DirectoryName newFile |> ensureDirectory
//           File.Copy(file, newFile, true))
//    |> ignore

//let benchmarkLibrary framework = testLibrary "src/Spatial.Benchmarks/" "Spatial.Benchmarks.csproj" framework
//let benchmarkRootDir = currentDirectory </> "src" </> "Spatial.Benchmarks"
//let benchmarkSourceFiles = benchmarkRootDir </> "BenchmarkDotNet.Artifacts" </> "results"
//let benchmarkDestination = benchmarkRootDir

//Target "Benchmarks" DoNothing
//Target "RunBenchmarks" DoNothing
//Target "CleanBenchmarks" (fun _ -> CleanDirs [ benchmarkRootDir </> "BenchmarkDotNet.Artifacts" ])

//Target "Benchmark#Core" (fun _ ->
//        benchmarkLibrary "netcoreapp2.0"
//        CopyBenchmarks benchmarkDestination benchmarkSourceFiles "netstandard20")
//Target "Benchmark#Net471" (fun _ ->
//        benchmarkLibrary "net471"
//        CopyBenchmarks benchmarkDestination benchmarkSourceFiles "net471")

//"BuildBenchmarks" ==> "Benchmark#Core" ==> "RunBenchmarks"
//"BuildBenchmarks" =?> ("Benchmark#Net471", isWindows) ==> "RunBenchmarks"

//"RestoreBenchmark"
//==> "CleanBenchmarks"
//==> "BuildBenchmarks"
//==> "RunBenchmarks"
//==> "Benchmarks"


// --------------------------------------------------------------------------------------
// Documentation
// --------------------------------------------------------------------------------------

// DOCS

Target "CleanDocs" (fun _ -> CleanDirs ["out/docs"])

let extraDocs =
    [ "LICENSE.md", "License.md"
      "CONTRIBUTING.md", "Contributing.md"
      "CONTRIBUTORS.md", "Contributors.md" ]

Target "Docs" (fun _ ->
    provideDocExtraFiles extraDocs releases
    generateDocs true false)
Target "DocsDev" (fun _ ->
    provideDocExtraFiles extraDocs releases
    generateDocs true true)
Target "DocsWatch" (fun _ ->
    provideDocExtraFiles extraDocs releases
    use watcher = new FileSystemWatcher(DirectoryInfo("docs/content").FullName, "*.*")
    watcher.EnableRaisingEvents <- true
    watcher.Changed.Add(fun e -> generateDocs false true)
    watcher.Created.Add(fun e -> generateDocs false true)
    watcher.Renamed.Add(fun e -> generateDocs false true)
    watcher.Deleted.Add(fun e -> generateDocs false true)
    traceImportant "Waiting for docs edits. Press any key to stop."
    System.Console.ReadKey() |> ignore
    watcher.EnableRaisingEvents <- false
    watcher.Dispose())

"Build" ==> "CleanDocs" ==> "Docs"

"Start"
  =?> ("CleanDocs", not (hasBuildParam "incremental"))
  ==> "DocsDev"
  ==> "DocsWatch"


// API REFERENCE

Target "CleanApi" (fun _ -> CleanDirs ["out/api"])

Target "Api" (fun _ ->
    !! "src/Spatial/bin/Release/net461/MathNet.Spatial.dll"
    |> Docu (fun p ->
        { p with
            ToolPath = "tools/docu/docu.exe"
            TemplatesPath = "tools/docu/templates/"
            TimeOut = TimeSpan.FromMinutes 10.
            OutputPath = "out/api/" }))

"Build" ==> "CleanApi" ==> "Api"


// --------------------------------------------------------------------------------------
// Publishing
// Requires permissions; intended only for maintainers
// --------------------------------------------------------------------------------------

Target "PublishTag" (fun _ -> publishReleaseTag "Math.NET Spatial" "" spatialRelease)

Target "PublishDocs" (fun _ -> publishDocs spatialRelease)
Target "PublishApi" (fun _ -> publishApi spatialRelease)

Target "PublishArchive" (fun _ -> publishArchives [spatialSolution; spatialStrongNameSolution])

Target "PublishNuGet" (fun _ -> publishNuGet [spatialSolution; spatialStrongNameSolution])

Target "Publish" DoNothing
Dependencies "Publish" [ "PublishTag"; "PublishDocs"; "PublishApi"; "PublishArchive"; "PublishNuGet" ]


// --------------------------------------------------------------------------------------
// Default Targets
// --------------------------------------------------------------------------------------

Target "All" DoNothing
Dependencies "All" [ "Build"; "Docs"; "Api"; "Test" ]

RunTargetOrDefault "Test"