shoulda-matchers 7.0.1 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63256c77182faa2d6d70c24f7f53d5cbb4c8f723ebea8ab062a912cea898d405
-  data.tar.gz: 1bc874eac2eb72cf6e73ff4a8f642deca0f911bb1a8939b7e6d4f257fc1fb3e6
+  metadata.gz: 0cad2b70febc8044b3a8a61bc3ce7aa00b780708d3e0d2baccedaa3922d6f42f
+  data.tar.gz: 4a3fca99d9bccfac2bc74035f1e1a8608ef24775a19dd7bc30b0a979e6f87ed1
 SHA512:
-  metadata.gz: 943c4db0909a15216ec5aa90cb01a04400cf000217f59dc70bfbfb9a4ac264466f757963ed66c79e1acc9174b4d42f445d9fac8f590d926a6699592f05108633
-  data.tar.gz: 914455300f3ae6ceccfec6ce50cac85f201643e4b1bca4cd152a2c8a6b2c45e161d7ba8b9fb9daf41ce90c9faeaee75bef5f03b985a3d38768cba5a8a040adf9
+  metadata.gz: 29dcf4008451127b46e668f2399fe58d851ec54d2057595e59c7a57937b2f0e72d4a2aa4bdacd90f78d6a12a6de79f253675ab15ff4339c4222813bcaa449c04
+  data.tar.gz: 3f5b06b148848185c566f381f8cf3871dc56e454ea9ff59cb6106f1e969b854de53d07d84d6fa6d9554090440efcb568f30f33ac3dcfaada6fd4304fcbc284b5

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)