done

Author: neuecc

ReadMe.md

@@ -269,6 +269,27 @@ Unfortunately, due to current C# specifications, lambda expressions and [local f
 
 In addition to `-h|--help`, there is another special built-in option: `--version`. In default, it displays the `AssemblyInformationalVersion` without source revision or `AssemblyVersion`. You can configure version string by `ConsoleApp.Version`, for example `ConsoleApp.Version = "2001.9.3f14-preview2";`.
 
+When a default value exists, that value is displayed by default. If you want to omit this display, add the `[HideDefaultValue]` attribute.
+
+```csharp
+ConsoleApp.Run(args, (Fruit myFruit = Fruit.Apple, [HideDefaultValue] Fruit myFruit2 = Fruit.Grape) => { });
+
+enum Fruit
+{
+    Orange, Grape, Apple
+}
+```
+
+```txt
+Usage: [options...] [-h|--help] [--version]
+
+Options:
+  --my-fruit <Fruit>      (Default: Apple)
+  --my-fruit2 <Fruit>
+```
+
+Additionally, if you add the `[Hidden]` attribute, the help for that parameter itself will be hidden.
+
 Command
 ---
 If you want to register multiple commands or perform complex operations (such as adding filters), instead of using `Run/RunAsync`, obtain the `ConsoleAppBuilder` using `ConsoleApp.Create()`. Call `Add`, `Add<T>`, or `UseFilter<T>` multiple times on the `ConsoleAppBuilder` to register commands and filters, and finally execute the application using `Run` or `RunAsync`.
@@ -574,6 +595,93 @@ If you want to change the deserialization options, you can set `JsonSerializerOp
 
 > NOTE: If they are not set when NativeAOT is used, a runtime exception may occur. If they are included in the parsing process, be sure to set source generated options.
 
+### GlobalOptions
+
+By calling `ConfigureGlobalOptions` on `ConsoleAppBuilder`, you can define global options that are enabled for all commands. For example, `--dry-run` or `--verbose` are suitable as common options.
+
+```csharp
+var app = ConsoleApp.Create();
+// builder: Func<ref ConsoleApp.GlobalOptionsBuilder, object>
+app.ConfigureGlobalOptions((ref builder) =>
+{
+    var dryRun = builder.AddGlobalOption<bool>("--dry-run");
+    var verbose = builder.AddGlobalOption<bool>("-v|--verbose");
+    var intParameter = builder.AddRequiredGlobalOption<int>("--int-parameter", "integer parameter");
+    // return value stored to ConsoleAppContext.GlobalOptions
+    return new GlobalOptions(dryRun, verbose, intParameter);
+});
+app.Add("", (int x, int y, ConsoleAppContext context) =>
+{
+    var globalOptions = (GlobalOptions)context.GlobalOptions;
+    Console.WriteLine(globalOptions + ":" + (x, y));
+});
+app.Run(args);
+internal record GlobalOptions(bool DryRun, bool Verbose, int IntParameter);
+```
+
+> NOTE: `(ref builder)` can be written in C# 14 and later. For earlier versions, you need to write `(ref ConsoleApp.GlobalOptionsBuilder builder)`.
+
+With `AddGlobalOption<T>`, you can define optional global options, and with `AddRequiredGlobalOption<T>`, you can define required global options. Each of these is also reflected in the command's help.
+
+To define name aliases, separate them with `|` like `-v|--verbose`.
+
+Unlike command parameters, the supported types are limited to types that can define C# compile-time constants (`string`, `char`, `sbyte`, `byte`, `short`, `int`, `long`, `uint`, `ushort`, `ulong`, `decimal`, `float`, `double`, `Enum`) and their `Nullable<T>` only.
+
+Parsed global options can be retrieved from `ConsoleAppContext.GlobalOptions`. Additionally, when combined with DI, you can retrieve them in a typed manner in each command.
+
+```csharp
+var app = ConsoleApp.Create();
+
+// builder: Func<ref ConsoleApp.GlobalOptionsBuilder, object>
+app.ConfigureGlobalOptions((ref builder) =>
+{
+    var dryRun = builder.AddGlobalOption<bool>("--dry-run");
+    var verbose = builder.AddGlobalOption<bool>("-v|--verbose");
+    var intParameter = builder.AddRequiredGlobalOption<int>("--int-parameter", "integer parameter");
+
+    // return value stored to ConsoleAppContext.GlobalOptions
+    return new GlobalOptions(dryRun, verbose, intParameter);
+});
+
+app.ConfigureServices((context, configuration, services) =>
+{
+    // store global-options to DI
+    var globalOptions = (GlobalOptions)context.GlobalOptions;
+    services.AddSingleton(globalOptions);
+
+    // check global-options value to configure services
+    services.AddLogging(logging =>
+    {
+        if (globalOptions.Verbose)
+        {
+            logging.SetMinimumLevel(LogLevel.Trace);
+        }
+    });
+});
+
+app.Add<Commands>();
+
+app.Run(args);
+
+internal record GlobalOptions(bool DryRun, bool Verbose, int IntParameter);
+
+// get GlobalOptions from DI
+internal class Commands(GlobalOptions globalOptions)
+{
+    [Command("cmd-a")]
+    public void CommandA(int x, int y)
+    {
+        Console.WriteLine("A:" + globalOptions + ":" + (x, y));
+    }
+
+    [Command("cmd-b")]
+    public void CommandB(int x, int y)
+    {
+        Console.WriteLine("B:" + globalOptions + ":" + (x, y));
+    }
+}
+```
+
 ### Custom Value Converter
 
 To perform custom binding to existing types that do not support `ISpanParsable<T>`, you can create and set up a custom parser. For example, if you want to pass `System.Numerics.Vector3` as a comma-separated string like `1.3,4.12,5.947` and parse it, you can create an `Attribute` with `AttributeTargets.Parameter` that implements `IArgumentParser<T>`'s `static bool TryParse(ReadOnlySpan<char> s, out Vector3 result)` as follows:
@@ -1074,6 +1182,8 @@ When `Microsoft.Extensions.Configuration` is imported, `ConfigureEmptyConfigurat
 
 Furthermore, overloads of `Action<IConfiguration, IServiceCollection> configure` and `Action<IConfiguration, ILoggingBuilder> configure` are added to `ConfigureServices` and `ConfigureLogging`, allowing you to retrieve the Configuration when executing the delegate.
 
+There are also overloads that receive ConsoleAppContext. If you want to obtain global options and build with them, you can use these overloads: `Action<ConsoleAppContext, IConfiguration, IServiceCollection>` and `Action<ConsoleAppContext, IConfiguration, ILoggingBuilder>`.
+
 without Hosting dependency, I've preferred these import packages.
 
 ```xml

sandbox/GeneratorSandbox/GeneratorSandbox.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
-    <LangVersion>13</LangVersion>
+    <LangVersion>preview</LangVersion>
 
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>disable</Nullable>

sandbox/GeneratorSandbox/Program.cs

@@ -5,95 +5,55 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
-//args = ["--x", "10", "--y", "20", "-v", "--prefix-output", "takoyakix"];
+args = ["cmd-a", "--x", "10", "--y", "20", "--int-parameter", "1000"];
 
 var app = ConsoleApp.Create();
 
-
-
-//
-// AddGlobalOption
-
-app.ConfigureGlobalOptions((ref ConsoleApp.GlobalOptionsBuilder builder) =>
+// builder: Func<ref ConsoleApp.GlobalOptionsBuilder, object>
+app.ConfigureGlobalOptions((ref builder) =>
 {
-    // builder.AddGlobalOption(description: "hoge", defaultValue: 0,  "tako");
-
-    var verbose = builder.AddGlobalOption<bool>($"-v", "");
-    var noColor = builder.AddGlobalOption<bool>("--no-color", "Don't colorize output.");
-    var dryRun = builder.AddGlobalOption<bool>("--dry-run", "");
-
-    var dame = builder.AddGlobalOption<int>("hoge", "huga", 0);
-
-    var takoyaki = builder.AddGlobalOption<int?>("hogemoge", defaultValue: null);
-
-    var prefixOutput = builder.AddRequiredGlobalOption<string>(description: "Prefix output with level.", name: "--prefix-output|-pp|-po");
+    var dryRun = builder.AddGlobalOption<bool>("--dry-run");
+    var verbose = builder.AddGlobalOption<bool>("-v|--verbose");
+    var intParameter = builder.AddRequiredGlobalOption<int>("--int-parameter", "integer parameter");
 
-    // var tako = builder.AddGlobalOption<int>("--in", "");
-    //var tako = builder.AddGlobalOption<MyFruit>("--fruit", "");
-
-    //return new GlobalOptions(true, true, true, "");
-    return new GlobalOptions(verbose, noColor, dryRun, prefixOutput);
+    // return value stored to ConsoleAppContext.GlobalOptions
+    return new GlobalOptions(dryRun, verbose, intParameter);
 });
 
-app.ConfigureServices((context, configuration, collection) =>
+app.ConfigureServices((context, configuration, services) =>
 {
+    // store global-options to DI
     var globalOptions = (GlobalOptions)context.GlobalOptions;
+    services.AddSingleton(globalOptions);
 
-    // simply use for filter/command body
-    collection.AddSingleton(globalOptions);
-
-    // variable for setup other DI
-    collection.AddLogging(logging =>
+    // check global-options value to configure services
+    services.AddLogging(logging =>
     {
-        var console = logging.AddSimpleConsole();
         if (globalOptions.Verbose)
         {
-            console.SetMinimumLevel(LogLevel.Trace);
+            logging.SetMinimumLevel(LogLevel.Trace);
         }
     });
 });
 
-app.Add<MyCommand>();
-
-// app.Add("", (int x, int y, [FromServices] GlobalOptions globalOptions) => Console.WriteLine(x + y + ":" + globalOptions));
-
-//var iii = int.Parse("1000");
-//var sss = new string('a', 3);
-//var datet  = DateTime.Parse("10000");
-
-// AddGlobalOption<int?>("hoge", "takoyaki", null);
+app.Add<Commands>();
 
 app.Run(args);
 
+internal record GlobalOptions(bool DryRun, bool Verbose, int IntParameter);
 
-// public T AddGlobalOption<T>([ConstantExpected] string name, [ConstantExpected] string description = "", T defaultValue = default(T))
-
-
-static void AddGlobalOption<T>([ConstantExpected] string name, [ConstantExpected] string description, [ConstantExpected] T defaultValue)
+// get GlobalOptions from DI
+internal class Commands(GlobalOptions globalOptions)
 {
-}
-
-internal record GlobalOptions(bool Verbose, bool NoColor, bool DryRun, string PrefixOutput);
-
-internal class MyCommand(GlobalOptions globalOptions)
-{
-    /// <summary>
-    /// my command
-    /// </summary>
-    [Command("")]
-    public void Run(int x)
+    [Command("cmd-a")]
+    public void CommandA(int x, int y)
     {
-        Console.WriteLine(globalOptions);
+        Console.WriteLine("A:" + globalOptions + ":" + (x, y));
     }
-}
-
-public enum MyFruit
-{
-    Apple, Orange, Grape
-}
-
-
-public class Takoyaki
-{
 
+    [Command("cmd-b")]
+    public void CommandB(int x, int y)
+    {
+        Console.WriteLine("B:" + globalOptions + ":" + (x, y));
+    }
 }

src/ConsoleAppFramework/Command.cs

@@ -155,7 +155,7 @@ public record class CommandParameter
     public required bool IsNullableReference { get; init; }
     public required bool IsParams { get; init; }
     public required bool IsHidden { get; init; } // Hide command parameter help
-    public bool IsDefaultValueHidden { get; init; } = false; // Hide default value in command parameter help
+    public required bool IsDefaultValueHidden { get; init; } // Hide default value in command parameter help
     public required string Name { get; init; }
     public required string OriginalParameterName { get; init; }
     public required bool HasDefaultValue { get; init; }
@@ -491,6 +491,7 @@ public CommandParameter ToDummyCommandParameter()
             IsCancellationToken = false,
             HasValidation = false,
             ArgumentIndex = -1,
+            IsDefaultValueHidden = false,
 
             Type = Type,
             HasDefaultValue = !IsRequired, // if not required, needs defaultValue

src/ConsoleAppFramework/CommandHelpBuilder.cs

@@ -203,7 +203,9 @@ static string BuildOptionsMessage(CommandHelpDefinition definition)
             else if (opt.DefaultValue != null)
             {
                 if (!opt.IsDefaultValueHidden)
+                {
                     sb.Append($" (Default: {opt.DefaultValue})");
+                }
             }
             else if (opt.IsRequired)
             {

src/ConsoleAppFramework/Parser.cs

@@ -3,6 +3,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using System.Collections.Immutable;
 using System.Runtime.InteropServices.ComTypes;
+using System.Xml.Linq;
 
 namespace ConsoleAppFramework;
 
@@ -452,6 +453,10 @@ bool IsParsableType(ITypeSymbol type)
                                 .SelectMany(x => x.Attributes)
                                 .Any(x => model.GetTypeInfo(x).Type?.Name == "HiddenAttribute");
 
+                var isDefaultValueHidden = x.AttributeLists
+                                .SelectMany(x => x.Attributes)
+                                .Any(x => model.GetTypeInfo(x).Type?.Name == "HideDefaultValueAttribute");
+
                 var customParserType = x.AttributeLists.SelectMany(x => x.Attributes)
                     .Select(x =>
                     {
@@ -562,6 +567,7 @@ bool IsParsableType(ITypeSymbol type)
                     IsConsoleAppContext = isConsoleAppContext,
                     IsParams = hasParams,
                     IsHidden = isHidden,
+                    IsDefaultValueHidden = isDefaultValueHidden,
                     Type = new EquatableTypeSymbol(type.Type!),
                     Location = x.GetLocation(),
                     HasDefaultValue = hasDefault,

tests/ConsoleAppFramework.GeneratorTests/GlobalOptionTest.cs

@@ -131,4 +131,23 @@ public void RequiredParse()
 
         error.Contains("Required argument '--parameter' was not specified.");
     }
+
+    [Fact]
+    public void NamedParameter()
+    {
+        verifier.Execute("""
+var app = ConsoleApp.Create();
+app.ConfigureGlobalOptions((ref ConsoleApp.GlobalOptionsBuilder builder) =>
+{
+    var p = builder.AddGlobalOption<int>("--parameter", defaultValue: 1000);
+    var d = builder.AddGlobalOption<bool>(description: "foo", name: "--dry-run");
+    return (p, d);
+});
+app.Add("", (int x, int y, ConsoleAppContext context) =>
+{
+    Console.Write($"{context.GlobalOptions} -> {(x, y)}");
+});
+app.Run(args);
+""", "--x 10 --dry-run --y 20", "(1000, True) -> (10, 20)");
+    }
 }

tests/ConsoleAppFramework.GeneratorTests/HelpTest.cs

@@ -344,6 +344,40 @@ Display Hello.
 Options:
   -m|--message <string>    Message to show.
 
+""");
+    }
+
+    [Fact]
+    public void GlobalOptions()
+    {
+        var code = """
+var app = ConsoleApp.Create();
+
+app.ConfigureGlobalOptions((ref ConsoleApp.GlobalOptionsBuilder builder) =>
+{
+    var p = builder.AddGlobalOption<int>("--parameter", "param global", defaultValue: 1000);
+    var d = builder.AddGlobalOption<bool>(description: "run dry dry", name: "--dry-run");
+    var r = builder.AddRequiredGlobalOption<int>("--p2|--p3", "param 2");
+    return (p, d, r);
+});
+
+app.Add("", (int x, int y) => { });
+app.Add("a", (int x, int y) => { });
+app.Add("ab", (int x, int y) => { });
+app.Add("a b c", (int x, int y) => { });
+app.Run(args);
+""";
+
+        verifier.Execute(code, args: "a --help", expected: """
+Usage: a [options...] [-h|--help] [--version]
+
+Options:
+  --x <int>             (Required)
+  --y <int>             (Required)
+  --parameter <int>    param global (Default: 1000)
+  --dry-run            run dry dry (Optional)
+  --p2|--p3 <int>      param 2 (Required)
+
 """);
     }