Yeah it's christmas time again, and santa's elves are quite busy.
And when I say busy, I don't mean:
I mean busy like this:
So they decided to build some automation productivity tools, and they choose Santa's favorite language to do the job:
F# of course !
No body would seriously use a compiled language for automation tools. Requiring compilation or a CI server for this kind of things usually kills motivation.
Of course it is possible to write bash/batch files but the syntax if fugly once you start to make more advanced tools.
Writing F# script is easy and fast. Test it from the command line:
:q to exit
now launch it on linux with:
or on windows:
The only problem is that typing the
fshapi --exec this is a bit tedious.
Bash/Batch to the rescue
We can create a bash/batch script to puth in the path that will launch the script (for linux):
or one windows
Better, but now we need to write a bash and/or a batch script for each F# script.
fck bash/batch dispatcher FTW !
We create a fck file (don't forget to chmod +x it) that takes a command [lang=bash] #!/usr/bin/env bash # #the fck tool path fckpath=\((readlink -f "\)0") #this fck tool dir dir=\((dirname\)fckpath) script="\(dir/fck-cmd/fck-\)1.fsx" shell="\(dir/fck-cmd/fck-\)1.sh" cmd="\(1" shift # #restore packages if needed if [ ! -d "\)dir/fck-cmd/packages" ] then pushd "\(dir/fck-cmd" > /dev/null mono "\)dir/fck-cmd/.paket/paket.bootstrapper.exe" --run restore popd > /dev/null fi # #execute script command if it exists if [ -e $script ] then mono "\(dir/fck-cmd/packages/FAKE/tools/FAKE.exe" "\)script" -- \(@ # #execute shell command if it exists elif [ -e\)shell ] then eval \(shell\)@ # #show help else pushd "\(dir/fck-cmd" > /dev/null mono "\)dir/fck-cmd/packages/FAKE/tools/FAKE.exe" "\(dir/fck-cmd/fck-help.fsx" --\)cmd $@ popd > /dev/null fi
and the batch version:
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:
Forget the paket part for now.
The bash take a command argument, and check whether a fck-cmd/fck-$cmd.fsx file exists. If it does, run it ! It also works with shell scripts name fck-$cmd.sh or batch scripts fck-$cmd.cmd to integrate quickly with existing tools.
Fake for faster startups
When F# scripts start to grow big, especially with things like Json or Xml type providers, load time can start to raise above acceptable limits for a cli.
Using Fake to launch scripts takes adventage of it's compilation cache. We get the best of both world:
- scriptability for quick changes and easy deployment
- automaticly cached jit compilation for fast startup and execution
We could have written all commands in a single fsx file and pattern maching on the command name, but once we start to have more commands, the script becomes bigger and compilation longer. The problem is also that the pattern matching becomes a friction point in the source control.
At some point we have recuring code in the tools. So we can create helper scripts that will be included by command scripts.
For instance parsing the command line is often useful so I created a helper:
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:
We use the
-- to delimit arguments reserved for the script.
Since Fake is used to launch scripts, we can also include FakeLib for all the fantastic helpers it contains.
Here is a sample fck-cmd/fck-hello.fsx script that can write hello.
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
It uses FakeLib for the
tracefn function and FckLib for
You can call it with (once fck is in your Path environment variable):
A tool without help is just a nightmare, and writing help should be easy.
The last part of fck bash script lanch the fck-help.fsx script:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23:
This script tries to find a fck-xxx.txt file and display it, or fallbacks to fck-help.txt.
For exemple the help for our fck hello command will be in fck-hello.txt:
1: 2: 3: 4:
Of course we can the pimp the fck-help.fsx to parse the txt help files and add codes for colors, verbosity etc.
Deployment is really easy. We can clone the git repository, and add it to $PATH.
Run the commands, it will automatically restore packages if missing, and lanch the script.
To upgrade to a new version, call fck update, defined in fck-update.sh :
1: 2: 3: 4: 5: 6: 7:
or batch fck-update.cmd: [lang=bash] git pull .paket\paket.bootstrapper.exe --run restore
Yep, that's that easy
Using Santa's elves tools, I hope you won't be stuck at work on xmas eve ! Enjoy !
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
String(value: char ) : String
String(value: nativeptr<char>) : String
String(value: nativeptr<sbyte>) : String
String(value: ReadOnlySpan<char>) : String
String(c: char, count: int) : String
String(value: char , startIndex: int, length: int) : String
String(value: nativeptr<char>, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: Text.Encoding) : String
String.Equals(a: string, b: string, comparisonType: StringComparison) : bool
| CurrentCulture = 0
| CurrentCultureIgnoreCase = 1
| InvariantCulture = 2
| InvariantCultureIgnoreCase = 3
| Ordinal = 4
| OrdinalIgnoreCase = 5
static member CommandLine : string
static member CurrentDirectory : string with get, set
static member CurrentManagedThreadId : int
static member Exit : exitCode:int -> unit
static member ExitCode : int with get, set
static member ExpandEnvironmentVariables : name:string -> string
static member FailFast : message:string -> unit + 2 overloads
static member GetCommandLineArgs : unit -> string
static member GetEnvironmentVariable : variable:string -> string + 1 overload
static member GetEnvironmentVariables : unit -> IDictionary + 1 overload
nested type SpecialFolder
nested type SpecialFolderOption
member Clone : unit -> obj
member CopyTo : array:Array * index:int -> unit + 1 overload
member GetEnumerator : unit -> IEnumerator
member GetLength : dimension:int -> int
member GetLongLength : dimension:int -> int64
member GetLowerBound : dimension:int -> int
member GetUpperBound : dimension:int -> int
member GetValue : [<ParamArray>] indices:int -> obj + 7 overloads
member Initialize : unit -> unit
member IsFixedSize : bool
type List<'T> =
| (  )
| ( :: ) of Head: 'T * Tail: 'T list
member GetReverseIndex : rank:int * offset:int -> int
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
get the command line, fck style...
active recognizer File: FileSystemInfo -> Choice<FileInfo,(DirectoryInfo * Collections.Generic.IEnumerable<FileSystemInfo>)>
type File =
static member AppendAllLines : path:string * contents:IEnumerable<string> -> unit + 1 overload
static member AppendAllLinesAsync : path:string * contents:IEnumerable<string> * ?cancellationToken:CancellationToken -> Task + 1 overload
static member AppendAllText : path:string * contents:string -> unit + 1 overload
static member AppendAllTextAsync : path:string * contents:string * ?cancellationToken:CancellationToken -> Task + 1 overload
static member AppendText : path:string -> StreamWriter
static member Copy : sourceFileName:string * destFileName:string -> unit + 1 overload
static member Create : path:string -> FileStream + 2 overloads
static member CreateText : path:string -> StreamWriter
static member Decrypt : path:string -> unit
static member Delete : path:string -> unit
File.ReadAllText(path: string, encoding: Text.Encoding) : string