/// <summary>
 /// Get the <see cref="ModelValidationRule"/> instances that are mapped from the fluent validation rule.
 /// </summary>
 /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ModelValidationRule"/> instances.</returns>
 public override IEnumerable<ModelValidationRule> GetRules(PropertyRule rule, IPropertyValidator validator)
 {
     yield return new ModelValidationRule(
         "Custom",
         base.FormatMessage(rule, validator),
         base.GetMemberNames(rule));
 }

        /// <summary>
        /// Creates a <see cref="IFluentAdapter"/> instance based on the provided <paramref name="propertyValidator"/>.
        /// </summary>
        /// <param name="propertyValidator">The <see cref="IPropertyValidator"/> for which the adapter should be created.</param>
        /// <returns>An <see cref="IFluentAdapter"/> instance.</returns>
        public IFluentAdapter Create(IPropertyValidator propertyValidator)
        {
            var adapter =
                this.adapters.SingleOrDefault(x => x.CanHandle(propertyValidator));

            return adapter ?? new FallbackAdapter();
        }

 public PropertyType(int key, IPropertyValidator propertyValidator, GroupTypeCollection groupsRead, GroupTypeCollection groupsWrite)
 {
     Key = key;
     Validator = propertyValidator;
     GroupsReadInternal = groupsRead;
     GroupsWriteInternal = groupsWrite;
 }

 /// <summary>
 /// Get the <see cref="ModelValidationRule"/> instances that are mapped from the fluent validation rule.
 /// </summary>
 /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ModelValidationRule"/> instances.</returns>
 public override IEnumerable<ModelValidationRule> GetRules(PropertyRule rule, IPropertyValidator validator)
 {
     yield return new RegexValidationRule(
         FormatMessage(rule, validator),
         GetMemberNames(rule),
         ((IRegularExpressionValidator)validator).Expression);
 }

 public Rule GeneratorFrom(string propertyName, IPropertyValidator propertyValidator)
 {
     return new Required
     {
         Message = propertyValidator.GetErrorMessageFor(propertyName)
     };
 }

        public DataAnnotationsValidatorFixture()
        {
            this.propertyValidator1 =
                A.Fake<IPropertyValidator>();

            this.propertyValidator2 =
                A.Fake<IPropertyValidator>();

            this.validatableObjectAdapter =
                A.Fake<IValidatableObjectAdapter>();

            this.validatorFactory =
                A.Fake<IPropertyValidatorFactory>();

            A.CallTo(() => this.validatorFactory.GetValidators(typeof(ModelUnderTest)))
               .Returns(new[] { this.propertyValidator1, this.propertyValidator2 });

            this.validator =
                new DataAnnotationsValidator(typeof(ModelUnderTest), this.validatorFactory, this.validatableObjectAdapter);

            var adapterFactory = new DefaultPropertyValidatorFactory(new IDataAnnotationsValidatorAdapter[]
            {
                new RangeValidatorAdapter(),
                new RegexValidatorAdapter(),
                new RequiredValidatorAdapter(),
                new StringLengthValidatorAdapter(),
                new OopsAdapter()
            });

            var adapter = A.Fake<IValidatableObjectAdapter>();

            this.factory = new DataAnnotationsValidatorFactory(adapterFactory, adapter);
        }

 public Rule GeneratorFrom(IPropertyValidator propertyValidator)
 {
     return new Required
     {
         Message = propertyValidator.ErrorMessageSource.GetString()
     };
 }

 public Rule GeneratorFrom(IPropertyValidator propertyValidator)
 {
     return new LessThanOrEqual
     {
         Value = ((LessThanOrEqualValidator)propertyValidator).ValueToCompare,
         Message = propertyValidator.ErrorMessageSource.GetString()
     };
 }

 public Rule GeneratorFrom(IPropertyValidator propertyValidator)
 {
     var emailRule = new Email
     {
         Message = propertyValidator.ErrorMessageSource.GetString()
     };
     return emailRule;
 }

 /// <summary>
 /// Get the <see cref="ModelValidationRule"/> instances that are mapped from the fluent validation rule.
 /// </summary>
 /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ModelValidationRule"/> instances.</returns>
 public override IEnumerable<ModelValidationRule> GetRules(PropertyRule rule, IPropertyValidator validator)
 {
     yield return new ComparisonValidationRule(
         base.FormatMessage(rule, validator),
         base.GetMemberNames(rule),
         ComparisonOperator.LessThan,
         ((LessThanValidator)validator).ValueToCompare);
 }

 public Rule GeneratorFrom(string propertyName, IPropertyValidator propertyValidator)
 {
     return new GreaterThanOrEqual
     {
         Value = ((GreaterThanOrEqualValidator)propertyValidator).ValueToCompare,
         Message = propertyValidator.GetErrorMessageFor(propertyName)
     };
 }

        public RequiredFluentValidationPropertyValidator(ModelMetadata metadata, ControllerContext controllerContext, PropertyRule rule, IPropertyValidator validator)
            : base(metadata, controllerContext, rule, validator)
        {
            bool isNonNullableValueType = !TypeAllowsNullValue(metadata.ModelType);
            bool nullWasSpecified = metadata.Model == null;

            ShouldValidate = isNonNullableValueType && nullWasSpecified;
        }

 public Rule GeneratorFrom(string propertyName, IPropertyValidator propertyValidator)
 {
     var emailRule = new Email
     {
         Message = propertyValidator.GetErrorMessageFor(propertyName)
     };
     return emailRule;
 }

 public Rule GeneratorFrom(string propertyName, IPropertyValidator propertyValidator)
 {
     return new LessThan
     {
         Value = ((LessThanValidator)propertyValidator).ValueToCompare,
         Message = propertyValidator.GetErrorMessageFor(propertyName)
     };
 }

 public Rule GeneratorFrom(IPropertyValidator propertyValidator)
 {
     return new GreaterThan
     {
         Value = ((GreaterThanValidator)propertyValidator).ValueToCompare,
         Message = propertyValidator.ErrorMessageSource.GetString()
     };
 }

 /// <summary>
 /// Get the <see cref="ModelValidationRule"/> instances that are mapped from the fluent validation rule.
 /// </summary>
 /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ModelValidationRule"/> instances.</returns>
 public override IEnumerable<ModelValidationRule> GetRules(PropertyRule rule, IPropertyValidator validator)
 {
     yield return new StringLengthValidationRule(
         base.FormatMessage(rule, validator),
         base.GetMemberNames(rule),
         ((ILengthValidator)validator).Min,
         ((ILengthValidator)validator).Max);
 }

 /// <summary>
 /// Get the formatted error message of the validator.
 /// </summary>
 /// <returns>A formatted error message string.</returns>
 protected virtual Func<string, string> FormatMessage(PropertyRule rule, IPropertyValidator validator)
 {
     return displayName =>
     {
         return new MessageFormatter()
             .AppendPropertyName(displayName ?? rule.GetDisplayName())
             .BuildMessage(validator.ErrorMessageSource.GetString());
     };
 }

 public SimpleUnitaryClientSideValidator(ModelMetadata metadata,
                                         ControllerContext controllerContext,
                                         PropertyRule rule,
                                         IPropertyValidator validator,
                                         string validationType)
     : base(metadata, controllerContext, rule, validator)
 {
     _validationType = validationType;
 }

 public Rule GeneratorFrom(string propertyName, IPropertyValidator propertyValidator)
 {
     return new Length
         {
             Min = ((ILengthValidator)propertyValidator).Min,
             Max = ((ILengthValidator)propertyValidator).Max,
             Message = propertyValidator.GetErrorMessageFor(propertyName)
         };
 }

 public Rule GeneratorFrom(IPropertyValidator propertyValidator)
 {
     var rule = new Regex
     {
         Message = propertyValidator.ErrorMessageSource.GetString(),
         Expression = ((IRegularExpressionValidator)propertyValidator).Expression
     };
     return rule;
 }