capybara 3.6.0 → 3.7.0

data/lib/capybara/queries/selector_query.rb

@@ -3,9 +3,8 @@
 module Capybara
   module Queries
     class SelectorQuery < Queries::BaseQuery
-      attr_accessor :selector, :locator, :options, :expression, :find, :negative
-
-      VALID_KEYS = COUNT_KEYS + %i[text id class visible exact exact_text match wait filter_set]
+      attr_reader :expression, :selector, :locator, :options
+      VALID_KEYS = COUNT_KEYS + %i[text id class visible exact exact_text normalize_ws match wait filter_set]
       VALID_MATCH = %i[first smart prefer_exact one].freeze
 
       def initialize(*args,
@@ -25,7 +24,7 @@ module Capybara
 
         raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
-        @expression = @selector.call(@locator, @options.merge(selector_config: { enable_aria_label: enable_aria_label, test_id: test_id }))
+        @expression = selector.call(@locator, @options.merge(selector_config: { enable_aria_label: enable_aria_label, test_id: test_id }))
 
         warn_exact_usage
 
@@ -36,22 +35,22 @@ module Capybara
       def label; selector.label || selector.name; end
 
       def description(applied = false)
-        @description = +''
-        if !applied || @applied_filters
-          @description << 'visible ' if visible == :visible
-          @description << 'non-visible ' if visible == :hidden
+        desc = +''
+        if !applied || applied_filters
+          desc << 'visible ' if visible == :visible
+          desc << 'non-visible ' if visible == :hidden
         end
-        @description << "#{label} #{locator.inspect}"
-        if !applied || @applied_filters
-          @description << " with#{' exact' if exact_text == true} text #{options[:text].inspect}" if options[:text]
-          @description << " with exact text #{exact_text}" if exact_text.is_a?(String)
+        desc << "#{label} #{locator.inspect}"
+        if !applied || applied_filters
+          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
-        @description << " with id #{options[:id]}" if options[:id]
-        @description << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
-        @description << selector.description(node_filters: !applied || (@applied_filters == :node), **options)
-        @description << ' that also matches the custom filter block' if @filter_block && (!applied || (@applied_filters == :node))
-        @description << " within #{@resolved_node.inspect}" if describe_within?
-        @description
+        desc << " with id #{options[:id]}" if options[:id]
+        desc << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
+        desc << selector.description(node_filters: !applied || (applied_filters == :node), **options)
+        desc << ' that also matches the custom filter block' if @filter_block && (!applied || (applied_filters == :node))
+        desc << " within #{@resolved_node.inspect}" if describe_within?
+        desc
       end
 
       def applied_description
@@ -59,15 +58,9 @@ module Capybara
       end
 
       def matches_filters?(node)
+        return true if (@resolved_node&.== node) && options[:allow_self]
         @applied_filters ||= :system
-        return false if options[:text] && !matches_text_filter(node, options[:text])
-        return false if exact_text.is_a?(String) && !matches_exact_text_filter(node, exact_text)
-
-        case visible
-        when :visible then return false unless node.visible?
-        when :hidden then return false if node.visible?
-        end
-
+        return false unless matches_text_filter?(node) && matches_exact_text_filter?(node) && matches_visible_filter?(node)
         @applied_filters = :node
         matches_node_filters?(node) && matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
@@ -106,17 +99,7 @@ module Capybara
         @applied_filters = false
         @resolved_node = node
         node.synchronize do
-          children = if selector.format == :css
-            node.find_css(css)
-          else
-            node.find_xpath(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
+          children = find_nodes_by_selector_format(node, exact).map(&method(:to_element))
           Capybara::Result.new(children, self)
         end
       end
@@ -136,15 +119,35 @@ module Capybara
 
     private
 
+      def applied_filters
+        @applied_filters ||= false
+      end
+
       def find_selector(locator)
         selector = if locator.is_a?(Symbol)
           Selector.all.fetch(locator) { |sel_type| raise ArgumentError, "Unknown selector type (:#{sel_type})" }
         else
-          Selector.all.values.find { |s| s.match?(locator) }
+          Selector.all.values.find { |sel| sel.match?(locator) }
         end
         selector || Selector.all[session_options.default_selector]
       end
 
+      def find_nodes_by_selector_format(node, exact)
+        if selector.format == :css
+          node.find_css(css)
+        else
+          node.find_xpath(xpath(exact))
+        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
@@ -171,7 +174,6 @@ module Capybara
 
       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
@@ -201,87 +203,91 @@ module Capybara
         unless VALID_MATCH.include?(match)
           raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(', ')}"
         end
-        unhandled_options = @options.keys - valid_keys
-        unhandled_options -= @options.keys.select do |option_name|
-          expression_filters.any? { |_nmae, ef| ef.handles_option? option_name } ||
+        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
 
         return if unhandled_options.empty?
         invalid_names = unhandled_options.map(&:inspect).join(', ')
-        valid_names = valid_keys.map(&:inspect).join(', ')
+        valid_names = (valid_keys - [:allow_self]).map(&:inspect).join(', ')
         raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
       end
 
       def filtered_xpath(expr)
-        if options.key?(:id) && !custom_keys.include?(:id)
-          expr = if options[:id].is_a? XPath::Expression
-            "(#{expr})[#{XPath.attr(:id)[options[:id]]}]"
+        if use_default_id_filter?
+          id_xpath = if options[:id].is_a? XPath::Expression
+            XPath.attr(:id)[options[:id]]
           else
-            "(#{expr})[#{XPath.attr(:id) == options[:id]}]"
+            XPath.attr(:id) == options[:id]
           end
+          expr = "(#{expr})[#{id_xpath}]"
         end
-        if options.key?(:class) && !custom_keys.include?(:class)
-          class_xpath = if options[:class].is_a?(XPath::Expression)
-            XPath.attr(:class)[options[:class]]
-          else
-            Array(options[:class]).map do |klass|
-              if klass.start_with?('!')
-                !XPath.attr(:class).contains_word(klass.slice(1))
-              else
-                XPath.attr(:class).contains_word(klass)
-              end
-            end.reduce(:&)
-          end
-          expr = "(#{expr})[#{class_xpath}]"
-        end
+        expr = "(#{expr})[#{xpath_from_classes}]" if use_default_class_filter?
         expr
       end
 
       def filtered_css(expr)
-        process_id = options.key?(:id) && !custom_keys.include?(:id)
-        process_class = options.key?(:class) && !custom_keys.include?(:class)
+        ::Capybara::Selector::CSS.split(expr).map do |sel|
+          sel += css_from_id if use_default_id_filter?
+          sel += css_from_classes if use_default_class_filter?
+          sel
+        end.join(', ')
+      end
 
-        if process_id && options[:id].is_a?(XPath::Expression)
-          raise ArgumentError, 'XPath expressions are not supported for the :id filter with CSS based selectors'
-        end
-        if process_class && options[:class].is_a?(XPath::Expression)
+      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 css_from_classes
+        if options[:class].is_a?(XPath::Expression)
           raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
         end
 
-        if process_id || process_class
-          expr = ::Capybara::Selector::CSS.split(expr).map do |sel|
-            sel += "##{::Capybara::Selector::CSS.escape(options[:id])}" if process_id
-            sel += css_from_classes(Array(options[:class])) if process_class
-            sel
-          end.join(', ')
-        end
+        classes = Array(options[:class]).group_by { |cl| cl.start_with? '!' }
+        (classes[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl)}" } +
+         classes[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1))})" }).join
+      end
 
-        expr
+      def css_from_id
+        if options[:id].is_a?(XPath::Expression)
+          raise ArgumentError, 'XPath expressions are not supported for the :id filter with CSS based selectors'
+        end
+        "##{::Capybara::Selector::CSS.escape(options[:id])}"
       end
 
-      def css_from_classes(classes)
-        classes = classes.group_by { |c| c.start_with? '!' }
-        (classes[false].to_a.map { |c| ".#{Capybara::Selector::CSS.escape(c)}" } +
-         classes[true].to_a.map { |c| ":not(.#{Capybara::Selector::CSS.escape(c.slice(1))})" }).join
+      def xpath_from_classes
+        return XPath.attr(:class)[options[:class]] if options[:class].is_a?(XPath::Expression)
+
+        Array(options[:class]).map do |klass|
+          if klass.start_with?('!')
+            !XPath.attr(:class).contains_word(klass.slice(1))
+          else
+            XPath.attr(:class).contains_word(klass)
+          end
+        end.reduce(:&)
       end
 
-      def apply_expression_filters(expr)
+      def apply_expression_filters(expression)
         unapplied_options = options.keys - valid_keys
-        expression_filters.inject(expr) do |memo, (name, ef)|
+        expression_filters.inject(expression) do |expr, (name, ef)|
           if ef.matcher?
-            unapplied_options.select { |option_name| ef.handles_option?(option_name) }.each do |option_name|
+            unapplied_options.select { |option_name| ef.handles_option?(option_name) }.inject(expr) do |memo, option_name|
               unapplied_options.delete(option_name)
-              memo = ef.apply_filter(memo, option_name, options[option_name])
+              ef.apply_filter(memo, option_name, options[option_name])
             end
-            memo
           elsif options.key?(name)
             unapplied_options.delete(name)
-            ef.apply_filter(memo, name, options[name])
+            ef.apply_filter(expr, name, options[name])
           elsif ef.default?
-            ef.apply_filter(memo, name, ef.default)
+            ef.apply_filter(expr, name, ef.default)
           else
-            memo
+            expr
           end
         end
       end
@@ -307,21 +313,40 @@ module Capybara
         node.is_a?(::Capybara::Node::Simple) && node.path == '/'
       end
 
-      def matches_text_filter(node, value)
-        return matches_exact_text_filter(node, value) if exact_text == true
+      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)
+        matches_text_regexp?(node, regexp)
       end
 
-      def matches_exact_text_filter(node, value)
+      def matches_exact_text_filter?(node)
+        return true unless exact_text.is_a?(String)
+        matches_text_exactly?(node, exact_text)
+      end
+
+      def matches_visible_filter?(node)
+        case visible
+        when :visible then node.visible?
+        when :hidden then !node.visible?
+        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)
+        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)
+      def matches_text_regexp?(node, regexp)
         text_visible = visible
         text_visible = :all if text_visible == :hidden
-        node.text(text_visible).match(regexp)
+        !!node.text(text_visible, normalize_ws: normalize_ws).match(regexp)
       end
     end
   end

data/lib/capybara/queries/text_query.rb

@@ -90,7 +90,8 @@ module Capybara
       end
 
       def text(node: @node, query_type: @type)
-        node.text(query_type, normalize_ws: options[:normalize_ws])
+        normalize_ws = options.fetch(:normalize_ws, session_options.default_normalize_ws)
+        node.text(query_type, normalize_ws: normalize_ws)
       end
 
       def default_type

data/lib/capybara/rack_test/form.rb

@@ -22,10 +22,10 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
     params = make_params
 
     form_element_types = %i[input select textarea]
-    form_elements_xpath = XPath.generate do |x|
-      xpath = x.descendant(*form_element_types).where(!x.attr(:form))
-      xpath += x.anywhere(*form_element_types).where(x.attr(:form) == native[:id]) if native[:id]
-      xpath.where(!x.attr(:disabled))
+    form_elements_xpath = XPath.generate do |xp|
+      xpath = xp.descendant(*form_element_types).where(!xp.attr(:form))
+      xpath += xp.anywhere(*form_element_types).where(xp.attr(:form) == native[:id]) if native[:id]
+      xpath.where(!xp.attr(:disabled))
     end.to_s
 
     native.xpath(form_elements_xpath).map do |field|

data/lib/capybara/rack_test/node.rb

@@ -105,11 +105,11 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
   end
 
   def find_xpath(locator)
-    native.xpath(locator).map { |n| self.class.new(driver, n) }
+    native.xpath(locator).map { |el| self.class.new(driver, el) }
   end
 
   def find_css(locator)
-    native.css(locator, Capybara::RackTest::CSSHandlers.new).map { |n| self.class.new(driver, n) }
+    native.css(locator, Capybara::RackTest::CSSHandlers.new).map { |el| self.class.new(driver, el) }
   end
 
   def ==(other)
@@ -165,7 +165,7 @@ private
   end
 
   def set_radio(_value) # rubocop:disable Naming/AccessorMethodName
-    other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name) == self[:name]] }.to_s
+    other_radios_xpath = XPath.generate { |xp| xp.anywhere(:input)[xp.attr(:name) == self[:name]] }.to_s
     driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute('checked') }
     native['checked'] = 'checked'
   end
@@ -185,11 +185,11 @@ private
       value = value.to_s[0...self[:maxlength].to_i]
     end
     if value.is_a?(Array) # Assert multiple attribute is present
-      value.each do |v|
+      value.each do |val|
         new_native = native.clone
         new_native.remove_attribute('value')
         native.add_next_sibling(new_native)
-        new_native['value'] = v.to_s
+        new_native['value'] = val.to_s
       end
       native.remove
     else

data/lib/capybara/result.rb

@@ -62,10 +62,7 @@ module Capybara
       if max_idx.nil?
         full_results[*args]
       else
-        loop do
-          break if @result_cache.size > max_idx
-          @result_cache << @results_enum.next
-        end
+        load_up_to(max_idx + 1)
         @result_cache[*args]
       end
     end
@@ -77,40 +74,26 @@ module Capybara
 
     def compare_count
       # Only check filters for as many elements as necessary to determine result
-      if @query.options[:count]
-        count_opt = Integer(@query.options[:count])
-        loop do
-          break if @result_cache.size > count_opt
-          @result_cache << @results_enum.next
-        end
-        return @result_cache.size <=> count_opt
+      if (count = @query.options[:count])
+        count = Integer(count)
+        return load_up_to(count + 1) <=> count
       end
 
-      if @query.options[:minimum]
-        min_opt = Integer(@query.options[:minimum])
-        begin
-          @result_cache << @results_enum.next while @result_cache.size < min_opt
-        rescue StopIteration
-          return -1
-        end
+      if (min = @query.options[:minimum])
+        min = Integer(min)
+        return -1 if load_up_to(min) < min
       end
 
-      if @query.options[:maximum]
-        max_opt = Integer(@query.options[:maximum])
-        loop do
-          return 1 if @result_cache.size > max_opt
-          @result_cache << @results_enum.next
-        end
+      if (max = @query.options[:maximum])
+        max = Integer(max)
+        return 1 if load_up_to(max + 1) > max
       end
 
-      if @query.options[:between]
-        min, max = @query.options[:between].minmax
-        loop do
-          break if @result_cache.size > max
-          @result_cache << @results_enum.next
-        end
-        return 0 if @query.options[:between].include? @result_cache.size
-        return @result_cache.size <=> min
+      if (between = @query.options[:between])
+        min, max = between.minmax
+        size = load_up_to(max + 1)
+        return 0 if between.include? size
+        return size <=> min
       end
 
       0
@@ -144,6 +127,14 @@ module Capybara
 
   private
 
+    def load_up_to(num)
+      loop do
+        break if @result_cache.size >= num
+        @result_cache << @results_enum.next
+      end
+      @result_cache.size
+    end
+
     def full_results
       loop { @result_cache << @results_enum.next }
       @result_cache