capybara 3.16.1 → 3.33.0

data/lib/capybara/selector/definition/table.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+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)
+          if xp
+            prev_cell = XPath.ancestor(:table)[1].join(xp)
+            cell_condition &= (prev_cell & prev_col_position?(prev_cell))
+          end
+          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_cell & 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?(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

data/lib/capybara/selector/definition/table_row.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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

data/lib/capybara/selector/definition/xpath.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:xpath, locator_type: [:to_xpath, String], raw_locator: true) do
+  xpath { |xpath| xpath }
+end

data/lib/capybara/selector/filter_set.rb

@@ -15,13 +15,15 @@ module Capybara
         instance_eval(&block)
       end
 
-      def node_filter(name, *types_and_options, &block)
-        add_filter(name, Filters::NodeFilter, *types_and_options, &block)
+      def node_filter(names, *types, **options, &block)
+        Array(names).each do |name|
+          add_filter(name, Filters::NodeFilter, *types, **options, &block)
+        end
       end
       alias_method :filter, :node_filter
 
-      def expression_filter(name, *types_and_options, &block)
-        add_filter(name, Filters::ExpressionFilter, *types_and_options, &block)
+      def expression_filter(name, *types, **options, &block)
+        add_filter(name, Filters::ExpressionFilter, *types, **options, &block)
       end
 
       def describe(what = nil, &block)
@@ -40,9 +42,9 @@ module Capybara
       def description(node_filters: true, expression_filters: true, **options)
         opts = options_with_defaults(options)
         description = +''
-        description << undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
-        description << expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
-        description << node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
+        description << undeclared_descriptions.map { |desc| desc.call(**opts).to_s }.join
+        description << expression_filter_descriptions.map { |desc| desc.call(**opts).to_s }.join if expression_filters
+        description << node_filter_descriptions.map { |desc| desc.call(**opts).to_s }.join if node_filters
         description
       end
 
@@ -110,9 +112,11 @@ module Capybara
 
       def add_filter(name, filter_class, *types, matcher: nil, **options, &block)
         types.each { |type| options[type] = true }
-        raise 'ArgumentError', ':default option is not supported for filters with a :matcher option' if matcher && options[:default]
+        if matcher && options[:default]
+          raise 'ArgumentError', ':default option is not supported for filters with a :matcher option'
+        end
 
-        filter = filter_class.new(name, matcher, block, options)
+        filter = filter_class.new(name, matcher, block, **options)
         (filter_class <= Filters::ExpressionFilter ? @expression_filters : @node_filters)[name] = filter
       end
     end

data/lib/capybara/selector/filters/base.rb

@@ -24,6 +24,10 @@ module Capybara
           @options.key?(:skip_if) && value == @options[:skip_if]
         end
 
+        def format
+          @options[:format]
+        end
+
         def matcher?
           !@matcher.nil?
         end
@@ -34,7 +38,7 @@ module Capybara
 
         def handles_option?(option_name)
           if matcher?
-            option_name =~ @matcher
+            @matcher.match? option_name
           else
             @name == option_name
           end
@@ -44,7 +48,12 @@ module Capybara
 
         def apply(subject, name, value, skip_value, ctx)
           return skip_value if skip?(value)
-          raise ArgumentError, "Invalid value #{value.inspect} passed to #{self.class.name.split('::').last} #{name}#{" : #{@name}" if @name.is_a?(Regexp)}" unless valid_value?(value)
+
+          unless valid_value?(value)
+            raise ArgumentError,
+                  "Invalid value #{value.inspect} passed to #{self.class.name.split('::').last} #{name}" \
+                  "#{" : #{name}" if @name.is_a?(Regexp)}"
+          end
 
           if @block.arity == 2
             filter_context(ctx).instance_exec(subject, value, &@block)

data/lib/capybara/selector/filters/locator_filter.rb

@@ -7,11 +7,21 @@ module Capybara
     module Filters
       class LocatorFilter < NodeFilter
         def initialize(block, **options)
-          super(nil, nil, block, options)
+          super(nil, nil, block, **options)
         end
 
-        def matches?(node, value, context = nil)
-          super(node, nil, value, context)
+        def matches?(node, value, context = nil, exact:)
+          apply(node, value, true, context, exact: exact, format: context&.default_format)
+        rescue Capybara::ElementNotFound
+          false
+        end
+
+      private
+
+        def apply(subject, value, skip_value, ctx, **options)
+          return skip_value if skip?(value)
+
+          filter_context(ctx).instance_exec(subject, value, **options, &@block)
         end
       end
     end

data/lib/capybara/selector/regexp_disassembler.rb

@@ -100,6 +100,8 @@ module Capybara
         def extract_strings(process_alternatives)
           strings = []
           each do |exp|
+            next if exp.ignore?
+
             next strings.push(nil) if exp.optional? && !process_alternatives
 
             next strings.push(exp.alternative_strings) if exp.alternation? && process_alternatives
@@ -159,6 +161,11 @@ module Capybara
           alts.all?(&:any?) ? Set.new(alts) : nil
         end
 
+        def ignore?
+          [Regexp::Expression::Assertion::NegativeLookahead,
+           Regexp::Expression::Assertion::NegativeLookbehind].any? { |klass| @exp.is_a? klass }
+        end
+
       private
 
         def indeterminate?
@@ -166,11 +173,11 @@ module Capybara
         end
 
         def min_repeat
-          @exp.quantifier&.min || 1
+          @exp.repetitions.begin
         end
 
         def max_repeat
-          @exp.quantifier&.max || 1
+          @exp.repetitions.end
         end
 
         def fixed_repeat?

data/lib/capybara/selector/selector.rb

@@ -1,190 +1,10 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
-require 'capybara/selector/filter_set'
-require 'capybara/selector/css'
-require 'capybara/selector/regexp_disassembler'
-require 'capybara/selector/builders/xpath_builder'
-require 'capybara/selector/builders/css_builder'
-
 module Capybara
-  #
-  # ## 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, 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
-  #       * :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 Selector
-    attr_reader :name, :format
-    extend Forwardable
-
+  class Selector < SimpleDelegator
     class << self
       def all
-        @selectors ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
+        @definitions ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       def [](name)
@@ -192,7 +12,7 @@ module Capybara
       end
 
       def add(name, **options, &block)
-        all[name.to_sym] = Capybara::Selector.new(name.to_sym, **options, &block)
+        all[name.to_sym] = Definition.new(name.to_sym, **options, &block)
       end
 
       def update(name, &block)
@@ -208,226 +28,63 @@ module Capybara
       end
     end
 
-    def initialize(name, locator_type: nil, raw_locator: false, &block)
-      @name = name
-      @filter_set = FilterSet.add(name) {}
-      @match = nil
-      @label = nil
-      @failure_message = nil
-      @format = nil
-      @expression = nil
-      @expression_filters = {}
-      @locator_filter = nil
-      @default_visibility = nil
-      @locator_type = locator_type
-      @raw_locator = raw_locator
-      @config = {
-        enable_aria_label: false,
-        test_id: nil
-      }
-      instance_eval(&block)
-    end
-
-    def custom_filters
-      warn "Deprecated: Selector#custom_filters is not valid when same named expression and node filter exist - don't use"
-      node_filters.merge(expression_filters).freeze
-    end
+    attr_reader :errors
 
-    def node_filters
-      @filter_set.node_filters
+    def initialize(definition, config:, format:)
+      definition = self.class[definition] unless definition.is_a? Definition
+      super(definition)
+      @definition = definition
+      @config = config
+      @format = format
+      @errors = []
     end
 
-    def expression_filters
-      @filter_set.expression_filters
+    def format
+      @format || @definition.default_format
     end
+    alias_method :current_format, :format
 
-    ##
-    #
-    # Define a selector by an xpath expression
-    #
-    # @overload xpath(*expression_filters, &block)
-    #   @param [Array<Symbol>] expression_filters ([])  Names of filters that are implemented via this expression, if not specified the names of any keyword parameters in the block will be used
-    #   @yield [locator, options]                       The block to use to generate the XPath expression
-    #   @yieldparam [String] locator                    The locator string passed to the query
-    #   @yieldparam [Hash] options                      The options hash passed to the query
-    #   @yieldreturn [#to_xpath, #to_s]                 An object that can produce an xpath expression
-    #
-    # @overload xpath()
-    # @return [#call]                             The block that will be called to generate the XPath expression
-    #
-    def xpath(*allowed_filters, &block)
-      expression(:xpath, allowed_filters, &block)
-    end
-
-    ##
-    #
-    # Define a selector by a CSS selector
-    #
-    # @overload css(*expression_filters, &block)
-    #   @param [Array<Symbol>] expression_filters ([])  Names of filters that can be implemented via this CSS selector
-    #   @yield [locator, options]                   The block to use to generate the CSS selector
-    #   @yieldparam [String] locator               The locator string passed to the query
-    #   @yieldparam [Hash] options                 The options hash passed to the query
-    #   @yieldreturn [#to_s]                        An object that can produce a CSS selector
-    #
-    # @overload css()
-    # @return [#call]                             The block that will be called to generate the CSS selector
-    #
-    def css(*allowed_filters, &block)
-      expression(:css, allowed_filters, &block)
+    def enable_aria_label
+      @config[:enable_aria_label]
     end
 
-    ##
-    #
-    # Automatic selector detection
-    #
-    # @yield [locator]                   This block takes the passed in locator string and returns whether or not it matches the selector
-    # @yieldparam [String], locator      The locator string used to determin if it matches the selector
-    # @yieldreturn [Boolean]             Whether this selector matches the locator string
-    # @return [#call]                    The block that will be used to detect selector match
-    #
-    def match(&block)
-      @match = block if block
-      @match
+    def enable_aria_role
+      @config[:enable_aria_role]
     end
 
-    ##
-    #
-    # Set/get a descriptive label for the selector
-    #
-    # @overload label(label)
-    #   @param [String] label            A descriptive label for this selector - used in error messages
-    # @overload label()
-    # @return [String]                 The currently set label
-    #
-    def label(label = nil)
-      @label = label if label
-      @label
+    def test_id
+      @config[:test_id]
     end
 
-    ##
-    #
-    # Description of the selector
-    #
-    # @!method description(options)
-    #   @param [Hash] options            The options of the query used to generate the description
-    #   @return [String]                 Description of the selector when used with the options passed
-    def_delegator :@filter_set, :description
-
-    def call(locator, selector_config: {}, **options)
-      @config.merge! selector_config
+    def call(locator, **options)
       if format
-        @expression.call(locator, options)
+        raise ArgumentError, "Selector #{@name} does not support #{format}" unless expressions.key?(format)
+
+        instance_exec(locator, **options, &expressions[format])
       else
         warn 'Selector has no format'
       end
     ensure
-      warn "Locator #{locator.inspect} must #{locator_description}. This will raise an error in a future version of Capybara." unless locator_valid?(locator)
-    end
-
-    ##
-    #
-    #  Should this selector be used for the passed in locator
-    #
-    #  This is used by the automatic selector selection mechanism when no selector type is passed to a selector query
-    #
-    # @param [String] locator     The locator passed to the query
-    # @return [Boolean]           Whether or not to use this selector
-    #
-    def match?(locator)
-      @match&.call(locator)
-    end
-
-    ##
-    #
-    # Define a node filter for use with this selector
-    #
-    # @!method node_filter(name, *types, options={}, &block)
-    #   @param [Symbol, Regexp] name            The filter name
-    #   @param [Array<Symbol>] types    The types of the filter - currently valid types are [:boolean]
-    #   @param [Hash] options ({})      Options of the filter
-    #   @option options [Array<>] :valid_values Valid values for this filter
-    #   @option options :default        The default value of the filter (if any)
-    #   @option options :skip_if        Value of the filter that will cause it to be skipped
-    #   @option options [Regexp] :matcher (nil) A Regexp used to check whether a specific option is handled by this filter.  If not provided the filter will be used for options matching the filter name.
-    #
-    # If a Symbol is passed for the name the block should accept | node, option_value |, while if a Regexp
-    # is passed for the name the block should accept | node, option_name, option_value |. In either case
-    # the block should return `true` if the node passes the filer or `false` if it doesn't
-
-    # @!method filter
-    #   See {Selector#node_filter}
-
-    ##
-    #
-    # Define an expression filter for use with this selector
-    #
-    # @!method expression_filter(name, *types, matcher: nil, **options, &block)
-    #   @param [Symbol, Regexp] name            The filter name
-    #   @param [Regexp] matcher (nil)   A Regexp used to check whether a specific option is handled by this filter
-    #   @param [Array<Symbol>] types    The types of the filter - currently valid types are [:boolean]
-    #   @param [Hash] options ({})      Options of the filter
-    #   @option options [Array<>] :valid_values Valid values for this filter
-    #   @option options :default        The default value of the filter (if any)
-    #   @option options :skip_if        Value of the filter that will cause it to be skipped
-    #   @option options [Regexp] :matcher (nil) A Regexp used to check whether a specific option is handled by this filter.  If not provided the filter will be used for options matching the filter name.
-    #
-    # If a Symbol is passed for the name the block should accept | current_expression, option_value |, while if a Regexp
-    # is passed for the name the block should accept | current_expression, option_name, option_value |. In either case
-    # the block should return the modified expression
-
-    def_delegators :@filter_set, :node_filter, :expression_filter, :filter
-
-    def locator_filter(*types, **options, &block)
-      types.each { |type| options[type] = true }
-      @locator_filter = Filters::LocatorFilter.new(block, options) if block
-      @locator_filter
-    end
-
-    def filter_set(name, filters_to_use = nil)
-      @filter_set.import(name, filters_to_use)
-    end
-
-    def_delegator :@filter_set, :describe
-
-    def describe_expression_filters(&block)
-      if block_given?
-        describe(:expression_filters, &block)
-      else
-        describe(:expression_filters) do |**options|
-          describe_all_expression_filters(options)
-        end
+      unless locator_valid?(locator)
+        warn "Locator #{locator.class}:#{locator.inspect} for selector #{name.inspect} must #{locator_description}. This will raise an error in a future version of Capybara."
       end
     end
 
-    def describe_node_filters(&block)
-      describe(:node_filters, &block)
+    def add_error(error_msg)
+      errors << error_msg
     end
 
-    ##
-    #
-    # Set the default visibility mode that shouble be used if no visibile option is passed when using the selector.
-    # If not specified will default to the behavior indicated by Capybara.ignore_hidden_elements
-    #
-    # @param [Symbol] default_visibility  Only find elements with the specified visibility:
-    #                                              * :all - finds visible and invisible elements.
-    #                                              * :hidden - only finds invisible elements.
-    #                                              * :visible - only finds visible elements.
-    def visible(default_visibility = nil, &block)
-      @default_visibility = block || default_visibility
+    def expression_for(name, locator, config: @config, format: current_format, **options)
+      Selector.new(name, config: config, format: format).call(locator, **options)
     end
 
-    def default_visibility(fallback = Capybara.ignore_hidden_elements, options = {})
-      vis = if @default_visibility&.respond_to?(:call)
-        @default_visibility.call(options)
-      else
-        @default_visibility
-      end
-      vis.nil? ? fallback : vis
-    end
-
-    def add_error(error_msg)
-      errors << error_msg
+    # @api private
+    def with_filter_errors(errors)
+      old_errors = @errors
+      @errors = errors
+      yield
+    ensure
+      @errors = old_errors
     end
 
     # @api private
@@ -438,39 +95,12 @@ module Capybara
       when :xpath
         Capybara::Selector::XPathBuilder
       else
-        raise NotImplementedError, "No builder exists for selector of type #{format}"
+        raise NotImplementedError, "No builder exists for selector of type #{default_format}"
       end.new(expr)
     end
 
-    # @api private
-    def with_filter_errors(errors)
-      Thread.current["capybara_#{object_id}_errors"] = errors
-      yield
-    ensure
-      Thread.current["capybara_#{object_id}_errors"] = nil
-    end
-
-    # @api private
-    def raw_locator?
-      !!@raw_locator
-    end
-
   private
 
-    def locator_types
-      return nil unless @locator_type
-
-      Array(@locator_type)
-    end
-
-    def locator_valid?(locator)
-      return true unless locator && locator_types
-
-      locator_types&.any? do |type_or_method|
-        type_or_method.is_a?(Symbol) ? locator.respond_to?(type_or_method) : type_or_method === locator # rubocop:disable Style/CaseEquality
-      end
-    end
-
     def locator_description
       locator_types.group_by { |lt| lt.is_a? Symbol }.map do |symbol, types_or_methods|
         if symbol
@@ -481,16 +111,12 @@ module Capybara
       end.join(' or ')
     end
 
-    def errors
-      Thread.current["capybara_#{object_id}_errors"] || []
-    end
-
-    def enable_aria_label
-      @config[:enable_aria_label]
-    end
+    def locator_valid?(locator)
+      return true unless locator && locator_types
 
-    def test_id
-      @config[:test_id]
+      locator_types&.any? do |type_or_method|
+        type_or_method.is_a?(Symbol) ? locator.respond_to?(type_or_method) : type_or_method === locator # rubocop:disable Style/CaseEquality
+      end
     end
 
     def locate_field(xpath, locator, **_options)
@@ -509,22 +135,6 @@ module Capybara
       locate_xpath + XPath.descendant(:label)[XPath.string.n.is(locator)].descendant(xpath)
     end
 
-    def describe_all_expression_filters(**opts)
-      expression_filters.map do |ef_name, ef|
-        if ef.matcher?
-          handled_custom_keys(ef, opts.keys).map { |key| " with #{ef_name}[#{key} => #{opts[key]}]" }.join
-        elsif opts.key?(ef_name)
-          " with #{ef_name} #{opts[ef_name]}"
-        end
-      end.join
-    end
-
-    def handled_custom_keys(filter, keys)
-      keys.select do |key|
-        filter.handles_option?(key) && !::Capybara::Queries::SelectorQuery::VALID_KEYS.include?(key)
-      end
-    end
-
     def find_by_attr(attribute, value)
       finder_name = "find_by_#{attribute}_attr"
       if respond_to?(finder_name, true)
@@ -537,20 +147,5 @@ module Capybara
     def find_by_class_attr(classes)
       Array(classes).map { |klass| XPath.attr(:class).contains_word(klass) }.reduce(:&)
     end
-
-    def parameter_names(block)
-      block.parameters.select { |(type, _name)| %i[key keyreq].include? type }.map { |(_type, name)| name }
-    end
-
-    def expression(type, allowed_filters, &block)
-      if block
-        @format, @expression = type, block
-        allowed_filters = parameter_names(block) if allowed_filters.empty?
-        allowed_filters.flatten.each { |ef| expression_filters[ef] = Filters::IdentityExpressionFilter.new(ef) }
-      end
-      format == type ? @expression : nil
-    end
   end
 end
-
-# rubocop:enable Style/AsciiComments