winui: add shared validation helpers

Add property and model validation helpers, which will be used by
Bitbucket's Windows UI helper in subsequent commits.

Author: mjcheetham

src/windows/Shared.UI.Windows/Controls/ValidationMessage.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+using System;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using Microsoft.Git.CredentialManager.UI.ViewModels.Validation;
+
+namespace Microsoft.Git.CredentialManager.UI.Controls
+{
+    public class ValidationMessage : UserControl
+    {
+        private const double DefaultTextChangeThrottle = 0.2;
+
+        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
+        {
+            if (e.Property.Name == nameof(Validator))
+            {
+                ShowError = Validator.ValidationResult.Status == ValidationStatus.Invalid;
+                Visibility = ShowError ? Visibility.Visible : Visibility.Hidden;
+                Text = Validator.ValidationResult.Message;
+
+                // This might look like an event handler leak, but we're making sure Validator can
+                // only be set once. If we ever want to allow it to be set more than once, we'll need
+                // to make sure to unsubscribe this event.
+                Validator.ValidationResultChanged += (s, vrce) =>
+                {
+                    ShowError = Validator.ValidationResult.Status == ValidationStatus.Invalid;
+                    Visibility = ShowError ? Visibility.Visible : Visibility.Hidden;
+                    Text = Validator.ValidationResult.Message;
+                };
+            }
+
+            base.OnPropertyChanged(e);
+        }
+
+        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(nameof(Text), typeof(string), typeof(ValidationMessage));
+
+        public string Text
+        {
+            get { return (string)GetValue(TextProperty); }
+            private set { SetValue(TextProperty, value); }
+        }
+
+        public static readonly DependencyProperty ShowErrorProperty = DependencyProperty.Register(nameof(ShowError), typeof(bool), typeof(ValidationMessage));
+
+        public bool ShowError
+        {
+            get { return (bool)GetValue(ShowErrorProperty); }
+            set { SetValue(ShowErrorProperty, value); }
+        }
+
+        public static readonly DependencyProperty TextChangeThrottleProperty = DependencyProperty.Register(nameof(TextChangeThrottle), typeof(double), typeof(ValidationMessage), new PropertyMetadata(DefaultTextChangeThrottle));
+
+        public double TextChangeThrottle
+        {
+            get { return (double)GetValue(TextChangeThrottleProperty); }
+            set { SetValue(TextChangeThrottleProperty, value); }
+        }
+
+        public static readonly DependencyProperty ValidatorProperty = DependencyProperty.Register(nameof(Validator), typeof(PropertyValidator), typeof(ValidationMessage));
+
+        public PropertyValidator Validator
+        {
+            get { return (PropertyValidator)GetValue(ValidatorProperty); }
+            set
+            {
+                if (value == null) throw new ArgumentNullException(nameof(ValidatorProperty));
+                Debug.Assert(Validator == null, "Only set this property once for now. If we really need it to be set more than once, we need to make sure we're not leaking event handlers");
+                SetValue(ValidatorProperty, value);
+            }
+        }
+
+        public static readonly DependencyProperty FillProperty =
+            DependencyProperty.Register(nameof(Fill), typeof(Brush), typeof(ValidationMessage), new PropertyMetadata(new SolidColorBrush(Color.FromRgb(0xe7, 0x4c, 0x3c))));
+
+        public Brush Fill
+        {
+            get { return (Brush)GetValue(FillProperty); }
+            set { SetValue(FillProperty, value); }
+        }
+
+        public static readonly DependencyProperty ErrorAdornerTemplateProperty = DependencyProperty.Register(nameof(ErrorAdornerTemplate), typeof(string), typeof(ValidationMessage), new PropertyMetadata("validationTemplate"));
+
+        public string ErrorAdornerTemplate
+        {
+            get { return (string)GetValue(ErrorAdornerTemplateProperty); }
+            set { SetValue(ErrorAdornerTemplateProperty, value); }
+        }
+
+        private bool IsAdornerEnabled()
+        {
+            return !string.IsNullOrEmpty(ErrorAdornerTemplate)
+                && !ErrorAdornerTemplate.Equals("None", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

src/windows/Shared.UI.Windows/ViewModels/Validation/ModelValidator.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.Git.CredentialManager.UI.ViewModels.Validation
+{
+    /// <summary>
+    /// A validator that binds to the validation state of a <see cref="ViewModel"/>.
+    /// It is valid if all child <see cref="PropertyValidator"/>s are valid.
+    /// </summary>
+    public class ModelValidator
+    {
+        private readonly IList<PropertyValidator> _validators = new List<PropertyValidator>();
+        public event EventHandler IsValidChanged;
+
+        private bool _isValid;
+        public bool IsValid
+        {
+            get => _isValid;
+            private set
+            {
+                if (_isValid != value)
+                {
+                    _isValid = value;
+                    IsValidChanged?.Invoke(this, EventArgs.Empty);
+                }
+            }
+        }
+
+        public void Add(PropertyValidator validator)
+        {
+            EnsureArgument.NotNull(validator, nameof(validator));
+
+            _validators.Add(validator);
+            validator.ValidationResultChanged += (s, e) => Evaluate();
+        }
+
+        private void Evaluate()
+        {
+            IsValid = _validators.All(x => x.ValidationResult.IsValid);
+        }
+    }
+}

src/windows/Shared.UI.Windows/ViewModels/Validation/PropertyValidationResult.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Microsoft.Git.CredentialManager.UI.ViewModels.Validation
+{
+    public class PropertyValidationResult
+    {
+        public static readonly PropertyValidationResult Success = new PropertyValidationResult(ValidationStatus.Valid);
+        public static readonly PropertyValidationResult Unvalidated = new PropertyValidationResult(ValidationStatus.Unvalidated);
+
+        /// <summary>
+        /// Describes if the property passes validation
+        /// </summary>
+        public bool IsValid { get; }
+
+        /// <summary>
+        /// Describes which state we are in - Valid, Not Validated, or Invalid
+        /// </summary>
+        public ValidationStatus Status { get; }
+
+        /// <summary>
+        /// An error message to display
+        /// </summary>
+        public string Message { get; }
+
+        /// <summary>
+        /// Describes if we should show this error in the UI We only show errors which have been
+        /// marked specifically as Invalid and we do not show errors for inputs which have not yet
+        /// been validated.
+        /// </summary>
+        public bool DisplayValidationError { get; }
+
+        public PropertyValidationResult(ValidationStatus validationStatus, string message = null)
+        {
+            Status = validationStatus;
+            IsValid = validationStatus == ValidationStatus.Valid;
+            DisplayValidationError = validationStatus == ValidationStatus.Invalid;
+            Message = message ?? string.Empty;
+        }
+    }
+}

src/windows/Shared.UI.Windows/ViewModels/Validation/PropertyValidator.cs

@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Microsoft.Git.CredentialManager.UI.ViewModels.Validation
+{
+    public abstract class PropertyValidator
+    {
+        public event EventHandler ValidationResultChanged;
+
+        /// <summary>
+        /// Creates a validator for a property. This validator is the starting point to attach other
+        /// validations to the property. This method itself doesn't apply any validations.
+        /// </summary>
+        /// <typeparam name="TObject">Type of the object with the property to validate.</typeparam>
+        /// <typeparam name="TProperty">The type of the property to validate.</typeparam>
+        /// <param name="source">The object with the property to validate.</param>
+        /// <param name="property">An expression for the property to validate</param>
+        /// <returns>A property validator</returns>
+        public static PropertyValidator<TObject, TProperty> For<TObject, TProperty>(TObject source, Expression<Func<TObject, TProperty>> property)
+            where TObject : INotifyPropertyChanged
+        {
+            return new PropertyValidator<TObject, TProperty>(source, property);
+        }
+
+        private PropertyValidationResult _validationResult = PropertyValidationResult.Unvalidated;
+
+        /// <summary>
+        /// The current validation result for this validator.
+        /// </summary>
+        public PropertyValidationResult ValidationResult
+        {
+            get => _validationResult;
+            protected set
+            {
+                _validationResult = value;
+                ValidationResultChanged?.Invoke(this, EventArgs.Empty);
+            }
+        }
+    }
+
+    public class PropertyValidator<TProperty> : PropertyValidator
+    {
+        private readonly IList<Func<TProperty, PropertyValidationResult>> _rules =
+            new List<Func<TProperty, PropertyValidationResult>>();
+
+        public void AddRule(Func<TProperty, PropertyValidationResult> predicate)
+        {
+            _rules.Add(predicate);
+        }
+
+        protected void Evaluate(TProperty property)
+        {
+            PropertyValidationResult result = PropertyValidationResult.Unvalidated;
+
+            foreach (Func<TProperty, PropertyValidationResult> rule in _rules)
+            {
+                result = rule(property);
+
+                // An invalid validation rule means we stop evaluating more rules
+                // and return the current result.
+                if (result.Status == ValidationStatus.Invalid)
+                {
+                    break;
+                }
+            }
+
+            ValidationResult = result;
+        }
+    }
+
+    /// <summary>
+    /// This validator watches the target property for changes and then propagates that change up the chain.
+    /// </summary>
+    /// <typeparam name="TObject"></typeparam>
+    /// <typeparam name="TProperty"></typeparam>
+    public class PropertyValidator<TObject, TProperty> : PropertyValidator<TProperty> where TObject : INotifyPropertyChanged
+    {
+        internal PropertyValidator(TObject source, Expression<Func<TObject, TProperty>> propertyExpression)
+        {
+            EnsureArgument.NotNull(source, nameof(source));
+            EnsureArgument.NotNull(propertyExpression, nameof(propertyExpression));
+
+            Func<TObject, TProperty> compiledProperty = propertyExpression.Compile();
+            PropertyInfo propertyInfo = GetPropertyInfo(propertyExpression);
+
+            // Start watching for changes to this property and propagate those changes to the chained validators.
+            source.PropertyChanged += (s, e) =>
+            {
+                if (e.PropertyName == propertyInfo.Name)
+                {
+                    Evaluate(compiledProperty(source));
+                }
+            };
+        }
+
+        private static PropertyInfo GetPropertyInfo(Expression<Func<TObject, TProperty>> propertyExpression)
+        {
+            var member = propertyExpression.Body as MemberExpression;
+            Debug.Assert(member != null, "Property expression doesn't refer to a member.");
+
+            var propertyInfo = member.Member as PropertyInfo;
+            Debug.Assert(propertyInfo != null, "Property expression does not refer to a property.");
+
+            var propertyType = typeof(TObject);
+            Debug.Assert(propertyInfo.ReflectedType != null
+                         && (propertyType == propertyInfo.ReflectedType ||
+                             propertyType.IsSubclassOf(propertyInfo.ReflectedType)),
+                "Property expression is not of the specified type");
+
+            return propertyInfo;
+        }
+    }
+}

src/windows/Shared.UI.Windows/ViewModels/Validation/PropertyValidatorExtensions.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+using System;
+using System.Security;
+
+namespace Microsoft.Git.CredentialManager.UI.ViewModels.Validation
+{
+    public static class PropertyValidatorExtensions
+    {
+        public static PropertyValidator<string> Required(this PropertyValidator<string> validator, string errorMessage)
+        {
+            return validator.ValidIfTrue(value => !string.IsNullOrEmpty(value), errorMessage);
+        }
+
+        public static PropertyValidator<SecureString> Required(this PropertyValidator<SecureString> validator, string errorMessage)
+        {
+            return validator.ValidIfTrue(value => value is null ? (bool?) null : value.Length > 0, errorMessage);
+        }
+
+        public static PropertyValidator<TProperty> ValidIfTrue<TProperty>(
+            this PropertyValidator<TProperty> validator,
+            Func<TProperty, bool?> predicate,
+            string errorMessage)
+        {
+            validator.AddRule(value =>
+            {
+                bool? result = predicate(value);
+                if (result.HasValue)
+                {
+                    return result.Value
+                        ? PropertyValidationResult.Success
+                        : new PropertyValidationResult(ValidationStatus.Invalid, errorMessage);
+                }
+
+                return PropertyValidationResult.Unvalidated;
+            });
+
+            return validator;
+        }
+    }
+}

src/windows/Shared.UI.Windows/ViewModels/Validation/ValidationStatus.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Microsoft.Git.CredentialManager.UI.ViewModels.Validation
+{
+    public enum ValidationStatus
+    {
+        Unvalidated = 0,
+        Invalid = 1,
+        Valid = 2,
+    }
+}