FAKE - F# Make


 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58: 
59: 
60: 
61: 
62: 
63: 
64: 
65: 
66: 
67: 
68: 
69: 
70: 
71: 
72: 
73: 
74: 
75: 
76: 
77: 
// Given a typical setup (with 'FSharp.Formatting' referenced using NuGet),
// the following will include binaries and load the literate script
#I "../lib/net40/"
#r "FSharp.Literate.dll"
#r "FSharp.CodeFormat.dll"
#r "FSharp.MetadataFormat.dll"
open System.IO
open FSharp.Literate

// ----------------------------------------------------------------------------
// SETUP
// ----------------------------------------------------------------------------

/// Return path relative to the current file location
let relative subdir = Path.Combine(__SOURCE_DIRECTORY__, subdir)

// Create output directories & copy content files there
// (We have two sets of samples in "output" and "output-all" directories,
//  for simplicitly, this just creates them & copies content there)
if not (Directory.Exists(relative "/output")) then
  Directory.CreateDirectory(relative "/output") |> ignore
  Directory.CreateDirectory (relative "/output/content") |> ignore
if not (Directory.Exists(relative "/output-all")) then
  Directory.CreateDirectory(relative "/output-all") |> ignore
  Directory.CreateDirectory (relative "/output-all/content") |> ignore

for fileInfo in DirectoryInfo(relative "/../content").EnumerateFiles() do
  fileInfo.CopyTo(Path.Combine(relative "/output/content", fileInfo.Name)) |> ignore
  fileInfo.CopyTo(Path.Combine(relative "/output-all/content", fileInfo.Name)) |> ignore

// ----------------------------------------------------------------------------
// EXAMPLES
// ----------------------------------------------------------------------------

/// Processes a single F# Script file and produce HTML output
let processScriptAsHtml () =
  let file = relative "/demo.fsx"
  let output = relative "/output/demo-script.html"
  let template = relative "/templates/template-file.html"
  Literate.ProcessScriptFile(file, template, output)

/// Processes a single F# Script file and produce LaTeX output
let processScriptAsHtml () =
  let file = relative "/demo.fsx"
  let output = relative "/output/demo-script.html"
  let template = relative "/templates/template-color.tex"
  Literate.ProcessScriptFile(file, template, output, format = OutputKind.Latex)


/// Processes a single Markdown document and produce HTML output
let processDocument templateFile outputKind =
  let file = relative "/demo.md"
  let output = relative "/output/demo-markdown.html"
  let template = relative "/templates/template-file.html"
  Literate.ProcessMarkdown(file, template, output)

/// Processes a single Markdown document and produce LaTeX output
let processDocument templateFile outputKind =
  let file = relative "/demo.md"
  let output = relative "/output/demo-markdown.tex"
  let template = relative "/templates/template-color.tex"
  Literate.ProcessMarkdown(file, template, output, format = outputKind)


/// Processes an entire directory containing multiple script files 
/// (*.fsx) and Markdown documents (*.md) and it specifies additional 
/// replacements for the template file
let processDirectory() =
  let template = relative "/templates/template-project.html"
  let projInfo =
    [ "page-description", "F# Literate Programming"
      "page-author", "Tomas Petricek"
      "github-link", "https://github.com/tpetricek/FSharp.Formatting"
      "project-name", "F# Formatting" ]
  Literate.ProcessDirectory
    ( __SOURCE_DIRECTORY__, template, dir + "/output-all", 
      OutputKind.Html, replacements = projInfo)
namespace System
namespace System.IO
namespace Microsoft.FSharp
val relative : subdir:string -> string

Full name: Build.relative


 Return path relative to the current file location
val subdir : string
type Path =
  static val DirectorySeparatorChar : char
  static val AltDirectorySeparatorChar : char
  static val VolumeSeparatorChar : char
  static val InvalidPathChars : char[]
  static val PathSeparator : char
  static member ChangeExtension : path:string * extension:string -> string
  static member Combine : [<ParamArray>] paths:string[] -> string + 3 overloads
  static member GetDirectoryName : path:string -> string
  static member GetExtension : path:string -> string
  static member GetFileName : path:string -> string
  ...

Full name: System.IO.Path
Path.Combine([<System.ParamArray>] paths: string []) : string
Path.Combine(path1: string, path2: string) : string
Path.Combine(path1: string, path2: string, path3: string) : string
Path.Combine(path1: string, path2: string, path3: string, path4: string) : string
val not : value:bool -> bool

Full name: Microsoft.FSharp.Core.Operators.not
type Directory =
  static member CreateDirectory : path:string -> DirectoryInfo + 1 overload
  static member Delete : path:string -> unit + 1 overload
  static member EnumerateDirectories : path:string -> IEnumerable<string> + 2 overloads
  static member EnumerateFileSystemEntries : path:string -> IEnumerable<string> + 2 overloads
  static member EnumerateFiles : path:string -> IEnumerable<string> + 2 overloads
  static member Exists : path:string -> bool
  static member GetAccessControl : path:string -> DirectorySecurity + 1 overload
  static member GetCreationTime : path:string -> DateTime
  static member GetCreationTimeUtc : path:string -> DateTime
  static member GetCurrentDirectory : unit -> string
  ...

Full name: System.IO.Directory
Directory.Exists(path: string) : bool
Directory.CreateDirectory(path: string) : DirectoryInfo
Directory.CreateDirectory(path: string, directorySecurity: System.Security.AccessControl.DirectorySecurity) : DirectoryInfo
val ignore : value:'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val fileInfo : FileInfo
Multiple items
type DirectoryInfo =
  inherit FileSystemInfo
  new : path:string -> DirectoryInfo
  member Create : unit -> unit + 1 overload
  member CreateSubdirectory : path:string -> DirectoryInfo + 1 overload
  member Delete : unit -> unit + 1 overload
  member EnumerateDirectories : unit -> IEnumerable<DirectoryInfo> + 2 overloads
  member EnumerateFileSystemInfos : unit -> IEnumerable<FileSystemInfo> + 2 overloads
  member EnumerateFiles : unit -> IEnumerable<FileInfo> + 2 overloads
  member Exists : bool
  member GetAccessControl : unit -> DirectorySecurity + 1 overload
  member GetDirectories : unit -> DirectoryInfo[] + 2 overloads
  ...

Full name: System.IO.DirectoryInfo

--------------------
DirectoryInfo(path: string) : unit
FileInfo.CopyTo(destFileName: string) : FileInfo
FileInfo.CopyTo(destFileName: string, overwrite: bool) : FileInfo
property FileInfo.Name: string
val processScriptAsHtml : unit -> 'a

Full name: Build.processScriptAsHtml


 Processes a single F# Script file and produce HTML output
val file : string
val output : string
val template : string
val processScriptAsHtml : unit -> 'a

Full name: Build.processScriptAsHtml


 Processes a single F# Script file and produce LaTeX output
val processDocument : templateFile:'a -> outputKind:'b -> 'c

Full name: Build.processDocument


 Processes a single Markdown document and produce HTML output
val templateFile : 'a
val outputKind : 'b
val processDocument : templateFile:'a -> outputKind:'b -> 'c

Full name: Build.processDocument


 Processes a single Markdown document and produce LaTeX output
val processDirectory : unit -> 'a

Full name: Build.processDirectory


 Processes an entire directory containing multiple script files
 (*.fsx) and Markdown documents (*.md) and it specifies additional
 replacements for the template file
val projInfo : (string * string) list
Fork me on GitHub