shoulda-matchers 2.5.0 → 2.6.0

data/lib/shoulda/matchers/active_model/ensure_length_of_matcher.rb

@@ -110,18 +110,18 @@ module Shoulda # :nodoc:
         def translate_messages!
           if Symbol === @short_message
             @short_message = default_error_message(@short_message,
-                                                   :model_name => @subject.class.to_s.underscore,
-                                                   :instance => @subject,
-                                                   :attribute => @attribute,
-                                                   :count => @options[:minimum])
+                                                   model_name: @subject.class.to_s.underscore,
+                                                   instance: @subject,
+                                                   attribute: @attribute,
+                                                   count: @options[:minimum])
           end
 
           if Symbol === @long_message
             @long_message = default_error_message(@long_message,
-                                                  :model_name => @subject.class.to_s.underscore,
-                                                  :instance => @subject,
-                                                  :attribute => @attribute,
-                                                  :count => @options[:maximum])
+                                                  model_name: @subject.class.to_s.underscore,
+                                                  instance: @subject,
+                                                  attribute: @attribute,
+                                                  count: @options[:maximum])
           end
         end
 

data/lib/shoulda/matchers/active_model/errors.rb

@@ -2,6 +2,46 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
       class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
+
+      class NonNullableBooleanError < Shoulda::Matchers::Error; end
+
+      class CouldNotClearAttribute < Shoulda::Matchers::Error
+        def self.create(actual_value)
+          super(actual_value: actual_value)
+        end
+
+        attr_accessor :actual_value
+
+        def message
+          "Expected value to be nil, but was #{actual_value.inspect}."
+        end
+      end
+
+      class CouldNotSetPasswordError < Shoulda::Matchers::Error
+        def self.create(model)
+          super(model: model)
+        end
+
+        attr_accessor :model
+
+        def message
+          <<-EOT.strip
+The validation failed because your #{model_name} model declares `has_secure_password`, and
+`validate_presence_of` was called on a #{record_name} which has `password` already set to a value.
+Please use a #{record_name} with an empty `password` instead.
+          EOT
+        end
+
+        private
+
+        def model_name
+          model.name
+        end
+
+        def record_name
+          model_name.humanize.downcase
+        end
+      end
     end
   end
 end

data/lib/shoulda/matchers/active_model/helpers.rb

@@ -6,7 +6,7 @@ module Shoulda # :nodoc:
           obj.errors.map do |attribute, model|
             msg = "#{attribute} #{model}"
             if attribute.to_sym != :base && obj.respond_to?(attribute)
-              msg << " (#{obj.send(attribute).inspect})"
+              msg << " (#{obj.__send__(attribute).inspect})"
             end
             msg
           end
@@ -19,10 +19,10 @@ module Shoulda # :nodoc:
         # instance is given.
         #
         #   default_error_message(:blank)
-        #   default_error_message(:too_short, :count => 5)
-        #   default_error_message(:too_long, :count => 60)
-        #   default_error_message(:blank, :model_name => 'user', :attribute => 'name')
-        #   default_error_message(:blank, :instance => #<Model>, :attribute => 'name')
+        #   default_error_message(:too_short, count: 5)
+        #   default_error_message(:too_long, count: 60)
+        #   default_error_message(:blank, model_name: 'user', attribute: 'name')
+        #   default_error_message(:blank, instance: #<Model>, attribute: 'name')
         def default_error_message(key, options = {})
           model_name = options.delete(:model_name)
           attribute = options.delete(:attribute)
@@ -36,7 +36,7 @@ module Shoulda # :nodoc:
                                     :"errors.attributes.#{attribute}.#{key}",
                                     :"errors.messages.#{key}" ]
             I18n.translate(:"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{key}",
-              { :default => default_translation }.merge(options))
+              { default: default_translation }.merge(options))
           end
         end
       end

data/lib/shoulda/matchers/active_model/numericality_matchers/comparison_matcher.rb

@@ -7,7 +7,11 @@ module Shoulda # :nodoc:
         #                 is_greater_than(6).
         #                 less_than(20)...(and so on) }
         class ComparisonMatcher < ValidationMatcher
-          def initialize(value, operator)
+          def initialize(numericality_matcher, value, operator)
+            unless numericality_matcher.respond_to? :diff_to_compare
+              raise ArgumentError, 'numericality_matcher is invalid'
+            end
+            @numericality_matcher = numericality_matcher
             @value = value
             @operator = operator
             @message = nil
@@ -20,27 +24,36 @@ module Shoulda # :nodoc:
 
           def matches?(subject)
             @subject = subject
-            disallows_value_of(value_to_compare, @message)
-          end
-
-          def allowed_types
-            'integer'
+            all_bounds_correct?
           end
 
           def with_message(message)
             @message = message
           end
 
+          def comparison_description
+            "#{expectation} #{@value}"
+          end
+
           private
 
-          def value_to_compare
-            case @operator
-              when :> then [@value, @value - 1].sample
-              when :>= then @value - 1
-              when :== then @value + 1
-              when :< then [@value, @value + 1].sample
-              when :<= then @value + 1
-            end
+          def comparison_combos
+            allow = :allows_value_of
+            disallow = :disallows_value_of
+            checker_types =
+              case @operator
+                when :> then [allow, disallow, disallow]
+                when :>= then [allow, allow, disallow]
+                when :== then [disallow, allow, disallow]
+                when :< then [disallow, disallow, allow]
+                when :<= then [disallow, allow, allow]
+              end
+            diffs_to_compare.zip(checker_types)
+          end
+
+          def diffs_to_compare
+            diff = @numericality_matcher.diff_to_compare
+            [diff, 0, -diff]
           end
 
           def expectation
@@ -52,6 +65,12 @@ module Shoulda # :nodoc:
               when :<= then "less than or equal to"
             end
           end
+
+          def all_bounds_correct?
+            comparison_combos.all? do |diff, checker_type|
+              __send__(checker_type, @value + diff, @message)
+            end
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_model/numericality_matchers/even_number_matcher.rb

@@ -0,0 +1,26 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      module NumericalityMatchers
+        class EvenNumberMatcher < NumericTypeMatcher # :nodoc:
+          NON_EVEN_NUMBER_VALUE = 1
+
+          def initialize(attribute, options = {})
+            @attribute = attribute
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_EVEN_NUMBER_VALUE).
+                for(@attribute).
+                with_message(:even)
+          end
+
+          def allowed_type
+            'even numbers'
+          end
+
+          def diff_to_compare
+            2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/numericality_matchers/{odd_even_number_matcher.rb → numeric_type_matcher.rb}

@@ -2,24 +2,9 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
       module NumericalityMatchers
-        class OddEvenNumberMatcher # :nodoc:
-          NON_EVEN_NUMBER_VALUE = 1
-          NON_ODD_NUMBER_VALUE  = 2
-
-          def initialize(attribute, options = {})
-            @attribute = attribute
-            options[:odd]   ||= true
-            options[:even]  ||= false
-
-            if options[:odd] && !options[:even]
-              @disallow_value_matcher = DisallowValueMatcher.new(NON_ODD_NUMBER_VALUE).
-                for(@attribute).
-                with_message(:odd)
-            else
-              @disallow_value_matcher = DisallowValueMatcher.new(NON_EVEN_NUMBER_VALUE).
-                for(@attribute).
-                with_message(:even)
-            end
+        class NumericTypeMatcher
+          def initialize
+            raise NotImplementedError
           end
 
           def matches?(subject)
@@ -31,8 +16,12 @@ module Shoulda # :nodoc:
             self
           end
 
-          def allowed_types
-            'integer'
+          def allowed_type
+            raise NotImplementedError
+          end
+
+          def diff_to_compare
+            raise NotImplementedError
           end
 
           def failure_message

data/lib/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher.rb

@@ -0,0 +1,26 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      module NumericalityMatchers
+        class OddNumberMatcher < NumericTypeMatcher # :nodoc:
+          NON_ODD_NUMBER_VALUE  = 2
+
+          def initialize(attribute, options = {})
+            @attribute = attribute
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_ODD_NUMBER_VALUE).
+                for(@attribute).
+                with_message(:odd)
+          end
+
+          def allowed_type
+            'odd numbers'
+          end
+
+          def diff_to_compare
+            2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher.rb

@@ -2,9 +2,8 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
       module NumericalityMatchers
-        class OnlyIntegerMatcher # :nodoc:
+        class OnlyIntegerMatcher < NumericTypeMatcher # :nodoc:
           NON_INTEGER_VALUE = 0.1
-
           def initialize(attribute)
             @attribute = attribute
             @disallow_value_matcher = DisallowValueMatcher.new(NON_INTEGER_VALUE).
@@ -12,28 +11,13 @@ module Shoulda # :nodoc:
               with_message(:not_an_integer)
           end
 
-          def matches?(subject)
-            @disallow_value_matcher.matches?(subject)
-          end
-
-          def with_message(message)
-            @disallow_value_matcher.with_message(message)
-            self
-          end
-
-          def allowed_types
-            'integer'
-          end
-
-          def failure_message
-            @disallow_value_matcher.failure_message
+          def allowed_type
+            'integers'
           end
-          alias failure_message_for_should failure_message
 
-          def failure_message_when_negated
-            @disallow_value_matcher.failure_message_when_negated
+          def diff_to_compare
+            1
           end
-          alias failure_message_for_should_not failure_message_when_negated
         end
       end
     end

data/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -64,7 +64,7 @@ module Shoulda # :nodoc:
         def set_confirmation(val)
           setter = :"#{@confirmation_attribute}="
           if @subject.respond_to?(setter)
-            @subject.send(setter, val)
+            @subject.__send__(setter, val)
           end
         end
 

data/lib/shoulda/matchers/active_model/validate_numericality_of_matcher.rb

@@ -10,66 +10,84 @@ module Shoulda # :nodoc:
       # * <tt>only_integer</tt> - allows only integer values
       # * <tt>odd</tt> - Specifies the value must be an odd number.
       # * <tt>even</tt> - Specifies the value must be an even number.
+      # * <tt>allow_nil</tt> - allows nil values
       #
       # Examples:
       #   it { should validate_numericality_of(:price) }
       #   it { should validate_numericality_of(:age).only_integer }
       #   it { should validate_numericality_of(:frequency).odd }
       #   it { should validate_numericality_of(:frequency).even }
+      #   it { should validate_numericality_of(:rank).is_less_than_or_equal_to(10).allow_nil }
       #
       def validate_numericality_of(attr)
         ValidateNumericalityOfMatcher.new(attr)
       end
 
       class ValidateNumericalityOfMatcher
+        NUMERIC_NAME = 'numbers'
         NON_NUMERIC_VALUE = 'abcd'
+        DEFAULT_DIFF_TO_COMPARE = 0.000_000_000_001
+        attr_reader :diff_to_compare
 
         def initialize(attribute)
           @attribute = attribute
           @submatchers = []
-
+          @diff_to_compare = DEFAULT_DIFF_TO_COMPARE
           add_disallow_value_matcher
         end
 
         def only_integer
-          add_submatcher(NumericalityMatchers::OnlyIntegerMatcher.new(@attribute))
+          prepare_submatcher(
+            NumericalityMatchers::OnlyIntegerMatcher.new(@attribute)
+          )
           self
         end
 
-        def is_greater_than(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>).for(@attribute))
+        def allow_nil
+          prepare_submatcher(
+            AllowValueMatcher.new(nil)
+              .for(@attribute)
+              .with_message(:not_a_number)
+          )
           self
         end
 
-        def is_greater_than_or_equal_to(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>=).for(@attribute))
+        def odd
+          prepare_submatcher(
+            NumericalityMatchers::OddNumberMatcher.new(@attribute)
+          )
           self
         end
 
-        def is_equal_to(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :==).for(@attribute))
+        def even
+          prepare_submatcher(
+            NumericalityMatchers::EvenNumberMatcher.new(@attribute)
+          )
           self
         end
 
-        def is_less_than(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<).for(@attribute))
+        def is_greater_than(value)
+          prepare_submatcher(comparison_matcher_for(value, :>).for(@attribute))
           self
         end
 
-        def is_less_than_or_equal_to(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<=).for(@attribute))
+        def is_greater_than_or_equal_to(value)
+          prepare_submatcher(comparison_matcher_for(value, :>=).for(@attribute))
           self
         end
 
-        def odd
-          odd_number_matcher = NumericalityMatchers::OddEvenNumberMatcher.new(@attribute, :odd => true)
-          add_submatcher(odd_number_matcher)
+        def is_equal_to(value)
+          prepare_submatcher(comparison_matcher_for(value, :==).for(@attribute))
           self
         end
 
-        def even
-          even_number_matcher = NumericalityMatchers::OddEvenNumberMatcher.new(@attribute, :even => true)
-          add_submatcher(even_number_matcher)
+        def is_less_than(value)
+          prepare_submatcher(comparison_matcher_for(value, :<).for(@attribute))
+          self
+        end
+
+        def is_less_than_or_equal_to(value)
+          prepare_submatcher(comparison_matcher_for(value, :<=).for(@attribute))
           self
         end
 
@@ -84,7 +102,7 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "only allow #{allowed_types} values for #{@attribute}"
+          "only allow #{allowed_types} for #{@attribute}#{comparison_descriptions}"
         end
 
         def failure_message
@@ -107,10 +125,27 @@ module Shoulda # :nodoc:
           add_submatcher(disallow_value_matcher)
         end
 
+        def prepare_submatcher(submatcher)
+          add_submatcher(submatcher)
+          if submatcher.respond_to?(:diff_to_compare)
+            update_diff_to_compare(submatcher)
+          end
+        end
+
+        def comparison_matcher_for(value, operator)
+          NumericalityMatchers::ComparisonMatcher
+            .new(self, value, operator)
+            .for(@attribute)
+        end
+
         def add_submatcher(submatcher)
           @submatchers << submatcher
         end
 
+        def update_diff_to_compare(matcher)
+          @diff_to_compare = [@diff_to_compare, matcher.diff_to_compare].max
+        end
+
         def submatchers_match?
           failing_submatchers.empty?
         end
@@ -128,12 +163,26 @@ module Shoulda # :nodoc:
         end
 
         def allowed_types
-          allowed = ['numeric'] + submatcher_allowed_types
-          allowed.join(', ')
+          allowed_array = submatcher_allowed_types
+          allowed_array.empty? ? NUMERIC_NAME : allowed_array.join(', ')
         end
 
         def submatcher_allowed_types
-          @submatchers.map(&:allowed_types).reject(&:empty?)
+          @submatchers.inject([]){|m, s| m << s.allowed_type if s.respond_to?(:allowed_type); m }
+        end
+
+        def comparison_descriptions
+          description_array = submatcher_comparison_descriptions
+          description_array.empty? ? '' : ' which are ' + submatcher_comparison_descriptions.join(' and ')
+        end
+
+        def submatcher_comparison_descriptions
+          @submatchers.inject([]) do |arr, submatcher|
+            if submatcher.respond_to? :comparison_description
+              arr << submatcher.comparison_description
+            end
+            arr
+          end
         end
       end
     end