returning ModelClientValidationEqualToRule for PropertyMustMatchRule

Author: h0lg

Source/FluentMetadata.Core.Specs/Builder/When_FluentMetadataBuilder_builds_metadata_copying_from_other_metadata.cs

@@ -134,6 +134,12 @@ public void It_does_not_duplicate_generic_property_rules()
             Assert.Equal(1, someViewModelMyPropertyRules.OfType<GenericRule<int>>().Count());
         }
 
+        [Fact]
+        public void It_does_not_duplicate_ClassRuleValidatingAPropertyWrapper()
+        {
+            Assert.Equal(1, someViewModelMyPropertyRules.OfType<ClassRuleValidatingAPropertyWrapper>().Count());
+        }
+
         #region System under test
 
         #region dependent metadata is defined before its dependency

Source/FluentMetadata.Core.Specs/Builder/When_FluentMetadataBuilder_builds_metadata_copying_from_other_metadata_that_does_not_apply.cs

@@ -90,6 +90,12 @@ public void It_does_not_copy_generic_property_rules()
             Assert.Equal(0, someViewModelMyPropertyRules.OfType<GenericRule<int>>().Count());
         }
 
+        [Fact]
+        public void It_does_not_copy_ClassRuleValidatingAPropertyWrapper()
+        {
+            Assert.Equal(0, someViewModelMyPropertyRules.OfType<ClassRuleValidatingAPropertyWrapper>().Count());
+        }
+
         #region System under test
 
         class SomeDomainModel

Source/FluentMetadata.Core/FluentMetadata.Core.csproj

@@ -74,6 +74,8 @@
     <Compile Include="Builder\ClassMetadataBuilder.cs" />
     <Compile Include="Builder\PropertiesInClassContextBuilder.cs" />
     <Compile Include="MetadataDefinitionSorter.cs" />
+    <Compile Include="Rules\ClassRuleValidatingAPropertyWrapper.cs" />
+    <Compile Include="Rules\ICompareProperties.cs" />
     <Compile Include="Rules\PropertyMustBeLessThanOtherRule.cs" />
     <Compile Include="Rules\GenericClassRule.cs" />
     <Compile Include="Rules\GenericRule.cs" />

Source/FluentMetadata.Core/MetaData.cs

@@ -331,6 +331,13 @@ internal void AddRule(IRule rule)
             {
                 rules.RemoveAll(r => r.Equals(rule));
                 rules.Add(rule);
+
+                var propertyValidatingRule = rule as IValidateAProperty;
+                if (propertyValidatingRule != null && Properties.Contains(propertyValidatingRule.PropertyName))
+                {
+                    Properties[propertyValidatingRule.PropertyName]
+                        .AddRule(new ClassRuleValidatingAPropertyWrapper(propertyValidatingRule));
+                }
             }
         }
 

Source/FluentMetadata.Core/Rules/ClassRuleValidatingAPropertyWrapper.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace FluentMetadata.Rules
+{
+    /// <summary>
+    /// A wrapper for a class rule validating a property used to relate the class rule to the property it is validating.
+    /// </summary>
+    class ClassRuleValidatingAPropertyWrapper : Rule
+    {
+        public override Type PropertyType
+        {
+            get
+            {
+                return PropertyValidatingRule.ClassType
+                    .GetProperty(PropertyValidatingRule.PropertyName)
+                    .PropertyType;
+            }
+        }
+
+        internal IValidateAProperty PropertyValidatingRule { get; private set; }
+
+        internal ClassRuleValidatingAPropertyWrapper(IValidateAProperty propertyValidatingRule)
+            : base(null)
+        {
+            PropertyValidatingRule = propertyValidatingRule;
+        }
+
+        public override bool IsValid(object value)
+        {
+            //should always validate since it's only a dummy for wrapping an IValidateAProperty
+            return true;
+        }
+
+        public override string FormatErrorMessage(string name)
+        {
+            throw new NotSupportedException(
+@"This rule is only a wrapper for a class rule validating a property.
+Please get the exception message from the wrapped class rule.");
+        }
+
+        protected override bool EqualsRule(Rule rule)
+        {
+            var classRuleValidatingAPropertyWrapper = rule as ClassRuleValidatingAPropertyWrapper;
+            return classRuleValidatingAPropertyWrapper == null ?
+                false :
+                classRuleValidatingAPropertyWrapper.PropertyValidatingRule.Equals(PropertyValidatingRule);
+        }
+    }
+}

Source/FluentMetadata.Core/Rules/ICompareProperties.cs

@@ -0,0 +1,12 @@
+namespace FluentMetadata.Rules
+{
+    internal interface IValidateAProperty : IClassRule
+    {
+        string PropertyName { get; }
+    }
+
+    internal interface ICompareProperties : IValidateAProperty
+    {
+        string OtherPropertyName { get; }
+    }
+}

Source/FluentMetadata.Core/Rules/PropertyMustMatchRule.cs

@@ -4,29 +4,29 @@
 
 namespace FluentMetadata.Rules
 {
-    public class PropertyMustMatchRule<T> : ClassRule<T>
+    public class PropertyMustMatchRule<T> : ClassRule<T>, ICompareProperties
     {
         const string DefaultErrorMessage = "'{0}' and '{1}' do not match.";
 
-        readonly string originalPropertyName;
-        readonly string confirmPropertyName;
+        public string PropertyName { get; private set; }
+        public string OtherPropertyName { get; private set; }
 
         public PropertyMustMatchRule(
             Expression<Func<T, object>> expression,
             Expression<Func<T, object>> confirmExpression)
             : base(DefaultErrorMessage)
         {
-            originalPropertyName = ExpressionHelper.GetPropertyName(expression);
-            confirmPropertyName = ExpressionHelper.GetPropertyName(confirmExpression);
+            PropertyName = ExpressionHelper.GetPropertyName(expression);
+            OtherPropertyName = ExpressionHelper.GetPropertyName(confirmExpression);
         }
 
         public override string FormatErrorMessage(string name)
         {
             return string.Format(
                 CultureInfo.CurrentCulture,
                 ErrorMessageFormat,
-                GetPropertyDisplayName(originalPropertyName),
-                GetPropertyDisplayName(confirmPropertyName));
+                GetPropertyDisplayName(PropertyName),
+                GetPropertyDisplayName(OtherPropertyName));
         }
 
         static string GetPropertyDisplayName(string propertyName)
@@ -48,8 +48,8 @@ public override bool IsValid(T instance)
                 return true;
 
             return Equals(
-                GetValueFromProperty(instance, originalPropertyName),
-                GetValueFromProperty(instance, confirmPropertyName));
+                GetValueFromProperty(instance, PropertyName),
+                GetValueFromProperty(instance, OtherPropertyName));
         }
 
         static object GetValueFromProperty(object instance, string propertyName)

Source/FluentMetadata.MVC.Specs/ComplexModel.cs

@@ -1,4 +1,3 @@
-using System;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
 using System.Web.Mvc;
@@ -13,11 +12,7 @@ public ComplexModelMetadata()
 
             Class
                 .Display.Name("Komplex")
-                .AssertThat(
-                    cm => !"Robert'); DROP TABLE Students; --".Equals( //http://xkcd.com/327/ :)
-                        cm.FirstName + cm.LastName,
-                        StringComparison.InvariantCultureIgnoreCase),
-                    "Gotcha, little Bobby Tables! You'll never be '{0}'!");
+                .Property(c => c.LastName).ShouldEqual(c => c.FirstName);
             Property(e => e.Id)
                 .Should.HiddenInput()
                 .Is.ReadOnly()
@@ -63,6 +58,7 @@ public class ComplexModel : ComplexDomainModel
         [DisplayFormat(NullDisplayText = "No lastname set")]
         [RegularExpression("^[A-Z]'?[- a-zA-Z]+$")]
         [AllowHtml]
+        [Compare("FirstName")]
         [StringLength(50)]
         public string LastName { get; set; }
 

Source/FluentMetadata.MVC.Specs/ConcernOfComparingMetadata.cs

@@ -257,5 +257,24 @@ public void RegularExpressionValidatorsMatch()
                     .OfType<ModelClientValidationRegexRule>()
                     .Count());
         }
+
+        [Observation]
+        public void EqualToClientValidationRulesMatch()
+        {
+            var controllerContext = new ControllerContext();
+            var expectedValidatorCount = new DataAnnotationsModelValidatorProvider()
+                .GetValidators(Expected, controllerContext)
+                .SelectMany(rmv => rmv.GetClientValidationRules())
+                .OfType<ModelClientValidationEqualToRule>()
+                .Count();
+            Assert.InRange(expectedValidatorCount, 0, 1);
+            Assert.Equal(
+                expectedValidatorCount,
+                new FluentValidationProvider()
+                    .GetValidators(Fluent, controllerContext)
+                    .SelectMany(rmv => rmv.GetClientValidationRules())
+                    .OfType<ModelClientValidationEqualToRule>()
+                    .Count());
+        }
     }
 }

Source/FluentMetadata.MVC.Specs/MetaData_ComplexModel_Specs.cs

@@ -66,7 +66,7 @@ public void The_validator_returns_1_ModelValidationResult()
         public void The_error_message_of_the_ModelValidationResult_equals_the_message_specified_in_the_rule()
         {
             Assert.Equal(
-                "Gotcha, little Bobby Tables! You'll never be 'Komplex'!",
+                "'LastName' and 'Vorname' do not match.",
                 validators[0].Validate(model).ToArray()[0].Message);
         }