shoulda-matchers 3.0.1 → 3.1.0

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

@@ -253,40 +253,50 @@ module Shoulda
           self
         end
 
-        def with_short_message(message)
+        def with_message(message)
           if message
+            @expects_custom_validation_message = true
             @short_message = message
+            @long_message = message
           end
+
           self
         end
 
-        def with_long_message(message)
+        def with_short_message(message)
           if message
-            @long_message = message
+            @expects_custom_validation_message = true
+            @short_message = message
           end
+
           self
         end
 
-        def with_message(message)
+        def with_long_message(message)
           if message
-            @short_message = message
+            @expects_custom_validation_message = true
             @long_message = message
           end
+
           self
         end
 
-        def description
-          description =  "ensure #{@attribute} has a length "
+        def simple_description
+          description = "validate that the length of :#{@attribute}"
+
           if @options.key?(:minimum) && @options.key?(:maximum)
             if @options[:minimum] == @options[:maximum]
-              description << "of exactly #{@options[:minimum]}"
+              description << " is #{@options[:minimum]}"
             else
-              description << "between #{@options[:minimum]} and #{@options[:maximum]}"
+              description << " is between #{@options[:minimum]}"
+              description << " and #{@options[:maximum]}"
             end
-          else
-            description << "of at least #{@options[:minimum]}" if @options[:minimum]
-            description << "of at most #{@options[:maximum]}" if @options[:maximum]
+          elsif @options.key?(:minimum)
+            description << " is at least #{@options[:minimum]}"
+          elsif @options.key?(:maximum)
+            description << " is at most #{@options[:maximum]}"
           end
+
           description
         end
 

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

@@ -279,7 +279,7 @@ module Shoulda
       #
       # Use `allow_nil` to assert that the attribute allows nil.
       #
-      #     class Age
+      #     class Post
       #       include ActiveModel::Model
       #       attr_accessor :age
       #
@@ -304,27 +304,37 @@ module Shoulda
 
       # @private
       class ValidateNumericalityOfMatcher
-        NUMERIC_NAME = 'numbers'
+        NUMERIC_NAME = 'number'
         NON_NUMERIC_VALUE = 'abcd'
         DEFAULT_DIFF_TO_COMPARE = 1
 
+        include Qualifiers::IgnoringInterferenceByWriter
+
         attr_reader :diff_to_compare
 
         def initialize(attribute)
+          super
           @attribute = attribute
           @submatchers = []
           @diff_to_compare = DEFAULT_DIFF_TO_COMPARE
-          @strict = false
-
-          add_disallow_value_matcher
+          @expects_custom_validation_message = false
+          @expects_to_allow_nil = false
+          @expects_strict = false
+          @allowed_type_adjective = nil
+          @allowed_type_name = 'number'
+          @context = nil
+          @expected_message = nil
         end
 
         def strict
-          @strict = true
-          @submatchers.each(&:strict)
+          @expects_strict = true
           self
         end
 
+        def expects_strict?
+          @expects_strict
+        end
+
         def only_integer
           prepare_submatcher(
             NumericalityMatchers::OnlyIntegerMatcher.new(self, @attribute)
@@ -333,6 +343,7 @@ module Shoulda
         end
 
         def allow_nil
+          @expects_to_allow_nil = true
           prepare_submatcher(
             AllowValueMatcher.new(nil)
               .for(@attribute)
@@ -341,6 +352,10 @@ module Shoulda
           self
         end
 
+        def expects_to_allow_nil?
+          @expects_to_allow_nil
+        end
+
         def odd
           prepare_submatcher(
             NumericalityMatchers::OddNumberMatcher.new(self, @attribute)
@@ -381,120 +396,216 @@ module Shoulda
         end
 
         def with_message(message)
-          @submatchers.each { |matcher| matcher.with_message(message) }
+          @expects_custom_validation_message = true
+          @expected_message = message
           self
         end
 
+        def expects_custom_validation_message?
+          @expects_custom_validation_message
+        end
+
         def on(context)
-          @submatchers.each { |matcher| matcher.on(context) }
+          @context = context
           self
         end
 
         def matches?(subject)
           @subject = subject
+          @number_of_submatchers = @submatchers.size
 
-          if given_numeric_column?
-            remove_disallow_value_matcher
-          end
-
-          if @submatchers.empty?
-            raise IneffectiveTestError.create(
-              model: @subject.class,
-              attribute: @attribute,
-              column_type: column_type
-            )
-          end
+          add_disallow_value_matcher
+          qualify_submatchers
 
           first_failing_submatcher.nil?
         end
 
-        def description
-          description_parts = ["only allow #{allowed_types} for #{@attribute}"]
+        def simple_description
+          description = ''
+
+          description << "validate that :#{@attribute} looks like "
+          description << Shoulda::Matchers::Util.a_or_an(full_allowed_type)
 
           if comparison_descriptions.present?
-            description_parts << comparison_descriptions
+            description << ' ' + comparison_descriptions
           end
 
-          if @strict
-            description_parts.insert(1, 'strictly')
-            description_parts.join(', ')
-          else
-            description_parts.join(' ')
-          end
+          description
+        end
+
+        def description
+          ValidationMatcher::BuildDescription.call(self, simple_description)
         end
 
         def failure_message
-          first_failing_submatcher.failure_message
+          overall_failure_message.dup.tap do |message|
+            message << "\n"
+            message << failure_message_for_first_failing_submatcher
+          end
         end
 
         def failure_message_when_negated
-          first_failing_submatcher.failure_message_when_negated
+          overall_failure_message_when_negated.dup.tap do |message|
+            if submatcher_failure_message_when_negated.present?
+              raise "hmm, this needs to be implemented."
+              message << "\n"
+              message << Shoulda::Matchers.word_wrap(
+                submatcher_failure_message_when_negated,
+                indent: 2
+              )
+            end
+          end
         end
 
         def given_numeric_column?
-          [:integer, :float, :decimal].include?(column_type)
+          attribute_is_active_record_column? &&
+            [:integer, :float, :decimal].include?(column_type)
         end
 
         private
 
+        def model
+          @subject.class
+        end
+
+        def overall_failure_message
+          Shoulda::Matchers.word_wrap(
+            "#{model.name} did not properly #{description}."
+          )
+        end
+
+        def overall_failure_message_when_negated
+          Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} not to #{description}, but it did."
+          )
+        end
+
+        def attribute_is_active_record_column?
+          columns_hash.key?(@attribute.to_s)
+        end
+
         def column_type
+          columns_hash[@attribute.to_s].type
+        end
+
+        def columns_hash
           if @subject.class.respond_to?(:columns_hash)
-            @subject.class.columns_hash[@attribute.to_s].type
+            @subject.class.columns_hash
+          else
+            {}
           end
         end
 
         def add_disallow_value_matcher
-          disallow_value_matcher = DisallowValueMatcher.new(NON_NUMERIC_VALUE).
+          disallow_value_matcher = DisallowValueMatcher.
+            new(NON_NUMERIC_VALUE).
             for(@attribute).
             with_message(:not_a_number)
 
           add_submatcher(disallow_value_matcher)
         end
 
-        def remove_disallow_value_matcher
-          @submatchers.shift
-        end
-
         def prepare_submatcher(submatcher)
           add_submatcher(submatcher)
-
-          if submatcher.respond_to?(:diff_to_compare)
-            update_diff_to_compare(submatcher)
-          end
+          submatcher
         end
 
         def comparison_matcher_for(value, operator)
-          NumericalityMatchers::ComparisonMatcher
-            .new(self, value, operator)
-            .for(@attribute)
+          NumericalityMatchers::ComparisonMatcher.
+            new(self, value, operator).
+            for(@attribute)
         end
 
         def add_submatcher(submatcher)
+          if submatcher.respond_to?(:allowed_type_name)
+            @allowed_type_name = submatcher.allowed_type_name
+          end
+
+          if submatcher.respond_to?(:allowed_type_adjective)
+            @allowed_type_adjective = submatcher.allowed_type_adjective
+          end
+
+          if submatcher.respond_to?(:diff_to_compare)
+            @diff_to_compare = [@diff_to_compare, submatcher.diff_to_compare].max
+          end
+
           @submatchers << submatcher
         end
 
-        def update_diff_to_compare(matcher)
-          @diff_to_compare = [@diff_to_compare, matcher.diff_to_compare].max
+        def qualify_submatchers
+          @submatchers.each do |submatcher|
+            if @expects_strict
+              submatcher.strict(@expects_strict)
+            end
+
+            if @expected_message.present?
+              submatcher.with_message(@expected_message)
+            end
+
+            if @context
+              submatcher.on(@context)
+            end
+
+            submatcher.ignoring_interference_by_writer(
+              ignore_interference_by_writer
+            )
+          end
+        end
+
+        def number_of_submatchers_for_failure_message
+          if has_been_qualified?
+            @submatchers.size - 1
+          else
+            @submatchers.size
+          end
+        end
+
+        def has_been_qualified?
+          @submatchers.any? do |submatcher|
+            submatcher.class.parent == NumericalityMatchers
+          end
         end
 
         def first_failing_submatcher
-          @_first_failing_submatcher ||= @submatchers.detect do |submatcher|
+          @_failing_submatchers ||= @submatchers.detect do |submatcher|
             !submatcher.matches?(@subject)
           end
         end
 
-        def allowed_types
-          allowed_array = submatcher_allowed_types
-          allowed_array.empty? ? NUMERIC_NAME : allowed_array.join(', ')
+        def submatcher_failure_message
+          first_failing_submatcher.failure_message
         end
 
-        def submatcher_allowed_types
-          @submatchers.inject([]){|m, s| m << s.allowed_type if s.respond_to?(:allowed_type); m }
+        def submatcher_failure_message_when_negated
+          first_failing_submatcher.failure_message_when_negated
+        end
+
+        def failure_message_for_first_failing_submatcher
+          submatcher = first_failing_submatcher
+
+          if number_of_submatchers_for_failure_message > 1
+            submatcher_description = submatcher.simple_description.
+              sub(/\bvalidate that\b/, 'validates').
+              sub(/\bdisallow\b/, 'disallows').
+              sub(/\ballow\b/, 'allows')
+            submatcher_message =
+              "In checking that #{model.name} #{submatcher_description}, " +
+              submatcher.failure_message[0].downcase +
+              submatcher.failure_message[1..-1]
+          else
+            submatcher_message = submatcher.failure_message
+          end
+
+          Shoulda::Matchers.word_wrap(submatcher_message, indent: 2)
+        end
+
+        def full_allowed_type
+          "#{@allowed_type_adjective} #{@allowed_type_name}".strip
         end
 
         def comparison_descriptions
           description_array = submatcher_comparison_descriptions
-          description_array.empty? ? '' : 'which are ' + submatcher_comparison_descriptions.join(' and ')
+          description_array.empty? ? '' : submatcher_comparison_descriptions.join(' and ')
         end
 
         def submatcher_comparison_descriptions
@@ -505,39 +616,6 @@ module Shoulda
             arr
           end
         end
-
-        class IneffectiveTestError < Shoulda::Matchers::Error
-          attr_accessor :model, :attribute, :column_type
-
-          def message
-            Shoulda::Matchers.word_wrap <<-MESSAGE
-You are attempting to use validate_numericality_of, but the attribute you're
-testing, :#{attribute}, is #{a_or_an(column_type)} column. One of the things
-that the numericality matcher does is to assert that setting :#{attribute} to a
-string that doesn't look like #{a_or_an(column_type)} will cause your
-#{humanized_model_name} to become invalid. In this case, it's impossible to make
-this assertion since :#{attribute} will typecast any incoming value to
-#{a_or_an(column_type)}. This means that it's already guaranteed to be numeric!
-Since this matcher isn't doing anything, you can remove it from your model
-tests, and in fact, you can remove the validation from your model as it isn't
-doing anything either.
-            MESSAGE
-          end
-
-          private
-
-          def humanized_model_name
-            model.name.humanize.downcase
-          end
-
-          def a_or_an(next_word)
-            if next_word =~ /[aeiou]/
-              "an #{next_word}"
-            else
-              "a #{next_word}"
-            end
-          end
-        end
       end
     end
   end

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

@@ -111,24 +111,24 @@ module Shoulda
 
       # @private
       class ValidatePresenceOfMatcher < ValidationMatcher
-        def with_message(message)
-          @expected_message = message if message
-          self
+        def initialize(attribute)
+          super
+          @expected_message = :blank
         end
 
         def matches?(subject)
           super(subject)
-          @expected_message ||= :blank
 
           if secure_password_being_validated?
+            ignore_interference_by_writer.default_to(when: :blank?)
             disallows_and_double_checks_value_of!(blank_value, @expected_message)
           else
             disallows_original_or_typecast_value?(blank_value, @expected_message)
           end
         end
 
-        def description
-          "require #{@attribute} to be set"
+        def simple_description
+          "validate that :#{@attribute} cannot be empty/falsy"
         end
 
         private
@@ -141,14 +141,12 @@ module Shoulda
 
         def disallows_and_double_checks_value_of!(value, message)
           disallows_value_of(value, message)
-        rescue ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
+        rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError
           raise ActiveModel::CouldNotSetPasswordError.create(@subject.class)
         end
 
         def disallows_original_or_typecast_value?(value, message)
           disallows_value_of(blank_value, @expected_message)
-        rescue ActiveModel::AllowValueMatcher::CouldNotSetAttributeError => error
-          error.actual_value.blank?
         end
 
         def blank_value