Merge pull request #2 from vbfox/SDK-&&-.Net-Core

Sdk && .net core

Author: vbfox

.gitignore

@@ -149,8 +149,6 @@ publish/
 *.nupkg
 # The packages folder can be ignored because of Package Restore
 **/packages/*
-# except build/, which is used as an MSBuild target.
-!**/packages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/packages/repositories.config
 # NuGet v3's project.json files produces more ignoreable files

.paket/Paket.Restore.targets

@@ -1,5 +1,13 @@
 language: csharp
 
+addons:
+    apt:
+      sources:
+        - ubuntu-toolchain-r-test
+      packages:
+        - libstdc++-4.9-dev
+        - libunwind8-dev
+
 script:
   - ./build.sh CI
 

.travis.yml

@@ -1,3 +1,7 @@
+### New in 1.0.0
+
+* The library now targets .Net 4.0, .Net standard 1.6 and .Net standard 2.0
+
 ### New in 0.2.1
 
 * NuGet package was accidentally dependent on FSharpLint.MSBuild

Release Notes.md

@@ -5,4 +5,4 @@ if errorlevel 1 (
   exit /b %errorlevel%
 )
 
-packages\FAKE\tools\FAKE.exe build\build.fsx %*
+packages\build\FAKE\tools\FAKE.exe build\build.fsx %*

build.cmd

@@ -3,4 +3,4 @@
 function dotnet { if test "$OS" = "Windows_NT"; then $@; else mono $@; fi }
 
 ./paket.sh restore || { exit $?; }
-dotnet packages/FAKE/tools/FAKE.exe $@ --fsiargs build/build.fsx
+dotnet packages/build/FAKE/tools/FAKE.exe $@ --fsiargs build/build.fsx

build.sh

@@ -1,6 +1,6 @@
 module BlackFox.AppVeyorEx
 
-#r "../packages/FAKE/tools/FakeLib.dll"
+#r "../packages/build/FAKE/tools/FakeLib.dll"
 #load "./CmdLine.fs"
 
 open BlackFox.CommandLine

build/AppVeyorEx.fsx

@@ -1,4 +1,4 @@
-#r "../packages/FAKE/tools/FakeLib.dll"
+#r "../packages/build/FAKE/tools/FakeLib.dll"
 
 namespace BlackFox
 

build/TaskDefinitionHelper.fsx

@@ -1,12 +1,15 @@
 // include Fake libs
-#r "../packages/FAKE/tools/FakeLib.dll"
+#r "../packages/build/FAKE/tools/FakeLib.dll"
+#r "System.Xml.Linq"
 #load "./TaskDefinitionHelper.fsx"
 #load "./AppVeyorEx.fsx"
 
 open System
+open System.Xml.Linq
 open Fake
+open Fake.AssemblyInfoFile
 open Fake.ReleaseNotesHelper
-open Fake.Testing.NUnit3
+open Fake.Testing.Expecto
 open BlackFox
 
 let configuration = environVarOrDefault "configuration" "Release"
@@ -16,9 +19,8 @@ let from s = { BaseDirectory = s; Includes = []; Excludes = [] }
 let rootDir = System.IO.Path.GetFullPath(__SOURCE_DIRECTORY__ </> "..")
 let srcDir = rootDir </> "src"
 let artifactsDir = rootDir </> "artifacts"
-let binDir = artifactsDir </> "bin"
 let librarySrcDir = srcDir </> "BlackFox.MasterOfFoo"
-let libraryBinDir = binDir </> "BlackFox.MasterOfFoo" </> configuration
+let libraryBinDir = artifactsDir </> "BlackFox.MasterOfFoo" </> configuration
 let projects = from srcDir ++ "**/*.*proj"
 
 /// The profile where the project is posted
@@ -31,63 +33,130 @@ let gitName = "MasterOfFoo"
 /// The url for the raw files hosted
 let gitRaw = environVarOrDefault "gitRaw" ("https://raw.github.com/" + gitOwner)
 
+let inline versionPartOrZero x = if x < 0 then 0 else x
+
 let release =
     let fromFile = LoadReleaseNotes (rootDir </> "Release Notes.md")
     if buildServer = AppVeyor then
         let appVeyorBuildVersion = int appVeyorBuildVersion
         let nugetVer = sprintf "%s-appveyor%04i" fromFile.NugetVersion appVeyorBuildVersion
         let asmVer = System.Version.Parse(fromFile.AssemblyVersion)
-        let asmVer = System.Version(asmVer.Major, asmVer.Minor, asmVer.Build, appVeyorBuildVersion)
+        let asmVer =
+            System.Version(
+                versionPartOrZero asmVer.Major,
+                versionPartOrZero asmVer.Minor,
+                versionPartOrZero asmVer.Build,
+                versionPartOrZero appVeyorBuildVersion)
         ReleaseNotes.New(asmVer.ToString(), nugetVer, fromFile.Date, fromFile.Notes)
     else
         fromFile
 
+let mutable dotnetExePath = "dotnet"
+
+Task "InstallDotNetCore" [] (fun _ ->
+    dotnetExePath <- DotNetCli.InstallDotNetSDK (DotNetCli.GetDotNetSDKVersionFromGlobalJson())
+)
+
 AppVeyorEx.updateBuild (fun info -> { info with Version = Some release.AssemblyVersion })
 
+let writeVersionProps() =
+    let doc =
+        XDocument(
+            XElement(XName.Get("Project"),
+                XElement(XName.Get("PropertyGroup"),
+                    XElement(XName.Get "Version", release.NugetVersion),
+                    XElement(XName.Get "PackageReleaseNotes", toLines release.Notes))))
+    let path = artifactsDir </> "Version.props"
+    System.IO.File.WriteAllText(path, doc.ToString())
+
 Task "Init" [] <| fun _ ->
     CreateDir artifactsDir
+    writeVersionProps ()
+    CreateFSharpAssemblyInfo (artifactsDir </> "Version.fs") [Attribute.Version release.AssemblyVersion]
 
-// Targets
 Task "Clean" ["Init"] <| fun _ ->
-    CleanDirs [artifactsDir]
-
-Task "Build" ["Init"; "?Clean"] <| fun _ ->
-    MSBuild null "Build" ["Configuration", configuration] projects
-        |> ignore
-
-Task "RunTests" [ "Build"] <| fun _ ->
+    let objDirs = projects |> Seq.map(fun p -> System.IO.Path.GetDirectoryName(p) </> "obj") |> List.ofSeq
+    CleanDirs (artifactsDir :: objDirs)
+
+Task "Build" ["InstallDotNetCore"; "Init"; "?Clean"] <| fun _ ->
+    DotNetCli.Build
+      (fun p ->
+           { p with
+                WorkingDir = srcDir
+                Configuration = configuration
+                ToolPath = dotnetExePath })
+
+module ExpectoDotNetCli =
+    open System.Diagnostics
+
+    let Expecto (setParams : ExpectoParams -> ExpectoParams) (assemblies : string seq) =
+        let args = setParams ExpectoParams.DefaultParams
+        use __ = assemblies |> separated ", " |> traceStartTaskUsing "Expecto"
+        let runAssembly testAssembly =
+            let argsString = sprintf "\"%s\" %s" testAssembly (string args)
+            let processTimeout = TimeSpan.MaxValue // Don't set a process timeout.  The timeout is per test.
+            let workingDir =
+                if isNotNullOrEmpty args.WorkingDirectory
+                then args.WorkingDirectory else DirectoryName testAssembly
+            let exitCode =
+                let info = ProcessStartInfo(dotnetExePath)
+                info.WorkingDirectory <- workingDir
+                info.Arguments <- argsString
+                info.UseShellExecute <- false
+                // Pass environment variables to the expecto console process in order to let it detect it's running on TeamCity
+                // (it checks TEAMCITY_PROJECT_NAME <> null specifically).
+                for name, value in environVars EnvironmentVariableTarget.Process do
+                    info.EnvironmentVariables.[string name] <- string value
+                use proc = Process.Start(info)
+                proc.WaitForExit() // Don't set a process timeout. The timeout is per test.
+                proc.ExitCode
+            testAssembly, exitCode
+        let res =
+            assemblies
+            |> Seq.map runAssembly
+            |> Seq.filter( snd >> (<>) 0)
+            |> Seq.toList
+        match res with
+        | [] -> ()
+        | failedAssemblies ->
+            failedAssemblies
+            |> List.map (fun (testAssembly,exitCode) -> sprintf "Expecto test of assembly '%s' failed. Process finished with exit code %d." testAssembly exitCode)
+            |> String.concat System.Environment.NewLine
+            |> FailedTestsException |> raise
+
+Task "RunTests" ["Build"] <| fun _ ->
     let nunitPath = rootDir </> @"packages" </> "NUnit.ConsoleRunner" </> "tools" </> "nunit3-console.exe"
     let testAssemblies = artifactsDir </> "bin" </> "*.Tests" </> configuration </> "*.Tests.dll"
     let testResults = artifactsDir </> "TestResults.xml"
 
-    !! testAssemblies
-      |> NUnit3 (fun p ->
-          {p with
-             ToolPath = nunitPath
-             TimeOut = TimeSpan.FromMinutes 20.
-             DisposeRunners = true
-             ResultSpecs = [testResults] })
+    [artifactsDir </> "BlackFox.MasterOfFoo.Tests" </> configuration </> "netcoreapp2.0" </> "BlackFox.MasterOfFoo.Tests.dll"]
+        |> ExpectoDotNetCli.Expecto (fun p ->
+            { p with
+                FailOnFocusedTests = true
+            })
 
-    AppVeyor.UploadTestResultsFile AppVeyor.NUnit3 testResults
+let nupkgDir = artifactsDir </> "BlackFox.MasterOfFoo" </> configuration
 
 Task "NuGet" ["Build"] <| fun _ ->
-    Paket.Pack <| fun p ->
-        { p with
-            OutputPath = artifactsDir
-            Version = release.NugetVersion
-            ReleaseNotes = toLines release.Notes
-            WorkingDir = librarySrcDir
-            BuildConfig = configuration
-            BuildPlatform = "AnyCPU"}
-    AppVeyor.PushArtifacts (from artifactsDir ++ "*.nupkg")
+    DotNetCli.Pack
+      (fun p ->
+           { p with
+                WorkingDir = librarySrcDir
+                Configuration = configuration
+                ToolPath = dotnetExePath })
+    let nupkg =
+        nupkgDir
+            </> (sprintf "BlackFox.MasterOfFoo.%s.nupkg" release.NugetVersion)
+
+    AppVeyor.PushArtifacts [nupkg]
 
 Task "PublishNuget" ["NuGet"] <| fun _ ->
     let key =
         match environVarOrNone "nuget-key" with
         | Some(key) -> key
         | None -> getUserPassword "NuGet key: "
 
-    Paket.Push <| fun p ->  { p with WorkingDir = artifactsDir; ApiKey = key }
+    Paket.Push <| fun p ->  { p with WorkingDir = nupkgDir; ApiKey = key }
 
 let zipFile = artifactsDir </> (sprintf "BlackFox.MasterOfFoo-%s.zip" release.NugetVersion)
 
@@ -99,7 +168,7 @@ Task "Zip" ["Build"] <| fun _ ->
         |> Zip libraryBinDir zipFile
     AppVeyor.PushArtifacts [zipFile]
 
-#load "../paket-files/fsharp/FAKE/modules/Octokit/Octokit.fsx"
+#load "../paket-files/build/fsharp/FAKE/modules/Octokit/Octokit.fsx"
 
 Task "GitHubRelease" ["Zip"] <| fun _ ->
     let user =

build/build.fsx

@@ -0,0 +1,5 @@
+{
+    "sdk": {
+        "version": "2.1.3"
+    }
+}