capybara 2.15.1 → 3.35.3

data/lib/capybara/node/simple.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
-
     ##
     #
     # A {Capybara::Node::Simple} is a simpler version of {Capybara::Node::Base} which
@@ -28,8 +28,9 @@ module Capybara
       #
       # @return [String]    The text of the element
       #
-      def text(type=nil)
-        native.text
+      def text(_type = nil, normalize_ws: false)
+        txt = native.text
+        normalize_ws ? txt.gsub(/[[:space:]]+/, ' ').strip : txt
       end
 
       ##
@@ -45,7 +46,7 @@ module Capybara
         attr_name = name.to_s
         if attr_name == 'value'
           value
-        elsif 'input' == tag_name and 'checkbox' == native[:type] and 'checked' == attr_name
+        elsif (tag_name == 'input') && (native[:type] == 'checkbox') && (attr_name == 'checked')
           native['checked'] == 'checked'
         else
           native[attr_name]
@@ -78,13 +79,13 @@ module Capybara
         if tag_name == 'textarea'
           native['_capybara_raw_value']
         elsif tag_name == 'select'
-          if native['multiple'] == 'multiple'
-            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content  }
+          selected_options = find_xpath('.//option[@selected]')
+          if multiple?
+            selected_options.map(&method(:option_value))
           else
-            option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
-            option[:value] || option.content if option
+            option_value(selected_options.first || find_xpath('.//option').first)
           end
-        elsif tag_name == 'input' && %w(radio checkbox).include?(native[:type])
+        elsif tag_name == 'input' && %w[radio checkbox].include?(native[:type])
           native[:value] || 'on'
         else
           native[:value]
@@ -99,15 +100,17 @@ module Capybara
       # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
       # @return [Boolean]     Whether the element is visible
       #
-      def visible?(check_ancestors = true)
-        return false if (tag_name == 'input') && (native[:type]=="hidden")
+      def visible?(check_ancestors = true) # rubocop:disable Style/OptionalBooleanParameter
+        return false if (tag_name == 'input') && (native[:type] == 'hidden')
+        return false if tag_name == 'template'
 
         if check_ancestors
-          #check size because oldest supported nokogiri doesnt support xpath boolean() function
-          native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head']").size() == 0
+          !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))
+          # No need for an xpath if only checking the current element
+          !(native.key?('hidden') ||
+            /display:\s?none/.match?(native[:style] || '') ||
+            %w[script head].include?(tag_name))
         end
       end
 
@@ -127,7 +130,8 @@ module Capybara
       #
       # @return [Boolean]     Whether the element is disabled
       def disabled?
-        native.has_attribute?('disabled')
+        native.has_attribute?('disabled') &&
+          %w[button input select textarea optgroup option menuitem fieldset].include?(tag_name)
       end
 
       ##
@@ -140,11 +144,19 @@ module Capybara
         native.has_attribute?('selected')
       end
 
-      def synchronize(seconds=nil)
+      def multiple?
+        native.has_attribute?('multiple')
+      end
+
+      def readonly?
+        native.has_attribute?('readonly')
+      end
+
+      def synchronize(_seconds = nil)
         yield # simple nodes don't need to wait
       end
 
-      def allow_reload!
+      def allow_reload!(*)
         # no op
       end
 
@@ -152,12 +164,7 @@ module Capybara
       #
       # @return [String]     The title of the document
       def title
-        if native.respond_to? :title
-          native.title
-        else
-          #old versions of nokogiri don't have #title - remove in 3.0
-          native.xpath('/html/head/title | /html/title').first.text
-        end
+        native.title
       end
 
       def inspect
@@ -165,12 +172,12 @@ module Capybara
       end
 
       # @api private
-      def find_css(css)
+      def find_css(css, **_options)
         native.css(css)
       end
 
       # @api private
-      def find_xpath(xpath)
+      def find_xpath(xpath, **_options)
         native.xpath(xpath)
       end
 
@@ -178,6 +185,28 @@ module Capybara
       def session_options
         Capybara.session_options
       end
+
+      # @api private
+      def initial_cache
+        {}
+      end
+
+    private
+
+      def option_value(option)
+        return nil if option.nil?
+
+        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') |
+          (~x.self(:summary) & XPath.parent(:details)[!XPath.attr(:open)])
+        ].boolean
+      end.to_s.freeze
     end
   end
 end

data/lib/capybara/queries/ancestor_query.rb

@@ -1,23 +1,25 @@
 # frozen_string_literal: true
+
 module Capybara
   module Queries
-    class AncestorQuery < MatchQuery
+    class AncestorQuery < Capybara::Queries::SelectorQuery
       # @api private
       def resolve_for(node, exact = nil)
-        @resolved_node = node
+        @child_node = node
+
         node.synchronize do
           match_results = super(node.session.current_scope, exact)
-          node.all(:xpath, XPath.ancestor) do |el|
-            match_results.include?(el)
-          end
+          ancestors = node.find_xpath(XPath.ancestor.to_s)
+                          .map(&method(:to_element))
+                          .select { |el| match_results.include?(el) }
+          Capybara::Result.new(ordered_results(ancestors), self)
         end
       end
 
-      def description
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
+        child_query = @child_node&.instance_variable_get(:@query)
         desc = super
-        if @resolved_node && (child_query = @resolved_node.instance_variable_get(:@query))
-          desc += " that is an ancestor of #{child_query.description}"
-        end
+        desc += " that is an ancestor of #{child_query.description}" if child_query
         desc
       end
     end

data/lib/capybara/queries/base_query.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module Capybara
   # @api private
   module Queries
     class BaseQuery
-      COUNT_KEYS = [:count, :minimum, :maximum, :between]
+      COUNT_KEYS = %i[count minimum maximum between].freeze
 
       attr_reader :options
       attr_writer :session_options
@@ -20,8 +21,11 @@ module Capybara
         self.class.wait(options, session_options.default_max_wait_time)
       end
 
-      def self.wait(options, default=Capybara.default_max_wait_time)
-        options.fetch(:wait, default) || 0
+      def self.wait(options, default = Capybara.default_max_wait_time)
+        # if no value or nil for the :wait option is passed it should default to the default
+        wait = options.fetch(:wait, nil)
+        wait = default if wait.nil?
+        wait || 0
       end
 
       ##
@@ -30,11 +34,7 @@ module Capybara
       # Returns false if query does not have any count options specified.
       #
       def expects_none?
-        if COUNT_KEYS.any? { |k| options.has_key? k }
-          matches_count?(0)
-        else
-          false
-        end
+        count_specified? ? matches_count?(0) : false
       end
 
       ##
@@ -47,11 +47,12 @@ module Capybara
       # @param [Integer] count     The actual number. Should be coercible via Integer()
       #
       def matches_count?(count)
-        return (Integer(options[:count]) == count)     if options[:count]
+        return (Integer(options[:count]) == count) if options[:count]
         return false if options[:maximum] && (Integer(options[:maximum]) < count)
         return false if options[:minimum] && (Integer(options[:minimum]) > count)
-        return false if options[:between] && !(options[:between] === count)
-        return true
+        return false if options[:between] && !options[:between].include?(count)
+
+        true
       end
 
       ##
@@ -59,36 +60,46 @@ module Capybara
       # Generates a failure message from the query description and count options.
       #
       def failure_message
-        String.new("expected to find #{description}") << count_message
+        +"expected to find #{description}" << count_message
       end
 
       def negative_failure_message
-        String.new("expected not to find #{description}") << count_message
+        +"expected not to find #{description}" << count_message
       end
 
-      private
+    private
+
+      def count_specified?
+        COUNT_KEYS.any? { |key| options.key? key }
+      end
 
       def count_message
-        message = String.new()
-        if options[:count]
-          message << " #{options[:count]} #{Capybara::Helpers.declension('time', 'times', options[:count])}"
-        elsif options[:between]
-          message << " between #{options[:between].first} and #{options[:between].last} times"
-        elsif options[:maximum]
-          message << " at most #{options[:maximum]} #{Capybara::Helpers.declension('time', 'times', options[:maximum])}"
-        elsif options[:minimum]
-          message << " at least #{options[:minimum]} #{Capybara::Helpers.declension('time', 'times', options[:minimum])}"
+        message = +''
+        count, between, maximum, minimum = options.values_at(:count, :between, :maximum, :minimum)
+        if count
+          message << " #{occurrences count}"
+        elsif between
+          message << " between #{between.begin ? between.first : 1} and" \
+                     " #{between.end ? between.last : 'infinite'} times"
+        elsif maximum
+          message << " at most #{occurrences maximum}"
+        elsif 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
-        unless invalid_keys.empty?
-          invalid_names = invalid_keys.map(&:inspect).join(", ")
-          valid_names = valid_keys.map(&:inspect).join(", ")
-          raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
-        end
+        return if invalid_keys.empty?
+
+        invalid_names = invalid_keys.map(&:inspect).join(', ')
+        valid_names = valid_keys.map(&:inspect).join(', ')
+        raise ArgumentError, "Invalid option(s) #{invalid_names}, should be one of #{valid_names}"
       end
     end
   end

data/lib/capybara/queries/current_path_query.rb

@@ -1,37 +1,35 @@
 # frozen_string_literal: true
+
 require 'addressable/uri'
 
 module Capybara
   # @api private
   module Queries
     class CurrentPathQuery < BaseQuery
-      def initialize(expected_path, options = {})
+      def initialize(expected_path, **options, &optional_filter_block)
         super(options)
         @expected_path = expected_path
         @options = {
-          url: false,
-          only_path: false }.merge(options)
+          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || '').hostname.nil?,
+          ignore_query: false
+        }.merge(options)
+        @filter_block = optional_filter_block
         assert_valid_keys
       end
 
       def resolves_for?(session)
-        @actual_path = if options[:url]
-          session.current_url
-        else
-          uri = ::Addressable::URI.parse(session.current_url)
-
-          if options[:only_path]
-            uri.path unless uri.nil? # Ensure the parsed url isn't nil.
-          else
-            uri.request_uri unless uri.nil? # Ensure the parsed url isn't nil.
-          end
+        uri = ::Addressable::URI.parse(session.current_url)
+        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).yield_self do |u|
+          options[:url] ? u&.to_s : u&.request_uri
         end
 
-        if @expected_path.is_a? Regexp
-          @actual_path.match(@expected_path)
+        res = if @expected_path.is_a? Regexp
+          @actual_path.to_s.match?(@expected_path)
         else
           ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end
+
+        res && matches_filter_block?(uri)
       end
 
       def failure_message
@@ -42,22 +40,21 @@ module Capybara
         failure_message_helper(' not')
       end
 
-      private
+    private
+
+      def matches_filter_block?(url)
+        return true unless @filter_block
+
+        @filter_block.call(url)
+      end
 
       def failure_message_helper(negated = '')
-        verb = (@expected_path.is_a?(Regexp))? 'match' : 'equal'
+        verb = @expected_path.is_a?(Regexp) ? 'match' : 'equal'
         "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"
       end
 
       def valid_keys
-        [:wait, :url, :only_path]
-      end
-
-      def assert_valid_keys
-        super
-        if options[:url] && options[:only_path]
-          raise ArgumentError, "the :url and :only_path options cannot both be true"
-        end
+        %i[wait url ignore_query]
       end
     end
   end

data/lib/capybara/queries/match_query.rb

@@ -1,19 +1,26 @@
+# frozen_string_literal: true
+
 module Capybara
   module Queries
     class MatchQuery < Capybara::Queries::SelectorQuery
       def visible
-        if options.has_key?(:visible)
-          super
-        else
-          :all
-        end
+        options.key?(:visible) ? super : :all
       end
 
-      private
+    private
+
+      def assert_valid_keys
+        invalid_options = @options.keys & COUNT_KEYS
+        unless invalid_options.empty?
+          raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
+        end
+
+        super
+      end
 
       def valid_keys
         super - COUNT_KEYS
       end
     end
   end
-end
+end

data/lib/capybara/queries/selector_query.rb

@@ -1,38 +1,51 @@
 # frozen_string_literal: true
+
+require 'matrix'
+
 module Capybara
   module Queries
     class SelectorQuery < Queries::BaseQuery
-      attr_accessor :selector, :locator, :options, :expression, :find, :negative
+      attr_reader :expression, :selector, :locator, :options
+
+      SPATIAL_KEYS = %i[above below left_of right_of near].freeze
+      VALID_KEYS = SPATIAL_KEYS + COUNT_KEYS +
+                   %i[text id class style visible obscured exact exact_text normalize_ws match wait filter_set]
+      VALID_MATCH = %i[first smart prefer_exact one].freeze
+
+      def initialize(*args,
+                     session_options:,
+                     enable_aria_label: session_options.enable_aria_label,
+                     enable_aria_role: session_options.enable_aria_role,
+                     test_id: session_options.test_id,
+                     selector_format: nil,
+                     order: nil,
+                     **options,
+                     &filter_block)
+        @resolved_node = nil
+        @resolved_count = 0
+        @options = options.dup
+        @order = order
+        @filter_cache = Hash.new { |hsh, key| hsh[key] = {} }
 
-      VALID_KEYS = COUNT_KEYS + [:text, :id, :class, :visible, :exact, :exact_text, :match, :wait, :filter_set]
-      VALID_MATCH = [:first, :smart, :prefer_exact, :one]
-
-      def initialize(*args, &filter_block)
-        @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
         super(@options)
-
+        self.session_options = session_options
+
+        @selector = Selector.new(
+          find_selector(args[0].is_a?(Symbol) ? args.shift : args[0]),
+          config: {
+            enable_aria_label: enable_aria_label,
+            enable_aria_role: enable_aria_role,
+            test_id: test_id
+          },
+          format: selector_format
+        )
+
+        @locator = args.shift
         @filter_block = filter_block
 
-        if args[0].is_a?(Symbol)
-          @selector = Selector.all.fetch(args.shift) do |selector_type|
-            raise ArgumentError, "Unknown selector type (:#{selector_type})"
-            nil
-          end
-          @locator = args.shift
-        else
-          @selector = Selector.all.values.find { |s| s.match?(args[0]) }
-          @locator = args.shift
-        end
-        @selector ||= Selector.all[session_options.default_selector]
+        raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
-        warn "Unused parameters passed to #{self.class.name} : #{args.to_s}" unless args.empty?
-
-        # for compatibility with Capybara 2.0
-        if session_options.exact_options and @selector == Selector.all[:option]
-          @options[:exact] = true
-        end
-
-        @expression = @selector.call(@locator, @options.merge(enable_aria_label: session_options.enable_aria_label))
+        @expression = selector.call(@locator, **@options)
 
         warn_exact_usage
 
@@ -40,205 +53,680 @@ module Capybara
       end
 
       def name; selector.name; end
-      def label; selector.label or selector.name; end
-
-      def description
-        @description = String.new()
-        @description << "visible " if visible == :visible
-        @description << "non-visible " if visible == :hidden
-        @description << "#{label} #{locator.inspect}"
-        @description << " with#{" exact" if exact_text == true} text #{options[:text].inspect}" if options[:text]
-        @description << " with exact text #{options[:exact_text]}" if options[:exact_text].is_a?(String)
-        @description << " with id #{options[:id]}" if options[:id]
-        @description << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
-        @description << selector.description(options)
-        @description << " that also matches the custom filter block" if @filter_block
-        @description
-      end
-
-      def matches_filters?(node)
-        if options[:text]
-          regexp = if options[:text].is_a?(Regexp)
-            options[:text]
-          else
-            if exact_text == true
-              /\A#{Regexp.escape(options[:text].to_s)}\z/
-            else
-              Regexp.escape(options[:text].to_s)
-            end
-          end
-          text_visible = visible
-          text_visible = :all if text_visible == :hidden
-          return false if not node.text(text_visible).match(regexp)
+      def label; selector.label || selector.name; end
+
+      def description(only_applied = false) # rubocop:disable Style/OptionalBooleanParameter
+        desc = +''
+        show_for = show_for_stage(only_applied)
+
+        if show_for[:any]
+          desc << 'visible ' if visible == :visible
+          desc << 'non-visible ' if visible == :hidden
         end
 
-        if exact_text.is_a?(String)
-          regexp = /\A#{Regexp.escape(options[:exact_text])}\z/
-          text_visible = visible
-          text_visible = :all if text_visible == :hidden
-          return false if not node.text(text_visible).match(regexp)
+        desc << "#{label} #{locator.inspect}"
+
+        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
 
-        case visible
-          when :visible then return false unless node.visible?
-          when :hidden then return false if node.visible?
+        desc << " with id #{options[:id]}" if options[:id]
+        desc << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
+
+        desc << case options[:style]
+        when String
+          " with style attribute #{options[:style].inspect}"
+        when Regexp
+          " with style attribute matching #{options[:style].inspect}"
+        when Hash
+          " with styles #{options[:style].inspect}"
+        else ''
         end
 
-        res = node_filters.all? do |name, filter|
-          if options.has_key?(name)
-            filter.matches?(node, options[name])
-          elsif filter.default?
-            filter.matches?(node, filter.default)
-          else
-            true
+        %i[above below left_of right_of near].each do |spatial_filter|
+          if options[spatial_filter] && show_for[:spatial]
+            desc << " #{spatial_filter} #{options[spatial_filter] rescue '<ERROR>'}" # rubocop:disable Style/RescueModifier
           end
         end
 
-        res &&= if node.respond_to?(:session)
-          node.session.using_wait_time(0){ @filter_block.call(node) }
-        else
-          @filter_block.call(node)
-        end unless @filter_block.nil?
+        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?
+        if locator.is_a?(String) && locator.start_with?('#', './/', '//') && !selector.raw_locator?
+          desc << "\nNote: It appears you may be passing a CSS selector or XPath expression rather than a locator. " \
+                  "Please see the documentation for acceptable locator values.\n\n"
+        end
+        desc
+      end
+
+      def applied_description
+        description(true)
+      end
 
-        res
+      def matches_filters?(node, node_filter_errors = [])
+        return true if (@resolved_node&.== node) && options[:allow_self]
 
+        matches_locator_filter?(node) &&
+          matches_system_filters?(node) &&
+          matches_spatial_filters?(node) &&
+          matches_node_filters?(node, node_filter_errors) &&
+          matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
-        return false
+        false
       end
 
       def visible
-        case (vis = options.fetch(:visible){ @selector.default_visibility(session_options.ignore_hidden_elements) })
-          when true then :visible
-          when false then :all
-          else vis
+        case (vis = options.fetch(:visible) { default_visibility })
+        when true then :visible
+        when false then :all
+        else vis
         end
       end
 
       def exact?
-        return false if !supports_exact?
-        options.fetch(:exact, session_options.exact)
+        supports_exact? ? options.fetch(:exact, session_options.exact) : false
       end
 
       def match
         options.fetch(:match, session_options.match)
       end
 
-      def xpath(exact=nil)
-        exact = self.exact? if exact.nil?
+      def xpath(exact = nil)
+        exact = exact? if exact.nil?
         expr = apply_expression_filters(@expression)
-        expr = if expr.respond_to?(:to_xpath) and exact
-          expr.to_xpath(:exact)
-        else
-          expr.to_s
-        end
-        filtered_xpath(expr)
+        expr = exact ? expr.to_xpath(:exact) : expr.to_s if expr.respond_to?(:to_xpath)
+        expr = filtered_expression(expr)
+        expr = "(#{expr})[#{xpath_text_conditions}]" if try_text_match_in_expression?
+        expr
       end
 
       def css
-        filtered_css(apply_expression_filters(@expression))
+        filtered_expression(apply_expression_filters(@expression))
       end
 
       # @api private
       def resolve_for(node, exact = nil)
+        applied_filters.clear
+        @filter_cache.clear
+        @resolved_node = node
+        @resolved_count += 1
+
         node.synchronize do
-          children = if selector.format == :css
-            node.find_css(self.css)
-          else
-            node.find_xpath(self.xpath(exact))
-          end.map do |child|
-            if node.is_a?(Capybara::Node::Base)
-              Capybara::Node::Element.new(node.session, child, node, self)
-            else
-              Capybara::Node::Simple.new(child)
-            end
-          end
-          Capybara::Result.new(children, self)
+          children = find_nodes_by_selector_format(node, exact).map(&method(:to_element))
+          Capybara::Result.new(ordered_results(children), self)
         end
       end
 
       # @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
 
-      private
+      def failure_message
+        +"expected to find #{applied_description}" << count_message
+      end
+
+      def negative_failure_message
+        +"expected not to find #{applied_description}" << count_message
+      end
+
+    private
+
+      def selector_format
+        @selector.format
+      end
+
+      def matching_text
+        options[:text] || options[:exact_text]
+      end
+
+      def text_fragments
+        (text = matching_text).is_a?(String) ? text.split : []
+      end
+
+      def xpath_text_conditions
+        case (text = matching_text)
+        when String
+          text.split.map { |txt| XPath.contains(txt) }.reduce(&:&)
+        when Regexp
+          condition = XPath.current
+          condition = condition.uppercase if text.casefold?
+          Selector::RegexpDisassembler.new(text).alternated_substrings.map do |strs|
+            strs.flat_map(&:split).map { |str| condition.contains(str) }.reduce(:&)
+          end.reduce(:|)
+        end
+      end
+
+      def try_text_match_in_expression?
+        first_try? &&
+          matching_text &&
+          @resolved_node.is_a?(Capybara::Node::Base) &&
+          @resolved_node.session&.driver&.wait?
+      end
+
+      def first_try?
+        @resolved_count == 1
+      end
+
+      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 ||= []
+      end
+
+      def find_selector(locator)
+        case locator
+        when Symbol then Selector[locator]
+        else Selector.for(locator)
+        end || Selector[session_options.default_selector]
+      end
+
+      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[:styles] = options[:style] if use_default_style_filter?
+        hints[:position] = true if use_spatial_filter?
+
+        case selector_format
+        when :css
+          if node.method(:find_css).arity == 1
+            node.find_css(css)
+          else
+            node.find_css(css, **hints)
+          end
+        when :xpath
+          if node.method(:find_xpath).arity == 1
+            node.find_xpath(xpath(exact))
+          else
+            node.find_xpath(xpath(exact), **hints)
+          end
+        else
+          raise ArgumentError, "Unknown format: #{selector_format}"
+        end
+      end
+
+      def to_element(node)
+        if @resolved_node.is_a?(Capybara::Node::Base)
+          Capybara::Node::Element.new(@resolved_node.session, node, @resolved_node, self)
+        else
+          Capybara::Node::Simple.new(node)
+        end
+      end
 
       def valid_keys
         VALID_KEYS + custom_keys
       end
 
-      def node_filters
-        if options.has_key?(:filter_set)
-          ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
+      def matches_node_filters?(node, errors)
+        applied_filters << :node
+
+        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)
+                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
+          end
+        end
+      end
+
+      def matches_filter_block?(node)
+        return true unless @filter_block
+
+        if node.respond_to?(:session)
+          node.session.using_wait_time(0) { @filter_block.call(node) }
         else
-          @selector.node_filters
+          @filter_block.call(node)
         end
       end
 
+      def filter_set(name)
+        ::Capybara::Selector::FilterSet[name]
+      end
+
+      def node_filters
+        if options.key?(:filter_set)
+          filter_set(options[:filter_set])
+        else
+          @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.has_key?(:filter_set)
+        filters.merge filter_set(options[:filter_set]).expression_filters if options.key?(:filter_set)
         filters
       end
 
+      def ordered_results(results)
+        case @order
+        when :reverse
+          results.reverse
+        else
+          results
+        end
+      end
+
       def custom_keys
         @custom_keys ||= node_filters.keys + expression_filters.keys
       end
 
       def assert_valid_keys
-        super
         unless VALID_MATCH.include?(match)
-          raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(", ")}"
+          raise ArgumentError, "Invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(', ')}"
         end
-      end
 
-      def filtered_xpath(expr)
-        if options.has_key?(:id) || options.has_key?(:class)
-          expr = "(#{expr})"
-          expr = "#{expr}[#{XPath.attr(:id) == options[:id]}]" if options.has_key?(:id) && !custom_keys.include?(:id)
-          if options.has_key?(:class) && !custom_keys.include?(:class)
-            class_xpath = Array(options[:class]).map do |klass|
-              "contains(concat(' ',normalize-space(@class),' '),' #{klass} ')"
-            end.join(" and ")
-            expr = "#{expr}[#{class_xpath}]"
-          end
+        unhandled_options = @options.keys.reject do |option_name|
+          valid_keys.include?(option_name) ||
+            expression_filters.any? { |_name, ef| ef.handles_option? option_name } ||
+            node_filters.any? { |_name, nf| nf.handles_option? option_name }
         end
-        expr
+
+        return if unhandled_options.empty?
+
+        invalid_names = unhandled_options.map(&:inspect).join(', ')
+        valid_names = (valid_keys - [:allow_self]).map(&:inspect).join(', ')
+        raise ArgumentError, "Invalid option(s) #{invalid_names}, should be one of #{valid_names}"
       end
 
-      def filtered_css(expr)
-        if options.has_key?(:id) || options.has_key?(:class)
-          css_selectors = expr.split(',').map(&:rstrip)
-          expr = css_selectors.map do |sel|
-           sel += "##{Capybara::Selector::CSS.escape(options[:id])}" if options.has_key?(:id) && !custom_keys.include?(:id)
-           sel += Array(options[:class]).map { |k| ".#{Capybara::Selector::CSS.escape(k)}"}.join if options.has_key?(:class) && !custom_keys.include?(:class)
-           sel
-          end.join(", ")
-        end
-        expr
+      def filtered_expression(expr)
+        conditions = {}
+        conditions[:id] = options[:id] if use_default_id_filter?
+        conditions[:class] = options[:class] if use_default_class_filter?
+        conditions[:style] = options[:style] if use_default_style_filter? && !options[:style].is_a?(Hash)
+        builder(expr).add_attribute_conditions(**conditions)
+      end
+
+      def use_default_id_filter?
+        options.key?(:id) && !custom_keys.include?(:id)
+      end
+
+      def use_default_class_filter?
+        options.key?(:class) && !custom_keys.include?(:class)
+      end
+
+      def use_default_style_filter?
+        options.key?(:style) && !custom_keys.include?(:style)
+      end
+
+      def use_spatial_filter?
+        options.values_at(*SPATIAL_KEYS).compact.any?
       end
 
-      def apply_expression_filters(expr)
-        expression_filters.inject(expr) do |memo, (name, ef)|
-          if options.has_key?(name)
-            ef.apply_filter(memo, options[name])
+      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)
+              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], @selector)
           elsif ef.default?
-            ef.apply_filter(memo, ef.default)
+            ef.apply_filter(expr, name, ef.default, @selector)
           else
-            memo
+            expr
           end
         end
       end
 
       def warn_exact_usage
-        if options.has_key?(:exact) && !supports_exact?
-          warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression.to_s}\" has no effect."
-        end
+        return unless options.key?(:exact) && !supports_exact?
+
+        warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression}\" has no effect."
       end
 
       def exact_text
         options.fetch(:exact_text, session_options.exact_text)
       end
+
+      def describe_within?
+        @resolved_node && !document?(@resolved_node) && !simple_root?(@resolved_node)
+      end
+
+      def document?(node)
+        node.is_a?(::Capybara::Node::Document)
+      end
+
+      def simple_root?(node)
+        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 && apply_filter?(@selector.locator_filter)
+
+        @selector.locator_filter.matches?(node, @locator, @selector, exact: exact?)
+      end
+
+      def matches_system_filters?(node)
+        applied_filters << :system
+
+        matches_visibility_filters?(node) &&
+          matches_id_filter?(node) &&
+          matches_class_filter?(node) &&
+          matches_style_filter?(node) &&
+          matches_text_filter?(node) &&
+          matches_exact_text_filter?(node)
+      end
+
+      def matches_spatial_filters?(node)
+        applied_filters << :spatial
+        return true unless use_spatial_filter?
+
+        node_rect = Rectangle.new(node.initial_cache[:position] || node.rect)
+
+        if options[:above]
+          el_rect = rect_cache(options[:above])
+          return false unless node_rect.above? el_rect
+        end
+
+        if options[:below]
+          el_rect = rect_cache(options[:below])
+          return false unless node_rect.below? el_rect
+        end
+
+        if options[:left_of]
+          el_rect = rect_cache(options[:left_of])
+          return false unless node_rect.left_of? el_rect
+        end
+
+        if options[:right_of]
+          el_rect = rect_cache(options[:right_of])
+          return false unless node_rect.right_of? el_rect
+        end
+
+        if options[:near]
+          return false if node == options[:near]
+
+          el_rect = rect_cache(options[:near])
+          return false unless node_rect.near? el_rect
+        end
+
+        true
+      end
+
+      def matches_id_filter?(node)
+        return true unless use_default_id_filter? && options[:id].is_a?(Regexp)
+
+        options[:id].match? node[:id]
+      end
+
+      def matches_class_filter?(node)
+        return true unless use_default_class_filter? && need_to_process_classes?
+
+        if options[:class].is_a? Regexp
+          options[:class].match? node[:class]
+        else
+          classes = (node[:class] || '').split
+          options[:class].select { |c| c.is_a? Regexp }.all? do |r|
+            classes.any? { |cls| r.match? cls }
+          end
+        end
+      end
+
+      def need_to_process_classes?
+        case options[:class]
+        when Regexp then true
+        when Array then options[:class].any?(Regexp)
+        else
+          false
+        end
+      end
+
+      def matches_style_filter?(node)
+        case options[:style]
+        when String, nil
+          true
+        when Regexp
+          options[:style].match? node[:style]
+        when Hash
+          matches_style?(node, options[:style])
+        end
+      end
+
+      def matches_style?(node, styles)
+        @actual_styles = node.initial_cache[:style] || node.style(*styles.keys)
+        styles.all? do |style, value|
+          if value.is_a? Regexp
+            value.match? @actual_styles[style.to_s]
+          else
+            @actual_styles[style.to_s] == value
+          end
+        end
+      end
+
+      def matches_text_filter?(node)
+        value = options[:text]
+        return true unless value
+        return matches_text_exactly?(node, value) if exact_text == true
+
+        regexp = value.is_a?(Regexp) ? value : Regexp.escape(value.to_s)
+        matches_text_regexp?(node, regexp)
+      end
+
+      def matches_exact_text_filter?(node)
+        return true unless exact_text.is_a?(String)
+
+        matches_text_exactly?(node, exact_text)
+      end
+
+      def matches_visibility_filters?(node)
+        obscured = options[:obscured]
+        return (visible != :hidden) && (node.initial_cache[:visible] != false) && !node.obscured? if obscured == false
+
+        vis = case visible
+        when :visible
+          node.initial_cache[:visible] || (node.initial_cache[:visible].nil? && node.visible?)
+        when :hidden
+          (node.initial_cache[:visible] == false) || (node.initial_cache[:visbile].nil? && !node.visible?)
+        else
+          true
+        end
+
+        vis && case obscured
+               when true
+                 node.obscured?
+               when false
+                 !node.obscured?
+               else
+                 true
+               end
+      end
+
+      def matches_text_exactly?(node, value)
+        regexp = value.is_a?(Regexp) ? value : /\A#{Regexp.escape(value.to_s)}\z/
+        matches_text_regexp?(node, regexp)
+      end
+
+      def normalize_ws
+        options.fetch(:normalize_ws, session_options.default_normalize_ws)
+      end
+
+      def matches_text_regexp?(node, regexp)
+        text_visible = visible
+        text_visible = :all if text_visible == :hidden
+        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(expr)
+        selector.builder(expr)
+      end
+
+      def position_cache(key)
+        @filter_cache[key][:position] ||= key.rect
+      end
+
+      def rect_cache(key)
+        @filter_cache[key][:rect] ||= Rectangle.new(position_cache(key))
+      end
+
+      class Rectangle
+        attr_reader :top, :bottom, :left, :right
+
+        def initialize(position)
+          # rubocop:disable Style/RescueModifier
+          @top = position['top'] rescue position['y']
+          @bottom = position['bottom'] rescue (@top + position['height'])
+          @left = position['left'] rescue position['x']
+          @right = position['right'] rescue (@left + position['width'])
+          # rubocop:enable Style/RescueModifier
+        end
+
+        def distance(other)
+          distance = Float::INFINITY
+
+          line_segments.each do |ls1|
+            other.line_segments.each do |ls2|
+              distance = [
+                distance,
+                distance_segment_segment(*ls1, *ls2)
+              ].min
+            end
+          end
+
+          distance
+        end
+
+        def above?(other)
+          bottom <= other.top
+        end
+
+        def below?(other)
+          top >= other.bottom
+        end
+
+        def left_of?(other)
+          right <= other.left
+        end
+
+        def right_of?(other)
+          left >= other.right
+        end
+
+        def near?(other)
+          distance(other) <= 50
+        end
+
+      protected
+
+        def line_segments
+          [
+            [Vector[top, left], Vector[top, right]],
+            [Vector[top, right], Vector[bottom, left]],
+            [Vector[bottom, left], Vector[bottom, right]],
+            [Vector[bottom, right], Vector[top, left]]
+          ]
+        end
+
+      private
+
+        def distance_segment_segment(l1p1, l1p2, l2p1, l2p2)
+          # See http://geomalgorithms.com/a07-_distance.html
+          # rubocop:disable Naming/VariableName
+          u = l1p2 - l1p1
+          v = l2p2 - l2p1
+          w = l1p1 - l2p1
+
+          a = u.dot u
+          b = u.dot v
+          c = v.dot v
+
+          d = u.dot w
+          e = v.dot w
+          cap_d = (a * c) - (b**2)
+          sD = tD = cap_d
+
+          # compute the line parameters of the two closest points
+          if cap_d < Float::EPSILON # the lines are almost parallel
+            sN = 0.0 # force using point P0 on segment S1
+            sD = 1.0 # to prevent possible division by 0.0 later
+            tN = e
+            tD = c
+          else # get the closest points on the infinite lines
+            sN = (b * e) - (c * d)
+            tN = (a * e) - (b * d)
+            if sN.negative? # sc < 0 => the s=0 edge is visible
+              sN = 0
+              tN = e
+              tD = c
+            elsif sN > sD # sc > 1 => the s=1 edge is visible
+              sN = sD
+              tN = e + b
+              tD = c
+            end
+          end
+
+          if tN.negative? # tc < 0 => the t=0 edge is visible
+            tN = 0
+            # recompute sc for this edge
+            if (-d).negative?
+              sN = 0.0
+            elsif -d > a
+              sN = sD
+            else
+              sN = -d
+              sD = a
+            end
+          elsif tN > tD # tc > 1 => the t=1 edge is visible
+            tN = tD
+            # recompute sc for this edge
+            if (-d + b).negative?
+              sN = 0.0
+            elsif (-d + b) > a
+              sN = sD
+            else
+              sN = (-d + b)
+              sD = a
+            end
+          end
+
+          # finally do the division to get sc and tc
+          sc = sN.abs < Float::EPSILON ? 0.0 : sN / sD
+          tc = tN.abs < Float::EPSILON ? 0.0 : tN / tD
+
+          # difference of the two closest points
+          dP = w + (u * sc) - (v * tc)
+
+          Math.sqrt(dP.dot(dP))
+          # rubocop:enable Naming/VariableName
+        end
+      end
+
+      private_constant :Rectangle
     end
   end
 end