build.old.fsx

// --------------------------------------------------------------------------------------
// FAKE build script
// --------------------------------------------------------------------------------------
#nowarn "0213"
#r "paket: groupref FakeBuild //"
#load "./tools/FSharpLint.fs"
#load "./tools/ElectronTools.fs"
#load "./tools/Updating.fs"
#load "./.fake/build.fsx/intellisense.fsx"

open BlackFox.CommandLine
open Fake.Core
open Fake.Core.TargetOperators
open Fake.DotNet
open Fake.JavaScript
open Fake.IO
open Fake.IO.FileSystemOperators
open Fake.IO.Globbing.Operators
open Fake.Net.Http
open Fake.Tools
open Fantomas.FakeHelpers
open Fantomas.FormatConfig
open Tools.Electron
open Tools.Linting
open Tools.Updating
open System
open System.IO

// The name of the project
// (used by attributes in AssemblyInfo, name of a NuGet package and directory in 'src')
let project = "issie"

// Short summary of the project
// (used as description in AssemblyInfo and as a short summary for NuGet package)
let summary = "Schematic editor and Simulator"

// Author(s) of the project
let author = "tomcl"

// File system information
let solutionFile  = "issie.sln"

// Build docs website root
let website = "https://tomcl.github.io/issie/docs"

// Github repository
let repo = @"https://github.com/tomcl/issie"

// Web or JS related fs projects
// Projects that have bindings to other languages where name linting needs to be more relaxed.
let relaxedNameLinting = 
    [ (__SOURCE_DIRECTORY__ @@ "src/Electron/**/*.fs") ]

let netCoreVersions = [ "netcoreapp3.1" ]

// OS runtime targets
let runTimes = ["win-x64";"linux-x64"]

// Read additional information from the release notes document
let release = ReleaseNotes.load (__SOURCE_DIRECTORY__ @@ "RELEASE_NOTES.md")

// Helper active pattern for project types
let (|Fsproj|Csproj|Vbproj|Shproj|) (projFileName:string) =
    match projFileName with
    | f when f.EndsWith("fsproj") -> Fsproj
    | f when f.EndsWith("csproj") -> Csproj
    | f when f.EndsWith("vbproj") -> Vbproj
    | f when f.EndsWith("shproj") -> Shproj
    | _                           -> failwith (sprintf "Project file %s not supported. Unknown project type." projFileName)

let tools      = __SOURCE_DIRECTORY__ @@ "tools"
let srcGlob    = __SOURCE_DIRECTORY__ @@ "src/**/*.??proj"
let fsSrcGlob  = __SOURCE_DIRECTORY__ @@ "src/**/*.fs"
let fsTestGlob = __SOURCE_DIRECTORY__ @@ "tests/**/*.fs"
let bin        = __SOURCE_DIRECTORY__ @@ "bin"
let temp       = __SOURCE_DIRECTORY__ @@ "temp"
let objFolder  = __SOURCE_DIRECTORY__ @@ "obj"
let dist       = __SOURCE_DIRECTORY__ @@ "dist"
let fable      = __SOURCE_DIRECTORY__ @@ ".fable"
let fsProjGlob =
    !! (__SOURCE_DIRECTORY__  @@ "src/**/*.fsproj")
    ++ (__SOURCE_DIRECTORY__  @@ "tests/**/*.fsproj")

let foldExcludeGlobs (g: IGlobbingPattern) (d: string) = g -- d
let foldIncludeGlobs (g: IGlobbingPattern) (d: string) = g ++ d

let fsSrcAndTest =
    !! fsSrcGlob
    ++ fsTestGlob
    -- (__SOURCE_DIRECTORY__  @@ "src/**/obj/**")
    -- (__SOURCE_DIRECTORY__  @@ "tests/**/obj/**")
    -- (__SOURCE_DIRECTORY__  @@ "src/**/AssemblyInfo.*")
    -- (__SOURCE_DIRECTORY__  @@ "src/**/**/AssemblyInfo.*")

let fsRelaxedNameLinting =
    let baseGlob s =
        !! s
        -- (__SOURCE_DIRECTORY__  @@ "src/**/AssemblyInfo.*")
        -- (__SOURCE_DIRECTORY__  @@ "src/**/obj/**")
        -- (__SOURCE_DIRECTORY__  @@ "tests/**/obj/**")
    match relaxedNameLinting with
    | [h] when relaxedNameLinting.Length = 1 -> baseGlob h |> Some
    | h::t -> List.fold foldIncludeGlobs (baseGlob h) t |> Some
    | _ -> None

let failOnBadExitAndPrint (p : ProcessResult) =
    if p.ExitCode <> 0 then
        p.Errors |> Seq.iter Trace.traceError
        failwithf "failed with exitcode %d" p.ExitCode

module dotnet =
    let tool optionConfig command args =
        DotNet.exec (fun p -> { p with WorkingDirectory = tools} |> optionConfig ) (sprintf "%s" command) args
        |> failOnBadExitAndPrint

    let femto optionConfig args =
        tool optionConfig (!!(__SOURCE_DIRECTORY__ @@ "packages/tooling/Femto/tools/**/**/Femto.dll") |> Seq.head) args

let setCmd f args =
    match Environment.isWindows with
    | true -> Command.RawCommand(f, Arguments.OfArgs args)
    | false -> Command.RawCommand("mono", Arguments.OfArgs (f::args))

let configuration() =
    FakeVar.getOrDefault "configuration" "Release"

let getEnvFromAllOrNone (s: string) =
    let envOpt (envVar: string) =
        if String.isNullOrEmpty envVar then None
        else Some(envVar)

    let procVar = Environment.GetEnvironmentVariable(s) |> envOpt
    let userVar = Environment.GetEnvironmentVariable(s, EnvironmentVariableTarget.User) |> envOpt
    let machVar = Environment.GetEnvironmentVariable(s, EnvironmentVariableTarget.Machine) |> envOpt

    match procVar,userVar,machVar with
    | Some(v), _, _
    | _, Some(v), _
    | _, _, Some(v)
        -> Some(v)
    | _ -> None


// --------------------------------------------------------------------------------------
// Initialisation and fixup actions

Target.create "Init" <| fun _ ->
    Fake.IO.File.delete (__SOURCE_DIRECTORY__ @@ ".paket/Paket.Restore.Targets")
    Fake.IO.Directory.delete (__SOURCE_DIRECTORY__ @@ "packet_files")

Target.create "KillCreated" <| fun _ ->
    Fake.Core.Process.killAllCreatedProcesses()

Target.create "KillZombies" <| fun _ ->
    Fake.Core.Process.killAllByName "issie.exe"
    Fake.Core.Process.killAllByName "node"
    Fake.Core.Process.killAllByName "dotnet"



// --------------------------------------------------------------------------------------
// Set configuration mode based on target

Target.create "ConfigDebug" <| fun _ ->
    FakeVar.set "configuration" "Debug"

Target.create "ConfigRelease" <| fun _ ->
    FakeVar.set "configuration" "Release"

// --------------------------------------------------------------------------------------
// Generate assembly info files with the right version & up-to-date information

Target.create "AssemblyInfo" <| fun _ ->
    let getAssemblyInfoAttributes projectName =
        [ AssemblyInfo.Title (projectName)
          AssemblyInfo.Product project
          AssemblyInfo.Description summary
          AssemblyInfo.Version release.AssemblyVersion
          AssemblyInfo.FileVersion release.AssemblyVersion
          AssemblyInfo.Configuration <| configuration()
          AssemblyInfo.InternalsVisibleTo (sprintf "%s.Tests" projectName) ]

    let getProjectDetails projectPath =
        let projectName = Path.GetFileNameWithoutExtension(projectPath)
        ( projectPath,
          projectName,
          Path.GetDirectoryName(projectPath),
          (getAssemblyInfoAttributes projectName)
        )

    !! srcGlob
    |> Seq.map getProjectDetails
    |> Seq.iter (fun (projFileName, _, folderName, attributes) ->
        match projFileName with
        | Fsproj -> AssemblyInfoFile.createFSharp (folderName </> "AssemblyInfo.fs") attributes
        | Csproj -> AssemblyInfoFile.createCSharp ((folderName </> "Properties") </> "AssemblyInfo.cs") attributes
        | Vbproj -> AssemblyInfoFile.createVisualBasic ((folderName </> "My Project") </> "AssemblyInfo.vb") attributes
        | Shproj -> () )

// --------------------------------------------------------------------------------------
// Update package.json version & name      

Target.create "PackageJson" <| fun _ ->
    let setValues (current: Json.JsonPackage) =
        { current with
            Name = Str.toKebabCase project |> Some
            Description = summary |> Some
            Version = release.NugetVersion |> Some
            Repository = 
                match current.Repository with
                | Some(r) ->
                    { r with
                        Json.RepositoryValue.Type = "git" |> Some
                        Json.RepositoryValue.Url = repo + ".git" |> Some }
                | _ ->
                    { Json.RepositoryValue.Type = "git" |> Some
                      Json.RepositoryValue.Url = repo + ".git" |> Some
                      Json.RepositoryValue.Directory = None }
                |> Some
            Author = author |> Some
            License = (File.readLine(__SOURCE_DIRECTORY__ @@ "LICENSE.md").Split(' ')) |> Array.head |> Some
            Bugs = { Json.BugsValue.Url = (repo + "/issues" |> Some) } |> Some
            Homepage = repo |> Some }
    
    Json.setJsonPkg setValues

// --------------------------------------------------------------------------------------
// Copies binaries from default VS location to expected bin folder
// But keeps a subdirectory structure for each project in the
// src folder to support multiple project outputs

Target.create "CopyBinaries" <| fun _ ->
    !! srcGlob
    -- (__SOURCE_DIRECTORY__ @@ "src/**/*.shproj")
    -- (__SOURCE_DIRECTORY__ @@ "src/**/Electron.Fable.fsproj")
    |> Seq.map (fun f -> ((Path.getDirectory f) @@ "bin" @@ configuration(), "bin" @@ (Path.GetFileNameWithoutExtension f)))
    |> Seq.iter (fun (fromDir, toDir) -> Shell.copyDir toDir fromDir (fun _ -> true))

// --------------------------------------------------------------------------------------
// Clean tasks

Target.create "Clean" <| fun _ ->
    let clean() =
        !! (__SOURCE_DIRECTORY__  @@ "tests/**/bin")
        ++ (__SOURCE_DIRECTORY__  @@ "tests/**/obj")
        ++ (__SOURCE_DIRECTORY__  @@ "tools/bin")
        ++ (__SOURCE_DIRECTORY__  @@ "tools/obj")
        ++ (__SOURCE_DIRECTORY__  @@ "src/**/bin")
        ++ (__SOURCE_DIRECTORY__  @@ "src/**/obj")
        |> Seq.toList
        |> List.append [bin; temp; objFolder; dist; fable]
        |> Shell.cleanDirs
    TaskRunner.runWithRetries clean 99

Target.create "CleanDocs" <| fun _ ->
    let clean() =
        Shell.cleanDirs ["docs"]
    TaskRunner.runWithRetries clean 99

Target.create "PostBuildClean" <| fun _ ->
    let clean() =
        !! srcGlob
        -- (__SOURCE_DIRECTORY__ @@ "src/**/*.shproj")
        |> Seq.map (
            (fun f -> (Path.getDirectory f) @@ "bin" @@ configuration()) 
            >> (fun f -> Directory.EnumerateDirectories(f) |> Seq.toList )
            >> (fun fL -> fL |> List.map (fun f -> Directory.EnumerateDirectories(f) |> Seq.toList)))
        |> (Seq.concat >> Seq.concat)
        |> Seq.iter Directory.delete
    TaskRunner.runWithRetries clean 99

Target.create "PostPublishClean" <| fun _ ->
    let clean() =
        !! (__SOURCE_DIRECTORY__ @@ "src/**/bin" @@ configuration() @@ "/**/publish")
        |> Seq.iter Directory.delete
    TaskRunner.runWithRetries clean 99

Target.create "CleanElectronBin"  <| fun _ ->
    let netCores =
        netCoreVersions
        |> List.map (fun s -> __SOURCE_DIRECTORY__ @@ "bin/Core" @@ s)

    let clean() =
        !! (__SOURCE_DIRECTORY__  @@ "bin/Main")
        ++ (__SOURCE_DIRECTORY__  @@ "bin/Renderer")
        ++ (__SOURCE_DIRECTORY__  @@ "bin/Common")
        ++ (__SOURCE_DIRECTORY__  @@ "bin/Simulator")
        ++ (__SOURCE_DIRECTORY__  @@ "bin/WidthInferer")
        |> List.ofSeq
        |> Shell.deleteDirs

        let runtimeDirs =
            runTimes 
            |> List.map (fun s ->
                netCores 
                |> List.map (fun coreVer -> coreVer @@ s @@ "**"))
            |> List.concat

        match netCores |> List.tryHead with
        | Some(h) ->
            !! (h @@ "**")
            |> (fun src -> List.fold foldIncludeGlobs src netCores.Tail)
            |> (fun src -> List.fold foldExcludeGlobs src runtimeDirs)
            |> Seq.iter Shell.rm
        | _ -> ()
    TaskRunner.runWithRetries clean 99

// --------------------------------------------------------------------------------------
// Restore tasks

let restoreSolution () =
    solutionFile
    |> DotNet.restore id

Target.create "Restore" <| fun _ ->
    TaskRunner.runWithRetries restoreSolution 5

// Add task to make Node.js cli ready
Target.create "YarnInstall" <| fun _ ->
    let setParams (defaults:Yarn.YarnParams) =
        if Environment.isLinux then
            defaults
        else
            { defaults with
                Yarn.YarnParams.YarnFilePath = (__SOURCE_DIRECTORY__ @@ "packages/tooling/Yarnpkg.Yarn/content/bin/yarn.cmd")
            }
    Yarn.install setParams

// Build Key.json if necessary from GD_KEY env variable
Target.create "BuildKeys" <| fun _ ->
    let jsonPath = 
        __SOURCE_DIRECTORY__ @@ "src/Core/Key.json"
        |> FileInfo.ofPath
    let key = 
        let insertKey s = sprintf "{ \"key\": \"%s\" }" s

        getEnvFromAllOrNone "GD_KEY"
        |> Option.map (insertKey)
        |> defaultArg <| ""
    TraceSecrets.register "<GD_KEY Json>" key
    
    if key <> "" && jsonPath.Exists |> not then
        File.writeString false jsonPath.FullName key
    else ()

// --------------------------------------------------------------------------------------
// Build tasks

Target.create "Build" <| fun _ ->
    let setParams (defaults:MSBuildParams) =
        { defaults with
            Verbosity = Some(Quiet)
            Targets = ["Build"]
            Properties =
                [
                    "Optimize", "True"
                    "DebugSymbols", "True"
                    "Configuration", configuration()
                    "Version", release.AssemblyVersion
                    "GenerateDocumentationFile", "true"
                    "DependsOnNETStandard", "true"
                ]
         }
    restoreSolution()
    MSBuild.build setParams solutionFile

Target.create "BuildElectron" <| fun _ ->
    Npm.exec "rebuild node-sass" id
    Yarn.exec "compile" id

// Run Dev mode
Target.create "Dev" <| fun _ ->
    Yarn.exec "dev" id

// Build artifacts
Target.create "DistWin" <| fun _ ->
    Yarn.exec "distwin" id

// Build artifacts
Target.create "DistMac" <| fun _ ->
    Yarn.exec "distmac" id

// Gets latest docker image to build for linux
Target.create "PullDockerImage" <| fun _ ->
    CmdLine.Empty
    |> CmdLine.append "pull"
    |> CmdLine.append "electronuserland/builder"
    |> CmdLine.toString
    |> CreateProcess.fromRawCommandLine "docker"
    |> CreateProcess.ensureExitCodeWithMessage "Pulling electronuserland/builder docker container failed."
    |> Proc.run
    |> ignore

// Build artifacts
Target.create "DistLinux" <| fun _ ->
    let sandboxPath = @"./node_modules/electron/dist/chrome-sandbox"

    CmdLine.Empty
    |> CmdLine.append "run"
    |> CmdLine.append "--rm"
    |> CmdLine.appendRaw (sprintf "-v %s:/project" __SOURCE_DIRECTORY__)
    |> CmdLine.appendRaw "-v electron:/root/.cache/electron"
    |> CmdLine.appendRaw "-v electron-builder:/root/.cache/electron-builder electronuserland/builder"
    |> CmdLine.appendRaw (sprintf "/bin/bash -c \"chown -R root %s && chmod 4755 %s && yarn --link-duplicates --pure-lockfile && yarn distLinux\"" sandboxPath sandboxPath)
    |> CmdLine.toString
    |> CreateProcess.fromRawCommandLine "docker"
    |> CreateProcess.ensureExitCodeWithMessage "Failed to build linux image."
    |> Proc.run
    |> ignore

// --------------------------------------------------------------------------------------
// Create differentials for updating

Target.create "CreateDiffs" <| fun _ ->
    let latestTag = (Git.CommandHelper.runSimpleGitCommand __SOURCE_DIRECTORY__ "describe --tag").Split('-').[0]
    let latestRelease =
        if Version(release.NugetVersion) <= Version(latestTag.Substring(1)) then 
            failwith "Cannot create diff of older version"
        else
            sprintf "https://github.com/Shmew/MordhauBuddy/releases/download/%s" latestTag

    let downloadSignature (fi: FileInfo) =
        let file =
            match fi.Extension with
            | ext when ext = ".exe" -> sprintf "MordhauBuddy.Setup.%s%s.sig" (latestTag.Substring(1)) ext
            | ext when ext = ".AppImage" -> sprintf "MordhauBuddy-%s%s.sig" (latestTag.Substring(1)) ext
            | _ -> failwith "Invalid file extention for generating delta"
        
        sprintf "%s/%s" latestRelease file
        |> downloadFile (fi.Directory.FullName @@ file)

    !! (__SOURCE_DIRECTORY__ @@ "dist/linux-x64/*.AppImage")
    ++ (__SOURCE_DIRECTORY__ @@ "dist/win-x64/*.exe")
    |> List.ofSeq
    |> List.distinct
    |> List.iter (fun f ->
        let fi = FileInfo.ofPath(f)
        genSigNew (sprintf "%s.sig" fi.Name) fi
        
        downloadSignature fi
        |> FileInfo.ofPath
        |> genDelta fi)

// --------------------------------------------------------------------------------------
// Publish net core applications

Target.create "PublishDotNet" <| fun _ ->
    let runPublish (project: string) (framework: string) =
        let buildWithRunTime (rt: string) =
            let setParams (defaults:MSBuildParams) =
                { defaults with
                    Verbosity = Some(Quiet)
                    Targets = ["Publish"]
                    Properties =
                        [
                            "Optimize", "True"
                            "DebugSymbols", "True"
                            "Configuration", configuration()
                            "Version", release.AssemblyVersion
                            "GenerateDocumentationFile", "true"
                            "TargetFramework", framework
                            "SelfContained", "true"
                            "RuntimeIdentifier", rt
                        ]
                }
            MSBuild.build setParams project
        runTimes |> List.iter buildWithRunTime

    !! srcGlob
    -- (__SOURCE_DIRECTORY__ @@ "src/**/*.shproj")
    -- (__SOURCE_DIRECTORY__ @@ "src/**/*.vbproj")
    |> Seq.map
        ((fun f -> (((Path.getDirectory f) @@ "bin" @@ configuration()), f) )
        >>
        (fun f ->
            Directory.EnumerateDirectories(fst f) 
            |> Seq.filter (fun frFolder -> frFolder.Contains("netcoreapp"))
            |> Seq.map (fun frFolder -> DirectoryInfo(frFolder).Name), snd f))
    |> Seq.iter (fun (l,p) -> l |> Seq.iter (runPublish p))

// --------------------------------------------------------------------------------------
// Lint and format source code to ensure consistency

Target.create "Format" <| fun _ ->
    let config =
        { FormatConfig.Default with
            PageWidth = 120
            SpaceBeforeColon = false }
        
    fsSrcAndTest
    |> List.ofSeq
    |> formatCode config
    |> Async.RunSynchronously
    |> printfn "Formatted files: %A"

Target.create "Lint" <| fun _ ->
    fsSrcAndTest
    -- (__SOURCE_DIRECTORY__  @@ "src/**/AssemblyInfo.*")
    |> (fun src -> List.fold foldExcludeGlobs src relaxedNameLinting)
    |> (fun fGlob ->
        match fsRelaxedNameLinting with
        | Some(glob) ->
            [(false, fGlob); (true, glob)]
        | None -> [(false, fGlob)])
    |> Seq.map (fun (b,glob) -> (b,glob |> List.ofSeq))
    |> List.ofSeq
    |> FSharpLinter.lintFiles (__SOURCE_DIRECTORY__ @@ "bin/LintResults.xml")

// --------------------------------------------------------------------------------------
// Validate JavaScript dependencies

Target.create "ValidateJSPackages" <| fun _ ->
    let validate () =
        fsProjGlob
        |> Seq.iter (fun file ->
            dotnet.femto id
                (sprintf "--resolve %s" file))
    TaskRunner.runWithRetries validate 5

// --------------------------------------------------------------------------------------
// Run the unit test binaries

Target.create "RunTests" <| fun _ ->
    !! ("tests/**/bin" @@ configuration() @@ "**" @@ "*Tests.exe")
    |> Seq.iter (fun f ->
        CreateProcess.fromCommand(setCmd f [])
        |> CreateProcess.withTimeout (TimeSpan.MaxValue)
        |> CreateProcess.ensureExitCodeWithMessage "Tests failed."
        |> Proc.run
        |> ignore)

// --------------------------------------------------------------------------------------
// Generate Paket load scripts
Target.create "LoadScripts" <| fun _ ->
    let frameworks =
        __SOURCE_DIRECTORY__ @@ "bin"
        |> Directory.EnumerateDirectories
        |> Seq.map (fun d ->
            Directory.EnumerateDirectories d
            |> Seq.map (fun f -> DirectoryInfo(f).Name)
            |> List.ofSeq)
        |> List.ofSeq
        |> List.reduce List.append
        |> List.distinct
        |> List.reduce (fun acc elem -> sprintf "%s --framework %s" elem acc)
        |> function
        | e when e.Length > 0 ->
            Some (sprintf "--framework %s" e)
        | _ -> None

    let arguments =
        [Some("generate-load-scripts"); frameworks]
        |> List.choose id
        |> List.reduce (fun acc elem -> sprintf "%s %s" acc elem)

    arguments
    |> CreateProcess.fromRawCommandLine ((__SOURCE_DIRECTORY__ @@ ".paket") @@ "paket.exe")
    |> CreateProcess.withTimeout (TimeSpan.MaxValue)
    |> CreateProcess.ensureExitCodeWithMessage "Failed to generate paket load scripts."
    |> Proc.run
    |> ignore

// --------------------------------------------------------------------------------------
// Generate the documentation


// Paths with template/source/output locations
let content     = __SOURCE_DIRECTORY__ @@ "docsrc/content"
let output      = __SOURCE_DIRECTORY__ @@ "docs"
let files       = __SOURCE_DIRECTORY__ @@ "docsrc/files"
let templates   = __SOURCE_DIRECTORY__ @@ "docsrc/tools/templates"
let formatting  = __SOURCE_DIRECTORY__ @@ "packages/formatting/FSharp.Formatting"
let toolPath    = __SOURCE_DIRECTORY__ @@ "packages/formatting/FSharp.Formatting.CommandTool/tools/fsformatting.exe"
let docTemplate = "docpage.cshtml"

Target.create "LocalDocs" <| fun _ ->
    FakeVar.set "Website" website // for now we never generate local docs
Target.create "ReleaseDocs" <| fun _ ->
    FakeVar.set "Website" website

// Specify more information about your project
let info () =
  [ "project-name", project
    "project-author", author
    "project-summary", summary
    "project-repo", repo
    "root", FakeVar.getOrDefault "Website" website ]

let referenceBinaries = []

let layoutRootsAll = new Collections.Generic.Dictionary<string, string list>()
layoutRootsAll.Add("en",[   templates;
                            formatting @@ "templates"
                            formatting @@ "templates/reference" ])

Target.create "ReferenceDocs" <| fun _ ->
    Directory.ensure (output @@ "reference")

    let lDirs = 
        DirectoryInfo.getSubDirectories <| DirectoryInfo bin
        |> Array.map DirectoryInfo.getSubDirectories
        |> Array.reduce Array.append
        |> Array.map (fun x -> x.FullName.ToLower())
        |> List.ofArray
    printfn "lDirs=%A" lDirs
    let binaries () =
        let manuallyAdded =
            referenceBinaries
            |> List.map (fun b -> bin @@ b)

        let conventionBased =
            DirectoryInfo.getSubDirectories <| DirectoryInfo bin
            |> Array.collect (fun d ->
                let name, dInfo =
                    let netFrameworkBin =
                        DirectoryInfo.getSubDirectories d |> Array.filter(fun x -> x.FullName.ToLower().Contains("net4"))
                    let netCoreBin =
                        DirectoryInfo.getSubDirectories d |> Array.filter(fun x -> x.FullName.ToLower().Contains("netcoreapp"))

                    match netFrameworkBin.Length > 0 with
                    | true ->
                        d.Name, netFrameworkBin |> Array.head
                    | false ->
                        d.Name, netCoreBin |> Array.head

                dInfo.GetFiles()
                |> Array.filter (fun x ->
                    x.Name.ToLower() = (sprintf "%s.dll" name).ToLower() 
                        || x.Name.ToLower() = (sprintf "%s.exe" name).ToLower())
                |> Array.map (fun x -> x.FullName))
            |> List.ofArray

        conventionBased @ manuallyAdded
    printfn "Binaries=%A" (binaries())
    binaries()
    |> FSFormatting.createDocsForDlls (fun args ->
        { args with
            OutputDirectory = output @@ "reference"
            LayoutRoots =  layoutRootsAll.["en"]
            ProjectParameters =  info()
            LibDirs = lDirs
            ToolPath = toolPath
            SourceRepository = repo @@ "tree/master" })

let copyFiles () =
    Shell.copyRecursive files output true
    |> Trace.logItems "Copying file: "
    Directory.ensure (output @@ "content")
    Shell.copyRecursive (formatting @@ "styles") (output @@ "content") true
    |> Trace.logItems "Copying styles and scripts: "

Target.create "Docs" <| fun _ ->
    File.delete "docsrc/content/release-notes.md"
    Shell.copyFile "docsrc/content/" "RELEASE_NOTES.md"
    Shell.rename "docsrc/content/release-notes.md" "docsrc/content/RELEASE_NOTES.md"

    DirectoryInfo.getSubDirectories (DirectoryInfo.ofPath templates)
    |> Seq.iter (fun d ->
                    let name = d.Name
                    if name.Length = 2 || name.Length = 3 then
                        layoutRootsAll.Add(
                                name, [templates @@ name
                                       formatting @@ "templates"
                                       formatting @@ "templates/reference" ]))
    copyFiles ()

    for dir in  [ content ] do
        let langSpecificPath(lang, path:string) =
            path.Split([|'/'; '\\'|], StringSplitOptions.RemoveEmptyEntries)
            |> Array.exists(fun i -> i = lang)
        let layoutRoots =
            let key = layoutRootsAll.Keys |> Seq.tryFind (fun i -> langSpecificPath(i, dir))
            match key with
            | Some lang -> layoutRootsAll.[lang]
            | None -> layoutRootsAll.["en"] // "en" is the default language

        FSFormatting.createDocs (fun args ->
            { args with
                Source = content
                OutputDirectory = output
                LayoutRoots = layoutRoots
                ProjectParameters  = info()
                Template = docTemplate })

Target.create "GenerateDocs" ignore

// --------------------------------------------------------------------------------------
// Release Scripts

Target.create "GitPush" <| fun p ->
    let msg =
        p.Context.Arguments
        |> List.choose (fun s ->
            match s.StartsWith("--Msg=") with
            | true -> Some(s.Substring 6)
            | false -> None)
        |> List.tryHead
        |> function
        | Some(s) -> s
        | None -> (sprintf "Bump version to %s" release.NugetVersion)

    Git.Staging.stageAll ""
    Git.Commit.exec "" msg
    Git.Branches.push ""

Target.create "GitTag" <| fun _ ->
    Git.Branches.tag "" release.NugetVersion
    Git.Branches.pushTag "" "origin" release.NugetVersion

// --------------------------------------------------------------------------------------
// Run all targets by default. Invoke 'build -t <Target>' to override

Target.create "All" ignore
Target.create "Release" ignore
Target.create "UpdateDocs" ignore
Target.create "AllDev" ignore
Target.create "QDev" <| fun _ ->
    Yarn.exec "dev" id

"Clean"
  ==> "AssemblyInfo"
  ==> "Restore"
  ==> "YarnInstall"
  ==> "Build"
  ==> "BuildElectron"
  ==> "PostBuildClean" 
  ==> "CopyBinaries"

"Build" ==> "RunTests"

"Build"
  ==> "PostBuildClean"
  ==> "PublishDotNet"
  ==> "PostPublishClean"
  ==> "CopyBinaries"

"Restore" ==> "Lint"
"Restore" ==> "Format"

"Lint" 
  ?=> "Build"
  ?=> "RunTests"
  ?=> "CleanDocs"

"CopyBinaries"
  ==> "CleanDocs"
  ==> "Docs"
  ==> "ReferenceDocs"
  ==> "GenerateDocs"
  ?=> "CleanElectronBin"

"Clean" 
  ==> "GitPush"
  ?=> "GitTag"

"All" <== [ "CleanElectronBin"]

"AllDev" <== ["CleanElectronBin"]

"All" ?=> "Release"

"LocalDocs" ?=> "All"
"ReleaseDocs" ?=> "All"

"ConfigDebug" ?=> "Clean"
"ConfigRelease" ?=> "Clean"

"PullDockerImage"
  ==> "DistLinux"


"YarnInstall"
  ==> "DistWin"


"DistWin" ?=> "DistLinux"

"Dev" <== ["All"; "LocalDocs"; "ConfigDebug"]

"DistWin" <== ["All"; "ConfigRelease"]
"DistLinux" <== ["All"; "ConfigRelease"]
"Release" <== ["All"; "ConfigRelease"; "DistWin"; "DistLinux"]
"UpdateDocs" <== ["All"; "ReleaseDocs"; "ConfigRelease"]

Target.runOrDefaultWithArguments "Dev"