remarkable_activerecord 3.1.8 → 3.1.9

data/lib/remarkable_activerecord/matchers/validate_inclusion_of_matcher.rb

@@ -1,57 +1,57 @@
-require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
-
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateInclusionOfMatcher < AllowValuesForMatcher #:nodoc:
+require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
+
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateInclusionOfMatcher < AllowValuesForMatcher #:nodoc:
         # Don't allow it to behave in the negative way.
-        undef_method :does_not_match?
+        undef_method :does_not_match?
 
         default_options :message => :inclusion
-
-        protected
-
-          def valid_values
-            @options[:in]
-          end
-
-          def invalid_values
-            if @in_range
-              [ @options[:in].first - 1, @options[:in].last + 1 ]
+
+        protected
+
+          def valid_values
+            @options[:in]
+          end
+
+          def invalid_values
+            if @in_range
+              [ @options[:in].first - 1, @options[:in].last + 1 ]
             else
               value = @options[:in].select{ |i| i.is_a?(String) }.max
-              value ? [ value.next ] : []
-            end
-          end
-
-      end
-
-      # Ensures that given values are valid for the attribute. If a range
-      # is given, ensures that the attribute is valid in the given range.
-      #
-      # If you give that :size accepts ["S", "M", "L"], it will test that "T"
-      # (the next of the array max value) is not allowed.
-      #
-      # == Options
-      #
-      # * <tt>:in</tt> - values to test inclusion.
-      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
-      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
-      #
-      # == Examples
-      #
-      #   should_validate_inclusion_of :size, :in => ["S", "M", "L", "XL"]
-      #   should_validate_inclusion_of :age, :in => 18..100
-      #
-      #   it { should validate_inclusion_of(:size, :in => ["S", "M", "L", "XL"]) }
-      #   it { should validate_inclusion_of(:age, :in => 18..100) }
-      #
-      def validate_inclusion_of(*args, &block)
-        ValidateInclusionOfMatcher.new(*args, &block).spec(self)
-      end
-
-    end
-  end
-end
+              value ? [ value.next ] : []
+            end
+          end
+
+      end
+
+      # Ensures that given values are valid for the attribute. If a range
+      # is given, ensures that the attribute is valid in the given range.
+      #
+      # If you give that :size accepts ["S", "M", "L"], it will test that "T"
+      # (the next of the array max value) is not allowed.
+      #
+      # == Options
+      #
+      # * <tt>:in</tt> - values to test inclusion.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_inclusion_of :size, :in => ["S", "M", "L", "XL"]
+      #   should_validate_inclusion_of :age, :in => 18..100
+      #
+      #   it { should validate_inclusion_of(:size, :in => ["S", "M", "L", "XL"]) }
+      #   it { should validate_inclusion_of(:age, :in => 18..100) }
+      #
+      def validate_inclusion_of(*args, &block)
+        ValidateInclusionOfMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_length_of_matcher.rb

@@ -1,150 +1,150 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateLengthOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :within, :alias => :in
-        optional :minimum, :maximum, :is
-        optional :token, :separator, :with_kind_of
-        optional :allow_nil, :allow_blank, :default => true
-        optional :message, :too_short, :too_long, :wrong_length
-
-        collection_assertions :less_than_min_length?, :exactly_min_length?,
-                              :more_than_max_length?, :exactly_max_length?,
-                              :allow_nil?, :allow_blank?
-
-        before_assert do
-          # Reassign :in to :within
-          @options[:within] ||= @options.delete(:in) if @options.key?(:in)
-
-          if @options[:is]
-            @min_value, @max_value = @options[:is], @options[:is]
-          elsif @options[:within]
-            @min_value, @max_value = @options[:within].first, @options[:within].last
-          elsif @options[:maximum]
-            @min_value, @max_value = nil, @options[:maximum]
-          elsif @options[:minimum]
-            @min_value, @max_value = @options[:minimum], nil
-          end
-        end
-
-        default_options :too_short => :too_short, :too_long => :too_long, :wrong_length => :wrong_length
-
-        protected
-          def allow_nil?
-            super(default_message_for(:too_short))
-          end
-
-          def allow_blank?
-            super(default_message_for(:too_short))
-          end
-
-          def less_than_min_length?
-            @min_value.nil? || @min_value <= 1 || bad?(value_for_length(@min_value - 1), default_message_for(:too_short))
-          end
-
-          def exactly_min_length?
-            @min_value.nil? || @min_value <= 0 || good?(value_for_length(@min_value), default_message_for(:too_short))
-          end
-
-          def more_than_max_length?
-            @max_value.nil? || bad?(value_for_length(@max_value + 1), default_message_for(:too_long))
-          end
-
-          def exactly_max_length?
-            @max_value.nil? || @min_value == @max_value || good?(value_for_length(@max_value), default_message_for(:too_long))
-          end
-
-          def value_for_length(value)
-            if @options[:with_kind_of]
-              [@options[:with_kind_of].new] * value
-            else
-              ([@options.fetch(:token, 'x')] * value).join(@options.fetch(:separator, ''))
-            end
-          end
-
-          def interpolation_options
-            { :minimum => @min_value, :maximum => @max_value }
-          end
-
-          # Returns the default message for the validation type.
-          # If user supplied :message, it will return it. Otherwise it will return
-          # wrong_length on :is validation and :too_short or :too_long in the other
-          # types.
-          #
-          def default_message_for(validation_type)
-            return :message if @options[:message]
-            @options.key?(:is) ? :wrong_length : validation_type
-          end
-      end
-
-      # Validates the length of the given attributes. You have also to supply
-      # one of the following options: minimum, maximum, is or within.
-      #
-      # Note: this method is also aliased as <tt>validate_size_of</tt>.
-      #
-      # == Options
-      #
-      # * <tt>:minimum</tt> - The minimum size of the attribute.
-      # * <tt>:maximum</tt> - The maximum size of the attribute.
-      # * <tt>:is</tt> - The exact size of the attribute.
-      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute.
-      # * <tt>:in</tt> - A synonym(or alias) for :within.
-      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
-      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
-      # * <tt>:too_short</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is too short.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
-      # * <tt>:too_long</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is too long.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
-      # * <tt>:wrong_length</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is the wrong length.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % range.last</tt>
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % value</tt>
-      #
-      # It also accepts an extra option called :with_kind_of. If you are validating
-      # the size of an association array, you have to specify the kind of the array
-      # being validated. For example, if your post accepts maximum 10 comments, you
-      # can do:
-      #
-      #   should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
-      #
-      # Finally, it also accepts :token and :separator, to specify how the
-      # tokenizer should work. For example, if you are splitting the attribute
-      # per word:
-      #
-      #   validates_length_of :essay, :minimum => 100, :tokenizer => lambda {|str| str.scan(/\w+/) }
-      #
-      # You could do this:
-      #
-      #   should_validate_length_of :essay, :minimum => 100, :token => "word", :separator => " "
-      #
-      # == Gotcha
-      #
-      # In Rails 2.3.x, when :message is supplied, it overwrites the messages
-      # supplied in :wrong_length, :too_short and :too_long. However, in earlier
-      # versions, Rails ignores the :message option.
-      #
-      # == Examples
-      #
-      #   it { should validate_length_of(:password).within(6..20) }
-      #   it { should validate_length_of(:password).maximum(20) }
-      #   it { should validate_length_of(:password).minimum(6) }
-      #   it { should validate_length_of(:age).is(18) }
-      #
-      #   should_validate_length_of :password, :within => 6..20
-      #   should_validate_length_of :password, :maximum => 20
-      #   should_validate_length_of :password, :minimum => 6
-      #   should_validate_length_of :age, :is => 18
-      #
-      #   should_validate_length_of :password do |m|
-      #     m.minimum 6
-      #     m.maximum 20
-      #   end
-      #
-      def validate_length_of(*attributes, &block)
-        ValidateLengthOfMatcher.new(*attributes, &block).spec(self)
-      end
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateLengthOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :within, :alias => :in
+        optional :minimum, :maximum, :is
+        optional :token, :separator, :with_kind_of
+        optional :allow_nil, :allow_blank, :default => true
+        optional :message, :too_short, :too_long, :wrong_length
+
+        collection_assertions :less_than_min_length?, :exactly_min_length?,
+                              :more_than_max_length?, :exactly_max_length?,
+                              :allow_nil?, :allow_blank?
+
+        before_assert do
+          # Reassign :in to :within
+          @options[:within] ||= @options.delete(:in) if @options.key?(:in)
+
+          if @options[:is]
+            @min_value, @max_value = @options[:is], @options[:is]
+          elsif @options[:within]
+            @min_value, @max_value = @options[:within].first, @options[:within].last
+          elsif @options[:maximum]
+            @min_value, @max_value = nil, @options[:maximum]
+          elsif @options[:minimum]
+            @min_value, @max_value = @options[:minimum], nil
+          end
+        end
+
+        default_options :too_short => :too_short, :too_long => :too_long, :wrong_length => :wrong_length
+
+        protected
+          def allow_nil?
+            super(default_message_for(:too_short))
+          end
+
+          def allow_blank?
+            super(default_message_for(:too_short))
+          end
+
+          def less_than_min_length?
+            @min_value.nil? || @min_value <= 1 || bad?(value_for_length(@min_value - 1), default_message_for(:too_short))
+          end
+
+          def exactly_min_length?
+            @min_value.nil? || @min_value <= 0 || good?(value_for_length(@min_value), default_message_for(:too_short))
+          end
+
+          def more_than_max_length?
+            @max_value.nil? || bad?(value_for_length(@max_value + 1), default_message_for(:too_long))
+          end
+
+          def exactly_max_length?
+            @max_value.nil? || @min_value == @max_value || good?(value_for_length(@max_value), default_message_for(:too_long))
+          end
+
+          def value_for_length(value)
+            if @options[:with_kind_of]
+              [@options[:with_kind_of].new] * value
+            else
+              ([@options.fetch(:token, 'x')] * value).join(@options.fetch(:separator, ''))
+            end
+          end
+
+          def interpolation_options
+            { :minimum => @min_value, :maximum => @max_value }
+          end
+
+          # Returns the default message for the validation type.
+          # If user supplied :message, it will return it. Otherwise it will return
+          # wrong_length on :is validation and :too_short or :too_long in the other
+          # types.
+          #
+          def default_message_for(validation_type)
+            return :message if @options[:message]
+            @options.key?(:is) ? :wrong_length : validation_type
+          end
+      end
+
+      # Validates the length of the given attributes. You have also to supply
+      # one of the following options: minimum, maximum, is or within.
+      #
+      # Note: this method is also aliased as <tt>validate_size_of</tt>.
+      #
+      # == Options
+      #
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute.
+      # * <tt>:in</tt> - A synonym(or alias) for :within.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
+      # * <tt>:too_short</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is too short.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
+      # * <tt>:too_long</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is too long.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
+      # * <tt>:wrong_length</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is the wrong length.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % range.last</tt>
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % value</tt>
+      #
+      # It also accepts an extra option called :with_kind_of. If you are validating
+      # the size of an association array, you have to specify the kind of the array
+      # being validated. For example, if your post accepts maximum 10 comments, you
+      # can do:
+      #
+      #   should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
+      #
+      # Finally, it also accepts :token and :separator, to specify how the
+      # tokenizer should work. For example, if you are splitting the attribute
+      # per word:
+      #
+      #   validates_length_of :essay, :minimum => 100, :tokenizer => lambda {|str| str.scan(/\w+/) }
+      #
+      # You could do this:
+      #
+      #   should_validate_length_of :essay, :minimum => 100, :token => "word", :separator => " "
+      #
+      # == Gotcha
+      #
+      # In Rails 2.3.x, when :message is supplied, it overwrites the messages
+      # supplied in :wrong_length, :too_short and :too_long. However, in earlier
+      # versions, Rails ignores the :message option.
+      #
+      # == Examples
+      #
+      #   it { should validate_length_of(:password).within(6..20) }
+      #   it { should validate_length_of(:password).maximum(20) }
+      #   it { should validate_length_of(:password).minimum(6) }
+      #   it { should validate_length_of(:age).is(18) }
+      #
+      #   should_validate_length_of :password, :within => 6..20
+      #   should_validate_length_of :password, :maximum => 20
+      #   should_validate_length_of :password, :minimum => 6
+      #   should_validate_length_of :age, :is => 18
+      #
+      #   should_validate_length_of :password do |m|
+      #     m.minimum 6
+      #     m.maximum 20
+      #   end
+      #
+      def validate_length_of(*attributes, &block)
+        ValidateLengthOfMatcher.new(*attributes, &block).spec(self)
+      end
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_numericality_of_matcher.rb

@@ -1,188 +1,188 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateNumericalityOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :equal_to, :greater_than_or_equal_to, :greater_than,
-                 :less_than_or_equal_to, :less_than, :message
-
-        optional :only_integer, :odd, :even, :allow_nil, :allow_blank, :default => true
-
-        collection_assertions :only_numeric_values?, :allow_blank?, :allow_nil?,
-                              :only_integer?, :only_odd?, :only_even?, :equals_to?,
-                              :less_than_minimum?, :more_than_maximum?
-
-        # Before assertions, we rearrange the values.
-        #
-        # Notice that :less_than gives a maximum value while :more_than given
-        # a minimum value. While :equal_to generate both.
-        #
-        before_assert do
-          @maximum_values = {}
-          @minimum_values = {}
-
-          if value = @options[:equal_to]
-            @maximum_values[:equal_to] = value
-            @minimum_values[:equal_to] = value
-          elsif value = @options[:less_than]
-            @maximum_values[:less_than] = value - 1
-          elsif value = @options[:greater_than]
-            @minimum_values[:greater_than] = value + 1
-          elsif value = @options[:less_than_or_equal_to]
-            @maximum_values[:less_than_or_equal_to] = value
-          elsif value = @options[:greater_than_or_equal_to]
-            @minimum_values[:greater_than_or_equal_to] = value
-          end
-        end
-
-        private
-
-          def allow_nil?
-            super(default_message_for(:not_a_number))
-          end
-
-          def allow_blank?
-            super(default_message_for(:not_a_number))
-          end
-
-          def only_numeric_values?
-            bad?("abcd", default_message_for(:not_a_number))
-          end
-
-          def only_integer?
-            assert_bad_or_good_if_key(:only_integer, valid_value_for_test.to_f, default_message_for(:not_a_number))
-          end
-
-          # In ActiveRecord, when we supply :even, does not matter the value, it
-          # considers that should even values should be accepted.
-          #
-          def only_even?
-            return true unless @options[:even]
-            bad?(even_valid_value_for_test + 1, default_message_for(:even))
-          end
-
-          # In ActiveRecord, when we supply :odd, does not matter the value, it
-          # considers that should odd values should be accepted.
-          #
-          def only_odd?
-            return true unless @options[:odd]
-            bad?(even_valid_value_for_test, default_message_for(:odd))
-          end
-
-          # Check equal_to for all registered values.
-          #
-          def equals_to?
-            values = {}
-            @maximum_values.each { |k, v| values[k] = v }
-            @minimum_values.each { |k, v| values[k] = v }
-
-            values.each do |key, value|
-              return false, :count => value unless good?(value, default_message_for(key))
-            end
-            true
-          end
-
-          # Check more_than_maximum? for equal_to, less_than and
-          # less_than_or_equal_to options.
-          #
-          def more_than_maximum?
-            @maximum_values.each do |key, value|
-              return false, :count => value unless bad?(value + 1, default_message_for(key))
-            end
-            true
-          end
-
-          # Check less_than_minimum? for equal_to, more_than and
-          # more_than_or_equal_to options.
-          #
-          def less_than_minimum?
-            @minimum_values.each do |key, value|
-              return false, :count => value unless bad?(value - 1, default_message_for(key))
-            end
-            true
-          end
-
-          # Returns a valid value for test.
-          #
-          def valid_value_for_test
-            value = @options[:equal_to] || @options[:less_than_or_equal_to] || @options[:greater_than_or_equal_to]
-
-            value ||= @options[:less_than]    - 1 if @options[:less_than]
-            value ||= @options[:greater_than] + 1 if @options[:greater_than]
-
-            value ||= 10
-
-            if @options[:even]
-              value = (value / 2) * 2
-            elsif @options[:odd]
-              value = ((value / 2) * 2) + 1
-            end
-
-            value
-          end
-
-          # Returns a valid even value for test.
-          # The method valid_value_for_test checks for :even option but does not
-          # return necessarily an even value
-          #
-          def even_valid_value_for_test
-            (valid_value_for_test / 2) * 2
-          end
-
-          # Returns the default message for each key (:odd, :even, :equal_to, ...).
-          # If the user provided a message, we use it, otherwise we should use
-          # the given key as message.
-          #
-          # For example, a default_message_for(:odd), if none is provided, will be
-          # :odd. So we have create :odd_message in the options hash, that when
-          # called later, will return :odd.
-          #
-          def default_message_for(key)
-            if @options[:message]
-              :message
-            else
-              @options[:"#{key}_message"] = key
-              :"#{key}_message"
-            end
-          end
-      end
-
-      # Ensures that the given attributes accepts only numbers.
-      #
-      # == Options
-      #
-      # * <tt>:only_integer</tt> - when supplied, checks if it accepts only integers or not
-      # * <tt>:odd</tt> - when supplied, checks if it accepts only odd values or not
-      # * <tt>:even</tt> - when supplied, checks if it accepts only even values or not
-      # * <tt>:equal_to</tt> - when supplied, checks if attributes are only valid when equal to given value
-      # * <tt>:less_than</tt> - when supplied, checks if attributes are only valid when less than given value
-      # * <tt>:greater_than</tt> - when supplied, checks if attributes are only valid when greater than given value
-      # * <tt>:less_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when less than or equal to given value
-      # * <tt>:greater_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when greater than or equal to given value
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
-      #
-      # == Examples
-      #
-      #   it { should validate_numericality_of(:age).odd }
-      #   it { should validate_numericality_of(:age).even }
-      #   it { should validate_numericality_of(:age).only_integer }
-      #   it { should validate_numericality_of(:age, :odd => true) }
-      #   it { should validate_numericality_of(:age, :even => true) }
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateNumericalityOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :equal_to, :greater_than_or_equal_to, :greater_than,
+                 :less_than_or_equal_to, :less_than, :message
+
+        optional :only_integer, :odd, :even, :allow_nil, :allow_blank, :default => true
+
+        collection_assertions :only_numeric_values?, :allow_blank?, :allow_nil?,
+                              :only_integer?, :only_odd?, :only_even?, :equals_to?,
+                              :less_than_minimum?, :more_than_maximum?
+
+        # Before assertions, we rearrange the values.
+        #
+        # Notice that :less_than gives a maximum value while :more_than given
+        # a minimum value. While :equal_to generate both.
+        #
+        before_assert do
+          @maximum_values = {}
+          @minimum_values = {}
+
+          if value = @options[:equal_to]
+            @maximum_values[:equal_to] = value
+            @minimum_values[:equal_to] = value
+          elsif value = @options[:less_than]
+            @maximum_values[:less_than] = value - 1
+          elsif value = @options[:greater_than]
+            @minimum_values[:greater_than] = value + 1
+          elsif value = @options[:less_than_or_equal_to]
+            @maximum_values[:less_than_or_equal_to] = value
+          elsif value = @options[:greater_than_or_equal_to]
+            @minimum_values[:greater_than_or_equal_to] = value
+          end
+        end
+
+        private
+
+          def allow_nil?
+            super(default_message_for(:not_a_number))
+          end
+
+          def allow_blank?
+            super(default_message_for(:not_a_number))
+          end
+
+          def only_numeric_values?
+            bad?("abcd", default_message_for(:not_a_number))
+          end
+
+          def only_integer?
+            assert_bad_or_good_if_key(:only_integer, valid_value_for_test.to_f, default_message_for(:not_a_number))
+          end
+
+          # In ActiveRecord, when we supply :even, does not matter the value, it
+          # considers that should even values should be accepted.
+          #
+          def only_even?
+            return true unless @options[:even]
+            bad?(even_valid_value_for_test + 1, default_message_for(:even))
+          end
+
+          # In ActiveRecord, when we supply :odd, does not matter the value, it
+          # considers that should odd values should be accepted.
+          #
+          def only_odd?
+            return true unless @options[:odd]
+            bad?(even_valid_value_for_test, default_message_for(:odd))
+          end
+
+          # Check equal_to for all registered values.
+          #
+          def equals_to?
+            values = {}
+            @maximum_values.each { |k, v| values[k] = v }
+            @minimum_values.each { |k, v| values[k] = v }
+
+            values.each do |key, value|
+              return false, :count => value unless good?(value, default_message_for(key))
+            end
+            true
+          end
+
+          # Check more_than_maximum? for equal_to, less_than and
+          # less_than_or_equal_to options.
+          #
+          def more_than_maximum?
+            @maximum_values.each do |key, value|
+              return false, :count => value unless bad?(value + 1, default_message_for(key))
+            end
+            true
+          end
+
+          # Check less_than_minimum? for equal_to, more_than and
+          # more_than_or_equal_to options.
+          #
+          def less_than_minimum?
+            @minimum_values.each do |key, value|
+              return false, :count => value unless bad?(value - 1, default_message_for(key))
+            end
+            true
+          end
+
+          # Returns a valid value for test.
+          #
+          def valid_value_for_test
+            value = @options[:equal_to] || @options[:less_than_or_equal_to] || @options[:greater_than_or_equal_to]
+
+            value ||= @options[:less_than]    - 1 if @options[:less_than]
+            value ||= @options[:greater_than] + 1 if @options[:greater_than]
+
+            value ||= 10
+
+            if @options[:even]
+              value = (value / 2) * 2
+            elsif @options[:odd]
+              value = ((value / 2) * 2) + 1
+            end
+
+            value
+          end
+
+          # Returns a valid even value for test.
+          # The method valid_value_for_test checks for :even option but does not
+          # return necessarily an even value
+          #
+          def even_valid_value_for_test
+            (valid_value_for_test / 2) * 2
+          end
+
+          # Returns the default message for each key (:odd, :even, :equal_to, ...).
+          # If the user provided a message, we use it, otherwise we should use
+          # the given key as message.
+          #
+          # For example, a default_message_for(:odd), if none is provided, will be
+          # :odd. So we have create :odd_message in the options hash, that when
+          # called later, will return :odd.
+          #
+          def default_message_for(key)
+            if @options[:message]
+              :message
+            else
+              @options[:"#{key}_message"] = key
+              :"#{key}_message"
+            end
+          end
+      end
+
+      # Ensures that the given attributes accepts only numbers.
       #
-      #   should_validate_numericality_of :age, :price
+      # == Options
+      #
+      # * <tt>:only_integer</tt> - when supplied, checks if it accepts only integers or not
+      # * <tt>:odd</tt> - when supplied, checks if it accepts only odd values or not
+      # * <tt>:even</tt> - when supplied, checks if it accepts only even values or not
+      # * <tt>:equal_to</tt> - when supplied, checks if attributes are only valid when equal to given value
+      # * <tt>:less_than</tt> - when supplied, checks if attributes are only valid when less than given value
+      # * <tt>:greater_than</tt> - when supplied, checks if attributes are only valid when greater than given value
+      # * <tt>:less_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when less than or equal to given value
+      # * <tt>:greater_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when greater than or equal to given value
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
+      #
+      # == Examples
+      #
+      #   it { should validate_numericality_of(:age).odd }
+      #   it { should validate_numericality_of(:age).even }
+      #   it { should validate_numericality_of(:age).only_integer }
+      #   it { should validate_numericality_of(:age, :odd => true) }
+      #   it { should validate_numericality_of(:age, :even => true) }
+      #
+      #   should_validate_numericality_of :age, :price
       #   should_validate_numericality_of :price, :only_integer => false, :greater_than => 10
       #
       #   should_validate_numericality_of :price do |m|
       #     m.only_integer = false
       #     m.greater_than = 10
       #   end
-      #
-      def validate_numericality_of(*attributes, &block)
-        ValidateNumericalityOfMatcher.new(*attributes, &block).spec(self)
-      end
-
-    end
-  end
-end
+      #
+      def validate_numericality_of(*attributes, &block)
+        ValidateNumericalityOfMatcher.new(*attributes, &block).spec(self)
+      end
+
+    end
+  end
+end