capybara 3.10.1 → 3.11.0

data/lib/capybara/node/matchers.rb

@@ -100,9 +100,7 @@ module Capybara
       #
       def assert_selector(*args, &optional_filter_block)
         _verify_selector_result(args, optional_filter_block) do |result, query|
-          unless result.matches_count? && (result.any? || query.expects_none?)
-            raise Capybara::ExpectationNotMet, result.failure_message
-          end
+          raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count? && (result.any? || query.expects_none?)
         end
       end
 

data/lib/capybara/node/simple.rb

@@ -104,10 +104,10 @@ module Capybara
         return false if (tag_name == 'input') && (native[:type] == 'hidden')
 
         if check_ancestors
-          !find_xpath("boolean(./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head'])")
+          !find_xpath(VISIBILITY_XPATH)
         else
           # No need for an xpath if only checking the current element
-          !(native.has_attribute?('hidden') || (native[:style] =~ /display:\s?none/) || %w[script head].include?(tag_name))
+          !(native.key?('hidden') || (native[:style] =~ /display:\s?none/) || %w[script head].include?(tag_name))
         end
       end
 
@@ -185,6 +185,14 @@ module Capybara
 
         option[:value] || option.content
       end
+
+      VISIBILITY_XPATH = XPath.generate do |x|
+        x.ancestor_or_self[
+          x.attr(:style)[x.contains('display:none') | x.contains('display: none')] |
+          x.attr(:hidden) |
+          x.qname.one_of('script', 'head')
+        ].boolean
+      end.to_s.freeze
     end
   end
 end

data/lib/capybara/queries/base_query.rb

@@ -77,17 +77,21 @@ module Capybara
         message = +''
         count, between, maximum, minimum = options.values_at(:count, :between, :maximum, :minimum)
         if count
-          message << " #{count} #{Capybara::Helpers.declension('time', 'times', count)}"
+          message << " #{occurrences count}"
         elsif between
           message << " between #{between.first} and #{between.last} times"
         elsif maximum
-          message << " at most #{maximum} #{Capybara::Helpers.declension('time', 'times', maximum)}"
+          message << " at most #{occurrences maximum}"
         elsif minimum
-          message << " at least #{minimum} #{Capybara::Helpers.declension('time', 'times', minimum)}"
+          message << " at least #{occurrences minimum}"
         end
         message
       end
 
+      def occurrences(count)
+        "#{count} #{Capybara::Helpers.declension('time', 'times', count)}"
+      end
+
       def assert_valid_keys
         invalid_keys = @options.keys - valid_keys
         return if invalid_keys.empty?

data/lib/capybara/queries/selector_query.rb

@@ -24,7 +24,8 @@ module Capybara
 
         raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
-        @expression = selector.call(@locator, @options.merge(selector_config: { enable_aria_label: enable_aria_label, test_id: test_id }))
+        selector_config = { enable_aria_label: enable_aria_label, test_id: test_id }
+        @expression = selector.call(@locator, @options.merge(selector_config: selector_config))
 
         warn_exact_usage
 
@@ -34,21 +35,23 @@ module Capybara
       def name; selector.name; end
       def label; selector.label || selector.name; end
 
-      def description(applied = false)
+      def description(only_applied = false)
         desc = +''
-        if !applied || applied_filters
+        show_for = show_for_stage(only_applied)
+
+        if show_for[:any]
           desc << 'visible ' if visible == :visible
           desc << 'non-visible ' if visible == :hidden
         end
         desc << "#{label} #{locator.inspect}"
-        if !applied || applied_filters
+        if show_for[:any]
           desc << " with#{' exact' if exact_text == true} text #{options[:text].inspect}" if options[:text]
           desc << " with exact text #{exact_text}" if exact_text.is_a?(String)
         end
         desc << " with id #{options[:id]}" if options[:id]
         desc << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
-        desc << selector.description(node_filters: !applied || (applied_filters == :node), **options)
-        desc << ' that also matches the custom filter block' if @filter_block && (!applied || (applied_filters == :node))
+        desc << selector.description(node_filters: show_for[:node], **options)
+        desc << ' that also matches the custom filter block' if @filter_block && show_for[:node]
         desc << " within #{@resolved_node.inspect}" if describe_within?
         desc
       end
@@ -57,20 +60,21 @@ module Capybara
         description(true)
       end
 
-      def matches_filters?(node)
+      def matches_filters?(node, node_filter_errors = [])
         return true if (@resolved_node&.== node) && options[:allow_self]
+        return false unless matches_locator_filter?(node)
 
-        @applied_filters ||= :system
+        applied_filters << :system
         return false unless matches_system_filters?(node)
 
-        @applied_filters = :node
-        matches_node_filters?(node) && matches_filter_block?(node)
+        applied_filters << :node
+        matches_node_filters?(node, node_filter_errors) && matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
         false
       end
 
       def visible
-        case (vis = options.fetch(:visible) { @selector.default_visibility(session_options.ignore_hidden_elements, options) })
+        case (vis = options.fetch(:visible) { default_visibility })
         when true then :visible
         when false then :all
         else vis
@@ -98,7 +102,7 @@ module Capybara
 
       # @api private
       def resolve_for(node, exact = nil)
-        @applied_filters = false
+        applied_filters.clear
         @resolved_node = node
         node.synchronize do
           children = find_nodes_by_selector_format(node, exact).map(&method(:to_element))
@@ -121,8 +125,14 @@ module Capybara
 
     private
 
+      def show_for_stage(only_applied)
+        lambda do |stage = :any|
+          !only_applied || (stage == :any ? applied_filters.any? : applied_filters.include?(stage))
+        end
+      end
+
       def applied_filters
-        @applied_filters ||= false
+        @applied_filters ||= []
       end
 
       def find_selector(locator)
@@ -154,21 +164,23 @@ module Capybara
         VALID_KEYS + custom_keys
       end
 
-      def matches_node_filters?(node)
+      def matches_node_filters?(node, errors)
         unapplied_options = options.keys - valid_keys
-        node_filters.all? do |filter_name, filter|
-          if filter.matcher?
-            unapplied_options.select { |option_name| filter.handles_option?(option_name) }.all? do |option_name|
-              unapplied_options.delete(option_name)
-              filter.matches?(node, option_name, options[option_name])
+        @selector.with_filter_errors(errors) do
+          node_filters.all? do |filter_name, filter|
+            if filter.matcher?
+              unapplied_options.select { |option_name| filter.handles_option?(option_name) }.all? do |option_name|
+                unapplied_options.delete(option_name)
+                filter.matches?(node, option_name, options[option_name], @selector)
+              end
+            elsif options.key?(filter_name)
+              unapplied_options.delete(filter_name)
+              filter.matches?(node, filter_name, options[filter_name], @selector)
+            elsif filter.default?
+              filter.matches?(node, filter_name, filter.default, @selector)
+            else
+              true
             end
-          elsif options.key?(filter_name)
-            unapplied_options.delete(filter_name)
-            filter.matches?(node, filter_name, options[filter_name])
-          elsif filter.default?
-            filter.matches?(node, filter_name, filter.default)
-          else
-            true
           end
         end
       end
@@ -183,17 +195,21 @@ module Capybara
         end
       end
 
+      def filter_set(name)
+        ::Capybara::Selector::FilterSet.all[name]
+      end
+
       def node_filters
         if options.key?(:filter_set)
-          ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
+          filter_set(options[:filter_set])
         else
-          @selector.node_filters
-        end
+          @selector
+        end.node_filters
       end
 
       def expression_filters
         filters = @selector.expression_filters
-        filters.merge ::Capybara::Selector::FilterSet.all[options[:filter_set]].expression_filters if options.key?(:filter_set)
+        filters.merge filter_set(options[:filter_set]).expression_filters if options.key?(:filter_set)
         filters
       end
 
@@ -253,15 +269,15 @@ module Capybara
         unapplied_options = options.keys - valid_keys
         expression_filters.inject(expression) do |expr, (name, ef)|
           if ef.matcher?
-            unapplied_options.select { |option_name| ef.handles_option?(option_name) }.inject(expr) do |memo, option_name|
+            unapplied_options.select(&ef.method(:handles_option?)).inject(expr) do |memo, option_name|
               unapplied_options.delete(option_name)
-              ef.apply_filter(memo, option_name, options[option_name])
+              ef.apply_filter(memo, option_name, options[option_name], @selector)
             end
           elsif options.key?(name)
             unapplied_options.delete(name)
-            ef.apply_filter(expr, name, options[name])
+            ef.apply_filter(expr, name, options[name], @selector)
           elsif ef.default?
-            ef.apply_filter(expr, name, ef.default)
+            ef.apply_filter(expr, name, ef.default, @selector)
           else
             expr
           end
@@ -290,6 +306,12 @@ module Capybara
         node.is_a?(::Capybara::Node::Simple) && node.path == '/'
       end
 
+      def matches_locator_filter?(node)
+        return true if @selector.locator_filter.nil?
+
+        @selector.locator_filter.call(node, @locator)
+      end
+
       def matches_system_filters?(node)
         matches_id_filter?(node) &&
           matches_class_filter?(node) &&
@@ -348,6 +370,10 @@ module Capybara
         !!node.text(text_visible, normalize_ws: normalize_ws).match(regexp)
       end
 
+      def default_visibility
+        @selector.default_visibility(session_options.ignore_hidden_elements, options)
+      end
+
       def builder
         selector.builder
       end

data/lib/capybara/queries/style_query.rb

@@ -5,7 +5,7 @@ module Capybara
   module Queries
     class StyleQuery < BaseQuery
       def initialize(expected_styles, session_options:, **options)
-        @expected_styles = expected_styles.each_with_object({}) { |(style, value), str_keys| str_keys[style.to_s] = value }
+        @expected_styles = stringify_keys(expected_styles)
         @options = options
         @actual_styles = {}
         super(@options)
@@ -33,6 +33,10 @@ module Capybara
 
     private
 
+      def stringify_keys(hsh)
+        hsh.each_with_object({}) { |(k, v), str_keys| str_keys[k.to_s] = v }
+      end
+
       def valid_keys
         %i[wait]
       end

data/lib/capybara/queries/text_query.rb

@@ -65,7 +65,7 @@ module Capybara
         insensitive_count = @actual_text.scan(insensitive_regexp).size
         return if insensitive_count == @count
 
-        "it was found #{insensitive_count} #{Capybara::Helpers.declension('time', 'times', insensitive_count)} using a case insensitive search"
+        "it was found #{occurrences insensitive_count} using a case insensitive search"
       end
 
       def invisible_message
@@ -73,7 +73,7 @@ module Capybara
         invisible_count = invisible_text.scan(@search_regexp).size
         return if invisible_count == @count
 
-        "it was found #{invisible_count} #{Capybara::Helpers.declension('time', 'times', invisible_count)} including non-visible text"
+        "it was found #{occurrences invisible_count} including non-visible text"
       rescue StandardError
         # An error getting the non-visible text (if element goes out of scope) should not affect the response
         nil

data/lib/capybara/queries/title_query.rb

@@ -8,7 +8,7 @@ module Capybara
         @expected_title = expected_title.is_a?(Regexp) ? expected_title : expected_title.to_s
         @options = options
         super(@options)
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_title, all_whitespace: true, exact: options.fetch(:exact, false))
+        @search_regexp = Helpers.to_regexp(@expected_title, all_whitespace: true, exact: options.fetch(:exact, false))
         assert_valid_keys
       end
 

data/lib/capybara/rack_test/node.rb

@@ -96,9 +96,9 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     return true if string_node.disabled?
 
     if %w[option optgroup].include? tag_name
-      find_xpath('parent::*[self::optgroup or self::select or self::datalist]')[0].disabled?
+      find_xpath(OPTION_OWNER_XPATH)[0].disabled?
     else
-      !find_xpath('parent::fieldset[@disabled] | ancestor::*[not(self::legend) or preceding-sibling::legend][parent::fieldset[@disabled]]').empty?
+      !find_xpath(DISABLED_BY_FIELDSET_XPATH).empty?
     end
   end
 
@@ -256,4 +256,18 @@ protected
   def textarea?
     tag_name == 'textarea'
   end
+
+  OPTION_OWNER_XPATH = XPath.parent(:optgroup, :select, :datalist).to_s.freeze
+  DISABLED_BY_FIELDSET_XPATH = XPath.generate do |x|
+    x.parent(:fieldset)[
+      XPath.attr(:disabled)
+    ] + x.ancestor[
+      ~x.self(:legend) |
+      x.preceding_sibling(:legend)
+    ][
+      x.parent(:fieldset)[
+        x.attr(:disabled)
+      ]
+    ]
+  end.to_s.freeze
 end

data/lib/capybara/result.rb

@@ -7,7 +7,7 @@ module Capybara
   # A {Capybara::Result} represents a collection of {Capybara::Node::Element} on the page. It is possible to interact with this
   # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
   #
-  # * []
+  # * \[\]
   # * each()
   # * at()
   # * size()
@@ -16,6 +16,8 @@ module Capybara
   # * first()
   # * last()
   # * empty?()
+  # * values_at()
+  # * sample()
   #
   # @see Capybara::Node::Element
   #
@@ -26,7 +28,8 @@ module Capybara
     def initialize(elements, query)
       @elements = elements
       @result_cache = []
-      @results_enum = lazy_select_elements { |node| query.matches_filters?(node) }
+      @filter_errors = []
+      @results_enum = lazy_select_elements { |node| query.matches_filters?(node, @filter_errors) }
       @query = query
     end
 
@@ -106,11 +109,13 @@ module Capybara
       if count.zero?
         message << ' but there were no matches'
       else
-        message << ", found #{count} #{Capybara::Helpers.declension('match', 'matches', count)}: " << full_results.map(&:text).map(&:inspect).join(', ')
+        message << ", found #{count} #{Capybara::Helpers.declension('match', 'matches', count)}: " \
+                << full_results.map(&:text).map(&:inspect).join(', ')
       end
       unless rest.empty?
         elements = rest.map { |el| el.text rescue '<<ERROR>>' }.map(&:inspect).join(', ') # rubocop:disable Style/RescueModifier
-        message << '. Also found ' << elements << ', which matched the selector but not all filters.'
+        message << '. Also found ' << elements << ', which matched the selector but not all filters. '
+        message << @filter_errors.join('. ') if (rest.size == 1) && count.zero?
       end
       message
     end

data/lib/capybara/rspec/features.rb

@@ -14,10 +14,10 @@ RSpec.configure do |config|
 end
 
 RSpec.configure do |config|
-  config.alias_example_group_to :feature, capybara_feature: true, type: :feature
-  config.alias_example_group_to :xfeature, capybara_feature: true, type: :feature, skip: 'Temporarily disabled with xfeature'
-  config.alias_example_group_to :ffeature, capybara_feature: true, type: :feature, focus: true
+  config.alias_example_group_to :feature, :capybara_feature, type: :feature
+  config.alias_example_group_to :xfeature, :capybara_feature, type: :feature, skip: 'Temporarily disabled with xfeature'
+  config.alias_example_group_to :ffeature, :capybara_feature, :focus, type: :feature
   config.alias_example_to :scenario
   config.alias_example_to :xscenario, skip: 'Temporarily disabled with xscenario'
-  config.alias_example_to :fscenario, focus: true
+  config.alias_example_to :fscenario, :focus
 end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -27,7 +27,9 @@ if RUBY_ENGINE == 'jruby'
 
       def included(base)
         warn 'including Capybara::DSL in the global scope is not recommended!' if base == Object
-        base.send(:include, ::Capybara::RSpecMatcherProxies) if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+        if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+          base.send(:include, ::Capybara::RSpecMatcherProxies)
+        end
         super
       end
     end

data/lib/capybara/rspec/matchers.rb

@@ -1,315 +1,52 @@
 # frozen_string_literal: true
 
-require 'capybara/rspec/compound'
+require 'capybara/rspec/matchers/have_selector'
+require 'capybara/rspec/matchers/match_selector'
+require 'capybara/rspec/matchers/have_current_path'
+require 'capybara/rspec/matchers/have_style'
+require 'capybara/rspec/matchers/have_text'
+require 'capybara/rspec/matchers/have_title'
+require 'capybara/rspec/matchers/become_closed'
 
 module Capybara
   module RSpecMatchers
-    class Matcher
-      include ::Capybara::RSpecMatchers::Compound if defined?(::Capybara::RSpecMatchers::Compound)
-
-      attr_reader :failure_message, :failure_message_when_negated
-
-      def initialize(*args, &filter_block)
-        @args = args.dup
-        @filter_block = filter_block
-      end
-
-      def wrap(actual)
-        actual = actual.to_capybara_node if actual.respond_to?(:to_capybara_node)
-        @context_el = if actual.respond_to?(:has_selector?)
-          actual
-        else
-          Capybara.string(actual.to_s)
-        end
-      end
-
-    private
-
-      def session_query_args
-        if @args.last.is_a? Hash
-          @args.last[:session_options] = session_options
-        else
-          @args.push(session_options: session_options)
-        end
-        @args
-      end
-
-      def session_options
-        @context_el ||= nil
-        if @context_el.respond_to? :session_options
-          @context_el.session_options
-        elsif @context_el.respond_to? :current_scope
-          @context_el.current_scope.session_options
-        else
-          Capybara.session_options
-        end
-      end
-    end
-
-    class WrappedElementMatcher < Matcher
-      def matches?(actual)
-        element_matches?(wrap(actual))
-      rescue Capybara::ExpectationNotMet => err
-        @failure_message = err.message
-        false
-      end
-
-      def does_not_match?(actual)
-        element_does_not_match?(wrap(actual))
-      rescue Capybara::ExpectationNotMet => err
-        @failure_message_when_negated = err.message
-        false
-      end
-    end
-
-    class HaveSelector < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_selector(*@args, &@filter_block)
-      end
-
-      def element_does_not_match?(el)
-        el.assert_no_selector(*@args, &@filter_block)
-      end
-
-      def description
-        "have #{query.description}"
-      end
-
-      def query
-        @query ||= Capybara::Queries::SelectorQuery.new(*session_query_args, &@filter_block)
-      end
-    end
-
-    class HaveAllSelectors < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_all_of_selectors(*@args, &@filter_block)
-      end
-
-      def does_not_match?(_actual)
-        raise ArgumentError, 'The have_all_selectors matcher does not support use with not_to/should_not'
-      end
-
-      def description
-        'have all selectors'
-      end
-    end
-
-    class HaveNoSelectors < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_none_of_selectors(*@args, &@filter_block)
-      end
-
-      def does_not_match?(_actual)
-        raise ArgumentError, 'The have_none_of_selectors matcher does not support use with not_to/should_not'
-      end
-
-      def description
-        'have no selectors'
-      end
-    end
-
-    class HaveAnySelectors < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_any_of_selectors(*@args, &@filter_block)
-      end
-
-      def does_not_match?(_actual)
-        el.assert_none_of_selectors(*@args, &@filter_block)
-      end
-
-      def description
-        'have any selectors'
-      end
-    end
-
-    class MatchSelector < HaveSelector
-      def element_matches?(el)
-        el.assert_matches_selector(*@args, &@filter_block)
-      end
-
-      def element_does_not_match?(el)
-        el.assert_not_matches_selector(*@args, &@filter_block)
-      end
-
-      def description
-        "match #{query.description}"
-      end
-
-      def query
-        @query ||= Capybara::Queries::MatchQuery.new(*session_query_args, &@filter_block)
-      end
-    end
-
-    class HaveText < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_text(*@args)
-      end
-
-      def element_does_not_match?(el)
-        el.assert_no_text(*@args)
-      end
-
-      def description
-        "text #{format(text)}"
-      end
-
-      def format(content)
-        content.inspect
-      end
-
-    private
-
-      def text
-        @args[0].is_a?(Symbol) ? @args[1] : @args[0]
-      end
-    end
-
-    class HaveTitle < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_title(*@args)
-      end
-
-      def element_does_not_match?(el)
-        el.assert_no_title(*@args)
-      end
-
-      def description
-        "have title #{title.inspect}"
-      end
-
-    private
-
-      def title
-        @args.first
-      end
-    end
-
-    class HaveCurrentPath < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_current_path(*@args)
-      end
-
-      def element_does_not_match?(el)
-        el.assert_no_current_path(*@args)
-      end
-
-      def description
-        "have current path #{current_path.inspect}"
-      end
-
-    private
-
-      def current_path
-        @args.first
-      end
-    end
-
-    class NegatedMatcher
-      include ::Capybara::RSpecMatchers::Compound if defined?(::Capybara::RSpecMatchers::Compound)
-
-      def initialize(matcher)
-        super()
-        @matcher = matcher
-      end
-
-      def matches?(actual)
-        @matcher.does_not_match?(actual)
-      end
-
-      def does_not_match?(actual)
-        @matcher.matches?(actual)
-      end
-
-      def description
-        "not #{@matcher.description}"
-      end
-
-      def failure_message
-        @matcher.failure_message_when_negated
-      end
-
-      def failure_message_when_negated
-        @matcher.failure_message
-      end
-    end
-
-    class HaveStyle < WrappedElementMatcher
-      def element_matches?(el)
-        el.assert_style(*@args)
-      end
-
-      def does_not_match?(_actual)
-        raise ArgumentError, 'The have_style matcher does not support use with not_to/should_not'
-      end
-
-      def description
-        'have style'
-      end
-    end
-
-    class BecomeClosed
-      def initialize(options)
-        @options = options
-      end
-
-      def matches?(window)
-        @window = window
-        @wait_time = Capybara::Queries::BaseQuery.wait(@options, window.session.config.default_max_wait_time)
-        timer = Capybara::Helpers.timer(expire_in: @wait_time)
-        while window.exists?
-          return false if timer.expired?
-
-          sleep 0.05
-        end
-        true
-      end
-
-      def failure_message
-        "expected #{@window.inspect} to become closed after #{@wait_time} seconds"
-      end
-
-      def failure_message_when_negated
-        "expected #{@window.inspect} not to become closed after #{@wait_time} seconds"
-      end
-    end
-
     # RSpec matcher for whether the element(s) matching a given selector exist
     # See {Capybara::Node::Matcher#assert_selector}
     def have_selector(*args, &optional_filter_block)
-      HaveSelector.new(*args, &optional_filter_block)
+      Matchers::HaveSelector.new(*args, &optional_filter_block)
     end
 
     # RSpec matcher for whether the element(s) matching a group of selectors exist
     # See {Capybara::Node::Matcher#assert_all_of_selectors}
     def have_all_of_selectors(*args, &optional_filter_block)
-      HaveAllSelectors.new(*args, &optional_filter_block)
+      Matchers::HaveAllSelectors.new(*args, &optional_filter_block)
     end
 
     # RSpec matcher for whether no element(s) matching a group of selectors exist
     # See {Capybara::Node::Matcher#assert_none_of_selectors}
     def have_none_of_selectors(*args, &optional_filter_block)
-      HaveNoSelectors.new(*args, &optional_filter_block)
+      Matchers::HaveNoSelectors.new(*args, &optional_filter_block)
     end
 
     # RSpec matcher for whether the element(s) matching any of a group of selectors exist
     # See {Capybara::Node::Matcher#assert_any_of_selectors}
     def have_any_of_selectors(*args, &optional_filter_block)
-      HaveAnySelectors.new(*args, &optional_filter_block)
+      Matchers::HaveAnySelectors.new(*args, &optional_filter_block)
     end
 
     # RSpec matcher for whether the current element matches a given selector
     # See {Capybara::Node::Matchers#assert_matches_selector}
     def match_selector(*args, &optional_filter_block)
-      MatchSelector.new(*args, &optional_filter_block)
+      Matchers::MatchSelector.new(*args, &optional_filter_block)
     end
 
     %i[css xpath].each do |selector|
       define_method "have_#{selector}" do |expr, **options, &optional_filter_block|
-        HaveSelector.new(selector, expr, options, &optional_filter_block)
+        Matchers::HaveSelector.new(selector, expr, options, &optional_filter_block)
       end
 
       define_method "match_#{selector}" do |expr, **options, &optional_filter_block|
-        MatchSelector.new(selector, expr, options, &optional_filter_block)
+        Matchers::MatchSelector.new(selector, expr, options, &optional_filter_block)
       end
     end
 
@@ -331,7 +68,7 @@ module Capybara
 
     %i[link button field select table].each do |selector|
       define_method "have_#{selector}" do |locator = nil, **options, &optional_filter_block|
-        HaveSelector.new(selector, locator, options, &optional_filter_block)
+        Matchers::HaveSelector.new(selector, locator, options, &optional_filter_block)
       end
     end
 
@@ -357,7 +94,7 @@ module Capybara
 
     %i[checked unchecked].each do |state|
       define_method "have_#{state}_field" do |locator = nil, **options, &optional_filter_block|
-        HaveSelector.new(:field, locator, options.merge(state => true), &optional_filter_block)
+        Matchers::HaveSelector.new(:field, locator, options.merge(state => true), &optional_filter_block)
       end
     end
 
@@ -372,36 +109,37 @@ module Capybara
     # RSpec matcher for text content
     # See {Capybara::SessionMatchers#assert_text}
     def have_text(*args)
-      HaveText.new(*args)
+      Matchers::HaveText.new(*args)
     end
     alias_method :have_content, :have_text
 
     def have_title(title, **options)
-      HaveTitle.new(title, options)
+      Matchers::HaveTitle.new(title, options)
     end
 
     # RSpec matcher for the current path
     # See {Capybara::SessionMatchers#assert_current_path}
     def have_current_path(path, **options)
-      HaveCurrentPath.new(path, options)
+      Matchers::HaveCurrentPath.new(path, options)
     end
 
     # RSpec matcher for element style
     # See {Capybara::Node::Matchers#has_style?}
     def have_style(styles, **options)
-      HaveStyle.new(styles, options)
+      Matchers::HaveStyle.new(styles, options)
     end
 
-    %w[selector css xpath text title current_path link button field checked_field unchecked_field select table].each do |matcher_type|
+    %w[selector css xpath text title current_path link button
+       field checked_field unchecked_field select table].each do |matcher_type|
       define_method "have_no_#{matcher_type}" do |*args, &optional_filter_block|
-        NegatedMatcher.new(send("have_#{matcher_type}", *args, &optional_filter_block))
+        Matchers::NegatedMatcher.new(send("have_#{matcher_type}", *args, &optional_filter_block))
       end
     end
     alias_method :have_no_content, :have_no_text
 
     %w[selector css xpath].each do |matcher_type|
       define_method "not_match_#{matcher_type}" do |*args, &optional_filter_block|
-        NegatedMatcher.new(send("match_#{matcher_type}", *args, &optional_filter_block))
+        Matchers::NegatedMatcher.new(send("match_#{matcher_type}", *args, &optional_filter_block))
       end
     end
 
@@ -412,7 +150,7 @@ module Capybara
     # @param options [Hash] optional param
     # @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum wait time
     def become_closed(**options)
-      BecomeClosed.new(options)
+      Matchers::BecomeClosed.new(options)
     end
   end
 end