FAKE - F# Make

Fake Namespace

ModuleDescription
Profile

Fake.Api Namespace

ModuleDescription
GitHub

Contains tasks to interact with GitHub releases

Sample

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
   Target.create "GitHubRelease" (fun _ ->
       let token =
           match Environment.environVarOrDefault "github_token" "" with
           | s when not (System.String.IsNullOrWhiteSpace s) -> s
           | _ -> failwith "please set the github_token environment variable to a github personal access token with repro access."

       let files =
           runtimes @ [ "portable"; "packages" ]
           |> List.map (fun n -> sprintf "release/dotnetcore/Fake.netcore/fake-dotnetcore-%s.zip" n)

       GitHub.createClientWithToken token
       |> GitHub.draftNewRelease gitOwner gitName release.NugetVersion (release.SemVer.PreRelease <> None) release.Notes
       |> GitHub.uploadFiles files
       |> GitHub.publishDraft
       |> Async.RunSynchronously)
val not : value:bool -> bool
namespace System
Multiple items
type String =
  new : value:char[] -> string + 8 overloads
  member Chars : int -> char
  member Clone : unit -> obj
  member CompareTo : value:obj -> int + 1 overload
  member Contains : value:string -> bool + 3 overloads
  member CopyTo : sourceIndex:int * destination:char[] * destinationIndex:int * count:int -> unit
  member EndsWith : value:string -> bool + 3 overloads
  member EnumerateRunes : unit -> StringRuneEnumerator
  member Equals : obj:obj -> bool + 2 overloads
  member GetEnumerator : unit -> CharEnumerator
  ...

--------------------
System.String(value: char []) : System.String
System.String(value: nativeptr<char>) : System.String
System.String(value: nativeptr<sbyte>) : System.String
System.String(value: System.ReadOnlySpan<char>) : System.String
System.String(c: char, count: int) : System.String
System.String(value: char [], startIndex: int, length: int) : System.String
System.String(value: nativeptr<char>, startIndex: int, length: int) : System.String
System.String(value: nativeptr<sbyte>, startIndex: int, length: int) : System.String
System.String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: System.Text.Encoding) : System.String
System.String.IsNullOrWhiteSpace(value: string) : bool
val failwith : message:string -> 'T
Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface IEnumerable
    interface IEnumerable<'T>
    member GetSlice : startIndex:int option * endIndex:int option -> 'T list
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    member Tail : 'T list
    ...
val map : mapping:('T -> 'U) -> list:'T list -> 'U list
val sprintf : format:Printf.StringFormat<'T> -> 'T
union case Option.None: Option<'T>
Multiple items
type Async =
  static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
  static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
  static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
  static member AwaitTask : task:Task -> Async<unit>
  static member AwaitTask : task:Task<'T> -> Async<'T>
  static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
  static member CancelDefaultToken : unit -> unit
  static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
  static member Choice : computations:seq<Async<'T option>> -> Async<'T option>
  static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
  ...

--------------------
type Async<'T> =
static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T
HockeyApp

Contains tasks to interact with HockeyApp

Slack

Contains a task to send notification messages to a Slack webhook

Fake.Azure Namespace

ModuleDescription
CloudServices

Contains tasks to package Azure Cloud Services.

Note: This documentation is for FAKE version 5.0 or later. The old documentation can be found here

Emulators

Contains tasks to control the local Azure Emulator

Kudu

Contains tasks to stage and deploy Azure website and webjobs using source code deployment with Kudu Sync.

WebJobs

Contains tasks to package and deploy Azure Web Jobs via the Kudu Zip controller

Note: This documentation is for FAKE version 5.0 or later. The old documentation can be found here

Fake.Build Namespace

ModuleDescription
CMake

Contains tasks which allow to use CMake to build CMakeLists files. See Samples/CMakeSupport for usage examples.

Fake.BuildServer Namespace

ModuleDescription
AppVeyor

native support for AppVeyor specific APIs. The general documentation on how to use CI server integration can be found here. This module does not provide any special APIs please use FAKE APIs and they should integrate into this CI server. If some integration is not working as expected or you have features you would like to use directly please open an issue.

AppVeyorImportExtensions
BitbucketPipelines
GitHubActions

native support for GitHub Actions specific APIs. The general documentation on how to use CI server integration can be found here. This module does not provide any special APIs please use FAKE APIs and they should integrate into this CI server. If some integration is not working as expected or you have features you would like to use directly please open an issue.

GitLab

native support for GitLab specific APIs. The general documentation on how to use CI server integration can be found here. This module does not provide any special APIs please use FAKE APIs and they should integrate into this CI server. If some integration is not working as expected or you have features you would like to use directly please open an issue.

GitLabImportExtensions
TeamCity

native support for TeamCity specific APIs. The general documentation on how to use CI server integration can be found here. This module does not provide any special APIs please use FAKE APIs and they should integrate into this CI server. If some integration is not working as expected or you have features you would like to use directly please open an issue.

For more information on TeamCity interaction from build scripts see here

TeamCityImportExtensions
TeamFoundation

native support for Azure DevOps (previously VSTS) / Team Foundation Server specific APIs. The general documentation on how to use CI server integration can be found here

Secret Variables

This CI server supports the concept of secret variables and uses the Vault to store them. In order to access secret variables you need to use one of the fake 5 tasks from vsts-fsharp.

Example implementation (supports runner and vault tasks)

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
   // Either use a local vault filled by the 'FAKE_VAULT_VARIABLES' environment variable
   // or fall back to the build process if none is given
   let vault =
       match Vault.fromFakeEnvironmentOrNone() with
       | Some v -> v // fake 5 vault task, uses 'FAKE_VAULT_VARIABLES' by default
       | None -> TeamFoundation.variables // fake 5 runner task

   // Only needed if you want to fallback to 'normal' environment variables (locally for example)
   let getVarOrDefault name =
       match vault.TryGet name with
       | Some v -> v
       | None -> Environment.environVarOrFail name
   Target.create "Deploy" (fun _ ->
       let token = getVarOrDefault "github_token"
       // Use token to deploy to github

       let apiKey = getVarOrDefault "nugetkey"
       // Use apiKey to deploy to nuget
       ()
   )
val vault : obj
union case Option.Some: Value: 'T -> Option<'T>
val v : obj
union case Option.None: Option<'T>
val getVarOrDefault : name:'a -> 'b
val name : 'a
val v : 'b
Travis

native support for Travis specific APIs. The general documentation on how to use CI server integration can be found here. This module does not provide any special APIs please use FAKE APIs and they should integrate into this CI server. If some integration is not working as expected or you have features you would like to use directly please open an issue.

Fake.Core Namespace

TypeDescription
BuildServer

The server type option.

BuildServerInstaller
TraceMode

The trace mode option.

Arguments

Represents a list of arguments

AsyncProcessResult<'a>
Command

The type of command to execute

ConsoleMessage

A record type which captures console messages

CreateProcess<'TRes>

Handle for creating a process and returning potential results.

DataRef<'T>

Represents basically an "out" parameter, allows to retrieve a value after a certain point in time. Used to retrieve "pipes"

EnvMap
ExecParams

Parameter type for process execution.

FilePath
IMap<'TKey, 'TValue>
ProcStartInfo
ProcessOutput

The output of the process. If ordering between stdout and stderr is important you need to use streams.

ProcessResult

A process result including error code, message log and errors.

ProcessResult<'a>
RawProcessResult
Shell

Allows to exec shell operations synchronously and asynchronously.

StartedProcessInfo

Some information regaring the started process

StreamRef
StreamSpecification

Various options to redirect streams.

ConsoleTraceListener

Implements a TraceListener for System.Console.

DotNetCoverageTool

Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

ITraceListener

Defines a TraceListener interface Note: Please contribute implementations to the fake repository, as external implementations are not supported.

ImportData

Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

KnownTags

Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

NunitDataVersion

Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

TagStatus

Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

TestStatus

Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

TraceData

Defines Tracing information for TraceListeners Note: Adding new cases to this type is not considered a breaking change! Please consider not using a match on this type in code external to the fake repository.

TraceSecret
Docopt
DocoptException
DocoptMap
DocoptResult
PreRelease

Information about PreRelease packages.

PreReleaseSegment
SemVerInfo

Contains the version information. For parsing use SemVer.parse

Note: If you use { version with Patch = myPath; Original = None } to overwrite some parts of this string make sure to overwrite Original to None in order to recalculate the version string. Note: For overwriting the PreRelease part use: { Version with Original = None; PreRelease = PreRelease.TryParse "alpha.1" }

BuildFailedException

Exception for request errors

TargetContext
TargetParameter
TargetResult
ModuleDescription
Context

This module tracks the context of the build. This allows us to run some modules without any context and change behavior depending on the context (For example Fake.Process kills all processes when the Fake Context exists, but it should not when used as library)

BuildServer
Environment
Operators
FakeVar

This module contains helpers for managing build time variables

Args

Helper functions for proper command line parsing

Arguments

Module for working with an Arguments instance

CreateProcess

Module for creating and modifying CreateProcess<'TRes> instances. You can manage:

  • The command (ie file to execute and arguments)
  • The working directory
  • The process environment
  • Stream redirection and pipes
  • Timeout for the process to exit
  • The result and the result transformations (map, mapResult)

More extensions can be found in the CreateProcess Extensions

Example

1: 
2: 
3: 
4: 
Command.RawCommand("file", Arguments.OfArgs ["arg1"; "arg2"])
|> CreateProcess.fromCommand
|> Proc.run
|> ignore
val ignore : value:'T -> unit
CreateProcessExt

Some extensions for the CreateProcess module, opened automatically (use add open Fake.Core)

EnvMap
IMap
Mono
Proc

Module to start or run processes, used in combination with the CreateProcess API.

Example

1: 
2: 
3: 
4: 
5: 
6: 
#r "paket: 
nuget Fake.Core.Process //"
open Fake.Core
CreateProcess.fromRawCommand "./folder/mytool.exe" ["arg1"; "arg2"]
|> Proc.run
|> ignore
namespace Fake
namespace Fake.Core
Multiple items
module CreateProcess

from Fake.Core.CreateProcessExt

--------------------
module CreateProcess

from Fake.Core

--------------------
module CreateProcess

from Fake.Core.CreateProcessDotNetExt

--------------------
type CreateProcess<'TRes> =
  private { InternalCommand: Command
            TraceCommand: bool
            InternalWorkingDirectory: string option
            InternalEnvironment: EnvMap option
            Streams: StreamSpecs
            Hook: IProcessHook<'TRes> }
    member Command : Command
    member CommandLine : string
    member Environment : EnvMap option
    member WorkingDirectory : string option
val fromRawCommand : command:FilePath -> args:seq<string> -> CreateProcess<ProcessResult<unit>>
module Proc

from Fake.Core
val run : c:CreateProcess<'a> -> 'a
val ignore : value:'T -> unit
ProcStartInfoExtensions
Process
ProcessUtils
StreamExtensions
String

Contains basic functions for string manipulation.

StringBuilder
ConsoleWriter
CoreTracing
TestStatus
Trace

This module contains function which allow to trace build output

TraceData
TraceSecrets
Xml

Contains functions to read and write XML files.

Vault

Provices a encrypted store of variables to prevent accidential leakage Please read the documentation

VaultExt
DocHelper
DocoptResult
Changelog

Contains helpers which allow to parse Change log text files. These files have to be in a format as described on http://keepachangelog.com/en/1.1.0/

ReleaseNotes

Contains helpers which allow to parse Release Notes text files. Either "simple" or "complex" format is accepted.

SemVer

Parser which allows to deal with Semantic Versioning (SemVer). Make sure to read the documentation in the SemVerInfo record as well if you manually create versions.

SemVerActivePattern

Contains active patterns which allow to deal with Semantic Versioning (SemVer).

Target
TargetOperators

Provides functions and operators to deal with FAKE targets and target dependencies.

TaskRunner

Contains a helper which can be used to implement timeouts and retries.

UserInput

Helpers for capturing user input

CreateProcessDotNetExt

Some extensions for the CreateProcess module, opened automatically (use add open Fake.Core)

Fake.Core.CommandLineParsing Namespace

TypeDescription
ArgumentParser<'TUserState, 'TResult>
ArgumentStream<'TUserState>
ArgumentStreamPosition
ArgumentStreamState<'TUserState>
IArgumentStream<'TUserState>
IArgumentStreamState<'TUserState>
OptionSection
OptionsParser
OptionsParserState
SafeOption
SafeOptions
Tag
UsageAst
UsageAstBuilder
UsageAstCell
UsageException
UsageParser
ModuleDescription
ArgParser
ArgumentArray
ArgumentStream

Fake.Core.DependencyManager.Paket Namespace

ModuleDescription
Internals

Fake.Documentation Namespace

ModuleDescription
DocFx

Contains helper functions to use DocFx https://dotnet.github.io/docfx/.

Fake.DotNet Namespace

TypeDescription
AssemblyInfoFileConfig

Represents options for configuring the emission of AssemblyInfo

DotNetFDDOptions
DotNetLocalTool

Information about a dotnet tool

ToolType

Describes which kind of application ToolPath references

BuildException
OBSOLETE

Using this is a BUG as this exception is no longer thrown! Use MSBuildException instead!

MSBuildDistributedLoggerConfig
MSBuildEntry
MSBuildException

An exception type to signal build errors.

MSBuildFileLoggerConfig

A type for MSBuild configuration

MSBuildLogParameter

MSBuild log option See https://docs.microsoft.com/de-de/visualstudio/msbuild/msbuild-command-line-reference?view=vs-2015

MSBuildLoggerConfig
MSBuildParams

A type for MSBuild task parameters

MSBuildProject

A type to represent MSBuild project files.

MSBuildVerbosity

MSBuild verbosity option

ModuleDescription
AssemblyInfo
AssemblyInfoFile
DotNet
ToolType
MSBuild
MSBuildBinLog

Analyse a binlog and emit proper CI messages

Fsc

Contains tasks to compiles F# source file with the FSharp.Compiler.Service.

Note: This documentation is for FAKE version 5.0 or later. The old documentation can be found here

FSFormatting

Contains tasks which allow to run FSharp.Formatting for generating documentation.

Fsi
FxCop

Contains a task to invoke the FxCop tool

Sample

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
   Target.create "FxCop" (fun _ ->
       Directory.ensure "./_Reports"
       let rules = [ "-Microsoft.Design#CA1011"   // maybe sometimes
                     "-Microsoft.Design#CA1062" ] // null checks,  In F#!
       !! ("**/bin/Debug/*.dll")
       |> FxCop.run { FxCop.Params.Create() with WorkingDirectory = "."
                                                 UseGAC = true
                                                 Verbose = false
                                                 ReportFileName = "_Reports/FxCopReport.xml"
                                                 Rules = rules
                                                 FailOnError = FxCop.ErrorLevel.Warning
                                                 IgnoreGeneratedCode = true})
ILMerge

Contains task a task which allows to merge .NET assemblies with ILMerge.

Sample

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
   Target.create "ILMerge" (fun _ ->
        let target = !!"./bin/Release/*.exe" |> Seq.head
        let out = "./bin" @@ (Path.GetFileName target)
        ILMerge.run
          { ILMerge.Params.Create() with DebugInfo = true
                                         TargetKind = ILMerge.TargetKind.Exe
                                         Internalize = ILMerge.InternalizeTypes.Internalize
                                         Libraries =
                                            Seq.concat
                                              [ !!"./bin/Release/Mono.C*.dll"
                                                !!"./bin/Release/Newton*.dll" ]
                                         AttributeFile = target } out target)
module Seq

from Microsoft.FSharp.Collections
val head : source:seq<'T> -> 'T
val concat : sources:seq<#seq<'T>> -> seq<'T>
Mage

Contains helper functions which allow FAKE to call the Manifest Generation and Editing Tool, in short 'MAGE'. The intentional use is the creation of a clickonce application.

Paket

Contains helper functions and task which allow to inspect, create and publish NuGet packages with Paket.

PaketTemplate

Contains helper functions and task which allow it to generate a paket.template file for Paket

Xamarin

Contains tasks for building Xamarin.iOS and Xamarin.Android apps

Xdt

Contains functions used to transform config (or any XML) files using Microsoft's XML Document Transformations.

Fake.DotNet.NuGet Namespace

ModuleDescription
Install

Contains tasks for installing NuGet packages using the nuget.exe install command.

NuGet

Contains helper functions and task which allow to inspect, create and publish NuGet packages. There is also a tutorial about nuget package creating available.

Restore

Contains tasks which allow to restore NuGet packages from a NuGet package feed like nuget.org. There is also a tutorial about nuget package restore available.

Update

Contains tasks for updating NuGet packages including assembly hint paths in the project files using the nuget.exe update command.

Version

Fake.DotNet.Testing Namespace

ModuleDescription
Coverlet

Contains options to run Coverlet as part of dotnet test.

DotCover

Contains a task which can be used to run DotCover on .NET assemblies.

MSpec

Contains a task to run machine.specifications tests.

MSTest

Contains tasks to run MSTest unit tests.

NUnit3

Contains tasks to run NUnit unit tests.

Sample

1: 
2: 
3: 
4: 
5: 
6: 
   Target.create "Test" (fun _ ->
       !! (testDir + "/NUnit.Test.*.dll")
         |> NUnit3.run (fun p ->
             {p with
                   ShadowCopy = false })
   )
XUnit2

Contains tasks to run xUnit v2 unit tests.

Expecto

Contains tasks to run Expecto unit tests.

OpenCover

Contains a task which can be used to run OpenCover on .NET assemblies.

SpecFlow
OBSOLETE

This API is obsolete after SpecFlow V2.4. Please use the SpecFlowNext module instead.

Contains a task which allows to run SpecFlow tests.

SpecFlowNext

Contains a task which allows to run SpecFlow tests with SpecFlow v2.4+.

VSTest

Contains tasks to run VSTest unit tests.

Fake.DotNet.Testing.NUnit Namespace

ModuleDescription
Common

Contains types and utility functions relaited to running NUnit unit tests.

Parallel

Contains tasks to run NUnit unit tests in parallel.

Sequential

Contains tasks to run NUnit unit tests.

Xml

Contains types and functions for working with NUnit unit tests result xml.

Fake.IO Namespace

TypeDescription
FileChange
FileStatus
IGlobbingPattern
ModuleDescription
ChangeWatcher

This module is part of the Fake.IO.FileSystem package

Directory
DirectoryInfo
File
FileFilter
FileInfo
FileSystemInfo
FileSystemOperators
GlobbingPattern
GlobbingPatternExtensions
Path

Contains helper function which allow to deal with files and directories.

Shell
Templates

NOTE: Maybe this should be an extra module? Contains basic templating functions. Used in other helpers.

Zip

This module contains helper function to create and extract zip archives.

Fake.IO.Globbing Namespace

TypeDescription
FileIncludes
OBSOLETE

Please use IGlobbingPattern instead

LazyGlobbingPattern
ResolvedGlobbingPattern
ModuleDescription
FileIncludes
OBSOLETE

Please use GlobbingPattern instead

Glob

This module contains a file pattern globbing implementation. This module is part of the Fake.IO.FileSystem package

Operators

Contains operators to find and process files. This module is part of the Fake.IO.FileSystem package

Simple glob using as list

1: 
2: 
3: 
4: 
5: 
6: 
#r "paket: nuget Fake.IO.FileSystem //"
open Fake.IO.Globbing.Operators
let csProjectFiles = !! "src/*.csproj"

for projectFile in csProjectFiles do
    printf "F# ProjectFile: %s" projectFile

Combine globs

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
#r "paket: nuget Fake.IO.FileSystem //"
open Fake.IO.Globbing.Operators
let projectFiles =
    !! "src/*/*.*proj"
    ++ "src/*/*.target"
    -- "src/*/*.vbproj"

for projectFile in projectFiles do
    printf "ProjectFile: %s" projectFile

Forward globs to tasks

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
#r "paket:
nuget Fake.Core.Target
nuget Fake.IO.FileSystem //"
open Fake.Core
open Fake.IO
open Fake.IO.Globbing.Operators
Target.create "Clean" (fun _ ->
   !! "src/*/*/obj/**/*.nuspec"
   |> File.deleteAll
)
namespace Fake
namespace Fake.IO
namespace Fake.IO.Globbing
module Operators

from Fake.IO.Globbing
val csProjectFiles : Fake.IO.IGlobbingPattern
val projectFile : string
val printf : format:Printf.TextWriterFormat<'T> -> 'T
val projectFiles : Fake.IO.IGlobbingPattern
namespace Fake.Core
Multiple items
module Target

from Fake.Core

--------------------
type Target =
  { Name: string
    Dependencies: string list
    SoftDependencies: string list
    Description: TargetDescription option
    Function: TargetParameter -> unit }
    member DescriptionAsString : TargetDescription
val create : name:string -> body:(TargetParameter -> unit) -> unit
module File

from Fake.IO
val deleteAll : files:seq<string> -> unit
Tools
OBSOLETE

use Fake.Core.Process and the ProcessUtils helpers instead.

Fake.Installer Namespace

ModuleDescription
InnoSetup

This module contains helper functions to create Inno Setup installers.

Squirrel

Contains types and utility functions related to creating Squirrel installer.

Wix

Contains tasks to create msi installers using the WiX toolset

Fake.JavaScript Namespace

ModuleDescription
Npm

Helpers to run the npm tool.

TypeScript

Helpers to run the typeScript compiler.

Yarn

Helpers for running the yarn tool

Fake.Net Namespace

ModuleDescription
Http

HTTP Client for downloading files

FTP

Contains helpers which allow to upload a whole folder/specific file into a FTP Server. Uses Passive Mode FTP and handles all files as binary (and not ASCII). Assumes direct network connectivity to destination FTP server (not via a proxy). Does not support FTPS and SFTP.

SSH

Contains a task which allows to perform SSH operations

Fake.Runtime Namespace

ModuleDescription
CompileRunner

Contains helper functions which allow to interact with the F# Interactive.

CoreCache

Contains helper functions which allow to interact with the F# Interactive.

Environment

This module contains functions which allow to read and write environment variables and build parameters

FSharpParser
FakeRuntime
FakeRuntimeHints
LegacyApiHelper
Path

Contains basic functions for string manipulation.

Runners

Contains helper functions which allow to interact with the F# Interactive.

ScriptRunner

Contains helper functions which allow to interact with the F# Interactive.

SdkAssemblyResolver
String

Contains basic functions for string manipulation.

Tooling

This module is to provide tooling support for FAKE scripts and provide common operations

Trace

This module contains function which allow to trace build output

Fake.Sql Namespace

ModuleDescription
DacPac
OBSOLETE

Use SqlPackage instead

Contains helpers around deploying databases.

SqlPackage

Contains helpers around deploying databases.

Fake.Testing Namespace

ModuleDescription
Common
Fixie

Contains tasks to run Fixie unit tests.

ReportGenerator

Contains a task which can be used to run ReportGenerator, which converts XML reports generated by PartCover, OpenCover or NCover into a readable report in various formats.

SonarQube

Contains a task to run the SonarQube static code analyzer. It uses the SonarScanner for MSBuild

Fake.Tools Namespace

ModuleDescription
GitVersion
Octo
Pickles

Contains tasks to run the Pickles living documentation generator

Rsync

Helpers for running rsync tool

Under windows you will need to add it yourself to your system or use something like cygwin/babun

SignTool

The SignTool tool is a command-line tool that digitally signs files, verifies signatures in files, or time stamps files.

Documentation & samples

Fake.Tools.Git Namespace

ModuleDescription
Branches

Contains helper functions which allow to deal with git branches.

CommandHelper

Contains helpers which allow to interact with git via the command line.

Commit

Contains helper functions which allow to commit to git repositories.

CommitMessage

Contains helper functions which allow to get and set the git commit message.

FileStatus

Contains helper functions which can be used to retrieve file status information from git.

Information

Contains helper functions which can be used to retrieve status information from git.

Merge

Contains helper functions which allow to deal with git merge.

Rebase

Contains helper functions which allow to deal with git rebase.

Repository

Contains functions which allow basic operations on git repositories. All operations assume that the CommandHelper can find git.exe.

Reset

Contains helper functions which allow to deal with git reset.

SHA1

Contains functions which allow the SHA1 of a file with git and without it.

SanityChecks

Contains helper function which can be used for sanity checks.

Staging

Contains helper functions which allow to deal with git's staging area.

Stash

Contains helper functions which allow to deal with git stash.

Submodule

Contains helper functions which allow to deal with git submodules.

Fake.Windows Namespace

ModuleDescription
Choco

Contains tasks which allow to call Chocolatey

Registry

Contains functions which allow to read and write information from/to the registry.

Yaaf.FSharp.Scripting Namespace

TypeDescription
OutputData
ModuleDescription
Log