more options, better error reporting, added some tests, unified entry point (xake for everything),

Author: OlegZee

XakeLibTests/CommandLineTests.fs

@@ -0,0 +1,95 @@
+namespace XakeLibTests
+
+open System.IO
+open NUnit.Framework
+
+open Xake
+
+[<TestFixture (Description = "Command line tests")>]
+type CommandLineTests() =
+
+    let currentDir = Path.Combine (__SOURCE_DIRECTORY__, "..")
+
+    [<Test (Description = "Verifies reading common switches")>]
+    member test.AcceptKnownSwitches() =
+
+        let scriptOptions = ref XakeOptions
+        let args =
+            ["/t"; "33"; "/R"; currentDir; "/LL"; "Loud";
+            "/FL"; "aaaaa"; "/D"; "AA=BBB"; "/D"; "AA1=CCC"; "/FLL"; "Silent"]
+    
+        do xakeArgs args XakeOptions {
+            wantOverride (["test"])
+
+            rules [
+              "test" => action {
+                  let! opts = getCtxOptions()
+                  scriptOptions := opts
+              }
+            ]
+        }
+
+        let finalOptions = !scriptOptions
+        Assert.AreEqual(33, finalOptions.Threads)
+        Assert.AreEqual(currentDir, finalOptions.ProjectRoot)
+        Assert.AreEqual("aaaaa", finalOptions.FileLog)
+        Assert.AreEqual(Verbosity.Silent, finalOptions.FileLogLevel)
+        Assert.AreEqual(Verbosity.Loud, finalOptions.ConLogLevel)
+        Assert.AreEqual([("AA", "BBB"); ("AA1", "CCC")], finalOptions.Vars)
+
+    [<Test (Description = "Verifies reading target list")>]
+    member test.ReadsTargets() =
+
+        let scriptOptions = ref XakeOptions
+        let executed2 = ref false
+        let args = ["/t"; "31"; "target1"; "target2"]
+    
+        do xakeArgs args XakeOptions {
+
+            rules [
+              "target1" => action {
+                  let! opts = getCtxOptions()
+                  scriptOptions := opts
+              }
+              "target2" => action {
+                  executed2 := true
+              }
+            ]
+        }
+
+        let finalOptions = !scriptOptions
+        Assert.AreEqual(31, finalOptions.Threads)
+        Assert.AreEqual(["target1"; "target2"], finalOptions.Want)
+        Assert.IsTrue !executed2
+
+
+    [<Test (Description = "Verifies reading incorrect"); Ignore>]
+    member test.WarnsOnIncorrectSwitch() =
+
+        do xakeArgs ["/xxx"] XakeOptions {
+            want ["ss"]
+        }
+
+        //raise <| new System.NotImplementedException()
+
+    [<Test (Description = "Verifies that command line is ignored when Ignore option is set")>]
+    member test.IgnoresCommandLine() =
+
+        let scriptOptions = ref XakeOptions
+        let args =
+            ["/t"; "33"; "/R"; currentDir; "/LL"; "Loud";
+            "/FL"; "aaaaa"; "target"]
+    
+        do xakeArgs args {XakeOptions with IgnoreCommandLine = true; Threads = 2; FileLog = "ss"; Want = ["main"]} {
+            rules [
+              "main" => action {
+                  let! opts = getCtxOptions()
+                  scriptOptions := opts
+              }
+            ]
+        }
+
+        let finalOptions = !scriptOptions
+        Assert.AreEqual(2, finalOptions.Threads)
+        Assert.AreEqual("ss", finalOptions.FileLog)
+        Assert.AreEqual(["main"], finalOptions.Want)

XakeLibTests/MiscTests.fs

@@ -7,7 +7,7 @@ open Xake
 open Storage
 open BuildLog
 
-[<TestFixture (Description = "Verious tests")>]
+[<TestFixture (Description = "Various tests")>]
 type MiscTests() =
 
     [<SetUp>]

XakeLibTests/XakeLibTests.fsproj

@@ -48,8 +48,9 @@
     <Compile Include="MiscTests.fs" />
     <Compile Include="StorageTests.fs" />
     <Compile Include="FileTasksTests.fs" />
-    <None Include="packages.config" />
     <Compile Include="ProgressTests.fs" />
+    <Compile Include="CommandLineTests.fs" />
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\core\Xake.Core.fsproj">

core/Program.fs

@@ -15,26 +15,27 @@ module internal ParseArgs = begin
     | "--" :: rest -> rest
     | _ :: tail -> get_script_args tail
 
-    let parseTopLevel arg optionsSoFar = 
-        match arg with 
+    let parseTopLevel (arg:string) optionsSoFar = 
+        match arg.ToLowerInvariant() with 
 
         // TODO support sequential/parallel runs e.g. "clean release-build;debug-build"
 
         | "-t" | "/t" -> 
             (optionsSoFar, Number ("thread count", fun o v -> {o with XakeOptionsType.Threads = v}))
-        | "-R" | "/R" -> 
+        | "-r" | "/r" -> 
             (optionsSoFar, String ("root folder", fun o v -> {o with XakeOptionsType.ProjectRoot = v}))
-        | "-FL" | "/FL" -> 
+        | "-fl" | "/fl" -> 
             (optionsSoFar, String ("file log filename", fun o v -> {o with XakeOptionsType.FileLog = v}))
-        | "-D" | "/D" -> 
+        | "-d" | "/d" -> 
             (optionsSoFar, KeyValue ("variable", fun o k v -> {o with Vars = o.Vars @ [(k,v)] }))
-        | "-LL" | "/LL" -> 
+        | "-ll" | "/ll" -> 
             (optionsSoFar, String ("console verbosity", fun o s -> {o with ConLogLevel = s |> parseVerbosity }))
-        | "-FLL" | "/FLL" -> 
+        | "-fll" | "/fll" -> 
             (optionsSoFar, String ("filelog verbosity", fun o s -> {o with FileLogLevel = s |> parseVerbosity }))
 
         // handle unrecognized option
-        | x when x.StartsWith("-") -> 
+        | x when x.StartsWith("-") || x.StartsWith("/") ->
+            // TODO write errors to log?
             printfn "Option '%s' is unrecognized" x
             (optionsSoFar, TopLevel)
         | x -> 
@@ -64,19 +65,29 @@ module internal ParseArgs = begin
 
         (fn optionsSoFar k v, TopLevel)
 
-    let foldFunction state element  = 
-        match state with
-        | (optionsSoFar, TopLevel) ->
-            parseTopLevel element optionsSoFar
-
-        | (optionsSoFar, Number (name, fn)) ->
-            readNumber name element optionsSoFar fn
-
-        | (optionsSoFar, String (name, fn)) ->
-            readString name element optionsSoFar fn
-
-        | (optionsSoFar, KeyValue (name, fn)) ->
-            readKeyValue name element optionsSoFar fn
+    let foldFunction state element =
+        try
+            match state with
+            | (optionsSoFar, TopLevel) ->
+                parseTopLevel element optionsSoFar
+
+            | (optionsSoFar, Number (name, fn)) ->
+                readNumber name element optionsSoFar fn
+
+            | (optionsSoFar, String (name, fn)) ->
+                readString name element optionsSoFar fn
+
+            | (optionsSoFar, KeyValue (name, fn)) ->
+                readKeyValue name element optionsSoFar fn
+        with e ->
+            let argName =
+                match state with
+                | (_, Number (name, _)) | (_, KeyValue (name, _)) | (_, String (name, _)) ->
+                    name
+                | _ ->
+                    "switch"
+            printfn "Failed to parse '%s' due to %s" argName e.Message
+            (fst state, TopLevel)
 
 end
 
@@ -85,28 +96,23 @@ module Main =
 
     open ParseArgs
 
-    /// <summary>
-    /// creates xake build script
-    /// </summary>
-    /// <param name="options"></param>
-    let xake options =
-
-        new RulesBuilder(options)
-
     /// <summary>
     /// Creates a script with script parameters passed as list of strings.
     /// </summary>
     /// <param name="args"></param>
     /// <param name="initialOptions"></param>
-    let xakeArgsStr args initialOptions =
-        let options = args |> List.fold foldFunction (initialOptions, TopLevel) |> fst
+    let xakeArgs args initialOptions =
+        let options =
+            if initialOptions.IgnoreCommandLine then initialOptions
+            else args |> List.fold foldFunction (initialOptions, TopLevel) |> fst
         new RulesBuilder (options)
 
     /// <summary>
     /// Create xake build script using command-line arguments to define script options
     /// </summary>
-    /// <param name="args"></param>
-    /// <param name="options"></param>
-    let xakeArgs =
+    /// <param name="options">Initial options set. Could be overridden by a command line arguments.
+    /// Define option IgnoreCommandLine=true to ignore command line arguments
+    /// </param>
+    let xake options =
         let args = get_args() |> get_script_args in
-        xakeArgsStr args
+        xakeArgs args options

core/XakeScript.fs

@@ -27,6 +27,9 @@ module XakeScript =
 
         /// Defines whether `run` should throw exception if script fails
         FailOnError: bool
+        
+        /// Ignores command line swithes
+        IgnoreCommandLine: bool
     }
 
     type private ExecStatus = | Succeed | Skipped | JustFile
@@ -71,6 +74,7 @@ module XakeScript =
         Want = []
         FailOnError = false
         Vars = List<string*string>.Empty
+        IgnoreCommandLine = false
         }
 
     module private Impl = begin

docs/implnotes.md

@@ -81,7 +81,7 @@ Tasks:
  * NETFX - framework version to use for compilation, resources. E.g. "2.0", "3.5", "4.0". Default: highest available on the computer
 
 
-## Script arguments
+## Command line parameters
 
 Script arguments allow to specify execution options, list of targets, logging options and others from command line.
 According to fsi.exe "--" arguments denotes the start of script arguments so in the most common case you will use it as:
@@ -93,13 +93,16 @@ where "clean" "build" and "deploy" are target names.
 The full list of parameters:
 
  * -t <task count> -- use <task count> simultaneous processes to execute the build tasks. * Default value is the number of processors
- * -R <root path> -- override the root path. All the targets and filesets are resolved relatively to this path. Default is current directory
- * -LL <log level> -- console log level (Silent | Quiet | Normal | Loud | Chatty | Diag)
- * -FL <file log path> -- specifies the name of the log file
- * -FLL <log level> -- specifies the logging level to a log file
+ * -r <root path> -- override the root path. All the targets and filesets are resolved relatively to this path. Default is current directory
+ * -ll <log level> -- console log level (Silent | Quiet | Normal | Loud | Chatty | Diag)
+ * -fl <file log path> -- specifies the name of the log file
+ * -fll <log level> -- specifies the logging level to a log file
  * target1 .. targetN -- define the list of targets. Targets are executed in strict order, the second one starts only after the first one is complete.
  * target1;target2;..targetN -- execute the targets simultaneously
- * -D <name>=<value> -- defines a script variable value
+ * -d <name>=<value> -- defines a script variable value
+
+### Do not allow to override options
+Command line arguments override the script options (XakeOptions type) unless you define options.IgnoreCommandLine = true.
 
 ## Other
 

samples/ar/build.fsx

@@ -63,7 +63,7 @@ module libs =
 let copyToOutput lib srcpath = ("out" </> lib) *> fun outfile -> action {do! cp (srcpath </> lib) outfile.FullName}
 
 // do xake {XakeOptions with FileLog = "build.log"; FileLogLevel = Verbosity.Diag; Threads = 4 } {
-do xakeArgs {
+do xake {
     XakeOptions with FileLog = "build.log"; FileLogLevel = Verbosity.Diag; Threads = 4; Vars = [("NETFX", "4.0"); ("NETFX-TARGET","3.5")] } {
 
     // top-level rules

samples/build-parms.fsx

@@ -3,7 +3,7 @@
 
 open Xake
 
-do xakeArgs {XakeOptions with FileLog = "build.log"; Threads = 4 } {
+do xake {XakeOptions with FileLog = "build.log"; Threads = 4 } {
 
   phony "main" (action {
     do! writeLog Message "Hello world!"