shoulda-matchers 1.1.0 → 1.2.0

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

@@ -2,7 +2,8 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
 
-      # Ensures that the length of the attribute is validated.
+      # Ensures that the length of the attribute is validated. Only works with
+      # string/text columns because it uses a string to check length.
       #
       # Options:
       # * <tt>is_at_least</tt> - minimum length of this attribute
@@ -36,47 +37,56 @@ module Shoulda # :nodoc:
       class EnsureLengthOfMatcher < ValidationMatcher # :nodoc:
         include Helpers
 
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+        end
+
         def is_at_least(length)
-          @minimum = length
+          @options[:minimum] = length
           @short_message ||= :too_short
           self
         end
 
         def is_at_most(length)
-          @maximum = length
+          @options[:maximum] = length
           @long_message ||= :too_long
           self
         end
 
         def is_equal_to(length)
-          @minimum = length
-          @maximum = length
+          @options[:minimum] = length
+          @options[:maximum] = length
           @short_message ||= :wrong_length
           self
         end
 
         def with_short_message(message)
-          @short_message = message if message
+          if message
+            @short_message = message
+          end
           self
         end
         alias_method :with_message, :with_short_message
 
         def with_long_message(message)
-          @long_message = message if message
+          if message
+            @long_message = message
+          end
           self
         end
 
         def description
           description =  "ensure #{@attribute} has a length "
-          if @minimum && @maximum
-            if @minimum == @maximum
-              description << "of exactly #{@minimum}"
+          if @options.key?(:minimum) && @options.key?(:maximum)
+            if @options[:minimum] == @options[:maximum]
+              description << "of exactly #{@options[:minimum]}"
             else
-              description << "between #{@minimum} and #{@maximum}"
+              description << "between #{@options[:minimum]} and #{@options[:maximum]}"
             end
           else
-            description << "of at least #{@minimum}" if @minimum
-            description << "of at most #{@maximum}" if @maximum
+            description << "of at least #{@options[:minimum]}" if @options[:minimum]
+            description << "of at most #{@options[:maximum]}" if @options[:maximum]
           end
           description
         end
@@ -84,11 +94,7 @@ module Shoulda # :nodoc:
         def matches?(subject)
           super(subject)
           translate_messages!
-          disallows_lower_length &&
-            allows_minimum_length &&
-            ((@minimum == @maximum) ||
-              (disallows_higher_length &&
-              allows_maximum_length))
+          lower_bound_matches? && upper_bound_matches?
         end
 
         private
@@ -96,39 +102,66 @@ module Shoulda # :nodoc:
         def translate_messages!
           if Symbol === @short_message
             @short_message = default_error_message(@short_message,
-                                                   :count => @minimum)
+                                                   :model_name => @subject.class.to_s.underscore,
+                                                   :attribute => @attribute,
+                                                   :count => @options[:minimum])
           end
 
           if Symbol === @long_message
             @long_message = default_error_message(@long_message,
-                                                  :count => @maximum)
+                                                  :model_name => @subject.class.to_s.underscore,
+                                                  :attribute => @attribute,
+                                                  :count => @options[:maximum])
           end
         end
 
-        def disallows_lower_length
-          @minimum == 0 ||
-            @minimum.nil? ||
-            disallows_length_of(@minimum - 1, @short_message)
+        def lower_bound_matches?
+          disallows_lower_length? && allows_minimum_length?
+        end
+
+        def upper_bound_matches?
+          disallows_higher_length? && allows_maximum_length?
+        end
+
+        def disallows_lower_length?
+          if @options.key?(:minimum)
+            @options[:minimum] == 0 ||
+              disallows_length_of?(@options[:minimum] - 1, @short_message)
+          else
+            true
+          end
         end
 
-        def disallows_higher_length
-          @maximum.nil? || disallows_length_of(@maximum + 1, @long_message)
+        def disallows_higher_length?
+          if @options.key?(:maximum)
+            disallows_length_of?(@options[:maximum] + 1, @long_message)
+          else
+            true
+          end
         end
 
-        def allows_minimum_length
-          allows_length_of(@minimum, @short_message)
+        def allows_minimum_length?
+          if @options.key?(:minimum)
+            allows_length_of?(@options[:minimum], @short_message)
+          else
+            true
+          end
         end
 
-        def allows_maximum_length
-          allows_length_of(@maximum, @long_message)
+        def allows_maximum_length?
+          if @options.key?(:maximum)
+            allows_length_of?(@options[:maximum], @long_message)
+          else
+            true
+          end
         end
 
-        def allows_length_of(length, message)
-          length.nil? || allows_value_of(string_of_length(length), message)
+        def allows_length_of?(length, message)
+          allows_value_of(string_of_length(length), message)
         end
 
-        def disallows_length_of(length, message)
-          length.nil? || disallows_value_of(string_of_length(length), message)
+        def disallows_length_of?(length, message)
+          disallows_value_of(string_of_length(length), message)
         end
 
         def string_of_length(length)

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

@@ -20,7 +20,9 @@ module Shoulda # :nodoc:
       class ValidateAcceptanceOfMatcher < ValidationMatcher # :nodoc:
 
         def with_message(message)
-          @expected_message = message if message
+          if message
+            @expected_message = message
+          end
           self
         end
 
@@ -33,9 +35,7 @@ module Shoulda # :nodoc:
         def description
           "require #{@attribute} to be accepted"
         end
-
       end
-
     end
   end
 end

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

@@ -1,7 +1,7 @@
 module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
-      # Ensure that the attribute is numeric
+      # Ensure that the attribute is numeric.
       #
       # Options:
       # * <tt>with_message</tt> - value the test expects to find in
@@ -18,9 +18,13 @@ module Shoulda # :nodoc:
       end
 
       class ValidateNumericalityOfMatcher < ValidationMatcher # :nodoc:
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+        end
 
         def only_integer
-          @only_integer = true
+          @options[:only_integer] = true
           self
         end
 
@@ -43,7 +47,7 @@ module Shoulda # :nodoc:
         private
 
         def allowed_type
-          if @only_integer
+          if @options[:only_integer]
             "integer"
           else
             "numeric"
@@ -51,9 +55,9 @@ module Shoulda # :nodoc:
         end
 
         def disallows_non_integers?
-          if @only_integer
+          if @options[:only_integer]
             message = @expected_message || :not_an_integer
-            disallows_value_of(0.1, message) && disallows_value_of('0.1', message)
+            disallows_value_of(0.1, message)
           else
             true
           end

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

@@ -47,15 +47,18 @@ module Shoulda # :nodoc:
         end
 
         def collection?
-          if @subject.class.respond_to?(:reflect_on_association) &&
-              reflection = @subject.class.reflect_on_association(@attribute)
+          if reflection
             [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
           else
             false
           end
         end
-      end
 
+        def reflection
+          @subject.class.respond_to?(:reflect_on_association) &&
+            @subject.class.reflect_on_association(@attribute)
+        end
+      end
     end
   end
 end

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

@@ -38,11 +38,12 @@ module Shoulda # :nodoc:
         include Helpers
 
         def initialize(attribute)
-          @attribute = attribute
+          super(attribute)
+          @options = {}
         end
 
         def scoped_to(*scopes)
-          @scopes = [*scopes].flatten
+          @options[:scopes] = [*scopes].flatten
           self
         end
 
@@ -52,30 +53,30 @@ module Shoulda # :nodoc:
         end
 
         def case_insensitive
-          @case_insensitive = true
+          @options[:case_insensitive] = true
           self
         end
 
         def description
           result = "require "
-          result << "case sensitive " unless @case_insensitive
+          result << "case sensitive " unless @options[:case_insensitive]
           result << "unique value for #{@attribute}"
-          result << " scoped to #{@scopes.join(', ')}" unless @scopes.blank?
+          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
           result
         end
 
         def matches?(subject)
           @subject = subject.class.new
           @expected_message ||= :taken
-          find_existing &&
+          has_existing? &&
             set_scoped_attributes &&
-            validate_attribute &&
-            validate_after_scope_change
+            validate_attribute? &&
+            validate_after_scope_change?
         end
 
         private
 
-        def find_existing
+        def has_existing?
           if @existing = @subject.class.find(:first)
             true
           else
@@ -85,32 +86,34 @@ module Shoulda # :nodoc:
         end
 
         def set_scoped_attributes
-          unless @scopes.blank?
-            @scopes.each do |scope|
+          if @options[:scopes].present?
+            @options[:scopes].all? do |scope|
               setter = :"#{scope}="
-              unless @subject.respond_to?(setter)
-                @failure_message =
-                  "#{class_name} doesn't seem to have a #{scope} attribute."
-                return false
+              if @subject.respond_to?(setter)
+                @subject.send("#{scope}=", @existing.send(scope))
+                true
+              else
+                @failure_message = "#{class_name} doesn't seem to have a #{scope} attribute."
+                false
               end
-              @subject.send("#{scope}=", @existing.send(scope))
             end
+          else
+            true
           end
-          true
         end
 
-        def validate_attribute
+        def validate_attribute?
           disallows_value_of(existing_value, @expected_message)
         end
 
         # TODO:  There is a chance that we could change the scoped field
         # to a value that's already taken.  An alternative implementation
         # could actually find all values for scope and create a unique
-        def validate_after_scope_change
-          if @scopes.blank?
+        def validate_after_scope_change?
+          if @options[:scopes].blank?
             true
           else
-            @scopes.all? do |scope|
+            @options[:scopes].all? do |scope|
               previous_value = @existing.send(scope)
 
               # Assume the scope is a foreign key if the field is nil
@@ -142,11 +145,12 @@ module Shoulda # :nodoc:
 
         def existing_value
           value = @existing.send(@attribute)
-          value.swapcase! if @case_insensitive && value.respond_to?(:swapcase!)
+          if @options[:case_insensitive] && value.respond_to?(:swapcase!)
+            value.swapcase!
+          end
           value
         end
       end
-
     end
   end
 end

data/lib/shoulda/matchers/active_record/accept_nested_attributes_for_matcher.rb

@@ -24,21 +24,21 @@ module Shoulda
       class AcceptNestedAttributesForMatcher
         def initialize(name)
           @name = name
-          self
+          @options = {}
         end
 
         def allow_destroy(allow_destroy)
-          @allow_destroy = allow_destroy
+          @options[:allow_destroy] = allow_destroy
           self
         end
 
         def limit(limit)
-          @limit = limit
+          @options[:limit] = limit
           self
         end
 
         def update_only(update_only)
-          @update_only = update_only
+          @options[:update_only] = update_only
           self
         end
 
@@ -60,9 +60,15 @@ module Shoulda
 
         def description
           description = "accepts_nested_attributes_for :#{@name}"
-          description += " allow_destroy => #{@allow_destroy}" if @allow_destroy
-          description += " limit => #{@limit}" if @limit
-          description += " update_only => #{@update_only}" if @update_only
+          if @options.key?(:allow_destroy)
+            description += " allow_destroy => #{@options[:allow_destroy]}"
+          end
+          if @options.key?(:limit)
+            description += " limit => #{@options[:limit]}"
+          end
+          if @options.key?(:update_only)
+            description += " update_only => #{@options[:update_only]}"
+          end
           description
         end
 
@@ -78,31 +84,30 @@ module Shoulda
         end
 
         def allow_destroy_correct?
-          if @allow_destroy.nil? || @allow_destroy == config[:allow_destroy]
-            true
-          else
-            @problem = (@allow_destroy ? "should" : "should not") +
-              " allow destroy"
-            false
-          end
+          failure_message = "#{should_or_should_not(@options[:allow_destroy])} allow destroy"
+          verify_option_is_correct(:allow_destroy, failure_message)
         end
 
         def limit_correct?
-          if @limit.nil? || @limit == config[:limit]
-            true
-          else
-            @problem = "limit should be #@limit, got #{config[:limit]}"
-            false
-          end
+          failure_message = "limit should be #{@options[:limit]}, got #{config[:limit]}"
+          verify_option_is_correct(:limit, failure_message)
         end
 
         def update_only_correct?
-          if @update_only.nil? || @update_only == config[:update_only]
-            true
+          failure_message = "#{should_or_should_not(@options[:update_only])} be update only"
+          verify_option_is_correct(:update_only, failure_message)
+        end
+
+        def verify_option_is_correct(option, failure_message)
+          if @options.key?(option)
+            if @options[option] == config[option]
+              true
+            else
+              @problem = failure_message
+              false
+            end
           else
-            @problem = (@update_only ? "should" : "should not") +
-              " be update only"
-            false
+            true
           end
         end
 
@@ -121,6 +126,14 @@ module Shoulda
         def expectation
           "#{model_class.name} to accept nested attributes for #{@name}"
         end
+
+        def should_or_should_not(value)
+          if value
+            "should"
+          else
+            "should not"
+          end
+        end
       end
     end
   end