shoulda-matchers 3.1.3 → 4.0.0.rc1

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

@@ -216,6 +216,27 @@ module Shoulda
       #         with_long_message('Secret key must be less than 100 characters')
       #     end
       #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` to assert that the attribute allows nil.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :bio
+      #
+      #       validates_length_of :bio, minimum: 15, allow_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should validate_length_of(:bio).is_at_least(15).allow_nil }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_length_of(:bio).is_at_least(15).allow_nil
+      #     end
+      #
       # @return [ValidateLengthOfMatcher]
       #
       def validate_length_of(attr)
@@ -281,6 +302,11 @@ module Shoulda
           self
         end
 
+        def allow_nil
+          @options[:allow_nil] = true
+          self
+        end
+
         def simple_description
           description = "validate that the length of :#{@attribute}"
 
@@ -302,69 +328,102 @@ module Shoulda
 
         def matches?(subject)
           super(subject)
-          translate_messages!
-          lower_bound_matches? && upper_bound_matches?
+
+          lower_bound_matches? &&
+            upper_bound_matches? &&
+            allow_nil_matches?
         end
 
-        private
+        def does_not_match?(subject)
+          super(subject)
 
-        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])
-          end
+          lower_bound_does_not_match? ||
+            upper_bound_does_not_match? ||
+            allow_nil_does_not_match?
+        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])
-          end
+        private
+
+        def expects_to_allow_nil?
+          @options[:allow_nil]
         end
 
         def lower_bound_matches?
           disallows_lower_length? && allows_minimum_length?
         end
 
+        def lower_bound_does_not_match?
+          allows_lower_length? || disallows_minimum_length?
+        end
+
         def upper_bound_matches?
           disallows_higher_length? && allows_maximum_length?
         end
 
+        def upper_bound_does_not_match?
+          allows_higher_length? || disallows_maximum_length?
+        end
+
+        def allows_lower_length?
+          @options.key?(:minimum) &&
+            @options[:minimum] > 0 &&
+            allows_length_of?(
+              @options[:minimum] - 1,
+              translated_short_message
+            )
+        end
+
         def disallows_lower_length?
-          if @options.key?(:minimum)
+          !@options.key?(:minimum) ||
             @options[:minimum] == 0 ||
-              disallows_length_of?(@options[:minimum] - 1, @short_message)
-          else
-            true
-          end
+            disallows_length_of?(
+              @options[:minimum] - 1,
+              translated_short_message
+            )
+        end
+
+        def allows_higher_length?
+          @options.key?(:maximum) &&
+            allows_length_of?(
+              @options[:maximum] + 1,
+              translated_long_message
+            )
         end
 
         def disallows_higher_length?
-          if @options.key?(:maximum)
-            disallows_length_of?(@options[:maximum] + 1, @long_message)
-          else
-            true
-          end
+          !@options.key?(:maximum) ||
+            disallows_length_of?(
+              @options[:maximum] + 1,
+              translated_long_message
+            )
         end
 
         def allows_minimum_length?
-          if @options.key?(:minimum)
-            allows_length_of?(@options[:minimum], @short_message)
-          else
-            true
-          end
+          !@options.key?(:minimum) ||
+            allows_length_of?(@options[:minimum], translated_short_message)
+        end
+
+        def disallows_minimum_length?
+          @options.key?(:minimum) &&
+            disallows_length_of?(@options[:minimum], translated_short_message)
         end
 
         def allows_maximum_length?
-          if @options.key?(:maximum)
-            allows_length_of?(@options[:maximum], @long_message)
-          else
-            true
-          end
+          !@options.key?(:maximum) ||
+            allows_length_of?(@options[:maximum], translated_long_message)
+        end
+
+        def disallows_maximum_length?
+          @options.key?(:maximum) &&
+            disallows_length_of?(@options[:maximum], translated_long_message)
+        end
+
+        def allow_nil_matches?
+          !expects_to_allow_nil? || allows_value_of(nil)
+        end
+
+        def allow_nil_does_not_match?
+          expects_to_allow_nil? && disallows_value_of(nil)
         end
 
         def allows_length_of?(length, message)
@@ -378,6 +437,36 @@ module Shoulda
         def string_of_length(length)
           'x' * length
         end
+
+        def translated_short_message
+          @_translated_short_message ||=
+            if @short_message.is_a?(Symbol)
+              default_error_message(
+                @short_message,
+                model_name: @subject.class.to_s.underscore,
+                instance: @subject,
+                attribute: @attribute,
+                count: @options[:minimum]
+              )
+            else
+              @short_message
+            end
+        end
+
+        def translated_long_message
+          @_translated_long_message ||=
+            if @long_message.is_a?(Symbol)
+              default_error_message(
+                @long_message,
+                model_name: @subject.class.to_s.underscore,
+                instance: @subject,
+                attribute: @attribute,
+                count: @options[:maximum]
+              )
+            else
+              @long_message
+            end
+        end
       end
     end
   end

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

@@ -411,13 +411,13 @@ module Shoulda
         end
 
         def matches?(subject)
-          @subject = subject
-          @number_of_submatchers = @submatchers.size
-
-          add_disallow_value_matcher
-          qualify_submatchers
+          matches_or_does_not_match?(subject)
+          first_submatcher_that_fails_to_match.nil?
+        end
 
-          first_failing_submatcher.nil?
+        def does_not_match?(subject)
+          matches_or_does_not_match?(subject)
+          first_submatcher_that_fails_to_not_match.nil?
         end
 
         def simple_description
@@ -440,20 +440,14 @@ module Shoulda
         def failure_message
           overall_failure_message.dup.tap do |message|
             message << "\n"
-            message << failure_message_for_first_failing_submatcher
+            message << failure_message_for_first_submatcher_that_fails_to_match
           end
         end
 
         def 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
+            message << "\n"
+            message << failure_message_for_first_submatcher_that_fails_to_not_match
           end
         end
 
@@ -464,19 +458,25 @@ module Shoulda
 
         private
 
-        def model
-          @subject.class
+        def matches_or_does_not_match?(subject)
+          @subject = subject
+          @number_of_submatchers = @submatchers.size
+
+          add_disallow_value_matcher
+          qualify_submatchers
         end
 
         def overall_failure_message
           Shoulda::Matchers.word_wrap(
-            "#{model.name} did not properly #{description}."
+            "Expected #{model.name} to #{description}, but this could not " +
+            'be proved.'
           )
         end
 
         def overall_failure_message_when_negated
           Shoulda::Matchers.word_wrap(
-            "Expected #{model.name} not to #{description}, but it did."
+            "Expected #{model.name} not to #{description}, but this could not " +
+            'be proved.'
           )
         end
 
@@ -566,35 +566,49 @@ module Shoulda
           end
         end
 
-        def first_failing_submatcher
+        def first_submatcher_that_fails_to_match
           @_failing_submatchers ||= @submatchers.detect do |submatcher|
             !submatcher.matches?(@subject)
           end
         end
 
-        def submatcher_failure_message
-          first_failing_submatcher.failure_message
+        def first_submatcher_that_fails_to_not_match
+          @_failing_submatchers ||= @submatchers.detect do |submatcher|
+            !submatcher.does_not_match?(@subject)
+          end
         end
 
-        def submatcher_failure_message_when_negated
-          first_failing_submatcher.failure_message_when_negated
+        def failure_message_for_first_submatcher_that_fails_to_match
+          build_submatcher_failure_message_for(
+            first_submatcher_that_fails_to_match,
+            :failure_message
+          )
         end
 
-        def failure_message_for_first_failing_submatcher
-          submatcher = first_failing_submatcher
+        def failure_message_for_first_submatcher_that_fails_to_not_match
+          build_submatcher_failure_message_for(
+            first_submatcher_that_fails_to_not_match,
+            :failure_message_when_negated
+          )
+        end
 
-          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 =
+        def build_submatcher_failure_message_for(
+          submatcher,
+          failure_message_method
+        )
+          failure_message = submatcher.public_send(failure_message_method)
+          submatcher_description = submatcher.simple_description.
+            sub(/\bvalidate that\b/, 'validates').
+            sub(/\bdisallow\b/, 'disallows').
+            sub(/\ballow\b/, 'allows')
+          submatcher_message =
+            if number_of_submatchers_for_failure_message > 1
               "In checking that #{model.name} #{submatcher_description}, " +
-              submatcher.failure_message[0].downcase +
-              submatcher.failure_message[1..-1]
-          else
-            submatcher_message = submatcher.failure_message
-          end
+                failure_message[0].downcase +
+                failure_message[1..-1]
+            else
+              failure_message
+            end
 
           Shoulda::Matchers.word_wrap(submatcher_message, indent: 2)
         end
@@ -616,6 +630,10 @@ module Shoulda
             arr
           end
         end
+
+        def model
+          @subject.class
+        end
       end
     end
   end

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

@@ -119,14 +119,27 @@ module Shoulda
         def matches?(subject)
           super(subject)
 
+          possibly_ignore_interference_by_writer
+
           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 does_not_match?(subject)
+          super(subject)
+
+          possibly_ignore_interference_by_writer
+
+          if secure_password_being_validated?
+            allows_and_double_checks_value_of!(blank_value, @expected_message)
+          else
+            allows_original_or_typecast_value?(blank_value, @expected_message)
+          end
+        end
+
         def simple_description
           "validate that :#{@attribute} cannot be empty/falsy"
         end
@@ -139,6 +152,22 @@ module Shoulda
             @attribute == :password
         end
 
+        def possibly_ignore_interference_by_writer
+          if secure_password_being_validated?
+            ignore_interference_by_writer.default_to(when: :blank?)
+          end
+        end
+
+        def allows_and_double_checks_value_of!(value, message)
+          allows_value_of(value, message)
+        rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError
+          raise ActiveModel::CouldNotSetPasswordError.create(@subject.class)
+        end
+
+        def allows_original_or_typecast_value?(value, message)
+          allows_value_of(blank_value, @expected_message)
+        end
+
         def disallows_and_double_checks_value_of!(value, message)
           disallows_value_of(value, message)
         rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError

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

@@ -51,6 +51,11 @@ module Shoulda
           false
         end
 
+        def does_not_match?(subject)
+          @subject = subject
+          true
+        end
+
         def failure_message
           overall_failure_message.dup.tap do |message|
             if failure_reason.present?
@@ -65,10 +70,10 @@ module Shoulda
 
         def failure_message_when_negated
           overall_failure_message_when_negated.dup.tap do |message|
-            if failure_reason_when_negated.present?
+            if failure_reason.present?
               message << "\n"
               message << Shoulda::Matchers.word_wrap(
-                failure_reason_when_negated,
+                failure_reason,
                 indent: 2
               )
             end
@@ -115,13 +120,15 @@ module Shoulda
 
         def overall_failure_message
           Shoulda::Matchers.word_wrap(
-            "#{model.name} did not properly #{description}."
+            "Expected #{model.name} to #{description}, but this could not be " +
+            'proved.'
           )
         end
 
         def overall_failure_message_when_negated
           Shoulda::Matchers.word_wrap(
-            "Expected #{model.name} not to #{description}, but it did."
+            "Expected #{model.name} not to #{description}, but this could " +
+            'not be proved.'
           )
         end