Allow to specify attributes on the fields in the model class.

• [Required(bool)]
• [Default(...)]
• [OptionName(shortName, longName)]
• [HelpText(...)]

• using xunit and .net core
• upload results to some 3th party website

See https://devblogs.microsoft.com/nuget/add-a-readme-to-your-nuget-package/

This library should honor systems where console color output has explicitly been requested to be turned off. See more information about this initiative at https://no-color.org.

• https://help.github.com/en/articles/configuring-nuget-for-use-with-github-package-registry
• https://help.github.com/en/articles/about-github-package-registry#supported-clients-and-formats

Description

I have an option specified as

[Name("c", "check")]
[Description("Reports the amount of duplicates without changing anything")]
[DefaultValue(true)] // Note defaults to true and not required
public bool OnlyCheck { get; set; }

But still it prints the usages when it should not print them in this case.

Run without specifying the "check" option as CLI argument.

Workaround

Current workaround: setting AutoPrintUsageAndErrors = false.

Todo

Problem is caused by CommandLineParser`TOption.cs#L255-L265.

We wrongly assume noArgsSupplied means we should print the usage.
This is mostly correct but there is a scenario where this shouldn't.

A scenario where we only have optional options that have at least one with DefaultValue specified.

Load and register all of the Command<>'s defined in a assembly marked with a custom attribute.
This is an opt-in option that should be called before the Parse method.

TBD: Attribute name.

There appears to be a bug in AutoPrintUsageAndErrors. It always prints the usage.

Only way to turn it off for now is to use new CommandLineParserOptions { AutoPrintUsageAndErrors = false }.

Should only print usage when help is requested by the user or there are errors.

I'm currently in favor of the EF.Core CLI help/usage style.

Example

PM> dotnet ef

                     _/\__       
               ---==/    \\      
         ___  ___   |.    \|\    
        | __|| __|  |  )   \\\   
        | _| | _|   \_/ |  //|\\ 
        |___||_|       /   \\\/\\

Entity Framework Core .NET Command-line Tools 2.2.0-preview2-35157

Usage: dotnet ef [options] [command]

Options:
  --version        Show version information
  -h|--help        Show help information
  -v|--verbose     Show verbose output.
  --no-color       Don't colorize output.
  --prefix-output  Prefix output with level.

Commands:
  database    Commands to manage the database.
  dbcontext   Commands to manage DbContext types.
  migrations  Commands to manage migrations.

Use "dotnet ef [command] --help" for more information about a command.

PM> dotnet ef database --help


Usage: dotnet ef database [options] [command]

Options:
  -h|--help        Show help information
  -v|--verbose     Show verbose output.
  --no-color       Don't colorize output.
  --prefix-output  Prefix output with level.

Commands:
  drop    Drops the database.
  update  Updates the database to a specified migration.

Use "database [command] --help" for more information about a command.

Todo

• #11 Create Command
• Description output
• Format usage
• Setup default convention

Create Commands

Allow to use commands with custom options or no options at all.

Usage

• myapp -param1 "something" -Add -A -m "Message"
• myapp -Add -A -m "Message"
• myapp -Add

Naming

• ICommand, ICommand<T> where T : class

Behavior

Unmapped arguments by the ICommand will fall back to the global options if any exist.

Discovery

We can automatically discover the commands or they can be manually added.

• Auto discover if class implements ICommand
• Manually
  • parser.ConfigureCommand<ICommand>()
  • parser.ConfigureCommand<ICommand<Option>>(Expression<Func<Option>>)

Execution

Executing the command can be sync or async

• ICommand.Execute()
• ICommand.ExecuteAsync()
• ICommand<Options>.Execute(Options)
• ICommand<Options>.ExecuteAsync(Options)

Progress

• Commands
• #11
• Async commands
• Command chaining

When the user wants to manually print usage for a requested option/command there currently is no easy way to do it.

Extending IUsagePrinter.PrintUsage(IArgument argument);

would allow the following scenario.

var parser = new CommandLineParser<Options>();

var parsed = parser.Parse(args);

if (parsed.HelpRequested)
{
    parser.Printer.PrintUsage(parsed.HelpRequestedFor);
}

Hi, the current interface is rather limiting for dealing with generic command loading.
I would expect another overload like this: RegisterCommand(typeof(Command), typeof(Options));

Hi Matthi!

The Configuration page on the project wiki contains following code:

var parseResult = parser.Parse(args);

if (result.HasErrors)
{
	Console.Error.WriteLine(result.Error);
	Console.ReadKey();

	return -1;
}

I suppose result should be parseResult there.
The issue is present in the demo code for Fluent API and Attributes config.

Example in git

❯ git pshu
git: 'pshu' is not a git command. See 'git --help'.

The most similar command is
        push

Algorithm to determine best matching option/command (Damerau-Levenshtein)

• https://bmcbioinformatics.biomedcentral.com/articles/10.1186/s12859-019-2819-0
• https://github.com/GlobalNamesArchitecture/damerau-levenshtein

Tasks

• Make it configurable

INFO

We should support positional arguments.

Example:

app.exe move "path/to/file" "move/to/path"

Where the move command contains

public class Model
{
     [OptionOrder(1)]
     public string SourcePath { get; set; }

     [OptionOrder(2)]
     public string MovePath { get; set; }
}

TODO

• Add attribute support
• Add Fluent API support
• Add support in argument parser
• Add Tests

CodeFactor found multiple issues last seen at b729b0b:

Duplicate Code

CommandLineParser\CommandLineParserTOption.cs:345-373 ](https://www.codefactor.io/repository/github/matthiware/commandlineparser.core/source/master/CommandLineParser/CommandLineParser%60TOption.cs#L345)[CommandLineParser\Core\Command\CommandLineCommandTOptionTCommandOption.cs:124-152 ](https://www.codefactor.io/repository/github/matthiware/commandlineparser.core/source/master/CommandLineParser/Core/Command/CommandLineCommand%60TOption%60TCommandOption.cs#L124)[CommandLineParser\CommandLineParserTOption.cs:451-500
CommandLineParser\Core\Command\CommandLineCommandTOptionTCommandOption.cs:316-365

Option clustering/grouping

See: Program Argument Syntax Convention

This should be allowed for bool and enum options.

-abc is the same as specifying -a -b -c

Assuming a, b, c are of type bool this will set them all to true.

Whitespaces not required as sperator

Relates to #42 and #43

Use Microsoft.Extensions.DependencyInjection instead of our own container resolver.

There is an issue with parsing the bool option without an explicit value.

    internal abstract class CommandOptions
    {
        [Name("v", "verb"), Description("Print usage"), DefaultValue(false)]
        public bool VerbA { get; set; }
    }

prog -v command
prog command -v

CommandOptions.VerrbA should be set to true (due to the -v), but is set to false.

Bool resolver is correct and have the null value in a list of the expected 'true' values, but the code in upper layers is wrong.

namespace MatthiWare.CommandLine.Core.Parsing.Resolvers
{
    internal class BoolResolver : ArgumentResolver<bool>
    {
        private static readonly string[] recognisedFalseArgs = new[] { "off", "0", "false", "no" };
        private static readonly string[] recognisedTrueArgs = new[] { "on", "1", "true", "yes", string.Empty, null };

The main problem is in CommandLineCommandTOptionTCommandOption.cs and CommandLineParser`TOption.cs.

                else if (!model.HasValue && option.HasDefault)
                {
                    option.UseDefault();

                    continue;
                }

and should be modified to something like this

                else if (!found && !model.HasValue && option.HasDefault)
                {
                    option.UseDefault();

                    continue;
                }

But that means, other resolvers shall be updated to cope with such situation and provide default value in such case.

Hi, i want to build a cli wrapper around an existing API. The API is instantiated with a static factory method which has a parameter called environment (PROD or TEST). This environment should be an option for the cli. How do i register the service properly to use it in Commands with DI?

SSL Cert expired and project got shut down for more info see: sourcerer-io/sourcerer-app#632

I'm currently looking for an alternative.

If you specify multiple optional commands with required parameters and you don't specify the optional command + required options they will be marked as errors in the result.

Extension of #77

public class ModelWithCommands
{
    public NonGenericCommand NonGenericCommand { get; set; } // doesn't register
    public GenericCommandWithParentOptions GenericCommandWithParentOptions { get; set; }
    public GenericCommandWithOwnOptions GenericCommandWithOwnOptions { get; set; }
}

Just like we have ArgumentResolver.cs (v0.2.2)'s we should also allow user defined value transformers that can be plugged into the option builders.

   // configure the options using the Fluent API
   parser.Configure(options => options.Port)
      .Name("p", "port")
      .Description("The port of the server")
      .Transform(value => Utils.UrlDecode(value)) // new api
      .Required();

Signature

IOptionBuilder<T> Transform(Expression<Func<T, T>> tranformation); 

We currently have a lot of classes/interfaces related to command configuration.

• ICommandConfigurationBuilder
• ICommandConfigurationBuilder<TSource>
• ICommandBuilder<TOption>
• ICommandBuilder<TOption, TCommandOption>

A lot of properties and methods are being duplicated. This has been done to not expose unwanted methods/properties in the public API.

Refactor of those interfaces/classes are needed for the 0.3 release.

CodeFactor found multiple issues:

Duplicate Code

CommandLineParser\CommandLineParser.cs:420-482
CommandLineParser\Core\Command\CommandLineCommandTOptionTCommandOption.cs:313-375
Commit 273e875
CommandLineParser\CommandLineParser.cs:314-342
CommandLineParser\Core\Command\CommandLineCommandTOptionTCommandOption.cs:121-149
Commit 4fb4f8c

The code must not contain multiple blank lines in a row.

CommandLineParser\Core\Command\CommandLineCommandTOptionTCommandOption.cs:40
Commit 4fb4f8c
CommandLineParser\Core\Parsing\ArgumentManager.cs:22
Commit 4fb4f8c

I want to define doc=dcebab66-49b6-4bb8-84d7-7401858d9667 as argument.

To allow this we need the following:

• Allow adding postfix values to the names of options.
• Don't require space between key (with postfix value) and actual value

For example;

If i want call a command without options:

server "localhost"

i need the first argument "localhost", without any option like --port.

Thanks !

void AddCommandLineParser<T>(this IServiceCollection services, CommandLineParserOptions options);

This should register the ICommandLineParser<T> interface.

Starting the console app without any parameters, the command line parser crashes:

System.ArgumentOutOfRangeException
HResult=0x80131502
Message=Index was out of range. Must be non-negative and less than the size of the collection.
Parameter name: index
Source=mscorlib
StackTrace:
at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
at System.Collections.Generic.List1.get_Item(Int32 index) at MatthiWare.CommandLine.Core.Parsing.ArgumentManager.SetArgumentUsed(Int32 idx, ICommandLineCommand cmd) at MatthiWare.CommandLine.Core.Parsing.ArgumentManager.Parse(IEnumerable1 list)
at MatthiWare.CommandLine.Core.Parsing.ArgumentManager..ctor(String[] args, ICollection1 commands, ICollection1 options)
at MatthiWare.CommandLine.CommandLineParser`1.Parse(String[] args)

Hi there,
In usage output, command descriptions are not aligned properly. Shift shall be based on the longest command.

Usage: ck550-cli [commands]

Commands:
  effect-breathing              Set a breathing effect
  effect-color-cycle            Set a color-cycle effect
  effect-circle-spectrum                Set a circle-spectrum effect
  effect-crosshair              Set a crosshair effect
  effect-fireball               Set a fireball effect
  effect-heartbeat              Set a heartbeat effect
  effect-off            Set an off effect
  effect-reactive-punch         Set a reactive-punch effect
  effect-reactive-tornado               Set a reactive-tornado effect
  effect-ripple         Set a ripple effect
  effect-single-key             Set a single-key effect
  effect-snowing                Set a snowing effect
  effect-stars          Set a stars effect
  effect-static         Set a static effect
  effect-water-ripple           Set a water-ripple effect
  effect-wave-ripple            Set a wave effect

When a CommandParseException occures the message is hardcoded to be empty.

This results in the printed errors to being empty.

Enhances #4 Nuget package from CI is not usable at the moment. Automate it further so it auto increases build version and adds correct binaries.

For the moment it is now mandatory to provide a generic parameter that represents the command options.
Some command don't require options so this is not mandatory but rather optional.

Assume you have the following command:

public class MyCommand : Abstractions.Command.Command
{
   // ...
}

In this case it is impossible to use the following commands

var parser = new CommandLineParser();

parser.RegisterCommand<MyCommand>();

// or

parser.RegisterCommand(typeof(MyCommand));

// or

parser.DiscoverCommands(typeof(MyCommand).Assembly);

This will allow for #45 and #54 to be implemented.

No need to create a custom resolver when the type has a constructor that takes in a string.

We should create a DefaultResolver that is able to resolve the following types:

• .ctor(String)
• bool TryParse(String, IFormatProvider, out T result)
• T Parse(String, IFormatProvider)

Description

When using your own custom usage printer there currently is no way to know the generate usage text.

PrintUsage() Should take in an already formatted string that is ready to be outputted (stdout, messagebox, ...)

Tasks

• Rework API
• Add error printing here as well

Create an abstract layer for parsed argument validations.
I'm not planning to build an argument validator framework on top of this one so I'm only going to expose an abstract API so we can plug-in already existing frameworks.

This means we will introduce a second package in this repo. MatthiWare.CommandLineParser.Core.Extensions.FluentValidations

Will be hosted in an Extensions\... folder.

Work to do

• Create public abstract validation API
• Create an nuget extension package "MatthiWare.CommandLineParser.Core.Extensions.FluentValidations"
• Update example and wiki

Currently there are some datatypes that are not supported

Mostly looking at the array and collection types.

• Add test for all data types

Once #11 is done

Allow any 3th party container to instantiate commands.

Example:

The output should be correctly alligned.