Added validate and addValidator fns.

Author: JordanMarr

src/FSharp.SystemCommandLine/Inputs.fs

@@ -19,11 +19,6 @@ type ActionContext =
         ParseResult: ParseResult
         CancellationToken: System.Threading.CancellationToken
     }
-    static member Create(parseResult: ParseResult) = 
-        {   
-            ParseResult = parseResult
-            CancellationToken = System.Threading.CancellationToken.None 
-        }
 
 type ActionInputSource = 
     | ParsedOption of Option
@@ -57,43 +52,43 @@ module Input =
     let option<'T> (name: string) = 
         Option<'T>(name) |> ActionInput.OfOption
 
-    let editOption (edit: Option<'T> -> unit) (hi: ActionInput<'T>) = 
-        match hi.Source with
+    let editOption (edit: Option<'T> -> unit) (input: ActionInput<'T>) = 
+        match input.Source with
         | ParsedOption o -> o :?> Option<'T> |> edit
         | _ -> ()
-        hi
+        input
 
-    let editArgument (edit: Argument<'T> -> unit) (hi: ActionInput<'T>) = 
-        match hi.Source with
+    let editArgument (edit: Argument<'T> -> unit) (input: ActionInput<'T>) = 
+        match input.Source with
         | ParsedArgument a -> a :?> Argument<'T> |> edit
         | _ -> ()
-        hi
+        input
 
-    let aliases (aliases: string seq) (hi: ActionInput<'T>) = 
-        hi |> editOption (fun o -> aliases |> Seq.iter o.Aliases.Add)
+    let aliases (aliases: string seq) (input: ActionInput<'T>) = 
+        input |> editOption (fun o -> aliases |> Seq.iter o.Aliases.Add)
 
-    let alias (alias: string) (hi: ActionInput<'T>) = 
-        hi |> editOption (fun o -> o.Aliases.Add alias)
+    let alias (alias: string) (input: ActionInput<'T>) = 
+        input |> editOption (fun o -> o.Aliases.Add alias)
 
-    let desc (description: string) (hi: ActionInput<'T>) = 
-        hi 
+    let desc (description: string) (input: ActionInput<'T>) = 
+        input 
         |> editOption (fun o -> o.Description <- description)
         |> editArgument (fun a -> a.Description <- description)
 
-    let defaultValue (defaultValue: 'T) (hi: ActionInput<'T>) = 
-        hi
+    let defaultValue (defaultValue: 'T) (input: ActionInput<'T>) = 
+        input
         |> editOption (fun o -> o.DefaultValueFactory <- (fun _ -> defaultValue))
         |> editArgument (fun a -> a.DefaultValueFactory <- (fun _ -> defaultValue))
 
     let def = defaultValue
 
-    let defFactory (defaultValueFactory: Parsing.ArgumentResult -> 'T) (hi: ActionInput<'T>) = 
-        hi
+    let defFactory (defaultValueFactory: Parsing.ArgumentResult -> 'T) (input: ActionInput<'T>) = 
+        input
         |> editOption (fun o -> o.DefaultValueFactory <- defaultValueFactory)
         |> editArgument (fun a -> a.DefaultValueFactory <- defaultValueFactory)
 
-    let required (hi: ActionInput<'T>) = 
-        hi |> editOption (fun o -> o.Required <- true)
+    let required (input: ActionInput<'T>) = 
+        input |> editOption (fun o -> o.Required <- true)
 
     let optionMaybe<'T> (name: string) = 
         let o = Option<'T option>(name, aliases = [||])
@@ -124,6 +119,31 @@ module Input =
         )
         ActionInput.OfArgument<'T option> a
 
+    let validate (validate: 'T -> Result<unit, string>) (input: ActionInput<'T>) = 
+        input 
+        |> editOption (fun o -> 
+            o.Validators.Add(fun res -> 
+                let value = res.GetValue<'T>(o.Name)
+                match validate value with
+                | Ok () -> ()
+                | Error err -> res.AddError(err)
+            )
+        )
+        |> editArgument (fun a -> 
+            a.Validators.Add(fun res -> 
+                let value = res.GetValue<'T>(a.Name)
+                match validate value with
+                | Ok () -> ()
+                | Error err -> res.AddError(err)
+            )
+        )
+
+    let addValidator (validator: Parsing.SymbolResult -> unit) (input: ActionInput<'T>) = 
+        input 
+        |> editOption (fun o -> o.Validators.Add(validator))
+        |> editArgument (fun a -> a.Validators.Add(validator))
+
+
     let ofOption (o: Option<'T>) = 
         ActionInput.OfOption<'T> o
 

src/Tests/SimpleAppTest.fs

@@ -114,4 +114,35 @@ let ``06 Token Replacer`` () =
                 1 // failure
         )
     } =! 0
-    
+    
+[<Test>]
+let ``07 - Validators`` () = 
+    handlerCalled <- true // Set to true to avoid false negatives in the test
+    let args = args "-w delete -s *"
+    let cfg = 
+        commandLineConfiguration {
+            description "Appends words together"
+            inputs (
+                option<string[]> "--word" 
+                |> alias "-w" 
+                |> desc "A list of words to be appended"
+                |> required
+                |> validate (fun words -> 
+                    if words |> Array.contains "delete" 
+                    then Error "Word 'delete' is not allowed." 
+                    else Ok ()
+                ),
+
+                optionMaybe<string> "--separator" 
+                |> alias "-s" 
+                |> desc "A character that will separate the joined words."
+            )
+
+            setAction (fun (words, separator) ->
+                () // Should not be called due to validation failure
+            )
+        }
+
+    printfn $"{cfg.Error}"
+    let result = cfg.Invoke(args)
+    result =! 1 // Expecting a failure due to the separator validation