capybara 3.23.0 → 3.35.3

data/lib/capybara/node/simple.rb

@@ -100,7 +100,7 @@ module Capybara
       # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
       # @return [Boolean]     Whether the element is visible
       #
-      def visible?(check_ancestors = true)
+      def visible?(check_ancestors = true) # rubocop:disable Style/OptionalBooleanParameter
         return false if (tag_name == 'input') && (native[:type] == 'hidden')
         return false if tag_name == 'template'
 
@@ -108,7 +108,9 @@ module Capybara
           !find_xpath(VISIBILITY_XPATH)
         else
           # 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))
+          !(native.key?('hidden') ||
+            /display:\s?none/.match?(native[:style] || '') ||
+            %w[script head].include?(tag_name))
         end
       end
 
@@ -146,11 +148,15 @@ module Capybara
         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
 
@@ -197,7 +203,8 @@ module Capybara
         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.qname.one_of('script', 'head') |
+          (~x.self(:summary) & XPath.parent(:details)[!XPath.attr(:open)])
         ].boolean
       end.to_s.freeze
     end

data/lib/capybara/queries/ancestor_query.rb

@@ -3,24 +3,20 @@
 module Capybara
   module Queries
     class AncestorQuery < Capybara::Queries::SelectorQuery
-      def initialize(*args)
-        super
-        @count_options = {}
-        COUNT_KEYS.each do |key|
-          @count_options[key] = @options.delete(key) if @options.key?(key)
-        end
-      end
-
       # @api private
       def resolve_for(node, exact = nil)
         @child_node = node
+
         node.synchronize do
           match_results = super(node.session.current_scope, exact)
-          node.all(:xpath, XPath.ancestor, **@count_options) { |el| match_results.include?(el) }
+          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(applied = false)
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
         child_query = @child_node&.instance_variable_get(:@query)
         desc = super
         desc += " that is an ancestor of #{child_query.description}" if child_query

data/lib/capybara/queries/base_query.rb

@@ -79,7 +79,8 @@ module Capybara
         if count
           message << " #{occurrences count}"
         elsif between
-          message << " between #{between.first} and #{between.end ? between.last : 'infinite'} times"
+          message << " between #{between.begin ? between.first : 1} and" \
+                     " #{between.end ? between.last : 'infinite'} times"
         elsif maximum
           message << " at most #{occurrences maximum}"
         elsif minimum

data/lib/capybara/queries/current_path_query.rb

@@ -6,26 +6,30 @@ 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: !@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)
         uri = ::Addressable::URI.parse(session.current_url)
-        uri&.query = nil if options[:ignore_query]
-        @actual_path = options[:url] ? uri&.to_s : uri&.request_uri
+        @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
+        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
@@ -38,6 +42,12 @@ module Capybara
 
     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'
         "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"

data/lib/capybara/queries/selector_query.rb

@@ -1,29 +1,42 @@
 # frozen_string_literal: true
 
+require 'matrix'
+
 module Capybara
   module Queries
     class SelectorQuery < Queries::BaseQuery
       attr_reader :expression, :selector, :locator, :options
-      VALID_KEYS = COUNT_KEYS +
+
+      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] = {} }
+
         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, test_id: test_id },
+          config: {
+            enable_aria_label: enable_aria_label,
+            enable_aria_role: enable_aria_role,
+            test_id: test_id
+          },
           format: selector_format
         )
 
@@ -32,7 +45,7 @@ module Capybara
 
         raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
-        @expression = selector.call(@locator, @options)
+        @expression = selector.call(@locator, **@options)
 
         warn_exact_usage
 
@@ -42,7 +55,7 @@ module Capybara
       def name; selector.name; end
       def label; selector.label || selector.name; end
 
-      def description(only_applied = false)
+      def description(only_applied = false) # rubocop:disable Style/OptionalBooleanParameter
         desc = +''
         show_for = show_for_stage(only_applied)
 
@@ -50,13 +63,17 @@ module Capybara
           desc << 'visible ' if visible == :visible
           desc << 'non-visible ' if visible == :hidden
         end
+
         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
+
         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}"
@@ -66,14 +83,21 @@ module Capybara
           " with styles #{options[:style].inspect}"
         else ''
         end
+
+        %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
+
         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?('#', './/', '//')
-          unless 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
+        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
@@ -87,6 +111,7 @@ module Capybara
 
         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 : [])
@@ -125,11 +150,13 @@ module Capybara
       # @api private
       def resolve_for(node, exact = nil)
         applied_filters.clear
+        @filter_cache.clear
         @resolved_node = node
         @resolved_count += 1
+
         node.synchronize do
           children = find_nodes_by_selector_format(node, exact).map(&method(:to_element))
-          Capybara::Result.new(children, self)
+          Capybara::Result.new(ordered_results(children), self)
         end
       end
 
@@ -208,18 +235,20 @@ module Capybara
         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?
 
-        if selector_format == :css
-          if node.method(:find_css).arity != 1
-            node.find_css(css, **hints)
-          else
+        case selector_format
+        when :css
+          if node.method(:find_css).arity == 1
             node.find_css(css)
-          end
-        elsif selector_format == :xpath
-          if node.method(:find_xpath).arity != 1
-            node.find_xpath(xpath(exact), **hints)
           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}"
@@ -291,6 +320,15 @@ module Capybara
         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
@@ -318,7 +356,7 @@ module Capybara
         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)
+        builder(expr).add_attribute_conditions(**conditions)
       end
 
       def use_default_id_filter?
@@ -333,6 +371,10 @@ module Capybara
         options.key?(:style) && !custom_keys.include?(:style)
       end
 
+      def use_spatial_filter?
+        options.values_at(*SPATIAL_KEYS).compact.any?
+      end
+
       def apply_expression_filters(expression)
         unapplied_options = options.keys - valid_keys
         expression_filters.inject(expression) do |expr, (name, ef)|
@@ -397,6 +439,42 @@ module Capybara
           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)
 
@@ -404,9 +482,25 @@ module Capybara
       end
 
       def matches_class_filter?(node)
-        return true unless use_default_class_filter? && options[:class].is_a?(Regexp)
+        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
 
-        options[:class].match? node[:class]
+      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)
@@ -451,9 +545,9 @@ module Capybara
         return (visible != :hidden) && (node.initial_cache[:visible] != false) && !node.obscured? if obscured == false
 
         vis = case visible
-        when :visible then
+        when :visible
           node.initial_cache[:visible] || (node.initial_cache[:visible].nil? && node.visible?)
-        when :hidden then
+        when :hidden
           (node.initial_cache[:visible] == false) || (node.initial_cache[:visbile].nil? && !node.visible?)
         else
           true
@@ -491,6 +585,148 @@ module Capybara
       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