Add support for validation and custom types

Issue by clmcgrath Monday Jun 26, 2017 at 18:21 GMT _Originally opened as https://github.com/gsscoder/commandline/issues/455_

---

Add some sort of hook or attribute to plug validation into the parser pipeline

similar some similar frameworks use attributes or factory registration to allow an entrypoint for custom validation and type mapping (DI support would be awesome as well 😉 )

a typical and widely used usage scenario for this would be filesystem path validation and mapping to IO classes such as FileInfo / DirectoryInfo an seemingly easy way to to add this type of validation functionality would be to allow validation attributes that inherit from a validation base class or interface and run custom or pre-written code

some examples of validation provided in similar frameworks are

[FileExists] 
[DirectoryExists] 
[FileNotExists]
[DirectoryNotExists] 
[RegExValidation]

Powerargs provides a special class called a Reviver for custom type mapping as well that the framework looks for to try and map values to a custom or complex type ie path string => FileInfo

It is very hard to find a framework that does all 3 of these well currently and make this library a go to framework for myself and many other developers i am sure

as CLP 2.x is still in beta and major rewrite phase i think now would be a good time to look at feature expansion as well to increase the power of this framework

[ohadschn]

The way I do this in the meantime is by adding a Validate method to my options class:

[Verb("open", HelpText = "Open the foo file")]
public class FooOptions
{
    [Option('f', "fooPath", Required = true, HelpText = "Foo")]
    public string FooPath { get; }

    protected FooOptions(string fooPath)
    {
        FooPath = fooPath;
    }

    public void Validate()
    {
        if (!File.Exists(FooPath))
        {
            throw new ArgumentValidationException($"Foo path does not exist!");
        }
    }
}

The exception I’m throwing is just a custom type:

class ArgumentValidationException : Exception
{
    public ArgumentValidationException(string message) : base(message) { }
}

And in my parsing code I do something like this:

static int Main(string[] args)
{
    try
    {
        return Parser.Default.ParseArguments<FooOptions>(args)
            .MapResult(
                (FooOptions opts) =>
                {
                    opts.Validate();
                    //do something with opts.FooPath
                    return 0;
                },
                errors => 1);
    }
    catch (ArgumentValidationException e)
    {
        Console.WriteLine("Invalid arguments detected: {0}", e);
        return 1;
    }
}

[lupino3]

Is there still interest to add validation capabilities to the framework?

I am thinking about adding to Option an optional Func<Error> which contains user-provided validation logic and runs after parsing is done.

The approach listed by @rducom would also be good IMHO.

In any case, I think it’s an useful addition to the library.