mirror of
https://github.com/supleed2/ELEC60015-HLP-CW.git
synced 2024-11-10 02:05:48 +00:00
786 lines
27 KiB
Plaintext
786 lines
27 KiB
Plaintext
// --------------------------------------------------------------------------------------
|
|
// 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"
|