Add support for command validators

Author: natemcmaster

src/CommandLineUtils/CommandLineApplication.Validation.cs

@@ -2,7 +2,9 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using McMaster.Extensions.CommandLineUtils.Validation;
 
 namespace McMaster.Extensions.CommandLineUtils
 {
@@ -20,6 +22,12 @@ public Func<ValidationResult, int> ValidationErrorHandler
             set => _validationErrorHandler = value ?? throw new ArgumentNullException(nameof(value));
         }
 
+        /// <summary>
+        /// A collection of validators that execute before invoking <see cref="OnExecute(Func{int})"/>.
+        /// When validation fails, <see cref="ValidationErrorHandler"/> is invoked.
+        /// </summary>
+        public ICollection<ICommandValidator> Validators { get; } = new List<ICommandValidator>();
+
         /// <summary>
         /// Validates arguments and options.
         /// </summary>
@@ -38,6 +46,16 @@ internal ValidationResult GetValidationResult()
 
             var factory = new CommandLineValidationContextFactory(this);
 
+            var commandContext = factory.Create(this);
+            foreach (var validator in Validators)
+            {
+                var result = validator.GetValidationResult(this, commandContext);
+                if (result != ValidationResult.Success)
+                {
+                    return result;
+                }
+            }
+
             foreach (var argument in Arguments)
             {
                 var context = factory.Create(argument);

src/CommandLineUtils/Conventions/ConventionBuilderExtensions.cs

@@ -30,6 +30,7 @@ public static IConventionBuilder UseDefaultConventions(this IConventionBuilder b
                 .SetSubcommandPropertyOnModel()
                 .SetParentPropertyOnModel()
                 .UseOnExecuteMethodFromModel()
+                .UseOnValidateMethodFromModel()
                 .UseOnValidationErrorMethodFromModel()
                 .UseConstructorInjection();
         }
@@ -149,7 +150,15 @@ public static IConventionBuilder UseSubcommandAttributes(this IConventionBuilder
             => builder.AddConvention(new SubcommandAttributeConvention());
 
         /// <summary>
-        /// Invokes a method named "OnValidationError" on the model type.
+        /// Invokes a method named "OnValidate" on the model type after parsing.
+        /// </summary>
+        /// <param name="builder">The builder.</param>
+        /// <returns>The builder.</returns>
+        public static IConventionBuilder UseOnValidateMethodFromModel(this IConventionBuilder builder)
+            => builder.AddConvention(new ValidateMethodConvention());
+
+        /// <summary>
+        /// Invokes a method named "OnValidationError" on the model type when validation fails.
         /// </summary>
         /// <param name="builder">The builder.</param>
         /// <returns>The builder.</returns>

src/CommandLineUtils/Conventions/ValidateMethodConvention.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Nate McMaster.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Reflection;
+using McMaster.Extensions.CommandLineUtils.Abstractions;
+using McMaster.Extensions.CommandLineUtils.Conventions;
+
+namespace McMaster.Extensions.CommandLineUtils
+{
+    /// <summary>
+    /// Invokes a method named "OnValidate" on the model type after parsing.
+    /// </summary>
+    public class ValidateMethodConvention : IConvention
+    {
+        /// <inheritdoc />
+        public void Apply(ConventionContext context)
+        {
+            if (context.ModelType == null)
+            {
+                return;
+            }
+
+            const BindingFlags MethodFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+
+            var method = context.ModelType
+                .GetTypeInfo()
+                .GetMethod("OnValidate", MethodFlags);
+
+            if (method == null)
+            {
+                return;
+            }
+
+            if (method.ReturnType != typeof(ValidationResult))
+            {
+                throw new InvalidOperationException(Strings.InvalidOnValidateReturnType(context.ModelType));
+            }
+
+            var accessor = context.ModelAccessor;
+            var methodParams = method.GetParameters();
+            context.Application.OnValidate(ctx =>
+            {
+                var arguments = new object[methodParams.Length];
+
+                for (var i = 0; i < methodParams.Length; i++)
+                {
+                    var methodParam = methodParams[i];
+
+                    if (typeof(ValidationContext).GetTypeInfo().IsAssignableFrom(methodParam.ParameterType))
+                    {
+                        arguments[i] = ctx;
+                    }
+                    else if (typeof(CommandLineContext).GetTypeInfo().IsAssignableFrom(methodParam.ParameterType))
+                    {
+                        arguments[i] = context.Application._context;
+                    }
+                    else
+                    {
+                        throw new InvalidOperationException(Strings.UnsupportedParameterTypeOnMethod(method.Name, methodParam));
+                    }
+                }
+
+                return (ValidationResult)method.Invoke(accessor.GetModel(), arguments);
+            });
+        }
+    }
+}

src/CommandLineUtils/Internal/CommandLineValidationContext.cs

@@ -2,9 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using McMaster.Extensions.CommandLineUtils.Abstractions;
 
 namespace McMaster.Extensions.CommandLineUtils
 {
@@ -17,6 +15,9 @@ public CommandLineValidationContextFactory(CommandLineApplication app)
             _app = app ?? throw new ArgumentNullException(nameof(app));
         }
 
+        public ValidationContext Create(CommandLineApplication app)
+            => new ValidationContext(app, _app, null);
+
         public ValidationContext Create(CommandArgument argument)
             => new ValidationContext(argument, _app, null);
 

src/CommandLineUtils/Properties/Strings.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.ComponentModel.DataAnnotations;
 using System.Reflection;
 
 namespace McMaster.Extensions.CommandLineUtils
@@ -30,6 +31,9 @@ public const string NoOnExecuteMethodFound
         public static string InvalidOnExecuteReturnType(string methodName)
             => methodName + " must have a return type of int or void, or if the method is async, Task<int> or Task.";
 
+        public static string InvalidOnValidateReturnType(Type modelType)
+            => $"The OnValidate method on {modelType.FullName} must return {typeof(ValidationResult).FullName}";
+
         public static string CannotDetermineOptionType(PropertyInfo member)
             => $"Could not automatically determine the {nameof(CommandOptionType)} for type {member.PropertyType.FullName}. " +
                     $"Set the {nameof(OptionAttribute.OptionType)} on the {nameof(OptionAttribute)} declaration for {member.DeclaringType.FullName}.{member.Name}.";

src/CommandLineUtils/Validation/DelegateValidator.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Nate McMaster.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace McMaster.Extensions.CommandLineUtils.Validation
+{
+    /// <summary>
+    /// Implements a validator with an anonymous function
+    /// </summary>
+    public class DelegateValidator : ICommandValidator, IArgumentValidator, IOptionValidator
+    {
+        private readonly Func<ValidationContext, ValidationResult> _validator;
+
+        /// <summary>
+        /// Initializes an instance of <see cref="DelegateValidator"/>.
+        /// </summary>
+        /// <param name="validator"></param>
+        public DelegateValidator(Func<ValidationContext, ValidationResult> validator)
+        {
+            _validator = validator ?? throw new ArgumentNullException(nameof(validator));
+        }
+
+        ValidationResult ICommandValidator.GetValidationResult(CommandLineApplication command, ValidationContext context)
+            => _validator(context);
+
+        ValidationResult IArgumentValidator.GetValidationResult(CommandArgument argument, ValidationContext context)
+            => _validator(context);
+
+        ValidationResult IOptionValidator.GetValidationResult(CommandOption option, ValidationContext context)
+            => _validator(context);
+    }
+}

src/CommandLineUtils/Validation/ICommandValidator.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Nate McMaster.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.ComponentModel.DataAnnotations;
+
+namespace McMaster.Extensions.CommandLineUtils.Validation
+{
+    /// <summary>
+    /// Provides validation on a command
+    /// </summary>
+    public interface ICommandValidator
+    {
+        /// <summary>
+        /// Validates a command
+        /// </summary>
+        /// <param name="command">The command.</param>
+        /// <param name="context">The validation context.</param>
+        /// <returns>The validation result. Returns <see cref="ValidationResult.Success"/> if the values pass validation.</returns>
+        ValidationResult GetValidationResult(CommandLineApplication command, ValidationContext context);
+    }
+}

src/CommandLineUtils/Validation/ValidationExtensions.cs

@@ -336,6 +336,42 @@ public static IValidationBuilder<double> Range(this IValidationBuilder<double> b
             return builder;
         }
 
+        /// <summary>
+        /// Adds a validator that runs after parsing is complete and before command execution.
+        /// </summary>
+        /// <param name="command">The command.</param>
+        /// <param name="validate">The callback. Return <see cref="ValidationResult.Success"/> if there is no error.</param>
+        /// <returns></returns>
+        public static CommandLineApplication OnValidate(this CommandLineApplication command, Func<ValidationContext, ValidationResult> validate)
+        {
+            command.Validators.Add(new DelegateValidator(validate));
+            return command;
+        }
+
+        /// <summary>
+        /// Adds a validator that runs after parsing is complete and before command execution.
+        /// </summary>
+        /// <param name="argument">The argument.</param>
+        /// <param name="validate">The callback. Return <see cref="ValidationResult.Success"/> if there is no error.</param>
+        /// <returns></returns>
+        public static CommandArgument OnValidate(this CommandArgument argument, Func<ValidationContext, ValidationResult> validate)
+        {
+            argument.Validators.Add(new DelegateValidator(validate));
+            return argument;
+        }
+
+        /// <summary>
+        /// Adds a validator that runs after parsing is complete and before command execution.
+        /// </summary>
+        /// <param name="option">The option.</param>
+        /// <param name="validate">The callback. Return <see cref="ValidationResult.Success"/> if there is no error.</param>
+        /// <returns></returns>
+        public static CommandOption OnValidate(this CommandOption option, Func<ValidationContext, ValidationResult> validate)
+        {
+            option.Validators.Add(new DelegateValidator(validate));
+            return option;
+        }
+
         private static T GetValidationAttr<T>(string errorMessage, object[] ctorArgs = null)
             where T : ValidationAttribute
         {

test/CommandLineUtils.Tests/ValidateMethodConventionTests.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Nate McMaster.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using McMaster.Extensions.CommandLineUtils.Abstractions;
+using Xunit;
+
+namespace McMaster.Extensions.CommandLineUtils.Tests
+{
+    public class ValidateMethodConventionTests
+    {
+        private class ProgramWithValidate
+        {
+            private ValidationResult OnValidate(ValidationContext context, CommandLineContext appContext)
+            {
+                return new ValidationResult("Failed");
+            }
+        }
+
+        [Fact]
+        public void ValidatorAddedViaConvention()
+        {
+            var app = new CommandLineApplication<ProgramWithValidate>();
+            app.Conventions.UseOnValidateMethodFromModel();
+            var result = app.GetValidationResult();
+            Assert.NotEqual(ValidationResult.Success, result);
+            Assert.Equal("Failed", result.ErrorMessage);
+        }
+
+        private class ProgramWithBadOnValidate
+        {
+            private void OnValidate() { }
+        }
+
+        [Fact]
+        public void ConventionThrowsIfOnValidateDoesNotReturnValidationresult()
+        {
+            var app = new CommandLineApplication<ProgramWithBadOnValidate>();
+            var ex = Assert.Throws<InvalidOperationException>(() => app.Conventions.UseOnValidateMethodFromModel());
+            Assert.Equal(Strings.InvalidOnValidateReturnType(typeof(ProgramWithBadOnValidate)), ex.Message);
+        }
+    }
+}

test/CommandLineUtils.Tests/ValidationTests.cs

@@ -42,6 +42,20 @@ public void ValidationHandlerOfSubcommandIsInvoked()
             Assert.True(called, "Validation on subcommand should be called");
         }
 
+        [Fact]
+        public void ValidatorInvoked()
+        {
+            var app = new CommandLineApplication();
+            var called = false;
+            app.OnValidate(_ =>
+            {
+                called = true;
+                return ValidationResult.Success;
+            });
+            Assert.Equal(0, app.Execute());
+            Assert.True(called);
+        }
+
         [Theory]
         [InlineData(CommandOptionType.NoValue, new string[0], false)]
         [InlineData(CommandOptionType.SingleValue, new string[0], false)]