- Added new Input fns: validateFileExists and validateDirectoryExists.

- Added a couple Input alias functions
- Added description comments to Input functions
- Simplified TestConsole usage by removing launchSettings.json

Author: JordanMarr

src/FSharp.SystemCommandLine/Inputs.fs

@@ -46,50 +46,65 @@ type ActionInput<'T>(inputType: ActionInputSource) =
 
 module Input = 
 
+    /// Injects an `ActionContext` into the action which contains the `ParseResult` and a cancellation token.
     let context = 
         ActionInput<ActionContext>(Context)
 
+    /// Creates a named option. Example: `option "--file-name"`
     let option<'T> (name: string) = 
         Option<'T>(name) |> ActionInput.OfOption
 
+    /// Edits the underlying System.CommandLine.Option<'T>.
     let editOption (edit: Option<'T> -> unit) (input: ActionInput<'T>) = 
         match input.Source with
         | ParsedOption o -> o :?> Option<'T> |> edit
         | _ -> ()
         input
 
+    /// Edits the underlying System.CommandLine.Argument<'T>.
     let editArgument (edit: Argument<'T> -> unit) (input: ActionInput<'T>) = 
         match input.Source with
         | ParsedArgument a -> a :?> Argument<'T> |> edit
         | _ -> ()
         input
 
+    /// Adds one or more aliases to an option.
     let aliases (aliases: string seq) (input: ActionInput<'T>) = 
         input |> editOption (fun o -> aliases |> Seq.iter o.Aliases.Add)
 
+    /// Adds an alias to an option.
     let alias (alias: string) (input: ActionInput<'T>) = 
         input |> editOption (fun o -> o.Aliases.Add alias)
 
-    let desc (description: string) (input: ActionInput<'T>) = 
+    /// Sets the description of an option or argument.
+    let description (description: string) (input: ActionInput<'T>) = 
         input 
         |> editOption (fun o -> o.Description <- description)
         |> editArgument (fun a -> a.Description <- description)
 
+    /// An alias for `description` to set the description of the input.
+    let desc = description
+
+    /// Sets the default value of an option or argument.
     let defaultValue (defaultValue: 'T) (input: ActionInput<'T>) = 
         input
         |> editOption (fun o -> o.DefaultValueFactory <- (fun _ -> defaultValue))
         |> editArgument (fun a -> a.DefaultValueFactory <- (fun _ -> defaultValue))
 
+    /// An alias for `defaultValue` to set the default value of an option or argument.
     let def = defaultValue
 
-    let defFactory (defaultValueFactory: Parsing.ArgumentResult -> 'T) (input: ActionInput<'T>) = 
+    /// Sets the default value factory of an option or argument.
+    let defaultValueFactory (defaultValueFactory: Parsing.ArgumentResult -> 'T) (input: ActionInput<'T>) = 
         input
         |> editOption (fun o -> o.DefaultValueFactory <- defaultValueFactory)
         |> editArgument (fun a -> a.DefaultValueFactory <- defaultValueFactory)
 
+    /// Marks an option as required.
     let required (input: ActionInput<'T>) = 
         input |> editOption (fun o -> o.Required <- true)
 
+    /// Creates a named option of type `Option<'T option>` that defaults to `None`.
     let optionMaybe<'T> (name: string) = 
         let o = Option<'T option>(name, aliases = [||])
         let isBool = typeof<'T> = typeof<bool>
@@ -104,10 +119,12 @@ module Input =
         o.DefaultValueFactory <- (fun _ -> None)
         ActionInput.OfOption<'T option> o
 
+    /// Creates a named argument. Example: `argument "file-name"`
     let argument<'T> (name: string) = 
         let a = Argument<'T>(name)
         ActionInput.OfArgument<'T> a
 
+    /// Creates a named argument of type `Argument<'T option>` that defaults to `None`.
     let argumentMaybe<'T> (name: string) = 
         let a = Argument<'T option>(name)
         a.DefaultValueFactory <- (fun _ -> None)
@@ -119,6 +136,7 @@ module Input =
         )
         ActionInput.OfArgument<'T option> a
 
+    /// Adds a validator that validates the parsed value of an option or argument.
     let validate (validate: 'T -> Result<unit, string>) (input: ActionInput<'T>) = 
         input 
         |> editOption (fun o -> 
@@ -138,15 +156,33 @@ module Input =
             )
         )
 
+    /// Validates that the file exists.
+    let validateFileExists (input: ActionInput<System.IO.FileInfo>) = 
+        input    
+        |> validate (fun file -> 
+            if file.Exists then Ok () 
+            else Error $"File '{file.FullName}' does not exist."
+        )
+
+    /// Validates that the directory exists.
+    let validateDirectoryExists (input: ActionInput<System.IO.DirectoryInfo>) = 
+        input    
+        |> validate (fun dir -> 
+            if dir.Exists then Ok () 
+            else Error $"Directory '{dir.FullName}' does not exist."
+        )
+
+    /// Adds a validator for the given `Parsing.SymbolResult`.
     let addValidator (validator: Parsing.SymbolResult -> unit) (input: ActionInput<'T>) = 
         input 
         |> editOption (fun o -> o.Validators.Add(validator))
         |> editArgument (fun a -> a.Validators.Add(validator))
 
-
+    /// Converts an `Option<'T>` to an `ActionInput<'T>` for usage with the command builders.
     let ofOption (o: Option<'T>) = 
         ActionInput.OfOption<'T> o
 
+    /// Converts an `Argument<'T>` to an `ActionInput<'T>` for usage with the command builders.
     let ofArgument (a: Argument<'T>) = 
         ActionInput.OfArgument<'T> a
 

src/TestConsole/Program.fs

@@ -1,21 +1,26 @@
 module Program
 
-open FSharp.SystemCommandLine
-open Input
+open System.CommandLine.Parsing
 
-let app (words: string array, separator: string option) =
-    let separator = separator |> Option.defaultValue ", "
-    System.String.Join(separator, words) |> printfn "Result: %s"
+let args commandLine =
+    CommandLineParser.SplitCommandLine(commandLine) |> Seq.toArray
 
 [<EntryPoint>]
-let main argv = 
-    //let words = Input.Option("word", ["--word"; "-w"], Array.empty, "A list of words to be appended")
-    //let separator = Input.OptionMaybe("separator", ["--separator"; "-s"], "A character that will separate the joined words.")
-    let words = option "--word" |> alias "-w" |> desc "A list of words to be appended"
-    let separator = optionMaybe "--separator" |> alias "-s" |> desc "A character that will separate the joined words."
-
-    rootCommand argv {
-        description "Appends words together"
-        inputs (words, separator)
-        setAction app
-    }
+let main _ = 
+    
+    //ProgramAlt1.main (args "--int-option 1 --bool-option true --file-option \"c:\test\"")
+    
+    //ProgramNoArgs.main (args "")
+    
+    //ProgramNestedSubCommands.main (args "io list \"c:/data/\" --enable-logging") // Also contains global options
+    
+    //ProgramSubCommand.main (args "list c:/data/")
+    //ProgramSubCommand.main (args "delete c:/data/ --recursive")
+    
+    //ProgramTask.main (args "-w hello -w world")
+    
+    //ProgramTokenReplacer.main (args "--package @shoelace-style/shoelace")
+    
+    //ProgramExtraInputs.main (args "-a A -b B -c C -d D -e E -1 1 -2 2 -3 3 -4 4 -5 5")
+    
+    ProgramAppendWords.main (args "-w hello -w world -s \", \"")

src/TestConsole/ProgramAlt1.fs

@@ -21,7 +21,6 @@ let action (parseResult: ParseResult) (cancel: CancellationToken) = task {
     return 5
 }
 
-//[<EntryPoint>]
 let main (argv: string[]) = 
     let cmd = RootCommand()
     cmd.Description <- "My sample app"

src/TestConsole/ProgramAppendWords.fs

@@ -0,0 +1,20 @@
+module ProgramAppendWords
+
+open FSharp.SystemCommandLine
+open Input
+
+let app (words: string array, separator: string option) =
+    let separator = separator |> Option.defaultValue ", "
+    System.String.Join(separator, words) |> printfn "Result: %s"
+    
+let main argv = 
+    //let words = Input.Option("word", ["--word"; "-w"], Array.empty, "A list of words to be appended")
+    //let separator = Input.OptionMaybe("separator", ["--separator"; "-s"], "A character that will separate the joined words.")
+    let words = option "--word" |> alias "-w" |> desc "A list of words to be appended"
+    let separator = optionMaybe "--separator" |> alias "-s" |> desc "A character that will separate the joined words."
+
+    rootCommand argv {
+        description "Appends words together"
+        inputs (words, separator)
+        setAction app
+    }

src/TestConsole/ProgramExtraInputs.fs

@@ -32,7 +32,6 @@ let app ctx =
     |> printfn "Result: %s"
     0
 
-//[<EntryPoint>]
 let main argv = 
     rootCommand argv {
         description "Appends words together"

src/TestConsole/ProgramNestedSubCommands.fs

@@ -68,7 +68,6 @@ let ioCmd =
         addCommands [ deleteCmd; listCmd ]
     }
 
-//[<EntryPoint>]
 let main (argv: string[]) =
     let cfg = 
         commandLineConfiguration {

src/TestConsole/ProgramNoArgs.fs

@@ -5,7 +5,6 @@ open FSharp.SystemCommandLine
 let app () = 
     printfn "Do stuff"
 
-//[<EntryPoint>]
 let main argv = 
     rootCommand argv {
         description "My sample app"

src/TestConsole/ProgramSubCommand.fs

@@ -6,42 +6,40 @@ open Input
 
 let listCmd =
     let action (dir: DirectoryInfo) =
-        if dir.Exists then
-            dir.EnumerateFiles()
-            |> Seq.iter (fun f -> printfn "%s" f.FullName)
-        else
-            printfn $"{dir.FullName} does not exist."
-
-    let dir = argument "directory" |> def (DirectoryInfo @"c:\default")
+        dir.EnumerateFiles()
+        |> Seq.iter (fun f -> printfn "%s" f.FullName)
 
     command "list" {
         description "lists contents of a directory"
-        inputs dir
+        inputs (
+            argument "directory" 
+            |> defaultValue (DirectoryInfo @"c:\default")
+            |> validateDirectoryExists
+        )
         setAction action
         addAlias "ls"
     }
 
 let deleteCmd =
     let action (dir: DirectoryInfo, recursive: bool) =
-        if dir.Exists then
-            if recursive 
-            then printfn $"Recursively deleting {dir.FullName}"
-            else printfn $"Deleting {dir.FullName}"
-        else
-            printfn $"{dir.FullName} does not exist."
-
-    let dir = argument "directory" |> def (DirectoryInfo @"c:\default")
-    let recursive = option "--recursive" |> def false
+        if recursive 
+        then printfn $"Recursively deleting {dir.FullName}"
+        else printfn $"Deleting {dir.FullName}"
 
     command "delete" {
         description "deletes a directory"
-        inputs (dir, recursive)
+        inputs (
+            argument "directory" 
+            |> defaultValue (DirectoryInfo @"c:\default")
+            |> validateDirectoryExists,
+
+            option "--recursive" 
+            |> defaultValue false
+        )
         setAction action
         addAliases [ "d"; "del" ]
     }
 
-
-// [<EntryPoint>]
 let main argv =
     rootCommand argv {
         description "File System Manager"

src/TestConsole/ProgramTask.fs

@@ -18,7 +18,6 @@ let app (ctx, words: string array, separator: string) =
         |> printfn "Result: %s"
     }
 
-//[<EntryPoint>]
 let main argv = 
     let words = option "--word" |> alias "-w" |> desc "A list of words to be appended"
     let separator = option "--separator" |> alias "-s" |> def ", " |> desc "A character that will separate the joined words."

src/TestConsole/ProgramTokenReplacer.fs

@@ -11,7 +11,6 @@ let app (package: string) =
         eprintfn "The package name does not start with a leading @"
         1
 
-//[<EntryPoint>]
 let main argv =
 
     // The package option needs to accept strings that start with "@" symbol.