shoulda-matchers 7.0.1 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63256c77182faa2d6d70c24f7f53d5cbb4c8f723ebea8ab062a912cea898d405
-  data.tar.gz: 1bc874eac2eb72cf6e73ff4a8f642deca0f911bb1a8939b7e6d4f257fc1fb3e6
+  metadata.gz: 223ff92a4826a7403e0f1016553453323108899c2d2f7029873ea9f99b68a1c0
+  data.tar.gz: 2014f3ded4620ce71736c035b8f73959a2a85c1adead8067692173fbca6907de
 SHA512:
-  metadata.gz: 943c4db0909a15216ec5aa90cb01a04400cf000217f59dc70bfbfb9a4ac264466f757963ed66c79e1acc9174b4d42f445d9fac8f590d926a6699592f05108633
-  data.tar.gz: 914455300f3ae6ceccfec6ce50cac85f201643e4b1bca4cd152a2c8a6b2c45e161d7ba8b9fb9daf41ce90c9faeaee75bef5f03b985a3d38768cba5a8a040adf9
+  metadata.gz: 3a23155ac210adef58ea71d3cead443b1277b0292972f1365c140b20c671de2f743c39516871ab0ce6ffe0e48b2298a86635533f9fb1f2838577320505b6f91f
+  data.tar.gz: 6999714a118645d1aff05c32ad2a7337111aa7c7501f42822a34ca28e31b5d7caa84d49138ecebf0c1dfad17e9f24fd25583e41b73f9e981c4b9ff1da673fd39

data/README.md

@@ -63,7 +63,7 @@ Start by including `shoulda-matchers` in your Gemfile:
 
 ```ruby
 group :test do
-  gem 'shoulda-matchers', '~> 6.0'
+  gem 'shoulda-matchers', '~> 8.0'
 end
 ```
 
@@ -125,7 +125,7 @@ Otherwise, add `shoulda-matchers` to your Gemfile:
 
 ```ruby
 group :test do
-  gem 'shoulda-matchers', '~> 6.0'
+  gem 'shoulda-matchers', '~> 8.0'
 end
 ```
 
@@ -341,6 +341,7 @@ RSpec.describe MySpecialModel, type: :model do
 end
 ```
 
+<a name="should-vs-is_expectedto"></a>
 ### `should` vs `is_expected.to`
 
 In this README and throughout the documentation, you'll notice that we use the
@@ -503,14 +504,18 @@ machine, understanding the codebase, and creating a good pull request.
 
 ## Compatibility
 
-Shoulda Matchers is tested and supported against Ruby 3.0+, Rails
-6.1+, RSpec 3.x, and Minitest 5.x.
+Shoulda Matchers is tested and supported against Ruby 3.3+, Rails
+7.2+, RSpec 3.x, and Minitest 5.x.
 
 - For Ruby < 2.4 and Rails < 4.1 compatibility, please use [v3.1.3][v3.1.3].
 - For Ruby < 3.0 and Rails < 6.1 compatibility, please use [v4.5.1][v4.5.1].
+- For Rails < 7.1 compatibility, please use [v6.5.0][v6.5.0].
+- For Ruby < 3.3 and Rails < 7.2 compatibility, please use [v7.0.1][v7.0.1].
 
 [v3.1.3]: https://github.com/thoughtbot/shoulda-matchers/tree/v3.1.3
 [v4.5.1]: https://github.com/thoughtbot/shoulda-matchers/tree/v4.5.1
+[v6.5.0]: https://github.com/thoughtbot/shoulda-matchers/tree/v6.5.0
+[v7.0.1]: https://github.com/thoughtbot/shoulda-matchers/tree/v7.0.1
 
 ## Versioning
 

data/lib/shoulda/matchers/action_controller/render_with_layout_matcher.rb

@@ -111,11 +111,7 @@ module Shoulda
         end
 
         def rendered_with_expected_layout?
-          if @expected_layout.nil?
-            true
-          else
-            rendered_layouts.include?(@expected_layout)
-          end
+          @expected_layout.nil? || rendered_layouts.include?(@expected_layout)
         end
 
         def rendered_layouts

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

@@ -458,7 +458,7 @@ module Shoulda
               message << '.'
             else
               message << " producing these validation errors:\n\n"
-              message << validator.all_formatted_validation_error_messages
+              message << validator.formatted_validation_error_messages
             end
           end
 

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

@@ -7,8 +7,10 @@ module Shoulda
           format_validation_errors(object.errors)
         end
 
-        def format_validation_errors(errors)
+        def format_validation_errors(errors, attr = nil)
           list_items = errors.to_hash.keys.map do |attribute|
+            next if attr && attr.to_sym != attribute.to_sym
+
             messages = errors[attribute]
             "* #{attribute}: #{messages}"
           end

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

@@ -70,10 +70,33 @@ module Shoulda
       #         with_message("there shall be peace on Earth")
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Robot
+      #       include ActiveModel::Model
+      #       attr_accessor :arms, :legs
+      #
+      #       validates_absence_of :arms, :legs
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Robot, type: :model do
+      #       it { should validate_absence_of(:arms, :legs) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RobotTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms, :legs)
+      #     end
+      #
       # @return [ValidateAbsenceOfMatcher}
       #
-      def validate_absence_of(attr)
-        ValidateAbsenceOfMatcher.new(attr)
+      def validate_absence_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateAbsenceOfMatcher.new(attr) }
       end
 
       # @private

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

@@ -73,10 +73,33 @@ module Shoulda
       #         with_message('You must accept the terms of service')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :terms, :privacy_policy
+      #
+      #       validates_acceptance_of :terms, :privacy_policy
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_acceptance_of(:terms, :privacy_policy) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms, :privacy_policy)
+      #     end
+      #
       # @return [ValidateAcceptanceOfMatcher]
       #
-      def validate_acceptance_of(attr)
-        ValidateAcceptanceOfMatcher.new(attr)
+      def validate_acceptance_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateAcceptanceOfMatcher.new(attr) }
       end
 
       # @private

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

@@ -272,10 +272,33 @@ module Shoulda
       #       should validate_comparison_of(:age).is_greater_than(0).allow_nil
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Item
+      #       include ActiveModel::Model
+      #       attr_accessor :width, :height
+      #
+      #       validates_comparison_of :width, :height, greater_than: 0
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Item, type: :model do
+      #       it { should validate_comparison_of(:width, :height).is_greater_than(0) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ItemTest < ActiveSupport::TestCase
+      #       should validate_comparison_of(:width, :height).is_greater_than(0)
+      #     end
+      #
       # @return [ValidateComparisonOfMatcher]
       #
-      def validate_comparison_of(attr)
-        ValidateComparisonOfMatcher.new(attr)
+      def validate_comparison_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateComparisonOfMatcher.new(attr) }
       end
 
       # @private
@@ -378,6 +401,13 @@ module Shoulda
           end
         end
 
+        def failure_reason
+          raw_submatcher_failure_reason_for(
+            first_submatcher_that_fails_to_match,
+            :failure_message,
+          )
+        end
+
         def given_numeric_column?
           attribute_is_active_record_column? &&
             [:integer, :float, :decimal].include?(column_type)
@@ -485,21 +515,26 @@ module Shoulda
           submatcher,
           failure_message_method
         )
+          Shoulda::Matchers.word_wrap(
+            raw_submatcher_failure_reason_for(submatcher, failure_message_method),
+            indent: 2,
+          )
+        end
+
+        def raw_submatcher_failure_reason_for(submatcher, failure_message_method)
           failure_message = submatcher.public_send(failure_message_method)
           submatcher_description = submatcher.simple_description.
             sub(/\bvalidate that\b/, 'validates').
             sub(/\bdisallow\b/, 'disallows').
             sub(/\ballow\b/, 'allows')
-          submatcher_message =
-            if number_of_submatchers_for_failure_message > 1
-              "In checking that #{model.name} #{submatcher_description}, " +
-                failure_message[0].downcase +
-                failure_message[1..]
-            else
-              failure_message
-            end
 
-          Shoulda::Matchers.word_wrap(submatcher_message, indent: 2)
+          if number_of_submatchers_for_failure_message > 1
+            "In checking that #{model.name} #{submatcher_description}, " +
+              failure_message[0].downcase +
+              failure_message[1..]
+          else
+            failure_message
+          end
         end
 
         def comparison_descriptions

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

@@ -70,10 +70,33 @@ module Shoulda
       #         with_message('Please re-enter your password')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password, :password_confirmation, :email, :email_confirmation
+      #
+      #       validates_confirmation_of :password, :email
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_confirmation_of(:password, :email) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password, :email)
+      #     end
+      #
       # @return [ValidateConfirmationOfMatcher]
       #
-      def validate_confirmation_of(attr)
-        ValidateConfirmationOfMatcher.new(attr)
+      def validate_confirmation_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateConfirmationOfMatcher.new(attr) }
       end
 
       # @private

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

@@ -112,10 +112,33 @@ module Shoulda
       #         with_message('You chose a puny weapon')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Article
+      #       include ActiveModel::Model
+      #       attr_accessor :slug, :handle
+      #
+      #       validates_exclusion_of :slug, :handle, in: %w[admin root]
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Article, type: :model do
+      #       it { should validate_exclusion_of(:slug, :handle).in_array(%w[admin root]) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ArticleTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:slug, :handle).in_array(%w[admin root])
+      #     end
+      #
       # @return [ValidateExclusionOfMatcher]
       #
-      def validate_exclusion_of(attr)
-        ValidateExclusionOfMatcher.new(attr)
+      def validate_exclusion_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateExclusionOfMatcher.new(attr) }
       end
 
       # @private

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

@@ -263,10 +263,33 @@ module Shoulda
       #         allow_blank
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Article
+      #       include ActiveModel::Model
+      #       attr_accessor :status, :category
+      #
+      #       validates_inclusion_of :status, :category, in: %w[draft published]
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Article, type: :model do
+      #       it { should validate_inclusion_of(:status, :category).in_array(%w[draft published]) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ArticleTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:status, :category).in_array(%w[draft published])
+      #     end
+      #
       # @return [ValidateInclusionOfMatcher]
       #
-      def validate_inclusion_of(attr)
-        ValidateInclusionOfMatcher.new(attr)
+      def validate_inclusion_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateInclusionOfMatcher.new(attr) }
       end
 
       # @private
@@ -278,18 +301,6 @@ module Shoulda
         ARBITRARY_OUTSIDE_DATE = Date.jd(9999999)
         ARBITRARY_OUTSIDE_DATETIME = DateTime.jd(9999999)
         ARBITRARY_OUTSIDE_TIME = Time.at(9999999999)
-        BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT.freeze
-You are using `validate_inclusion_of` to assert that a boolean column allows
-boolean values and disallows non-boolean ones. Be aware that it is not possible
-to fully test this, as boolean columns will automatically convert non-boolean
-values to boolean ones. Hence, you should consider removing this test.
-EOT
-        BOOLEAN_ALLOWS_NIL_MESSAGE = <<EOT.freeze
-You are using `validate_inclusion_of` to assert that a boolean column allows nil.
-Be aware that it is not possible to fully test this, as anything other than
-true, false or nil will be converted to false. Hence, you should consider
-removing this test.
-EOT
 
         def initialize(attribute)
           super(attribute)
@@ -400,6 +411,24 @@ EOT
 
         private
 
+        def boolean_allows_boolean_message
+          <<-EOT.strip
+            You are using `validate_inclusion_of` to assert that the column '#{@subject.class.name}##{attribute}'
+            allows boolean values and disallows non-boolean ones. Be aware that it
+            is not possible to fully test this, as boolean columns will automatically
+            convert non-boolean values to boolean ones. Hence, you should consider
+            removing this test.
+          EOT
+        end
+
+        def boolean_allows_nil_message
+          <<-EOT.strip
+            You are using `validate_inclusion_of` to assert that the column '#{@subject.class.name}##{attribute}'
+            allows nil. Be aware that it is not possible to fully test this, as anything other than
+            true, false or nil will be converted to false. Hence, you should consider removing this test.
+          EOT
+        end
+
         def minimum_range_value
           @range.begin
         end
@@ -492,11 +521,11 @@ EOT
           if attribute_type == :boolean
             case @array
             when [false, true], [true, false]
-              Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
+              Shoulda::Matchers.warn boolean_allows_boolean_message
               return true
             when [nil]
               if attribute_column.null
-                Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
+                Shoulda::Matchers.warn boolean_allows_nil_message
                 return true
               else
                 raise NonNullableBooleanError.create(@attribute)
@@ -513,11 +542,11 @@ EOT
           if attribute_type == :boolean
             case @array
             when [false, true], [true, false]
-              Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
+              Shoulda::Matchers.warn boolean_allows_boolean_message
               return true
             when [nil]
               if attribute_column.null
-                Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
+                Shoulda::Matchers.warn boolean_allows_nil_message
                 return true
               else
                 raise NonNullableBooleanError.create(@attribute)

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

@@ -240,7 +240,6 @@ module Shoulda
       #       should validate_length_of(:bio).is_at_least(15).allow_nil
       #     end
       #
-      # @return [ValidateLengthOfMatcher]
       #
       # ##### allow_blank
       #
@@ -286,8 +285,32 @@ module Shoulda
       #       should validate_length_of(:arr).as_array.is_at_least(15)
       #     end
       #
-      def validate_length_of(attr)
-        ValidateLengthOfMatcher.new(attr)
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :first_name, :last_name
+      #
+      #       validates_length_of :first_name, :last_name, minimum: 2
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_length_of(:first_name, :last_name).is_at_least(2) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_length_of(:first_name, :last_name).is_at_least(2)
+      #     end
+      #
+      # @return [ValidateLengthOfMatcher]
+      def validate_length_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateLengthOfMatcher.new(attr) }
       end
 
       # @private

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

@@ -350,10 +350,33 @@ module Shoulda
       #       should validate_numericality_of(:age).allow_nil
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Item
+      #       include ActiveModel::Model
+      #       attr_accessor :price, :quantity
+      #
+      #       validates_numericality_of :price, :quantity
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Item, type: :model do
+      #       it { should validate_numericality_of(:price, :quantity) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ItemTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:price, :quantity)
+      #     end
+      #
       # @return [ValidateNumericalityOfMatcher]
       #
-      def validate_numericality_of(attr)
-        ValidateNumericalityOfMatcher.new(attr)
+      def validate_numericality_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateNumericalityOfMatcher.new(attr) }
       end
 
       # @private
@@ -482,6 +505,13 @@ module Shoulda
           end
         end
 
+        def failure_reason
+          raw_submatcher_failure_reason_for(
+            first_submatcher_that_fails_to_match,
+            :failure_message,
+          )
+        end
+
         def given_numeric_column?
           attribute_is_active_record_column? &&
             [:integer, :float, :decimal].include?(column_type)
@@ -620,21 +650,26 @@ module Shoulda
           submatcher,
           failure_message_method
         )
+          Shoulda::Matchers.word_wrap(
+            raw_submatcher_failure_reason_for(submatcher, failure_message_method),
+            indent: 2,
+          )
+        end
+
+        def raw_submatcher_failure_reason_for(submatcher, failure_message_method)
           failure_message = submatcher.public_send(failure_message_method)
           submatcher_description = submatcher.simple_description.
             sub(/\bvalidate that\b/, 'validates').
             sub(/\bdisallow\b/, 'disallows').
             sub(/\ballow\b/, 'allows')
-          submatcher_message =
-            if number_of_submatchers_for_failure_message > 1
-              "In checking that #{model.name} #{submatcher_description}, " +
-                failure_message[0].downcase +
-                failure_message[1..]
-            else
-              failure_message
-            end
 
-          Shoulda::Matchers.word_wrap(submatcher_message, indent: 2)
+          if number_of_submatchers_for_failure_message > 1
+            "In checking that #{model.name} #{submatcher_description}, " +
+              failure_message[0].downcase +
+              failure_message[1..]
+          else
+            failure_message
+          end
         end
 
         def full_allowed_type

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

@@ -145,10 +145,34 @@ module Shoulda
       #         with_message('Robot has no legs')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Robot
+      #       include ActiveModel::Model
+      #       attr_accessor :arms, :legs
+      #
+      #       validates_presence_of :arms, :legs
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Robot, type: :model do
+      #       it { should validate_presence_of(:arms, :legs) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RobotTest < ActiveSupport::TestCase
+      #       should validate_presence_of(:arms, :legs)
+      #     end
+      #
       # @return [ValidatePresenceOfMatcher]
       #
-      def validate_presence_of(attr)
-        ValidatePresenceOfMatcher.new(attr)
+
+      def validate_presence_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidatePresenceOfMatcher.new(attr) }
       end
 
       # @private
@@ -206,27 +230,29 @@ module Shoulda
           "validate that :#{@attribute} cannot be empty/falsy"
         end
 
-        def failure_message
-          message = super
-
+        def failure_reason
+          reason = super
           if should_add_footnote_about_belongs_to?
-            message << "\n\n"
-            message << Shoulda::Matchers.word_wrap(<<-MESSAGE.strip, indent: 2)
-You're getting this error because #{reason_for_existing_presence_validation}.
-*This* presence validation doesn't use "can't be blank", the usual validation
-message, but "must exist" instead.
-
-With that said, did you know that the `belong_to` matcher can test this
-validation for you? Instead of using `validate_presence_of`, try
-#{suggestions_for_belongs_to}
-            MESSAGE
+            "#{reason}\n\n#{belongs_to_footnote}"
+          else
+            reason
           end
-
-          message
         end
 
         private
 
+        def belongs_to_footnote
+          <<~MESSAGE.strip
+            You're getting this error because #{reason_for_existing_presence_validation}.
+            *This* presence validation doesn't use "can't be blank", the usual validation
+            message, but "must exist" instead.
+
+            With that said, did you know that the `belong_to` matcher can test this
+            validation for you? Instead of using `validate_presence_of`, try
+            #{suggestions_for_belongs_to}
+          MESSAGE
+        end
+
         def secure_password_being_validated?
           Shoulda::Matchers::RailsShim.digestible_attributes_in(@subject).
             include?(@attribute)

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

@@ -86,6 +86,10 @@ module Shoulda
           end
         end
 
+        def failure_reason
+          last_submatcher_run.try(:failure_message)
+        end
+
         protected
 
         attr_reader :attribute, :context, :subject, :last_submatcher_run
@@ -150,14 +154,6 @@ module Shoulda
           )
         end
 
-        def failure_reason
-          last_submatcher_run.try(:failure_message)
-        end
-
-        def failure_reason_when_negated
-          last_submatcher_run.try(:failure_message_when_negated)
-        end
-
         def build_allow_or_disallow_value_matcher(args)
           matcher_class = args.fetch(:matcher_class)
           value = args.fetch(:value)

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

@@ -45,6 +45,10 @@ module Shoulda
           validation_result[:validation_exception_message]
         end
 
+        def formatted_validation_error_messages
+          format_validation_errors(all_validation_errors, attribute)
+        end
+
         protected
 
         attr_reader :attribute, :context, :record

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

@@ -372,6 +372,25 @@ module Shoulda
       #       should belong_to(:organization).optional
       #     end
       #
+      # ##### deprecated
+      #
+      # Use `deprecated` to assert that the `:deprecated` option was specified.
+      # (Enabled by default in Rails 8.1+).
+      #
+      #     class Account < ActiveRecord::Base
+      #       belongs_to :bank, deprecated: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Account, type: :model do
+      #       it { should belong_to(:bank).deprecated(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class AccountTest < ActiveSupport::TestCase
+      #       should belong_to(:bank).deprecated(true)
+      #     end
+      #
       # @return [AssociationMatcher]
       #
       def belong_to(name)
@@ -681,9 +700,27 @@ module Shoulda
       #       should have_delegated_type(:drivable).optional
       #     end
       #
+      # ##### deprecated
+      #
+      # Use `deprecated` to assert that the `:deprecated` option was specified.
+      # (Enabled by default in Rails 8.1+).
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), deprecated: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Vehicle
+      #       it { should have_delegated_type(:drivable).deprecated }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).deprecated
+      #     end
+      #
       # @return [AssociationMatcher]
       #
-
       def have_delegated_type(name)
         AssociationMatcher.new(:belongs_to, name)
       end
@@ -822,7 +859,7 @@ module Shoulda
       # Use `with_foreign_type` to test usage of the `:foreign_type` option.
       #
       #     class Hotel < ActiveRecord::Base
-      #       has_many :visitors, foreign_key: 'facility_type', as: :location
+      #       has_many :visitors, foreign_type: 'facility_type', as: :location
       #     end
       #
       #     # RSpec
@@ -970,6 +1007,26 @@ module Shoulda
       #       should have_many(:employees).inverse_of(:company)
       #     end
       #
+      #
+      # ##### deprecated
+      #
+      # Use `deprecated` to assert that the `:deprecated` option was specified.
+      # (Enabled by default in Rails 8.1+)
+      #
+      #     class Player < ActiveRecord::Base
+      #       has_many :games, deprecated: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Player, type: :model do
+      #       it { should have_many(:games).deprecated(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PlayerTest < ActiveSupport::TestCase
+      #       should have_many(:games).deprecated(true)
+      #     end
+      #
       # @return [AssociationMatcher]
       #
       def have_many(name)
@@ -1217,6 +1274,26 @@ module Shoulda
       #       should have_one(:brain).required
       #     end
       #
+      #
+      # ##### deprecated
+      #
+      # Use `deprecated` to assert that the `:deprecated` option was specified.
+      # (Enabled by default in Rails 8.1+).
+      #
+      #     class Account < ActiveRecord::Base
+      #       has_one :bank, deprecated: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Account, type: :model do
+      #       it { should have_one(:bank).deprecated(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class AccountTest < ActiveSupport::TestCase
+      #       should have_one(:bank).deprecated(true)
+      #     end
+      #
       # @return [AssociationMatcher]
       #
       def have_one(name)
@@ -1375,6 +1452,25 @@ module Shoulda
       #       should have_and_belong_to_many(:advertisers).autosave(true)
       #     end
       #
+      # ##### deprecated
+      #
+      # Use `deprecated` to assert that the `:deprecated` option was specified.
+      # (Enabled by default in Rails 8.1+).
+      #
+      #     class Publisher < ActiveRecord::Base
+      #       has_and_belongs_to_many :advertisers, deprecated: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Publisher, type: :model do
+      #       it { should have_and_belong_to_many(:advertisers).deprecated(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class AccountTest < ActiveSupport::TestCase
+      #       should have_and_belong_to_many(:advertisers).deprecated(true)
+      #     end
+      #
       # @return [AssociationMatcher]
       #
       def have_and_belong_to_many(name)
@@ -1546,6 +1642,16 @@ module Shoulda
           self
         end
 
+        def deprecated(deprecated = true)
+          if Shoulda::Matchers::RailsShim.active_record_gte_8_1?
+            @options[:deprecated] = deprecated
+            self
+          else
+            raise NotImplementedError,
+              '`deprecated` association matcher is only available on Active Record >= 8.1.'
+          end
+        end
+
         def without_validating_presence
           remove_submatcher(AssociationMatchers::RequiredMatcher)
           self
@@ -1586,6 +1692,7 @@ module Shoulda
             touch_correct? &&
             types_correct? &&
             strict_loading_correct? &&
+            deprecated_correct? &&
             submatchers_match?
         end
 
@@ -1848,6 +1955,16 @@ module Shoulda
           end
         end
 
+        def deprecated_correct?
+          if option_verifier.correct_for_boolean?(:deprecated, options[:deprecated])
+            true
+          else
+            @missing = "#{name} should have deprecated set to"\
+                " #{options[:deprecated]}"
+            false
+          end
+        end
+
         def types_correct?
           if options.key?(:types)
             types = options[:types]

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

@@ -49,12 +49,10 @@ module Shoulda
                   'to '
                 end
 
-              missing_option_string << (
-                'fail validation if '\
+              missing_option_string << 'fail validation if '\
                 ":#{attribute_name} is unset; i.e., either the association "\
                 'should have been defined with `optional: '\
                 "#{optional.inspect}`, or there "
-              )
 
               missing_option_string <<
                 if optional

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

@@ -54,12 +54,10 @@ module Shoulda
                   'not to '
                 end
 
-              missing_option_string << (
-                'fail validation if '\
+              missing_option_string << 'fail validation if '\
                 ":#{attribute_name} is unset; i.e., either the association "\
                 'should have been defined with `required: '\
                 "#{required.inspect}`, or there "
-              )
 
               missing_option_string <<
                 if required

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

@@ -320,6 +320,12 @@ module Shoulda
           self
         end
 
+        def with_options(**)
+          raise NotImplementedError,
+            'with_options is not a valid qualifier for the define_enum_for matcher. '\
+            'Did you mean to use with_values instead?'
+        end
+
         def with_prefix(expected_prefix = true)
           options[:prefix] = expected_prefix
           self
@@ -667,7 +673,7 @@ module Shoulda
           end
 
           value = case attribute_schema
-                  in [_, { default: default_value } ]
+                  in [_, { default: default_value }]
                     default_value
                   in [_, default_value, *]
                     default_value

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

@@ -88,10 +88,31 @@ module Shoulda
       #       should have_one_attached(:avatar).strict_loading
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User < ActiveRecord::Base
+      #       has_one_attached :avatar
+      #       has_one_attached :cover
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar, :cover) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar, :cover)
+      #     end
+      #
       # @return [HaveAttachedMatcher]
       #
-      def have_one_attached(name)
-        HaveAttachedMatcher.new(:one, name)
+      def have_one_attached(*names)
+        MatcherCollection.build(names) { |name| HaveAttachedMatcher.new(:one, name) }
       end
 
       # The `have_many_attached` matcher tests usage of the
@@ -140,6 +161,10 @@ Expected #{expectation}, but this could not be proved.
           MESSAGE
         end
 
+        def failure_reason
+          @failure
+        end
+
         def failure_message_when_negated
           <<-MESSAGE
 Did not expect #{expectation}, but it does.

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

@@ -18,10 +18,30 @@ module Shoulda
       #       should have_readonly_attribute(:password)
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User < ActiveRecord::Base
+      #       attr_readonly :name, :email
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_readonly_attribute(:name, :email) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_readonly_attribute(:name, :email)
+      #     end
+      #
       # @return [HaveReadonlyAttributeMatcher]
       #
-      def have_readonly_attribute(value)
-        HaveReadonlyAttributeMatcher.new(value)
+      def have_readonly_attribute(*values)
+        MatcherCollection.build(values) { |value| HaveReadonlyAttributeMatcher.new(value) }
       end
 
       # @private
@@ -32,6 +52,10 @@ module Shoulda
 
         attr_reader :failure_message, :failure_message_when_negated
 
+        def failure_reason
+          @failure_message
+        end
+
         def matches?(subject)
           @subject = subject
           if readonly_attributes.include?(@attribute)

data/lib/shoulda/matchers/active_record/uniqueness/namespace.rb

@@ -10,7 +10,7 @@ module Shoulda
           end
 
           def has?(name)
-            constant.const_defined?(name)
+            constant.const_defined?(name, false)
           end
 
           def set(name, value)
@@ -18,8 +18,25 @@ module Shoulda
           end
 
           def clear
+            test_model_classes = []
+
             constant.constants.each do |child_constant|
-              constant.__send__(:remove_const, child_constant)
+              child = constant.const_get(child_constant)
+
+              if defined?(::ActiveRecord::Base) &&
+                 child.is_a?(Class) &&
+                 child < ::ActiveRecord::Base
+                test_model_classes << child
+              end
+
+              constant.remove_const(child_constant)
+            rescue NameError
+              # Constant may have been removed elsewhere; ignore
+            end
+
+            if defined?(::ActiveSupport::DescendantsTracker) &&
+               test_model_classes.any?
+              ::ActiveSupport::DescendantsTracker.clear(test_model_classes)
             end
           end
 

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

@@ -304,7 +304,6 @@ module Shoulda
           }
           @existing_record_created = false
           @failure_reason = nil
-          @failure_reason_when_negated = nil
           @attribute_setters = {
             existing_record: AttributeSetters.new,
             new_record: AttributeSetters.new,
@@ -407,10 +406,6 @@ module Shoulda
           @failure_reason || super
         end
 
-        def failure_reason_when_negated
-          @failure_reason_when_negated || super
-        end
-
         def build_allow_or_disallow_value_matcher(args)
           super.tap do |matcher|
             matcher.failure_message_preface = method(:failure_message_preface)
@@ -558,12 +553,9 @@ module Shoulda
         end
 
         def does_not_match_allow_nil?
-          expects_to_allow_nil? && (
-            update_existing_record!(nil) &&
-            (@failure_reason = nil ||
-              disallows_value_of(nil, @expected_message)
+          expects_to_allow_nil? && update_existing_record!(nil) &&
+            (@failure_reason = disallows_value_of(nil, @expected_message)
             )
-          )
         end
 
         def matches_allow_blank?
@@ -574,10 +566,8 @@ module Shoulda
         end
 
         def does_not_match_allow_blank?
-          expects_to_allow_blank? && (
-            update_existing_record!('') &&
-            (@failure_reason = nil || disallows_value_of('', @expected_message))
-          )
+          expects_to_allow_blank? && update_existing_record!('') &&
+            (@failure_reason = disallows_value_of('', @expected_message))
         end
 
         def existing_record

data/lib/shoulda/matchers/matcher_collection.rb

@@ -0,0 +1,99 @@
+module Shoulda
+  module Matchers
+    # @private
+    class MatcherCollection
+      def self.build(attrs, &block)
+        new(attrs.map(&block))
+      end
+
+      def initialize(matchers)
+        @matchers = matchers
+        @failed_matchers = []
+      end
+
+      def description
+        matchers.map(&:description).join(' and ')
+      end
+
+      def matches?(subject)
+        @subject = subject
+        @failed_matchers = matchers.reject do |matcher|
+          matcher.matches?(fresh_subject_for(subject))
+        end
+        @failed_matchers.empty?
+      end
+
+      def does_not_match?(subject)
+        @subject = subject
+        @failed_matchers = matchers.reject do |matcher|
+          fresh_subject = fresh_subject_for(subject)
+          if matcher.respond_to?(:does_not_match?)
+            matcher.does_not_match?(fresh_subject)
+          else
+            !matcher.matches?(fresh_subject)
+          end
+        end
+        @failed_matchers.empty?
+      end
+
+      def failure_message
+        if matchers.one?
+          matchers.first.failure_message
+        else
+          build_failure_message('to')
+        end
+      end
+
+      def failure_message_when_negated
+        if matchers.one?
+          matchers.first.failure_message_when_negated
+        else
+          build_failure_message('not to')
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if all_matchers_respond_to?(method)
+          matchers.each { |matcher| matcher.send(method, *args, &block) }
+          self
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        all_matchers_respond_to?(method) || super
+      end
+
+      private
+
+      attr_reader :matchers
+
+      def fresh_subject_for(subject)
+        matchers.one? ? subject : subject.dup
+      end
+
+      def build_failure_message(direction)
+        header = Shoulda::Matchers.word_wrap(
+          "Expected #{@subject.class.name} #{direction} "\
+          "#{failed_description}, but this could not be proved.",
+        )
+
+        reasons = @failed_matchers.filter_map do |matcher|
+          reason = matcher.failure_reason
+          Shoulda::Matchers.word_wrap(reason, indent: 2) if reason.present?
+        end
+
+        ([header] + reasons).join("\n")
+      end
+
+      def failed_description
+        @failed_matchers.map(&:description).join(' and ')
+      end
+
+      def all_matchers_respond_to?(method)
+        matchers.all? { |matcher| matcher.respond_to?(method) }
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/rails_shim.rb

@@ -25,6 +25,10 @@ module Shoulda
           Gem::Requirement.new('< 7').satisfied_by?(active_model_version)
         end
 
+        def active_record_gte_8_1?
+          Gem::Requirement.new('>= 8.1').satisfied_by?(active_record_version)
+        end
+
         def generate_validation_message(
           record,
           attribute,
@@ -139,10 +143,6 @@ 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(

data/lib/shoulda/matchers/version.rb

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

data/lib/shoulda/matchers.rb

@@ -3,6 +3,7 @@ require 'shoulda/matchers/doublespeak'
 require 'shoulda/matchers/error'
 require 'shoulda/matchers/independent'
 require 'shoulda/matchers/integrations'
+require 'shoulda/matchers/matcher_collection'
 require 'shoulda/matchers/matcher_context'
 require 'shoulda/matchers/rails_shim'
 require 'shoulda/matchers/util'

data/shoulda-matchers.gemspec

@@ -30,13 +30,14 @@ Gem::Specification.new do |s|
     'documentation_uri' => 'https://matchers.shoulda.io/docs',
     'homepage_uri' => 'https://matchers.shoulda.io',
     'source_code_uri' => 'https://github.com/thoughtbot/shoulda-matchers',
+    'rubygems_mfa_required' => 'true',
   }
 
   s.files = Dir['{docs,lib}/**/*', 'README.md', 'LICENSE',
-    'shoulda-matchers.gemspec']
+    'shoulda-matchers.gemspec',]
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 3.2'
-  s.add_dependency 'activesupport', '>= 7.1'
+  s.required_ruby_version = '>= 3.3'
+  s.add_dependency 'activesupport', '>= 7.2'
   s.add_development_dependency 'mutex_m'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shoulda-matchers
 version: !ruby/object:Gem::Version
-  version: 7.0.1
+  version: 8.0.0
 platform: ruby
 authors:
 - Tammer Saleh
@@ -13,7 +13,7 @@ authors:
 - Elliot Winkler
 bindir: bin
 cert_chain: []
-date: 2025-10-31 00:00:00.000000000 Z
+date: 2026-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -21,14 +21,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: mutex_m
   requirement: !ruby/object:Gem::Requirement
@@ -179,6 +179,7 @@ files:
 - lib/shoulda/matchers/integrations/test_frameworks/missing_test_framework.rb
 - lib/shoulda/matchers/integrations/test_frameworks/rspec.rb
 - lib/shoulda/matchers/integrations/test_frameworks/test_unit.rb
+- lib/shoulda/matchers/matcher_collection.rb
 - lib/shoulda/matchers/matcher_context.rb
 - lib/shoulda/matchers/rails_shim.rb
 - lib/shoulda/matchers/routing.rb
@@ -196,6 +197,7 @@ metadata:
   documentation_uri: https://matchers.shoulda.io/docs
   homepage_uri: https://matchers.shoulda.io
   source_code_uri: https://github.com/thoughtbot/shoulda-matchers
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -203,14 +205,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Simple one-liner tests for common Rails functionality
 test_files: []