shoulda-matchers 2.8.0.rc1 → 2.8.0.rc2

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

@@ -42,25 +42,80 @@ module Shoulda
             "#{expectation} #{@value}"
           end
 
+          def failure_message
+            last_failing_submatcher.failure_message
+          end
+          alias failure_message_for_should failure_message
+
+          def failure_message_when_negated
+            last_failing_submatcher.failure_message_when_negated
+          end
+          alias failure_message_for_should_not failure_message_when_negated
+
           private
 
+          def all_bounds_correct?
+            failing_submatchers.empty?
+          end
+
+          def failing_submatchers
+            submatchers_and_results.
+              select { |x| !x[:matched] }.
+              map { |x| x[:matcher] }
+          end
+
+          def last_failing_submatcher
+            failing_submatchers.last
+          end
+
+          def submatchers
+            @_submatchers ||=
+              comparison_combos.map do |diff, submatcher_method_name|
+                matcher = __send__(submatcher_method_name, @value + diff, nil)
+                matcher.with_message(@message, values: { count: @value })
+                matcher
+              end
+          end
+
+          def submatchers_and_results
+            @_submatchers_and_results ||=
+              submatchers.map do |matcher|
+                { matcher: matcher, matched: matcher.matches?(@subject) }
+              end
+          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]
+            diffs_to_compare.zip(submatcher_method_names)
+          end
+
+          def submatcher_method_names
+            assertions.map do |value|
+              if value
+                :allow_value_matcher
+              else
+                :disallow_value_matcher
               end
-            diffs_to_compare.zip(checker_types)
+            end
+          end
+
+          def assertions
+            case @operator
+            when :>
+              [false, false, true]
+            when :>=
+              [false, true, true]
+            when :==
+              [false, true, false]
+            when :<
+              [true, false, false]
+            when :<=
+              [true, true, false]
+            end
           end
 
           def diffs_to_compare
             diff = @numericality_matcher.diff_to_compare
-            [diff, 0, -diff]
+            [-diff, 0, diff]
           end
 
           def expectation
@@ -72,14 +127,6 @@ module Shoulda
               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) do |matcher|
-                matcher.with_message(@message, values: { count: @value })
-              end
-            end
-          end
         end
       end
     end

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

@@ -0,0 +1,51 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module StrictValidator
+        def allow_description(allowed_values)
+          "doesn't raise when #{attribute} is set to #{allowed_values}"
+        end
+
+        def expected_message_from(attribute_message)
+          "#{human_attribute_name} #{attribute_message}"
+        end
+
+        def formatted_messages
+          [messages.first.message]
+        end
+
+        def messages_description
+          if has_messages?
+            ': ' + messages.first.message.inspect
+          else
+            ' no exception'
+          end
+        end
+
+        def expected_messages_description(expected_message)
+          if expected_message
+            "exception to include #{expected_message.inspect}"
+          else
+            'an exception to have been raised'
+          end
+        end
+
+        protected
+
+        def collect_messages
+          validation_exceptions
+        end
+
+        private
+
+        def validation_exceptions
+          record.valid?(context)
+          []
+        rescue ::ActiveModel::StrictValidationFailed => exception
+          [exception]
+        end
+      end
+    end
+  end
+end

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

@@ -355,7 +355,7 @@ module Shoulda
 
         def matches?(subject)
           @subject = subject
-          submatchers_match?
+          failing_submatchers.empty?
         end
 
         def description
@@ -363,12 +363,12 @@ module Shoulda
         end
 
         def failure_message
-          submatcher_failure_messages_for_should.last
+          last_failing_submatcher.failure_message
         end
         alias failure_message_for_should failure_message
 
         def failure_message_when_negated
-          submatcher_failure_messages_for_should_not.last
+          last_failing_submatcher.failure_message_when_negated
         end
         alias failure_message_for_should_not failure_message_when_negated
 
@@ -403,20 +403,21 @@ module Shoulda
           @diff_to_compare = [@diff_to_compare, matcher.diff_to_compare].max
         end
 
-        def submatchers_match?
-          failing_submatchers.empty?
-        end
-
-        def submatcher_failure_messages_for_should
-          failing_submatchers.map(&:failure_message)
+        def submatchers_and_results
+          @_submatchers_and_results ||=
+            @submatchers.map do |matcher|
+              { matcher: matcher, matched: matcher.matches?(@subject) }
+            end
         end
 
-        def submatcher_failure_messages_for_should_not
-          failing_submatchers.map(&:failure_message_when_negated)
+        def failing_submatchers
+          submatchers_and_results.
+            select { |x| !x[:matched] }.
+            map { |x| x[:matcher] }
         end
 
-        def failing_submatchers
-          @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject) }
+        def last_failing_submatcher
+          failing_submatchers.last
         end
 
         def allowed_types

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

@@ -0,0 +1,113 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class Validator
+        include Helpers
+
+        attr_writer :attribute, :context, :record
+
+        def initialize
+          reset
+        end
+
+        def reset
+          @messages = nil
+        end
+
+        def strict=(strict)
+          @strict = strict
+
+          if strict
+            extend StrictValidator
+          end
+        end
+
+        def capture_range_error(exception)
+          @captured_range_error = exception
+          extend ValidatorWithCapturedRangeError
+        end
+
+        def allow_description(allowed_values)
+          "allow #{attribute} to be set to #{allowed_values}"
+        end
+
+        def expected_message_from(attribute_message)
+          attribute_message
+        end
+
+        def messages
+          @messages ||= collect_messages
+        end
+
+        def formatted_messages
+          messages
+        end
+
+        def has_messages?
+          messages.any?
+        end
+
+        def messages_description
+          if has_messages?
+            " errors:\n#{pretty_error_messages(record)}"
+          else
+            ' no errors'
+          end
+        end
+
+        def expected_messages_description(expected_message)
+          if expected_message
+            "errors to include #{expected_message.inspect}"
+          else
+            'errors'
+          end
+        end
+
+        def captured_range_error?
+          !!captured_range_error
+        end
+
+        protected
+
+        attr_reader :attribute, :context, :strict, :record,
+          :captured_range_error
+
+        def collect_messages
+          validation_errors
+        end
+
+        private
+
+        def strict?
+          !!@strict
+        end
+
+        def collect_errors_or_exceptions
+          collect_messages
+        rescue RangeError => exception
+          capture_range_error(exception)
+          []
+        end
+
+        def validation_errors
+          if context
+            record.valid?(context)
+          else
+            record.valid?
+          end
+
+          if record.errors.respond_to?(:[])
+            record.errors[attribute]
+          else
+            record.errors.on(attribute)
+          end
+        end
+
+        def human_attribute_name
+          record.class.human_attribute_name(attribute)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module ValidatorWithCapturedRangeError
+        def messages_description
+          ' RangeError: ' + captured_range_error.message.inspect
+        end
+      end
+    end
+  end
+end

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

@@ -162,6 +162,24 @@ module Shoulda
       #       should belong_to(:world).dependent(:destroy)
       #     end
       #
+      # To assert that *any* `:dependent` option was specified, use `true`:
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should belong_to(:world).dependent(true) }
+      #     end
+      #
+      # To assert that *no* `:dependent` option was specified, use `false`:
+      #
+      #     class Person < ActiveRecord::Base
+      #       belongs_to :company
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should belong_to(:company).dependent(false) }
+      #     end
+      #
       # ##### counter_cache
       #
       # Use `counter_cache` to assert that the `:counter_cache` option was
@@ -993,7 +1011,7 @@ module Shoulda
         end
 
         def macro_supports_primary_key?
-          macro == :belongs_to || 
+          macro == :belongs_to ||
             ([:has_many, :has_one].include?(macro) && !through?)
         end
 

data/lib/shoulda/matchers/active_record/association_matchers/dependent_matcher.rb

@@ -19,10 +19,10 @@ module Shoulda
           def matches?(subject)
             self.subject = ModelReflector.new(subject, name)
 
-            if option_verifier.correct_for_string?(:dependent, dependent)
+            if option_matches?
               true
             else
-              self.missing_option = "#{name} should have #{dependent} dependency"
+              self.missing_option = generate_missing_option
               false
             end
           end
@@ -31,9 +31,30 @@ module Shoulda
 
           attr_accessor :subject, :dependent, :name
 
+          private
+
           def option_verifier
             @option_verifier ||= OptionVerifier.new(subject)
           end
+
+          def option_matches?
+            option_verifier.correct_for?(option_type, :dependent, dependent)
+          end
+
+          def option_type
+            case dependent
+              when true, false then :boolean
+              else :string
+            end
+          end
+
+          def generate_missing_option
+            [
+              "#{name} should have",
+              (dependent == true ? 'a' : dependent),
+              'dependency'
+            ].join(' ')
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_record/association_matchers/option_verifier.rb

@@ -32,6 +32,20 @@ module Shoulda
             correct_for?(:relation_clause, name, expected_value)
           end
 
+          def correct_for?(*args)
+            expected_value, name, type = args.reverse
+            if expected_value.nil?
+              true
+            else
+              expected_value = type_cast(
+                type,
+                expected_value_for(type, name, expected_value)
+              )
+              actual_value = type_cast(type, actual_value_for(name))
+              expected_value == actual_value
+            end
+          end
+
           def actual_value_for(name)
             if RELATION_OPTIONS.include?(name)
               actual_value_for_relation_clause(name)
@@ -49,17 +63,6 @@ module Shoulda
 
           attr_reader :reflector
 
-          def correct_for?(*args)
-            expected_value, name, type = args.reverse
-            if expected_value.nil?
-              true
-            else
-              expected_value = type_cast(type, expected_value_for(type, name, expected_value))
-              actual_value = type_cast(type, actual_value_for(name))
-              expected_value == actual_value
-            end
-          end
-
           def type_cast(type, value)
             case type
               when :string, :relation_clause then value.to_s