shoulda-matchers 5.2.0 → 6.0.0

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

@@ -0,0 +1,151 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `normalize` matcher is used to ensure attribute normalizations
+      # are transforming attribute values as expected.
+      #
+      # Take this model for example:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, with: -> email { email.strip.downcase }
+      #     end
+      #
+      # You can use `normalize` providing an input and defining the expected
+      # normalization output:
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #     end
+      #
+      # You can use `normalize` to test multiple attributes at once:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, :handle, with: -> value { value.strip.downcase }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email, :handle).from(" Example\n").to("example")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email, handle).from(" Example\n").to("example")
+      #     end
+      #
+      # If the normalization accepts nil values with the `apply_to_nil` option,
+      # you just need to use `.from(nil).to("Your expected value here")`.
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :name, with: -> name { name&.titleize || 'Untitled' },
+      #         apply_to_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should normalize(:name).from("jane doe").to("Jane Doe") }
+      #       it { should normalize(:name).from(nil).to("Untitled") }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:name).from("jane doe").to("Jane Doe")
+      #       should normalize(:name).from(nil).to("Untitled")
+      #     end
+      #
+      # @return [NormalizeMatcher]
+      #
+      def normalize(*attributes)
+        if attributes.empty?
+          raise ArgumentError, 'need at least one attribute'
+        else
+          NormalizeMatcher.new(*attributes)
+        end
+      end
+
+      # @private
+      class NormalizeMatcher
+        attr_reader :attributes, :from_value, :to_value, :failure_message,
+          :failure_message_when_negated
+
+        def initialize(*attributes)
+          @attributes = attributes
+        end
+
+        def description
+          %(
+            normalize #{attributes.to_sentence(last_word_connector: ' and ')} from
+            ‹#{from_value.inspect}› to ‹#{to_value.inspect}›
+          ).squish
+        end
+
+        def from(value)
+          @from_value = value
+
+          self
+        end
+
+        def to(value)
+          @to_value = value
+
+          self
+        end
+
+        def matches?(subject)
+          attributes.all? { |attribute| attribute_matches?(subject, attribute) }
+        end
+
+        def does_not_match?(subject)
+          attributes.all? { |attribute| attribute_does_not_match?(subject, attribute) }
+        end
+
+        private
+
+        def attribute_matches?(subject, attribute)
+          return true if normalize_attribute?(subject, attribute)
+
+          @failure_message = build_failure_message(
+            attribute,
+            subject.class.normalize_value_for(attribute, from_value),
+          )
+          false
+        end
+
+        def attribute_does_not_match?(subject, attribute)
+          return true unless normalize_attribute?(subject, attribute)
+
+          @failure_message_when_negated = build_failure_message_when_negated(attribute)
+          false
+        end
+
+        def normalize_attribute?(subject, attribute)
+          subject.class.normalize_value_for(attribute, from_value) == to_value
+        end
+
+        def build_failure_message(attribute, attribute_value)
+          %(
+            Expected to normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized to ‹#{attribute_value.inspect}›
+          ).squish
+        end
+
+        def build_failure_message_when_negated(attribute)
+          %(
+            Expected to not normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized
+          ).squish
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record.rb

@@ -24,6 +24,7 @@ require 'shoulda/matchers/active_record/define_enum_for_matcher'
 require 'shoulda/matchers/active_record/uniqueness'
 require 'shoulda/matchers/active_record/validate_uniqueness_of_matcher'
 require 'shoulda/matchers/active_record/have_attached_matcher'
+require 'shoulda/matchers/active_record/normalize_matcher'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/independent/delegate_method_matcher.rb

@@ -400,7 +400,7 @@ module Shoulda
                 false
               rescue NoMethodError => e
                 if e.message =~
-                   /undefined method `#{delegate_method}' for nil:NilClass/
+                   /undefined method `#{delegate_method}' for nil/
                   false
                 else
                   raise e

data/lib/shoulda/matchers/rails_shim.rb

@@ -1,7 +1,7 @@
 module Shoulda
   module Matchers
     # @private
-    module RailsShim # rubocop:disable Metrics/ModuleLength
+    module RailsShim
       class << self
         def action_pack_version
           Gem::Version.new(::ActionPack::VERSION::STRING)
@@ -9,10 +9,6 @@ module Shoulda
           Gem::Version.new('0')
         end
 
-        def active_record_gte_6?
-          Gem::Requirement.new('>= 6').satisfied_by?(active_record_version)
-        end
-
         def active_record_version
           Gem::Version.new(::ActiveRecord::VERSION::STRING)
         rescue NameError
@@ -25,8 +21,8 @@ module Shoulda
           Gem::Version.new('0')
         end
 
-        def active_model_gte_7?
-          Gem::Requirement.new('>= 7').satisfied_by?(active_model_version)
+        def active_model_st_6_1?
+          Gem::Requirement.new('< 6.1').satisfied_by?(active_model_version)
         end
 
         def active_model_lt_7?
@@ -60,9 +56,10 @@ module Shoulda
         end
 
         def serialized_attributes_for(model)
+          type_serialized_defined = Object.const_defined?('ActiveRecord::Type::Serialized')
           attribute_types_for(model).
             inject({}) do |hash, (attribute_name, attribute_type)|
-              if attribute_type.is_a?(::ActiveRecord::Type::Serialized)
+              if type_serialized_defined && attribute_type.is_a?(::ActiveRecord::Type::Serialized)
                 hash.merge(attribute_name => attribute_type.coder)
               else
                 hash
@@ -146,6 +143,10 @@ module Shoulda
             model.respond_to?(:attribute_types)
         end
 
+        def validates_column_options?
+          Gem::Requirement.new('>= 7.1.0').satisfied_by?(active_record_version)
+        end
+
         private
 
         def simply_generate_validation_message(
@@ -172,6 +173,7 @@ module Shoulda
           I18n.translate(primary_translation_key, translate_options)
         end
 
+        # @private
         class FakeAttributeType
           def initialize(model, attribute_name)
             @model = model

data/lib/shoulda/matchers/util/word_wrap.rb

@@ -41,7 +41,7 @@ module Shoulda
 
     # @private
     class Text < ::String
-      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/.freeze
+      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/
 
       def indented?
         self =~ /\A +/
@@ -92,7 +92,7 @@ module Shoulda
           if line.list_item?
             combined_lines << line
           else
-            combined_lines.last << (" #{line}").squeeze(' ')
+            combined_lines.last << " #{line}".squeeze(' ')
           end
 
           combined_lines

data/lib/shoulda/matchers/util.rb

@@ -94,7 +94,7 @@ module Shoulda
             0
           when :date
             Date.new(2100, 1, 1)
-          when :datetime, :timestamp
+          when :datetime, :timestamp, :timestamptz
             DateTime.new(2100, 1, 1)
           when :time
             Time.new(2000, 1, 1)

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '5.2.0'.freeze
+    VERSION = '6.0.0'.freeze
   end
 end

data/lib/shoulda/matchers.rb

@@ -14,8 +14,8 @@ require 'shoulda/matchers/active_model'
 require 'shoulda/matchers/active_record'
 require 'shoulda/matchers/routing'
 
-module Shoulda
-  module Matchers
+module Shoulda # :nodoc:
+  module Matchers # :nodoc:
     class << self
       # @private
       attr_accessor :assertion_exception_class

data/shoulda-matchers.gemspec

@@ -36,6 +36,6 @@ Gem::Specification.new do |s|
     'shoulda-matchers.gemspec']
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 2.6.0'
+  s.required_ruby_version = '>= 3.0.5'
   s.add_dependency('activesupport', '>= 5.2.0')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shoulda-matchers
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Tammer Saleh
@@ -11,10 +11,10 @@ authors:
 - Matt Jankowski
 - Stafford Brunk
 - Elliot Winkler
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-17 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -69,16 +69,18 @@ files:
 - lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setters_and_validators.rb
 - lib/shoulda/matchers/active_model/allow_value_matcher/successful_check.rb
 - lib/shoulda/matchers/active_model/allow_value_matcher/successful_setting.rb
+- lib/shoulda/matchers/active_model/comparison_matcher.rb
 - lib/shoulda/matchers/active_model/disallow_value_matcher.rb
 - lib/shoulda/matchers/active_model/errors.rb
 - lib/shoulda/matchers/active_model/have_secure_password_matcher.rb
 - lib/shoulda/matchers/active_model/helpers.rb
 - lib/shoulda/matchers/active_model/numericality_matchers.rb
-- lib/shoulda/matchers/active_model/numericality_matchers/comparison_matcher.rb
 - lib/shoulda/matchers/active_model/numericality_matchers/even_number_matcher.rb
 - lib/shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher.rb
 - lib/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher.rb
 - lib/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher.rb
+- lib/shoulda/matchers/active_model/numericality_matchers/range_matcher.rb
+- lib/shoulda/matchers/active_model/numericality_matchers/submatchers.rb
 - lib/shoulda/matchers/active_model/qualifiers.rb
 - lib/shoulda/matchers/active_model/qualifiers/allow_blank.rb
 - lib/shoulda/matchers/active_model/qualifiers/allow_nil.rb
@@ -86,6 +88,7 @@ files:
 - lib/shoulda/matchers/active_model/qualifiers/ignoring_interference_by_writer.rb
 - lib/shoulda/matchers/active_model/validate_absence_of_matcher.rb
 - lib/shoulda/matchers/active_model/validate_acceptance_of_matcher.rb
+- lib/shoulda/matchers/active_model/validate_comparison_of_matcher.rb
 - lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb
 - lib/shoulda/matchers/active_model/validate_exclusion_of_matcher.rb
 - lib/shoulda/matchers/active_model/validate_inclusion_of_matcher.rb
@@ -120,6 +123,7 @@ files:
 - lib/shoulda/matchers/active_record/have_readonly_attribute_matcher.rb
 - lib/shoulda/matchers/active_record/have_rich_text_matcher.rb
 - lib/shoulda/matchers/active_record/have_secure_token_matcher.rb
+- lib/shoulda/matchers/active_record/normalize_matcher.rb
 - lib/shoulda/matchers/active_record/serialize_matcher.rb
 - lib/shoulda/matchers/active_record/uniqueness.rb
 - lib/shoulda/matchers/active_record/uniqueness/model.rb
@@ -178,7 +182,7 @@ metadata:
   documentation_uri: https://matchers.shoulda.io/docs
   homepage_uri: https://matchers.shoulda.io
   source_code_uri: https://github.com/thoughtbot/shoulda-matchers
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -186,15 +190,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: Simple one-liner tests for common Rails functionality
 test_files: []

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

@@ -1,157 +0,0 @@
-module Shoulda
-  module Matchers
-    module ActiveModel
-      module NumericalityMatchers
-        # @private
-        class ComparisonMatcher < ValidationMatcher
-          ERROR_MESSAGES = {
-            :> => {
-              label: :greater_than,
-              assertions: [false, false, true],
-            },
-            :>= => {
-              label: :greater_than_or_equal_to,
-              assertions: [false, true, true],
-            },
-            :< => {
-              label: :less_than,
-              assertions: [true, false, false],
-            },
-            :<= => {
-              label: :less_than_or_equal_to,
-              assertions: [true, true, false],
-            },
-            :== => {
-              label: :equal_to,
-              assertions: [false, true, false],
-            },
-            :!= => {
-              label: :other_than,
-              assertions: [true, false, true],
-            },
-          }.freeze
-
-          def initialize(numericality_matcher, value, operator)
-            super(nil)
-            unless numericality_matcher.respond_to? :diff_to_compare
-              raise ArgumentError, 'numericality_matcher is invalid'
-            end
-
-            @numericality_matcher = numericality_matcher
-            @value = value
-            @operator = operator
-            @message = ERROR_MESSAGES[operator][:label]
-          end
-
-          def simple_description
-            description = ''
-
-            if expects_strict?
-              description << ' strictly'
-            end
-
-            description +
-              "disallow :#{attribute} from being a number that is not " +
-              "#{comparison_expectation} #{@value}"
-          end
-
-          def for(attribute)
-            @attribute = attribute
-            self
-          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?
-          end
-
-          def failure_message
-            last_failing_submatcher.failure_message
-          end
-
-          def failure_message_when_negated
-            last_failing_submatcher.failure_message_when_negated
-          end
-
-          def comparison_description
-            "#{comparison_expectation} #{@value}"
-          end
-
-          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, 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
-            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
-            end
-          end
-
-          def assertions
-            ERROR_MESSAGES[@operator][:assertions]
-          end
-
-          def diffs_to_compare
-            diff_to_compare = @numericality_matcher.diff_to_compare
-            values = [-1, 0, 1].map { |sign| @value + (diff_to_compare * sign) }
-
-            if @numericality_matcher.given_numeric_column?
-              values
-            else
-              values.map(&:to_s)
-            end
-          end
-
-          def comparison_expectation
-            ERROR_MESSAGES[@operator][:label].to_s.tr('_', ' ')
-          end
-        end
-      end
-    end
-  end
-end