capybara 3.18.0 → 3.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cb32760328428839877de78f879a68af52098b0d1540c1d0de102acce58bc4b
-  data.tar.gz: b2c40ed521b21b43b4a44e1fe91f38b704e6c85e04829673fcc4493ff8fd217a
+  metadata.gz: cdee23fb17ec93c0e1c5e8e9b61607f11211e065ff94a99084dc28e3ff0cc24c
+  data.tar.gz: 428519d0593d850d7c355e7300ed0805637dbbd498805b70452dcb9521a78a04
 SHA512:
-  metadata.gz: 69163470d9db2ce8831cad207bbc14aa286181357ac650b909f266fde4e50e2400a851f1451fb0091d54f859f8e270cfe267afbfc8d76b74b6e46f4a2cca21b9
-  data.tar.gz: 48b79d23c6c3c87e9bdcbfd2128a15b475b001699b3b15b79f208772d2dfbc8444f442267ece4d331be25b7489f6c39c869c4edcc017f4d03629d79b09dbbe57
+  metadata.gz: dd137a4698f4c9e797ecce6da32a1fb62e2011daf412b9898ecd85f1e8146447278c0fd60350b9b9baeff37ac35d1f3da62794ec7c17dd87509f767d5847cfa7
+  data.tar.gz: 85625218afed65274c180acb2e9cf2f8e809e52855150966f07c6db8e181dd0cd28bfd908ce39a1a53b52cdbcb09af631e7a4d5d694afd9af4330cd0588122fd

data/History.md

@@ -1,3 +1,19 @@
+# Version 3.19.0
+Release date: 2019-05-09
+
+### Added
+
+
+* Syntactic sugar `#once`, `#twice`, `#thrice`, `#excatly`, `#at_least`, `#at_most` to
+  `have_selector`, `have_css`, `have_xpath`, and `have_text` RSpec matchers
+* Support for multiple expression types in Selector definitions
+* Reduced wirecalls for common actions in Selenium driver
+
+### Fixed
+
+* Workaround Chrome 75 appending files to multiple file inputs
+* Suppressed retry when detecting http vs https server connection
+
 # Version 3.18.0
 Release date: 2019-04-22
 

data/README.md

@@ -3,10 +3,11 @@
 [![Build Status](https://secure.travis-ci.org/teamcapybara/capybara.svg)](https://travis-ci.org/teamcapybara/capybara)
 [![Build Status](https://ci.appveyor.com/api/projects/status/github/teamcapybara/capybara?svg=true)](https://ci.appveyor.com/api/projects/github/teamcapybara/capybara)
 [![Code Climate](https://codeclimate.com/github/teamcapybara/capybara.svg)](https://codeclimate.com/github/teamcapybara/capybara)
+[![Coverage Status](https://coveralls.io/repos/github/teamcapybara/capybara/badge.svg?branch=master)](https://coveralls.io/github/teamcapybara/capybara?branch=master)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jnicklas/capybara?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=capybara&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=capybara&package-manager=bundler&version-scheme=semver)
 
-**Note** You are viewing the README for the 3.18.x version of Capybara.
+**Note** You are viewing the README for the 3.19.x version of Capybara.
 
 
 Capybara helps you test web applications by simulating how a real user would
@@ -183,7 +184,7 @@ to one specific driver. For example:
 ```ruby
 describe 'some stuff which requires js', js: true do
   it 'will use the default js driver'
-  it 'will switch to one specific driver', driver: :webkit
+  it 'will switch to one specific driver', driver: :apparition
 end
 ```
 
@@ -260,7 +261,7 @@ end
 
 ## <a name="using-capybara-with-minitest"></a>Using Capybara with Minitest
 
-* If you are using Rails, add the following code in your `test_helper.rb`
+* If you are using Rails, but not using Rails system tests, add the following code in your `test_helper.rb`
     file to make Capybara available in all test cases deriving from
     `ActionDispatch::IntegrationTest`:
 
@@ -275,8 +276,7 @@ end
       include Capybara::Minitest::Assertions
 
       # Reset sessions and driver between tests
-      # Use super wherever this method is redefined in your individual test classes
-      def teardown
+      teardown do
         Capybara.reset_sessions!
         Capybara.use_default_driver
       end
@@ -341,9 +341,9 @@ For example if you'd prefer to run everything in Selenium, you could do:
 Capybara.default_driver = :selenium # :selenium_chrome and :selenium_chrome_headless are also registered
 ```
 
-However, if you are using RSpec or Cucumber, you may instead want to consider
-leaving the faster `:rack_test` as the __default_driver__, and marking only those
-tests that require a JavaScript-capable driver using `js: true` or
+However, if you are using RSpec or Cucumber (and your app runs correctly without JS),
+you may instead want to consider leaving the faster `:rack_test` as the __default_driver__, and
+marking only those tests that require a JavaScript-capable driver using `js: true` or
 `@javascript`, respectively.  By default, JavaScript tests are run using the
 `:selenium` driver. You can change this by setting
 `Capybara.javascript_driver`.
@@ -352,7 +352,7 @@ You can also change the driver temporarily (typically in the Before/setup and
 After/teardown blocks):
 
 ```ruby
-Capybara.current_driver = :webkit # temporarily select different driver
+Capybara.current_driver = :apparition # temporarily select different driver
 # tests here
 Capybara.use_default_driver       # switch back to default driver
 ```
@@ -410,42 +410,12 @@ and test server, see [Transactions and database setup](#transactions-and-databas
 
 ### <a name="apparition"></a>Apparition
 
-The [apparition driver](https://github.com/twalpole/apparition) in a new driver that allows you to run tests using Chrome in a headless
+The [apparition driver](https://github.com/twalpole/apparition) is a new driver that allows you to run tests using Chrome in a headless
 or headed configuration. It attempts to provide backwards compatibility with the [Poltergeist driver API](https://github.com/teampoltergeist/poltergeist)
-while allowing for the use of modern JS/CSS. It uses CDP to communicate with Chrome, thereby obviating the need for chromedriver.
-A compatibility layer for capybara-webkit is planned, although has not yet been started. This driver is being developed by the
-maintainer of Capybara and will attempt to keep up to date with new Capybara releases. It will probably be moved into the
-teamcapybara repo once completely stable.
-
-### <a name="capybara-webkit"></a>Capybara-webkit
-
-Note: `capybara-webkit` depends on QtWebkit which went end-of-life quite some time ago. There has been an attempt to revive the project but `capybara-webkit` is not yet (as far as I know) compatible with the revived version of QtWebKit (could be a good open source project for someone) and as such is still limited to an old version of QtWebKit.  This means its support for modern JS and CSS is severely limited.
-
-The [capybara-webkit driver](https://github.com/thoughtbot/capybara-webkit) is for true headless
-testing. It uses QtWebKit to start a rendering engine process. It can execute JavaScript as well.
-It is significantly faster than drivers like Selenium since it does not load an entire browser.
-
-You can install it with:
-
-```bash
-gem install capybara-webkit
-```
-
-And you can use it by:
-
-```ruby
-Capybara.javascript_driver = :webkit
-```
-
-### <a name="poltergeist"></a>Poltergeist
-
-Note: `poltergeist` depends on PhantomJS for which active development ended quite some time ago (2.1.1). As such it is roughly equivalent to a 6-7 year old version of Safari, meaning lack of support for modern JS and CSS. If any effort to update PhantomJS succeeds in the future this situation could change.
-
-[Poltergeist](https://github.com/teampoltergeist/poltergeist) is another
-headless driver which integrates Capybara with
-[PhantomJS](http://phantomjs.org/). It is truly headless, so doesn't
-require Xvfb to run on your CI server. It will also detect and report
-any Javascript errors that happen within the page.
+and [capybara-webkit API](https://github.com/thoughtbot/capybara-webkit) while allowing for the use of modern JS/CSS. It
+uses CDP to communicate with Chrome, thereby obviating the need for chromedriver. This driver is being developed by the
+current developer of Capybara and will attempt to keep up to date with new Capybara releases. It will probably be moved into the
+teamcapybara repo once it reaches v1.0.
 
 ## <a name="the-dsl"></a>The DSL
 

data/lib/capybara/node/actions.rb

@@ -300,12 +300,12 @@ module Capybara
         synchronize(Capybara::Queries::BaseQuery.wait(options, session_options.default_max_wait_time)) do
           begin
             find(:select, from, options)
-          rescue Capybara::ElementNotFound => select_error # rubocop:disable Naming/RescuedExceptionsVariableName
+          rescue Capybara::ElementNotFound => select_error # _rubocop:disable Naming/RescuedExceptionsVariableName
             raise if %i[selected with_selected multiple].any? { |option| options.key?(option) }
 
             begin
               find(:datalist_input, from, options)
-            rescue Capybara::ElementNotFound => dlinput_error
+            rescue Capybara::ElementNotFound => dlinput_error # _rubocop:disable Naming/RescuedExceptionsVariableName
               raise Capybara::ElementNotFound, "#{select_error.message} and #{dlinput_error.message}"
             end
           end

data/lib/capybara/node/element.rb

@@ -126,7 +126,6 @@ module Capybara
       #
       # @return [Capybara::Node::Element]  The element
       def select_option(wait: nil)
-        warn "Attempt to select disabled option: #{value || text}" if disabled?
         synchronize(wait) { base.select_option }
         self
       end
@@ -276,7 +275,8 @@ module Capybara
       # @return [String]      The tag name of the element
       #
       def tag_name
-        synchronize { base.tag_name }
+        # Element type is immutable so cache it
+        @tag_name ||= synchronize { base.tag_name }
       end
 
       ##
@@ -480,9 +480,7 @@ module Capybara
         %(#<Capybara::Node::Element tag="#{base.tag_name}" path="#{base.path}">)
       rescue NotSupportedByDriverError
         %(#<Capybara::Node::Element tag="#{base.tag_name}">)
-      rescue StandardError => err
-        raise unless session.driver.invalid_element_errors.any? { |et| err.is_a?(et) }
-
+      rescue *session.driver.invalid_element_errors
         %(Obsolete #<Capybara::Node::Element>)
       end
 

data/lib/capybara/queries/selector_query.rb

@@ -11,6 +11,7 @@ module Capybara
                      session_options:,
                      enable_aria_label: session_options.enable_aria_label,
                      test_id: session_options.test_id,
+                     selector_format: nil,
                      **options,
                      &filter_block)
         @resolved_node = nil
@@ -19,14 +20,18 @@ module Capybara
         super(@options)
         self.session_options = session_options
 
-        @selector = find_selector(args[0].is_a?(Symbol) ? args.shift : args[0])
+        @selector = Selector.new(
+          find_selector(args[0].is_a?(Symbol) ? args.shift : args[0]),
+          config: { enable_aria_label: enable_aria_label, test_id: test_id },
+          format: selector_format
+        )
+
         @locator = args.shift
         @filter_block = filter_block
 
         raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
-        selector_config = { enable_aria_label: enable_aria_label, test_id: test_id }
-        @expression = selector.call(@locator, @options.merge(selector_config: selector_config))
+        @expression = selector.call(@locator, @options)
 
         warn_exact_usage
 
@@ -83,7 +88,7 @@ module Capybara
           matches_system_filters?(node) &&
           matches_node_filters?(node, node_filter_errors) &&
           matches_filter_block?(node)
-      rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : []) # rubocop:disable Naming/RescuedExceptionsVariableName
+      rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : []) # _rubocop:disable Naming/RescuedExceptionsVariableName
         false
       end
 
@@ -129,7 +134,9 @@ module Capybara
 
       # @api private
       def supports_exact?
-        @expression.respond_to? :to_xpath
+        return @expression.respond_to? :to_xpath if @selector.supports_exact?.nil?
+
+        @selector.supports_exact?
       end
 
       def failure_message
@@ -142,6 +149,10 @@ module Capybara
 
     private
 
+      def selector_format
+        @selector.format
+      end
+
       def text_fragments
         text = (options[:text] || options[:exact_text])
         text.is_a?(String) ? text.split : []
@@ -192,23 +203,23 @@ module Capybara
       def find_nodes_by_selector_format(node, exact)
         hints = {}
         hints[:uses_visibility] = true unless visible == :all
-        hints[:texts] = text_fragments unless selector.format == :xpath
+        hints[:texts] = text_fragments unless selector_format == :xpath
         hints[:styles] = options[:style] if use_default_style_filter?
 
-        if selector.format == :css
+        if selector_format == :css
           if node.method(:find_css).arity != 1
             node.find_css(css, **hints)
           else
             node.find_css(css)
           end
-        elsif selector.format == :xpath
+        elsif selector_format == :xpath
           if node.method(:find_xpath).arity != 1
             node.find_xpath(xpath(exact), **hints)
           else
             node.find_xpath(xpath(exact))
           end
         else
-          raise ArgumentError, "Unknown format: #{selector.format}"
+          raise ArgumentError, "Unknown format: #{selector_format}"
         end
       end
 
@@ -230,6 +241,8 @@ module Capybara
         unapplied_options = options.keys - valid_keys
         @selector.with_filter_errors(errors) do
           node_filters.all? do |filter_name, filter|
+            next true unless apply_filter?(filter)
+
             if filter.matcher?
               unapplied_options.select { |option_name| filter.handles_option?(option_name) }.all? do |option_name|
                 unapplied_options.delete(option_name)
@@ -320,6 +333,8 @@ module Capybara
       def apply_expression_filters(expression)
         unapplied_options = options.keys - valid_keys
         expression_filters.inject(expression) do |expr, (name, ef)|
+          next expr unless apply_filter?(ef)
+
           if ef.matcher?
             unapplied_options.select(&ef.method(:handles_option?)).inject(expr) do |memo, option_name|
               unapplied_options.delete(option_name)
@@ -358,10 +373,14 @@ module Capybara
         node.is_a?(::Capybara::Node::Simple) && node.path == '/'
       end
 
+      def apply_filter?(filter)
+        filter.format.nil? || (filter.format == selector_format)
+      end
+
       def matches_locator_filter?(node)
-        return true unless @selector.locator_filter
+        return true unless @selector.locator_filter && apply_filter?(@selector.locator_filter)
 
-        @selector.locator_filter.matches?(node, @locator, @selector)
+        @selector.locator_filter.matches?(node, @locator, @selector, exact: exact?)
       end
 
       def matches_system_filters?(node)

data/lib/capybara/rack_test/node.rb

@@ -118,7 +118,7 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
 
   public_instance_methods(false).each do |meth_name|
     alias_method "unchecked_#{meth_name}", meth_name
-    private "unchecked_#{meth_name}" # rubocop:disable Layout/AccessModifierIndentation,Style/AccessModifierDeclarations
+    private "unchecked_#{meth_name}" # rubocop:disable Style/AccessModifierDeclarations
 
     define_method meth_name do |*args|
       stale_check

data/lib/capybara/result.rb

@@ -153,7 +153,9 @@ module Capybara
       # causes a concurrency issue with network requests here
       # https://github.com/jruby/jruby/issues/4212
       if (RUBY_PLATFORM == 'java') && (Gem::Version.new(JRUBY_VERSION) < Gem::Version.new('9.2.8.0'))
+        # :nocov:
         @elements.select(&block).to_enum # non-lazy evaluation
+        # :nocov:
       else
         @elements.lazy.select(&block)
       end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -21,6 +21,7 @@ module Capybara
 end
 
 if RUBY_ENGINE == 'jruby'
+  # :nocov:
   module Capybara::DSL
     class <<self
       remove_method :included
@@ -43,6 +44,7 @@ if RUBY_ENGINE == 'jruby'
       end
     end
   end
+  # :nocov:
 else
   module Capybara::DSLRSpecProxyInstaller
     module ClassMethods

data/lib/capybara/rspec/matchers/base.rb

@@ -48,8 +48,8 @@ module Capybara
 
         def does_not_match?(actual)
           element_does_not_match?(wrap(actual))
-        rescue Capybara::ExpectationNotMet => err
-          @failure_message_when_negated = err.message
+        rescue Capybara::ExpectationNotMet => e
+          @failure_message_when_negated = e.message
           false
         end
 

data/lib/capybara/rspec/matchers/count_sugar.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Capybara
+  module RSpecMatchers
+    module CountSugar
+      def once; exactly(1); end
+      def twice; exactly(2); end
+      def thrice; exactly(3); end
+
+      def exactly(number)
+        options[:count] = number
+        self
+      end
+
+      def at_most(number)
+        options[:maximum] = number
+        self
+      end
+
+      def at_least(number)
+        options[:minimum] = number
+        self
+      end
+
+      def times
+        self
+      end
+
+    private
+
+      def options
+        (@args.last.is_a?(Hash) ? @args : @args.push({})).last
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_selector.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require 'capybara/rspec/matchers/base'
+require 'capybara/rspec/matchers/count_sugar'
 
 module Capybara
   module RSpecMatchers
     module Matchers
       class HaveSelector < WrappedElementMatcher
+        include CountSugar
+
         def element_matches?(el)
           el.assert_selector(*@args, &@filter_block)
         end

data/lib/capybara/rspec/matchers/have_text.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require 'capybara/rspec/matchers/base'
+require 'capybara/rspec/matchers/count_sugar'
 
 module Capybara
   module RSpecMatchers
     module Matchers
       class HaveText < WrappedElementMatcher
+        include CountSugar
+
         def element_matches?(el)
           el.assert_text(*@args)
         end

data/lib/capybara/selector.rb

@@ -2,6 +2,181 @@
 
 require 'capybara/selector/xpath_extensions'
 require 'capybara/selector/selector'
+require 'capybara/selector/definition'
+
+# rubocop:disable Style/AsciiComments
+#
+# ## Built-in Selectors
+#
+#   * **:xpath** - Select elements by XPath expression
+#     * Locator: An XPath expression
+#
+#   * **:css** - Select elements by CSS selector
+#     * Locator: A CSS selector
+#
+#   * **:id** - Select element by id
+#     * Locator: (String, Regexp, XPath::Expression) The id of the element to match
+#
+#   * **:field** - Select field elements (input [not of type submit, image, or hidden], textarea, select)
+#     * Locator: Matches against the id, Capybara.test_id attribute, name, or placeholder
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :name (String) — Matches the name attribute
+#       * :placeholder (String) — Matches the placeholder attribute
+#       * :type (String) — Matches the type attribute of the field or element type for 'textarea' and 'select'
+#       * :readonly (Boolean)
+#       * :with (String) — Matches the current value of the field
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :checked (Boolean) — Match checked fields?
+#       * :unchecked (Boolean) — Match unchecked fields?
+#       * :disabled (Boolean) — Match disabled field?
+#       * :multiple (Boolean) — Match fields that accept multiple values
+#       * :style (String, Regexp, Hash)
+#
+#   * **:fieldset** - Select fieldset elements
+#     * Locator: Matches id or contents of wrapped legend
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches id attribute
+#       * :legend (String) — Matches contents of wrapped legend
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :style (String, Regexp, Hash)
+#
+#   * **:link** - Find links ( <a> elements with an href attribute )
+#     * Locator: Matches the id or title attributes, or the string content of the link, or the alt attribute of a contained img element
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :title (String) — Matches the title attribute
+#       * :alt (String) — Matches the alt attribute of a contained img element
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :href (String, Regexp, nil) — Matches the normalized href of the link, if nil will find <a> elements with no href attribute
+#       * :style (String, Regexp, Hash)
+#
+#   * **:button** - Find buttons ( input [of type submit, reset, image, button] or button elements )
+#     * Locator: Matches the id, Capybara.test_id attribute, name, value, or title attributes, string content of a button, or the alt attribute of an image type button or of a descendant image of a button
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :name (String) - Matches the name attribute
+#       * :title (String) — Matches the title attribute
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :value (String) — Matches the value of an input button
+#       * :type
+#       * :style (String, Regexp, Hash)
+#
+#   * **:link_or_button** - Find links or buttons
+#     * Locator: See :link and :button selectors
+#
+#   * **:fillable_field** - Find text fillable fields ( textarea, input [not of type submit, image, radio, checkbox, hidden, file] )
+#     * Locator: Matches against the id, Capybara.test_id attribute, name, or placeholder
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :name (String) — Matches the name attribute
+#       * :placeholder (String) — Matches the placeholder attribute
+#       * :with (String) — Matches the current value of the field
+#       * :type (String) — Matches the type attribute of the field or element type for 'textarea'
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :disabled (Boolean) — Match disabled field?
+#       * :multiple (Boolean) — Match fields that accept multiple values
+#       * :style (String, Regexp, Hash)
+#
+#   * **:radio_button** - Find radio buttons
+#     * Locator: Match id, Capybara.test_id attribute, name, or associated label text
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :name (String) — Matches the name attribute
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :checked (Boolean) — Match checked fields?
+#       * :unchecked (Boolean) — Match unchecked fields?
+#       * :disabled (Boolean) — Match disabled field?
+#       * :option (String) — Match the value
+#       * :style (String, Regexp, Hash)
+#
+#   * **:checkbox** - Find checkboxes
+#     * Locator: Match id, Capybara.test_id attribute, name, or associated label text
+#     * Filters:
+#       * *:id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * *:name (String) — Matches the name attribute
+#       * *:class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * *:checked (Boolean) — Match checked fields?
+#       * *:unchecked (Boolean) — Match unchecked fields?
+#       * *:disabled (Boolean) — Match disabled field?
+#       * *:option (String) — Match the value
+#       * :style (String, Regexp, Hash)
+#
+#   * **:select** - Find select elements
+#     * Locator: Match id, Capybara.test_id attribute, name, placeholder, or associated label text
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :name (String) — Matches the name attribute
+#       * :placeholder (String) — Matches the placeholder attribute
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :disabled (Boolean) — Match disabled field?
+#       * :multiple (Boolean) — Match fields that accept multiple values
+#       * :options (Array<String>) — Exact match options
+#       * :with_options (Array<String>) — Partial match options
+#       * :selected (String, Array<String>) — Match the selection(s)
+#       * :with_selected (String, Array<String>) — Partial match the selection(s)
+#       * :style (String, Regexp, Hash)
+#
+#   * **:option** - Find option elements
+#     * Locator: Match text of option
+#     * Filters:
+#       * :disabled (Boolean) — Match disabled option
+#       * :selected (Boolean) — Match selected option
+#
+#   * **:datalist_input**
+#     * Locator:
+#     * Filters:
+#       * :disabled
+#       * :name
+#       * :placeholder
+#
+#   * **:datalist_option**
+#     * Locator:
+#
+#   * **:file_field** - Find file input elements
+#     * Locator: Match id, Capybara.test_id attribute, name, or associated label text
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
+#       * :name (String) — Matches the name attribute
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :disabled (Boolean) — Match disabled field?
+#       * :multiple (Boolean) — Match field that accepts multiple values
+#       * :style (String, Regexp, Hash)
+#
+#   * **:label** - Find label elements
+#     * Locator: Match id or text contents
+#     * Filters:
+#       * :for (Element, String) — The element or id of the element associated with the label
+#
+#   * **:table** - Find table elements
+#     * Locator: id or caption text of table
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Match id attribute of table
+#       * :caption (String) — Match text of associated caption
+#       * :class ((String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :style (String, Regexp, Hash)
+#       * :with_rows (Array<Array<String>>, Array<Hash<String, String>>) - Partial match <td> data - visibility of <td> elements is not considered
+#       * :rows (Array<Array<String>>) — Match all <td>s - visibility of <td> elements is not considered
+#       * :with_cols (Array<Array<String>>, Array<Hash<String, String>>) - Partial match <td> data - visibility of <td> elements is not considered
+#       * :cols (Array<Array<String>>) — Match all <td>s - visibility of <td> elements is not considered
+#
+#   * **:table_row** - Find table row
+#     * Locator: Array<String>, Hash<String,String> table row <td> contents - visibility of <td> elements is not considered
+#
+#   * **:frame** - Find frame/iframe elements
+#     * Locator: Match id or name
+#     * Filters:
+#       * :id (String, Regexp, XPath::Expression) — Match id attribute
+#       * :name (String) — Match name attribute
+#       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
+#       * :style (String, Regexp, Hash)
+#
+#   * **:element**
+#     * Locator: Type of element ('div', 'a', etc) - if not specified defaults to '*'
+#     * Filters: Matches on any element attribute
+class Capybara::Selector; end
+#
+# rubocop:enable Style/AsciiComments
 
 Capybara::Selector::FilterSet.add(:_field) do
   node_filter(:checked, :boolean) { |node, value| !(value ^ node.checked?) }
@@ -33,602 +208,24 @@ Capybara::Selector::FilterSet.add(:_field) do
   end
 end
 
-# rubocop:disable Metrics/BlockLength
-
-Capybara.add_selector(:xpath, locator_type: [:to_xpath, String], raw_locator: true) do
-  xpath { |xpath| xpath }
-end
-
-Capybara.add_selector(:css, locator_type: [String, Symbol], raw_locator: true) do
-  css { |css| css }
-end
-
-Capybara.add_selector(:id, locator_type: [String, Symbol, Regexp]) do
-  xpath { |id| builder(XPath.descendant).add_attribute_conditions(id: id) }
-  locator_filter {  |node, id| id.is_a?(Regexp) ? id.match?(node[:id]) : true }
-end
-
-Capybara.add_selector(:field, locator_type: [String, Symbol]) do
-  visible { |options| :hidden if options[:type].to_s == 'hidden' }
-  xpath do |locator, **options|
-    invalid_types = %w[submit image]
-    invalid_types << 'hidden' unless options[:type].to_s == 'hidden'
-    xpath = XPath.descendant(:input, :textarea, :select)[!XPath.attr(:type).one_of(*invalid_types)]
-    locate_field(xpath, locator, options)
-  end
-
-  expression_filter(:type) do |expr, type|
-    type = type.to_s
-    if %w[textarea select].include?(type)
-      expr.self(type.to_sym)
-    else
-      expr[XPath.attr(:type) == type]
-    end
-  end
-
-  filter_set(:_field) # checked/unchecked/disabled/multiple/name/placeholder
-
-  node_filter(:readonly, :boolean) { |node, value| !(value ^ node.readonly?) }
-  node_filter(:with) do |node, with|
-    val = node.value
-    (with.is_a?(Regexp) ? with.match?(val) : val == with.to_s).tap do |res|
-      add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
-    end
-  end
-
-  describe_expression_filters do |type: nil, **|
-    " of type #{type.inspect}" if type
-  end
-
-  describe_node_filters do |**options|
-    " with value #{options[:with].to_s.inspect}" if options.key?(:with)
-  end
-end
-
-Capybara.add_selector(:fieldset, locator_type: [String, Symbol]) do
-  xpath do |locator, legend: nil, **|
-    locator_matchers = (XPath.attr(:id) == locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]
-    locator_matchers |= XPath.attr(test_id) == locator.to_s if test_id
-    xpath = XPath.descendant(:fieldset)[locator && locator_matchers]
-    xpath = xpath[XPath.child(:legend)[XPath.string.n.is(legend)]] if legend
-    xpath
-  end
-
-  node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
-  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
-end
-
-Capybara.add_selector(:link, locator_type: [String, Symbol]) do
-  xpath do |locator, href: true, alt: nil, title: nil, **|
-    xpath = builder(XPath.descendant(:a)).add_attribute_conditions(href: href)
-
-    unless locator.nil?
-      locator = locator.to_s
-      matchers = [XPath.attr(:id) == locator,
-                  XPath.string.n.is(locator),
-                  XPath.attr(:title).is(locator),
-                  XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
-      matchers << XPath.attr(:'aria-label').is(locator) if enable_aria_label
-      matchers << XPath.attr(test_id).equals(locator) if test_id
-      xpath = xpath[matchers.reduce(:|)]
-    end
-
-    xpath = xpath[find_by_attr(:title, title)]
-    xpath = xpath[XPath.descendant(:img)[XPath.attr(:alt) == alt]] if alt
-    xpath
-  end
-
-  node_filter(:href) do |node, href|
-    # If not a Regexp it's been handled in the main XPath
-    (href.is_a?(Regexp) ? node[:href].match?(href) : true).tap do |res|
-      add_error "Expected href to match #{href.inspect} but it was #{node[:href].inspect}" unless res
-    end
-  end
-
-  expression_filter(:download, valid_values: [true, false, String]) do |expr, download|
-    builder(expr).add_attribute_conditions(download: download)
-  end
-
-  describe_expression_filters do |download: nil, **options|
-    desc = +''
-    if (href = options[:href])
-      desc << " with href #{'matching ' if href.is_a? Regexp}#{href.inspect}"
-    elsif options.key?(:href) # is nil/false specified?
-      desc << ' with no href attribute'
-    end
-    desc << " with download attribute#{" #{download}" if download.is_a? String}" if download
-    desc << ' without download attribute' if download == false
-    desc
-  end
-end
-
-Capybara.add_selector(:button, locator_type: [String, Symbol]) do
-  xpath(:value, :title, :type, :name) do |locator, **options|
-    input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
-    btn_xpath = XPath.descendant(:button)
-    image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type) == 'image']
-
-    unless locator.nil?
-      locator = locator.to_s
-      locator_matchers = XPath.attr(:id).equals(locator) | XPath.attr(:name).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)
-      locator_matchers |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
-      locator_matchers |= XPath.attr(test_id) == locator if test_id
-
-      input_btn_xpath = input_btn_xpath[locator_matchers]
-
-      btn_xpath = btn_xpath[locator_matchers | XPath.string.n.is(locator) | XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
-
-      alt_matches = XPath.attr(:alt).is(locator)
-      alt_matches |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
-      image_btn_xpath = image_btn_xpath[alt_matches]
-    end
-
-    %i[value title type name].inject(input_btn_xpath.union(btn_xpath).union(image_btn_xpath)) do |memo, ef|
-      memo[find_by_attr(ef, options[ef])]
-    end
-  end
-
-  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
-  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
-
-  describe_expression_filters do |disabled: nil, **options|
-    desc = +''
-    desc << ' that is not disabled' if disabled == false
-    desc << describe_all_expression_filters(options)
-  end
-
-  describe_node_filters do |disabled: nil, **|
-    ' that is disabled' if disabled == true
-  end
-end
-
-Capybara.add_selector(:link_or_button, locator_type: [String, Symbol]) do
-  label 'link or button'
-  xpath do |locator, **options|
-    self.class.all.values_at(:link, :button).map do |selector|
-      instance_exec(locator, options, &selector.xpath)
-    end.reduce(:union)
-  end
-
-  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
-
-  describe_node_filters do |disabled: nil, **|
-    ' that is disabled' if disabled == true
-  end
-end
-
-Capybara.add_selector(:fillable_field, locator_type: [String, Symbol]) do
-  label 'field'
-  xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input, :textarea)[
-      !XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')
-    ]
-    locate_field(xpath, locator, options)
-  end
-
-  expression_filter(:type) do |expr, type|
-    type = type.to_s
-    if type == 'textarea'
-      expr.self(type.to_sym)
-    else
-      expr[XPath.attr(:type) == type]
-    end
-  end
-
-  filter_set(:_field, %i[disabled multiple name placeholder])
-
-  node_filter(:with) do |node, with|
-    val = node.value
-    (with.is_a?(Regexp) ? with.match?(val) : val == with.to_s).tap do |res|
-      add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
-    end
-  end
-
-  describe_node_filters do |**options|
-    " with value #{options[:with].to_s.inspect}" if options.key?(:with)
-  end
-end
-
-Capybara.add_selector(:radio_button, locator_type: [String, Symbol]) do
-  label 'radio button'
-  xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input)[
-      XPath.attr(:type) == 'radio'
-    ]
-    locate_field(xpath, locator, options)
-  end
-
-  filter_set(:_field, %i[checked unchecked disabled name])
-
-  node_filter(:option) do |node, value|
-    val = node.value
-    (val == value.to_s).tap do |res|
-      add_error("Expected option value to be #{value.inspect} but it was #{val.inspect}") unless res
-    end
-  end
-
-  describe_node_filters do |option: nil, **|
-    " with value #{option.inspect}" if option
-  end
-end
-
-Capybara.add_selector(:checkbox, locator_type: [String, Symbol]) do
-  xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input)[
-      XPath.attr(:type) == 'checkbox'
-    ]
-    locate_field(xpath, locator, options)
-  end
-
-  filter_set(:_field, %i[checked unchecked disabled name])
-
-  node_filter(:option) do |node, value|
-    val = node.value
-    (val == value.to_s).tap do |res|
-      add_error("Expected option value to be #{value.inspect} but it was #{val.inspect}") unless res
-    end
-  end
-
-  describe_node_filters do |option: nil, **|
-    " with value #{option.inspect}" if option
-  end
-end
-
-Capybara.add_selector(:select, locator_type: [String, Symbol]) do
-  label 'select box'
-
-  xpath do |locator, **options|
-    xpath = XPath.descendant(:select)
-    locate_field(xpath, locator, options)
-  end
-
-  filter_set(:_field, %i[disabled multiple name placeholder])
-
-  node_filter(:options) do |node, options|
-    actual = if node.visible?
-      node.all(:xpath, './/option', wait: false).map(&:text)
-    else
-      node.all(:xpath, './/option', visible: false, wait: false).map { |option| option.text(:all) }
-    end
-    (options.sort == actual.sort).tap do |res|
-      add_error("Expected options #{options.inspect} found #{actual.inspect}") unless res
-    end
-  end
-
-  expression_filter(:with_options) do |expr, options|
-    options.inject(expr) do |xpath, option|
-      xpath[self.class.all[:option].call(option)]
-    end
-  end
-
-  node_filter(:selected) do |node, selected|
-    actual = node.all(:xpath, './/option', visible: false, wait: false).select(&:selected?).map { |option| option.text(:all) }
-    (Array(selected).sort == actual.sort).tap do |res|
-      add_error("Expected #{selected.inspect} to be selected found #{actual.inspect}") unless res
-    end
-  end
-
-  node_filter(:with_selected) do |node, selected|
-    actual = node.all(:xpath, './/option', visible: false, wait: false).select(&:selected?).map { |option| option.text(:all) }
-    (Array(selected) - actual).empty?.tap do |res|
-      add_error("Expected at least #{selected.inspect} to be selected found #{actual.inspect}") unless res
-    end
-  end
-
-  describe_expression_filters do |with_options: nil, **|
-    desc = +''
-    desc << " with at least options #{with_options.inspect}" if with_options
-    desc
-  end
-
-  describe_node_filters do |options: nil, selected: nil, with_selected: nil, disabled: nil, **|
-    desc = +''
-    desc << " with options #{options.inspect}" if options
-    desc << " with #{selected.inspect} selected" if selected
-    desc << " with at least #{with_selected.inspect} selected" if with_selected
-    desc << ' which is disabled' if disabled
-    desc
-  end
-end
-
-Capybara.add_selector(:datalist_input, locator_type: [String, Symbol]) do
-  label 'input box with datalist completion'
-
-  xpath do |locator, **options|
-    xpath = XPath.descendant(:input)[XPath.attr(:list)]
-    locate_field(xpath, locator, options)
-  end
-
-  filter_set(:_field, %i[disabled name placeholder])
-
-  node_filter(:options) do |node, options|
-    actual = node.find("//datalist[@id=#{node[:list]}]", visible: :all).all(:datalist_option, wait: false).map(&:value)
-    (options.sort == actual.sort).tap do |res|
-      add_error("Expected #{options.inspect} options found #{actual.inspect}") unless res
-    end
-  end
-
-  expression_filter(:with_options) do |expr, options|
-    options.inject(expr) do |xpath, option|
-      xpath[XPath.attr(:list) == XPath.anywhere(:datalist)[self.class.all[:datalist_option].call(option)].attr(:id)]
-    end
-  end
-
-  describe_expression_filters do |with_options: nil, **|
-    desc = +''
-    desc << " with at least options #{with_options.inspect}" if with_options
-    desc
-  end
-
-  describe_node_filters do |options: nil, **|
-    " with options #{options.inspect}" if options
-  end
-end
-
-Capybara.add_selector(:option, locator_type: [String, Symbol]) do
-  xpath do |locator|
-    xpath = XPath.descendant(:option)
-    xpath = xpath[XPath.string.n.is(locator.to_s)] unless locator.nil?
-    xpath
-  end
-
-  node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
-  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
-
-  node_filter(:selected, :boolean) { |node, value| !(value ^ node.selected?) }
-
-  describe_expression_filters do |disabled: nil, **options|
-    desc = +''
-    desc << ' that is not disabled' if disabled == false
-    (expression_filters.keys & options.keys).inject(desc) { |memo, ef| memo << " with #{ef} #{options[ef]}" }
-  end
-
-  describe_node_filters do |**options|
-    desc = +''
-    desc << ' that is disabled' if options[:disabled]
-    desc << " that is#{' not' unless options[:selected]} selected" if options.key?(:selected)
-    desc
-  end
-end
-
-Capybara.add_selector(:datalist_option, locator_type: [String, Symbol]) do
-  label 'datalist option'
-  visible(:all)
-
-  xpath do |locator|
-    xpath = XPath.descendant(:option)
-    xpath = xpath[XPath.string.n.is(locator.to_s) | (XPath.attr(:value) == locator.to_s)] unless locator.nil?
-    xpath
-  end
-
-  node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
-  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
-
-  describe_expression_filters do |disabled: nil, **options|
-    desc = +''
-    desc << ' that is not disabled' if disabled == false
-    desc << describe_all_expression_filters(options)
-  end
-
-  describe_node_filters do |**options|
-    ' that is disabled' if options[:disabled]
-  end
-end
-
-Capybara.add_selector(:file_field, locator_type: [String, Symbol]) do
-  label 'file field'
-  xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input)[
-      XPath.attr(:type) == 'file'
-    ]
-    locate_field(xpath, locator, options)
-  end
-
-  filter_set(:_field, %i[disabled multiple name])
-end
-
-Capybara.add_selector(:label, locator_type: [String, Symbol]) do
-  label 'label'
-  xpath(:for) do |locator, options|
-    xpath = XPath.descendant(:label)
-    unless locator.nil?
-      locator_matchers = XPath.string.n.is(locator.to_s) | (XPath.attr(:id) == locator.to_s)
-      locator_matchers |= XPath.attr(test_id) == locator if test_id
-      xpath = xpath[locator_matchers]
-    end
-    if options.key?(:for)
-      if (for_option = options[:for].is_a?(Capybara::Node::Element) ? options[:for][:id] : options[:for])
-        with_attr = XPath.attr(:for) == for_option.to_s
-        labelable_elements = %i[button input keygen meter output progress select textarea]
-        wrapped = !XPath.attr(:for) &
-                  XPath.descendant(*labelable_elements)[XPath.attr(:id) == for_option.to_s]
-        xpath = xpath[with_attr | wrapped]
-      end
-    end
-    xpath
-  end
-
-  node_filter(:for) do |node, field_or_value|
-    # Non element values were handled through the expression filter
-    next true unless field_or_value.is_a? Capybara::Node::Element
-
-    if (for_val = node[:for])
-      field_or_value[:id] == for_val
-    else
-      field_or_value.find_xpath('./ancestor::label[1]').include? node.base
-    end
-  end
-
-  describe_expression_filters do |**options|
-    " for element with id of \"#{options[:for]}\"" if options.key?(:for) && !options[:for].is_a?(Capybara::Node::Element)
-  end
-  describe_node_filters do |**options|
-    " for element #{options[:for]}" if options[:for]&.is_a?(Capybara::Node::Element)
-  end
-end
-
-Capybara.add_selector(:table, locator_type: [String, Symbol]) do
-  xpath do |locator, caption: nil, **|
-    xpath = XPath.descendant(:table)
-    unless locator.nil?
-      locator_matchers = (XPath.attr(:id) == locator.to_s) | XPath.descendant(:caption).is(locator.to_s)
-      locator_matchers |= XPath.attr(test_id) == locator if test_id
-      xpath = xpath[locator_matchers]
-    end
-    xpath = xpath[XPath.descendant(:caption) == caption] if caption
-    xpath
-  end
-
-  expression_filter(:with_cols, valid_values: [Array]) do |xpath, cols|
-    col_conditions = cols.map do |col|
-      if col.is_a? Hash
-        col.reduce(nil) do |xp, (header, cell_str)|
-          header = XPath.descendant(:th)[XPath.string.n.is(header)]
-          td = XPath.descendant(:tr)[header].descendant(:td)
-          cell_condition = XPath.string.n.is(cell_str)
-          cell_condition &= prev_col_position?(XPath.ancestor(:table)[1].join(xp)) if xp
-          td[cell_condition]
-        end
-      else
-        cells_xp = col.reduce(nil) do |prev_cell, cell_str|
-          cell_condition = XPath.string.n.is(cell_str)
-
-          if prev_cell
-            prev_cell = XPath.ancestor(:tr)[1].preceding_sibling(:tr).join(prev_cell)
-            cell_condition &= prev_col_position?(prev_cell)
-          end
-
-          XPath.descendant(:td)[cell_condition]
-        end
-        XPath.descendant(:tr).join(cells_xp)
-      end
-    end.reduce(:&)
-    xpath[col_conditions]
-  end
-
-  expression_filter(:cols, valid_values: [Array]) do |xpath, cols|
-    raise ArgumentError, ':cols must be an Array of Arrays' unless cols.all? { |col| col.is_a? Array }
-
-    rows = cols.transpose
-    col_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)
-    xpath[match_row_count(rows.size)][col_conditions]
-  end
-
-  expression_filter(:with_rows, valid_values: [Array]) do |xpath, rows|
-    rows_conditions = rows.map { |row| match_row(row) }.reduce(:&)
-    xpath[rows_conditions]
-  end
-
-  expression_filter(:rows, valid_values: [Array]) do |xpath, rows|
-    rows_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)
-    xpath[match_row_count(rows.size)][rows_conditions]
-  end
-
-  describe_expression_filters do |caption: nil, **|
-    " with caption \"#{caption}\"" if caption
-  end
-
-  def prev_col_position?(cell)
-    XPath.position.equals(cell_position(cell))
-  end
-
-  def cell_position(cell)
-    cell.preceding_sibling(:td).count.plus(1)
-  end
-
-  def match_row(row, match_size: false)
-    xp = XPath.descendant(:tr)[
-      if row.is_a? Hash
-        row_match_cells_to_headers(row)
-      else
-        XPath.descendant(:td)[row_match_ordered_cells(row)]
-      end
-    ]
-    xp = xp[XPath.descendant(:td).count.equals(row.size)] if match_size
-    xp
-  end
-
-  def match_row_count(size)
-    XPath.descendant(:tbody).descendant(:tr).count.equals(size) | (XPath.descendant(:tr).count.equals(size) & ~XPath.descendant(:tbody))
-  end
-
-  def row_match_cells_to_headers(row)
-    row.map do |header, cell|
-      header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
-      XPath.descendant(:td)[
-        XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
-      ]
-    end.reduce(:&)
-  end
-
-  def row_match_ordered_cells(row)
-    row_conditions = row.map do |cell|
-      XPath.self(:td)[XPath.string.n.is(cell)]
-    end
-    row_conditions.reverse.reduce do |cond, cell|
-      cell[XPath.following_sibling[cond]]
-    end
-  end
-end
-
-Capybara.add_selector(:table_row, locator_type: [Array, Hash]) do
-  xpath do |locator|
-    xpath = XPath.descendant(:tr)
-    if locator.is_a? Hash
-      locator.reduce(xpath) do |xp, (header, cell)|
-        header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
-        cell_xp = XPath.descendant(:td)[
-          XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
-        ]
-        xp[cell_xp]
-      end
-    else
-      initial_td = XPath.descendant(:td)[XPath.string.n.is(locator.shift)]
-      tds = locator.reverse.map { |cell| XPath.following_sibling(:td)[XPath.string.n.is(cell)] }.reduce { |xp, cell| xp[cell] }
-      xpath[initial_td[tds]]
-    end
-  end
-end
-
-Capybara.add_selector(:frame, locator_type: [String, Symbol]) do
-  xpath do |locator, name: nil, **|
-    xpath = XPath.descendant(:iframe).union(XPath.descendant(:frame))
-    unless locator.nil?
-      locator_matchers = (XPath.attr(:id) == locator.to_s) | (XPath.attr(:name) == locator.to_s)
-      locator_matchers |= XPath.attr(test_id) == locator if test_id
-      xpath = xpath[locator_matchers]
-    end
-    xpath[find_by_attr(:name, name)]
-  end
-
-  describe_expression_filters do |name: nil, **|
-    " with name #{name}" if name
-  end
-end
-
-Capybara.add_selector(:element, locator_type: [String, Symbol]) do
-  xpath do |locator, **|
-    XPath.descendant.where(locator ? XPath.local_name == locator.to_s : nil)
-  end
-
-  expression_filter(:attributes, matcher: /.+/) do |xpath, name, val|
-    builder(xpath).add_attribute_conditions(name => val)
-  end
-
-  node_filter(:attributes, matcher: /.+/) do |node, name, val|
-    next true unless val.is_a?(Regexp)
-
-    (val.match? node[name]).tap do |res|
-      add_error("Expected #{name} to match #{val.inspect} but it was #{node[name]}") unless res
-    end
-  end
-
-  describe_expression_filters do |**options|
-    booleans, values = options.partition { |_k, v| [true, false].include? v }.map(&:to_h)
-    desc = describe_all_expression_filters(values)
-    desc + booleans.map do |k, v|
-      v ? " with #{k} attribute" : "without #{k} attribute"
-    end.join
-  end
-end
-# rubocop:enable Metrics/BlockLength
+require 'capybara/selector/definition/xpath'
+require 'capybara/selector/definition/css'
+require 'capybara/selector/definition/id'
+require 'capybara/selector/definition/field'
+require 'capybara/selector/definition/fieldset'
+require 'capybara/selector/definition/link'
+require 'capybara/selector/definition/button'
+require 'capybara/selector/definition/link_or_button'
+require 'capybara/selector/definition/fillable_field'
+require 'capybara/selector/definition/radio_button'
+require 'capybara/selector/definition/checkbox'
+require 'capybara/selector/definition/select'
+require 'capybara/selector/definition/datalist_input'
+require 'capybara/selector/definition/option'
+require 'capybara/selector/definition/datalist_option'
+require 'capybara/selector/definition/file_field'
+require 'capybara/selector/definition/label'
+require 'capybara/selector/definition/table'
+require 'capybara/selector/definition/table_row'
+require 'capybara/selector/definition/frame'
+require 'capybara/selector/definition/element'