Add IConstraintFactory (#487)

Addresses part of #472

Author: jbagga

src/Microsoft.AspNetCore.Dispatcher/Constraints/CompositeDispatcherValueConstraint.cs

@@ -0,0 +1,52 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.AspNetCore.Dispatcher
+{
+    /// <summary>
+    /// Constrains a dispatcher value by several child constraints.
+    /// </summary>
+    public class CompositeDispatcherValueConstraint : IDispatcherValueConstraint
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CompositeDispatcherValueConstraint" /> class.
+        /// </summary>
+        /// <param name="constraints">The child constraints that must match for this constraint to match.</param>
+        public CompositeDispatcherValueConstraint(IEnumerable<IDispatcherValueConstraint> constraints)
+        {
+            if (constraints == null)
+            {
+                throw new ArgumentNullException(nameof(constraints));
+            }
+
+            Constraints = constraints;
+        }
+
+        /// <summary>
+        /// Gets the child constraints that must match for this constraint to match.
+        /// </summary>
+        public IEnumerable<IDispatcherValueConstraint> Constraints { get; private set; }
+
+        /// <inheritdoc />
+        public bool Match(DispatcherValueConstraintContext constraintContext)
+        {
+            if (constraintContext == null)
+            {
+                throw new ArgumentNullException(nameof(constraintContext));
+            }
+
+            foreach (var constraint in Constraints)
+            {
+                if (!constraint.Match(constraintContext))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

src/Microsoft.AspNetCore.Dispatcher/Constraints/DefaultConstraintFactory.cs

@@ -0,0 +1,152 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// 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.Globalization;
+using System.Linq;
+using System.Reflection;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.AspNetCore.Dispatcher
+{
+    /// <summary>
+    /// The default implementation of <see cref="IConstraintFactory"/>. Resolves constraints by parsing
+    /// a constraint key and constraint arguments, using a map to resolve the constraint type, and calling an
+    /// appropriate constructor for the constraint type.
+    /// </summary>
+    public class DefaultConstraintFactory : IConstraintFactory
+    {
+        private readonly IDictionary<string, Type> _constraintMap;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultConstraintFactory"/> class.
+        /// </summary>
+        /// <param name="dispatcherOptions">
+        /// Accessor for <see cref="DispatcherOptions"/> containing the constraints of interest.
+        /// </param>
+        public DefaultConstraintFactory(IOptions<DispatcherOptions> dispatcherOptions)
+        {
+            _constraintMap = dispatcherOptions.Value.ConstraintMap;
+        }
+
+        /// <inheritdoc />
+        /// <example>
+        /// A typical constraint looks like the following
+        /// "exampleConstraint(arg1, arg2, 12)".
+        /// Here if the type registered for exampleConstraint has a single constructor with one argument,
+        /// The entire string "arg1, arg2, 12" will be treated as a single argument.
+        /// In all other cases arguments are split at comma.
+        /// </example>
+        public virtual IDispatcherValueConstraint ResolveConstraint(string constraint)
+        {
+            if (constraint == null)
+            {
+                throw new ArgumentNullException(nameof(constraint));
+            }
+
+            string constraintKey;
+            string argumentString;
+            var indexOfFirstOpenParens = constraint.IndexOf('(');
+            if (indexOfFirstOpenParens >= 0 && constraint.EndsWith(")", StringComparison.Ordinal))
+            {
+                constraintKey = constraint.Substring(0, indexOfFirstOpenParens);
+                argumentString = constraint.Substring(indexOfFirstOpenParens + 1,
+                                                            constraint.Length - indexOfFirstOpenParens - 2);
+            }
+            else
+            {
+                constraintKey = constraint;
+                argumentString = null;
+            }
+
+            if (!_constraintMap.TryGetValue(constraintKey, out var constraintType))
+            {
+                // Cannot resolve the constraint key
+                return null;
+            }
+
+            if (!typeof(IDispatcherValueConstraint).GetTypeInfo().IsAssignableFrom(constraintType.GetTypeInfo()))
+            {
+                throw new InvalidOperationException(
+                            Resources.FormatDefaultConstraintResolver_TypeNotConstraint(
+                                                        constraintType, constraintKey, typeof(IDispatcherValueConstraint).Name));
+            }
+
+            try
+            {
+                return CreateConstraint(constraintType, argumentString);
+            }
+            catch (Exception exception)
+            {
+                throw new InvalidOperationException(
+                    $"An error occurred while trying to create an instance of route constraint '{constraintType.FullName}'.",
+                    exception);
+            }
+        }
+
+        private static IDispatcherValueConstraint CreateConstraint(Type constraintType, string argumentString)
+        {
+            // No arguments - call the default constructor
+            if (argumentString == null)
+            {
+                return (IDispatcherValueConstraint)Activator.CreateInstance(constraintType);
+            }
+
+            var constraintTypeInfo = constraintType.GetTypeInfo();
+            ConstructorInfo activationConstructor = null;
+            object[] parameters = null;
+            var constructors = constraintTypeInfo.DeclaredConstructors.ToArray();
+
+            // If there is only one constructor and it has a single parameter, pass the argument string directly
+            // This is necessary for the RegexDispatcherValueConstraint to ensure that patterns are not split on commas.
+            if (constructors.Length == 1 && constructors[0].GetParameters().Length == 1)
+            {
+                activationConstructor = constructors[0];
+                parameters = ConvertArguments(activationConstructor.GetParameters(), new string[] { argumentString });
+            }
+            else
+            {
+                var arguments = argumentString.Split(',').Select(argument => argument.Trim()).ToArray();
+
+                var matchingConstructors = constructors.Where(ci => ci.GetParameters().Length == arguments.Length)
+                                                       .ToArray();
+                var constructorMatches = matchingConstructors.Length;
+
+                if (constructorMatches == 0)
+                {
+                    throw new InvalidOperationException(
+                                Resources.FormatDefaultConstraintResolver_CouldNotFindCtor(
+                                                       constraintTypeInfo.Name, arguments.Length));
+                }
+                else if (constructorMatches == 1)
+                {
+                    activationConstructor = matchingConstructors[0];
+                    parameters = ConvertArguments(activationConstructor.GetParameters(), arguments);
+                }
+                else
+                {
+                    throw new InvalidOperationException(
+                                Resources.FormatDefaultConstraintResolver_AmbiguousCtors(
+                                                       constraintTypeInfo.Name, arguments.Length));
+                }
+            }
+
+            return (IDispatcherValueConstraint)activationConstructor.Invoke(parameters);
+        }
+
+        private static object[] ConvertArguments(ParameterInfo[] parameterInfos, string[] arguments)
+        {
+            var parameters = new object[parameterInfos.Length];
+            for (var i = 0; i < parameterInfos.Length; i++)
+            {
+                var parameter = parameterInfos[i];
+                var parameterType = parameter.ParameterType;
+                parameters[i] = Convert.ChangeType(arguments[i], parameterType, CultureInfo.InvariantCulture);
+            }
+
+            return parameters;
+        }
+    }
+}
+

src/Microsoft.AspNetCore.Dispatcher/Constraints/DispatcherValueConstraintBuilder.cs

@@ -0,0 +1,189 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.AspNetCore.Dispatcher
+{
+    /// <summary>
+    /// A builder for producing a mapping of keys to <see cref="IDispatcherValueConstraint"/>.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="DispatcherValueConstraintBuilder"/> allows iterative building a set of route constraints, and will
+    /// merge multiple entries for the same key.
+    /// </remarks>
+    public class DispatcherValueConstraintBuilder
+    {
+        private readonly IConstraintFactory _constraintFactory;
+        private readonly string _rawText;
+        private readonly Dictionary<string, List<IDispatcherValueConstraint>> _constraints;
+        private readonly HashSet<string> _optionalParameters;
+
+        /// <summary>
+        /// Creates a new <see cref="DispatcherValueConstraintBuilder"/> instance.
+        /// </summary>
+        /// <param name="constraintFactory">The <see cref="IConstraintFactory"/>.</param>
+        /// <param name="rawText">The display name (for use in error messages).</param>
+        public DispatcherValueConstraintBuilder(
+            IConstraintFactory constraintFactory,
+            string rawText)
+        {
+            if (constraintFactory == null)
+            {
+                throw new ArgumentNullException(nameof(constraintFactory));
+            }
+
+            if (rawText == null)
+            {
+                throw new ArgumentNullException(nameof(rawText));
+            }
+
+            _constraintFactory = constraintFactory;
+            _rawText = rawText;
+
+            _constraints = new Dictionary<string, List<IDispatcherValueConstraint>>(StringComparer.OrdinalIgnoreCase);
+            _optionalParameters = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Builds a mapping of constraints.
+        /// </summary>
+        /// <returns>An <see cref="IDictionary{String, IDispatcherValueConstraint}"/> of the constraints.</returns>
+        public IDictionary<string, IDispatcherValueConstraint> Build()
+        {
+            var constraints = new Dictionary<string, IDispatcherValueConstraint>(StringComparer.OrdinalIgnoreCase);
+            foreach (var kvp in _constraints)
+            {
+                IDispatcherValueConstraint constraint;
+                if (kvp.Value.Count == 1)
+                {
+                    constraint = kvp.Value[0];
+                }
+                else
+                {
+                    constraint = new CompositeDispatcherValueConstraint(kvp.Value.ToArray());
+                }
+
+                if (_optionalParameters.Contains(kvp.Key))
+                {
+                    var optionalConstraint = new OptionalDispatcherValueConstraint(constraint);
+                    constraints.Add(kvp.Key, optionalConstraint);
+                }
+                else
+                {
+                    constraints.Add(kvp.Key, constraint);
+                }
+            }
+
+            return constraints;
+        }
+
+        /// <summary>
+        /// Adds a constraint instance for the given key.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">
+        /// The constraint instance. Must either be a string or an instance of <see cref="IDispatcherValueConstraint"/>.
+        /// </param>
+        /// <remarks>
+        /// If the <paramref name="value"/> is a string, it will be converted to a <see cref="RegexDispatcherValueConstraint"/>.
+        ///
+        /// For example, the string <code>Product[0-9]+</code> will be converted to the regular expression
+        /// <code>^(Product[0-9]+)</code>. See <see cref="System.Text.RegularExpressions.Regex"/> for more details.
+        /// </remarks>
+        public void AddConstraint(string key, object value)
+        {
+            if (key == null)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+
+            var constraint = value as IDispatcherValueConstraint;
+            if (constraint == null)
+            {
+                var regexPattern = value as string;
+                if (regexPattern == null)
+                {
+                    throw new InvalidOperationException(
+                        Resources.FormatDispatcherValueConstraintBuilder_ValidationMustBeStringOrCustomConstraint(
+                            key,
+                            value,
+                            _rawText,
+                            typeof(IDispatcherValueConstraint)));
+                }
+
+                var constraintsRegEx = "^(" + regexPattern + ")$";
+                constraint = new RegexDispatcherValueConstraint(constraintsRegEx);
+            }
+
+            Add(key, constraint);
+        }
+
+        /// <summary>
+        /// Adds a constraint for the given key, resolved by the <see cref="IConstraintFactory"/>.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="constraintText">The text to be resolved by <see cref="IConstraintFactory"/>.</param>
+        /// <remarks>
+        /// The <see cref="IConstraintFactory"/> can create <see cref="IDispatcherValueConstraint"/> instances
+        /// based on <paramref name="constraintText"/>. See <see cref="DispatcherOptions.ConstraintMap"/> to register
+        /// custom constraint types.
+        /// </remarks>
+        public void AddResolvedConstraint(string key, string constraintText)
+        {
+            if (key == null)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            if (constraintText == null)
+            {
+                throw new ArgumentNullException(nameof(constraintText));
+            }
+
+            var constraint = _constraintFactory.ResolveConstraint(constraintText);
+            if (constraint == null)
+            {
+                throw new InvalidOperationException(
+                    Resources.FormatDispatcherValueConstraintBuilder_CouldNotResolveConstraint(
+                        key,
+                        constraintText,
+                        _rawText,
+                        _constraintFactory.GetType().Name));
+            }
+
+            Add(key, constraint);
+        }
+
+        /// <summary>
+        /// Sets the given key as optional.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        public void SetOptional(string key)
+        {
+            if (key == null)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            _optionalParameters.Add(key);
+        }
+
+        private void Add(string key, IDispatcherValueConstraint constraint)
+        {
+            if (!_constraints.TryGetValue(key, out var list))
+            {
+                list = new List<IDispatcherValueConstraint>();
+                _constraints.Add(key, list);
+            }
+
+            list.Add(constraint);
+        }
+    }
+}