shoulda-matchers 2.6.1 → 2.6.2

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

@@ -1,8 +1,10 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
+      # @private
       class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
 
+      # @private
       class NonNullableBooleanError < Shoulda::Matchers::Error
         def self.create(attribute)
           super(attribute: attribute)
@@ -19,6 +21,7 @@ Hence, this test will fail and there is no way to make it pass.
         end
       end
 
+      # @private
       class CouldNotSetPasswordError < Shoulda::Matchers::Error
         def self.create(model)
           super(model: model)

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

@@ -1,7 +1,7 @@
 module Shoulda
   module Matchers
     module ActiveModel
-      # Finds message information from exceptions thrown by #valid?
+      # @private
       class ExceptionMessageFinder
         def initialize(instance, attribute, context=nil)
           @instance = instance

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

@@ -1,16 +1,37 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
-
-      # Ensures that the model exhibits behavior added by has_secure_password.
+    module ActiveModel
+      # The `have_secure_password` matcher tests usage of the
+      # `has_secure_password` macro.
+      #
+      # #### Example
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       include ActiveModel::SecurePassword
+      #       attr_accessor :password
+      #
+      #       has_secure_password
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should have_secure_password }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_password
+      #     end
+      #
+      # @return [HaveSecurePasswordMatcher]
       #
-      # Example:
-      #   it { should have_secure_password }
       def have_secure_password
         HaveSecurePasswordMatcher.new
       end
 
-      class HaveSecurePasswordMatcher # :nodoc:
+      # @private
+      class HaveSecurePasswordMatcher
         attr_reader :failure_message
 
         alias failure_message_for_should failure_message
@@ -47,7 +68,7 @@ module Shoulda # :nodoc:
           failure.nil?
         end
 
-        private
+        protected
 
         attr_reader :subject
 

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

@@ -1,14 +1,26 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
+      # @private
       module Helpers
-        def pretty_error_messages(obj) # :nodoc:
-          obj.errors.map do |attribute, model|
-            msg = "#{attribute} #{model}"
-            if attribute.to_sym != :base && obj.respond_to?(attribute)
-              msg << " (#{obj.__send__(attribute).inspect})"
+        def pretty_error_messages(obj)
+          obj.errors.map do |attribute, message|
+            full_message = message.dup
+            parenthetical_parts = []
+
+            unless attribute.to_sym == :base
+              parenthetical_parts << "attribute: #{attribute.to_s.inspect}"
+
+              if obj.respond_to?(attribute)
+                parenthetical_parts << "value: #{obj.__send__(attribute).inspect}"
+              end
             end
-            msg
+
+            if parenthetical_parts.any?
+              full_message << " (#{parenthetical_parts.join(', ')})"
+            end
+
+            full_message
           end
         end
 

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

@@ -0,0 +1,9 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module NumericalityMatchers
+      end
+    end
+  end
+end

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

@@ -1,11 +1,8 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
       module NumericalityMatchers
-        # Examples:
-        #   it { should validate_numericality_of(:attr).
-        #                 is_greater_than(6).
-        #                 less_than(20)...(and so on) }
+        # @private
         class ComparisonMatcher < ValidationMatcher
           ERROR_MESSAGES = {
             :> => :greater_than,
@@ -24,6 +21,7 @@ module Shoulda # :nodoc:
             @operator = operator
             @message = ERROR_MESSAGES[operator]
             @comparison_combos = comparison_combos
+            @strict = false
           end
 
           def for(attribute)

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

@@ -1,8 +1,9 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
       module NumericalityMatchers
-        class EvenNumberMatcher < NumericTypeMatcher # :nodoc:
+        # @private
+        class EvenNumberMatcher < NumericTypeMatcher
           NON_EVEN_NUMBER_VALUE = 1
 
           def initialize(attribute, options = {})

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

@@ -1,7 +1,8 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
       module NumericalityMatchers
+        # @private
         class NumericTypeMatcher
           def initialize
             raise NotImplementedError

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

@@ -1,8 +1,9 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
       module NumericalityMatchers
-        class OddNumberMatcher < NumericTypeMatcher # :nodoc:
+        # @private
+        class OddNumberMatcher < NumericTypeMatcher
           NON_ODD_NUMBER_VALUE  = 2
 
           def initialize(attribute, options = {})

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

@@ -1,8 +1,9 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
+    module ActiveModel
       module NumericalityMatchers
-        class OnlyIntegerMatcher < NumericTypeMatcher # :nodoc:
+        # @private
+        class OnlyIntegerMatcher < NumericTypeMatcher
           NON_INTEGER_VALUE = 0.1
           def initialize(attribute)
             @attribute = attribute

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

@@ -1,24 +1,62 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
-
-      # Ensures that the model is not valid if the given attribute is present.
+    module ActiveModel
+      # The `validate_absence_of` matcher tests the usage of the
+      # `validates_absence_of` validation.
+      #
+      #     class Artillery
+      #       include ActiveModel::Model
+      #       attr_accessor :arms
+      #
+      #       validates_absence_of :arms
+      #     end
+      #
+      #     # RSpec
+      #     describe Artillery do
+      #       it { should validate_absence_of(:arms) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class ArtilleryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### with_message
       #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
-      #   Defaults to the translation for <tt>:present</tt>.
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Artillery
+      #       include ActiveModel::Model
+      #       attr_accessor :arms
+      #
+      #       validates_absence_of :arms,
+      #         message: "We're fresh outta arms here, soldier!"
+      #     end
+      #
+      #     # RSpec
+      #     describe Artillery do
+      #       it do
+      #         should validate_absence_of(:arms).
+      #           with_message("We're fresh outta arms here, soldier!")
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class ArtilleryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms).
+      #         with_message("We're fresh outta arms here, soldier!")
+      #     end
+      #
+      # @return [ValidateAbsenceOfMatcher}
       #
-      # Examples:
-      #   it { should validate_absence_of(:name) }
-      #   it { should validate_absence_of(:name).
-      #                 with_message(/may not be set/) }
       def validate_absence_of(attr)
         ValidateAbsenceOfMatcher.new(attr)
       end
 
-      class ValidateAbsenceOfMatcher < ValidationMatcher # :nodoc:
-
+      # @private
+      class ValidateAbsenceOfMatcher < ValidationMatcher
         def with_message(message)
           @expected_message = message
           self

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

@@ -1,24 +1,62 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
-
-      # Ensures that the model cannot be saved if the given attribute is not
-      # accepted.
+    module ActiveModel
+      # The `validate_acceptance_of` matcher tests usage of the
+      # `validates_acceptance_of` validation.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #       attr_accessor :eula
+      #
+      #       validates_acceptance_of :eula
+      #     end
+      #
+      #     # RSpec
+      #     describe Registration do
+      #       it { should validate_acceptance_of(:eula) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:eula)
+      #     end
+      #
+      # #### Qualifiers
       #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
-      #   translation for <tt>:accepted</tt>.
+      # ##### with_message
       #
-      # Example:
-      #   it { should validate_acceptance_of(:eula) }
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #       attr_accessor :terms_of_service
+      #
+      #       validates_acceptance_of :terms_of_service,
+      #         message: 'You must accept the terms of service'
+      #     end
+      #
+      #     # RSpec
+      #     describe Registration do
+      #       it do
+      #         should validate_acceptance_of(:terms_of_service).
+      #           with_message('You must accept the terms of service')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms_of_service).
+      #         with_message('You must accept the terms of service')
+      #     end
+      #
+      # @return [ValidateAcceptanceOfMatcher]
       #
       def validate_acceptance_of(attr)
         ValidateAcceptanceOfMatcher.new(attr)
       end
 
-      class ValidateAcceptanceOfMatcher < ValidationMatcher # :nodoc:
-
+      # @private
+      class ValidateAcceptanceOfMatcher < ValidationMatcher
         def with_message(message)
           if message
             @expected_message = message

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

@@ -1,22 +1,68 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
-      # Ensures that the model's attribute matches confirmation
+    module ActiveModel
+      # The `validate_confirmation_of` matcher tests usage of the
+      # `validates_confirmation_of` validation.
       #
-      # Example:
-      #   it { should validate_confirmation_of(:password) }
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :email
+      #
+      #       validates_confirmation_of :email
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should validate_confirmation_of(:email) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:email)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password
+      #
+      #       validates_confirmation_of :password,
+      #         message: 'Please re-enter your password'
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it do
+      #         should validate_confirmation_of(:password).
+      #           with_message('Please re-enter your password')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password).
+      #         with_message('Please re-enter your password')
+      #     end
+      #
+      # @return [ValidateConfirmationOfMatcher]
       #
       def validate_confirmation_of(attr)
         ValidateConfirmationOfMatcher.new(attr)
       end
 
-      class ValidateConfirmationOfMatcher < ValidationMatcher # :nodoc:
+      # @private
+      class ValidateConfirmationOfMatcher < ValidationMatcher
         include Helpers
 
         attr_reader :attribute, :confirmation_attribute
 
         def initialize(attribute)
-          @attribute = attribute
+          super(attribute)
           @confirmation_attribute = "#{attribute}_confirmation"
         end
 

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

@@ -1,28 +1,284 @@
-module Shoulda # :nodoc:
+module Shoulda
   module Matchers
-    module ActiveModel # :nodoc:
-      # Ensure that the attribute is numeric.
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
-      #   translation for <tt>:not_a_number</tt>.
-      # * <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 }
+    module ActiveModel
+      # The `validate_numericality_of` matcher tests usage of the
+      # `validates_numericality_of` validation.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :gpa
+      #
+      #       validates_numericality_of :gpa
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:gpa) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:gpa)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### only_integer
+      #
+      # Use `only_integer` to test usage of the `:only_integer` option. This
+      # asserts that your attribute only allows integer numbers and disallows
+      # non-integer ones.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :age
+      #
+      #       validates_numericality_of :age, only_integer: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:age).only_integer }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:age).only_integer
+      #     end
+      #
+      # ##### is_less_than
+      #
+      # Use `is_less_than` to test usage of the the `:less_than` option. This
+      # asserts that the attribute can take a number which is less than the
+      # given value and cannot take a number which is greater than or equal to
+      # it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :number_of_cars
+      #
+      #       validates_numericality_of :number_of_cars, less_than: 2
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:number_of_cars).
+      #           is_less_than(2)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:number_of_cars).
+      #         is_less_than(2)
+      #     end
+      #
+      # ##### is_less_than_or_equal_to
+      #
+      # Use `is_less_than_or_equal_to` to test usage of the
+      # `:less_than_or_equal_to` option. This asserts that the attribute can
+      # take a number which is less than or equal to the given value and cannot
+      # take a number which is greater than it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :birth_year
+      #
+      #       validates_numericality_of :birth_year, less_than_or_equal_to: 1987
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:birth_year).
+      #           is_less_than_or_equal_to(1987)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_year).
+      #         is_less_than_or_equal_to(1987)
+      #     end
+      #
+      # ##### is_equal_to
+      #
+      # Use `is_equal_to` to test usage of the `:equal_to` option. This asserts
+      # that the attribute can take a number which is equal to the given value
+      # and cannot take a number which is not equal.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :weight
+      #
+      #       validates_numericality_of :weight, equal_to: 150
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:weight).is_equal_to(150) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:weight).is_equal_to(150)
+      #     end
+      #
+      # ##### is_greater_than_or_equal_to
+      #
+      # Use `is_greater_than_or_equal_to` to test usage of the
+      # `:greater_than_or_equal_to` option. This asserts that the attribute can
+      # take a number which is greater than or equal to the given value and
+      # cannot take a number which is less than it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :height
+      #
+      #       validates_numericality_of :height, greater_than_or_equal_to: 55
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:height).
+      #           is_greater_than_or_equal_to(55)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:height).
+      #         is_greater_than_or_equal_to(55)
+      #     end
+      #
+      # ##### is_greater_than
+      #
+      # Use `is_greater_than` to test usage of tthe `:greater_than` option.
+      # This asserts that the attribute can take a number which is greater than
+      # the given value and cannot take a number less than or equal to it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :legal_age
+      #
+      #       validates_numericality_of :legal_age, greater_than: 21
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:legal_age).
+      #           is_greater_than(21)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:legal_age).
+      #         is_greater_than(21)
+      #     end
+      #
+      # ##### even
+      #
+      # Use `even` to test usage of the `:even` option. This asserts that the
+      # attribute can take odd numbers and cannot take even ones.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :birth_month
+      #
+      #       validates_numericality_of :birth_month, even: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:birth_month).even }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_month).even
+      #     end
+      #
+      # ##### odd
+      #
+      # Use `odd` to test usage of the `:odd` option. This asserts that the
+      # attribute can take a number which is odd and cannot take a number which
+      # is even.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :birth_day
+      #
+      #       validates_numericality_of :birth_day, odd: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:birth_day).odd }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_day).odd
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :number_of_dependents
+      #
+      #       validates_numericality_of :number_of_dependents,
+      #         message: 'Number of dependents must be a number'
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:number_of_dependents).
+      #           with_message('Number of dependents must be a number')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:number_of_dependents).
+      #         with_message('Number of dependents must be a number')
+      #     end
+      #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` to assert that the attribute allows nil.
+      #
+      #     class Age
+      #       include ActiveModel::Model
+      #       attr_accessor :age
+      #
+      #       validates_numericality_of :age, allow_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it { should validate_numericality_of(:age).allow_nil }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:age).allow_nil
+      #     end
+      #
+      # @return [ValidateNumericalityOfMatcher]
       #
       def validate_numericality_of(attr)
         ValidateNumericalityOfMatcher.new(attr)
       end
 
+      # @private
       class ValidateNumericalityOfMatcher
         NUMERIC_NAME = 'numbers'
         NON_NUMERIC_VALUE = 'abcd'