shoulda-matchers 3.0.1 → 3.1.0

data/lib/shoulda/matchers/active_model/allow_value_matcher/successful_check.rb

@@ -0,0 +1,14 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class SuccessfulCheck
+          def successful?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/allow_value_matcher/successful_setting.rb

@@ -0,0 +1,14 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class SuccessfulSetting
+          def successful?
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,46 +7,66 @@ module Shoulda
       class DisallowValueMatcher
         extend Forwardable
 
-        def_delegators :allow_matcher, :_after_setting_value
+        def_delegators(
+          :allow_matcher,
+          :_after_setting_value,
+          :attribute_changed_value_message=,
+          :attribute_to_set,
+          :description,
+          :expects_strict?,
+          :failure_message_preface,
+          :failure_message_preface=,
+          :ignore_interference_by_writer,
+          :last_attribute_setter_used,
+          :last_value_set,
+          :model,
+          :simple_description,
+          :values_to_preset=,
+        )
+
         def initialize(value)
           @allow_matcher = AllowValueMatcher.new(value)
         end
 
         def matches?(subject)
-          !@allow_matcher.matches?(subject)
+          allow_matcher.does_not_match?(subject)
+        end
+
+        def does_not_match?(subject)
+          allow_matcher.matches?(subject)
         end
 
         def for(attribute)
-          @allow_matcher.for(attribute)
+          allow_matcher.for(attribute)
           self
         end
 
         def on(context)
-          @allow_matcher.on(context)
+          allow_matcher.on(context)
           self
         end
 
         def with_message(message, options={})
-          @allow_matcher.with_message(message, options)
+          allow_matcher.with_message(message, options)
           self
         end
 
-        def ignoring_interference_by_writer
-          @allow_matcher.ignoring_interference_by_writer
+        def strict(strict = true)
+          allow_matcher.strict(strict)
           self
         end
 
-        def failure_message
-          @allow_matcher.failure_message_when_negated
+        def ignoring_interference_by_writer(value = :always)
+          allow_matcher.ignoring_interference_by_writer(value)
+          self
         end
 
-        def failure_message_when_negated
-          @allow_matcher.failure_message
+        def failure_message
+          allow_matcher.failure_message_when_negated
         end
 
-        def strict
-          @allow_matcher.strict
-          self
+        def failure_message_when_negated
+          allow_matcher.failure_message
         end
 
         protected

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

@@ -3,25 +3,17 @@ module Shoulda
     module ActiveModel
       # @private
       module Helpers
-        def pretty_error_messages(obj)
-          obj.errors.map do |attribute, message|
-            full_message = message.dup.inspect
-            parenthetical_parts = []
-
-            unless attribute.to_sym == :base
-              parenthetical_parts << "attribute: #{attribute}"
-
-              if obj.respond_to?(attribute)
-                parenthetical_parts << "value: #{obj.__send__(attribute).inspect}"
-              end
-            end
+        def pretty_error_messages(object)
+          format_validation_errors(object.errors)
+        end
 
-            if parenthetical_parts.any?
-              full_message << " (#{parenthetical_parts.join(', ')})"
-            end
+        def format_validation_errors(errors)
+          list_items = errors.keys.map do |attribute|
+            messages = errors[attribute]
+            "* #{attribute}: #{messages}"
+          end
 
-            "* " + full_message
-          end.join("\n")
+          list_items.join("\n")
         end
 
         def default_error_message(type, options = {})

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

@@ -13,6 +13,7 @@ module Shoulda
           }
 
           def initialize(numericality_matcher, value, operator)
+            super(nil)
             unless numericality_matcher.respond_to? :diff_to_compare
               raise ArgumentError, 'numericality_matcher is invalid'
             end
@@ -20,17 +21,18 @@ module Shoulda
             @value = value
             @operator = operator
             @message = ERROR_MESSAGES[operator]
-            @strict = false
           end
 
-          def description
-            message = "validate that #{@attribute} is #{comparison_expectation} #{@value}"
+          def simple_description
+            description = ''
 
-            if @strict
-              message << " strictly"
+            if expects_strict?
+              description << ' strictly'
             end
 
-            message
+            description +
+              "disallow :#{attribute} from being a number that is not " +
+              "#{comparison_expectation} #{@value}"
           end
 
           def for(attribute)
@@ -39,10 +41,15 @@ module Shoulda
           end
 
           def with_message(message)
+            @expects_custom_validation_message = true
             @message = message
             self
           end
 
+          def expects_custom_validation_message?
+            @expects_custom_validation_message
+          end
+
           def matches?(subject)
             @subject = subject
             all_bounds_correct?

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

@@ -6,8 +6,19 @@ module Shoulda
         class EvenNumberMatcher < NumericTypeMatcher
           NON_EVEN_NUMBER_VALUE = 1
 
-          def allowed_type
-            'even numbers'
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << 'strictly '
+            end
+
+            description +
+              "disallow :#{attribute} from being an odd number"
+          end
+
+          def allowed_type_adjective
+            'even'
           end
 
           def diff_to_compare

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

@@ -8,35 +8,31 @@ module Shoulda
         class NumericTypeMatcher
           extend Forwardable
 
-          def_delegators :disallow_value_matcher, :matches?, :failure_message,
-            :failure_message_when_negated
-
-          def initialize(numeric_type_matcher, attribute, options = {})
+          def_delegators(
+            :disallow_value_matcher,
+            :expects_custom_validation_message?,
+            :expects_strict?,
+            :failure_message,
+            :failure_message_when_negated,
+            :ignore_interference_by_writer,
+            :ignoring_interference_by_writer,
+            :matches?,
+            :on,
+            :strict,
+            :with_message,
+          )
+
+          def initialize(numeric_type_matcher, attribute)
             @numeric_type_matcher = numeric_type_matcher
             @attribute = attribute
-            @options = options
-            @message = nil
-            @context = nil
-            @strict = false
-          end
-
-          def with_message(message)
-            @message = message
-            self
           end
 
-          def strict
-            @strict = true
-            self
+          def allowed_type_name
+            'number'
           end
 
-          def on(context)
-            @context = context
-            self
-          end
-
-          def allowed_type
-            raise NotImplementedError
+          def allowed_type_adjective
+            ''
           end
 
           def diff_to_compare
@@ -62,18 +58,6 @@ module Shoulda
               DisallowValueMatcher.new(disallowed_value).tap do |matcher|
                 matcher.for(attribute)
                 wrap_disallow_value_matcher(matcher)
-
-                if @message
-                  matcher.with_message(@message)
-                end
-
-                if @strict
-                  matcher.strict
-                end
-
-                if @context
-                  matcher.on(@context)
-                end
               end
             end
           end

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

@@ -6,8 +6,19 @@ module Shoulda
         class OddNumberMatcher < NumericTypeMatcher
           NON_ODD_NUMBER_VALUE = 2
 
-          def allowed_type
-            'odd numbers'
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << 'strictly '
+            end
+
+            description +
+              "disallow :#{attribute} from being an even number"
+          end
+
+          def allowed_type_adjective
+            'odd'
           end
 
           def diff_to_compare

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

@@ -6,8 +6,18 @@ module Shoulda
         class OnlyIntegerMatcher < NumericTypeMatcher
           NON_INTEGER_VALUE = 0.1
 
-          def allowed_type
-            'integers'
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << ' strictly'
+            end
+
+            description + "disallow :#{attribute} from being a decimal number"
+          end
+
+          def allowed_type_name
+            'integer'
           end
 
           def diff_to_compare

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

@@ -0,0 +1,12 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module Qualifiers
+      end
+    end
+  end
+end
+
+require_relative 'qualifiers/ignore_interference_by_writer'
+require_relative 'qualifiers/ignoring_interference_by_writer'

data/lib/shoulda/matchers/active_model/qualifiers/ignore_interference_by_writer.rb

@@ -0,0 +1,101 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        class IgnoreInterferenceByWriter
+          attr_reader :setting, :condition
+
+          def initialize(argument = :always)
+            set(argument)
+            @changed = false
+          end
+
+          def set(argument)
+            if argument.is_a?(self.class)
+              @setting = argument.setting
+              @condition = argument.condition
+            else
+              case argument
+              when true, :always
+                @setting = :always
+              when false, :never
+                @setting = :never
+              else
+                @setting = :sometimes
+
+                if argument.is_a?(Hash)
+                  @condition = argument.fetch(:when)
+                else
+                  raise invalid_argument_error(argument)
+                end
+              end
+            end
+
+            @changed = true
+
+            self
+          rescue KeyError
+            raise invalid_argument_error(argument)
+          end
+
+          def default_to(argument)
+            temporary_ignore_interference_by_writer =
+              IgnoreInterferenceByWriter.new(argument)
+
+            unless changed?
+              @setting = temporary_ignore_interference_by_writer.setting
+              @condition = temporary_ignore_interference_by_writer.condition
+            end
+
+            self
+          end
+
+          def considering?(value)
+            case setting
+            when :always then true
+            when :never then false
+            else condition_matches?(value)
+            end
+          end
+
+          def always?
+            setting == :always
+          end
+
+          def never?
+            setting == :never
+          end
+
+          def changed?
+            @changed
+          end
+
+          private
+
+          def invalid_argument_error(invalid_argument)
+            ArgumentError.new(<<-ERROR)
+Unknown argument: #{invalid_argument.inspect}.
+
+ignoring_interference_by_writer takes one of three arguments:
+
+* A symbol, either :never or :always.
+* A boolean, either true (which means always) or false (which means
+  never).
+* A hash with a single key, :when, and a single value, which is either
+  the name of a method or a Proc.
+            ERROR
+          end
+
+          def condition_matches?(value)
+            if condition.respond_to?(:call)
+              condition.call(value)
+            else
+              value.public_send(condition)
+            end
+          end
+        end
+      end
+    end
+  end
+end