capybara 3.8.2 → 3.9.0

data/lib/capybara/result.rb

@@ -93,6 +93,7 @@ module Capybara
         min, max = between.minmax
         size = load_up_to(max + 1)
         return 0 if between.include? size
+
         return size <=> min
       end
 
@@ -130,6 +131,7 @@ module Capybara
     def load_up_to(num)
       loop do
         break if @result_cache.size >= num
+
         @result_cache << @results_enum.next
       end
       @result_cache.size

data/lib/capybara/rspec/compound.rb

@@ -43,6 +43,7 @@ if defined?(::RSpec::Expectations::Version)
               syncer.synchronize do
                 @evaluator.reset
                 raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].all?
+
                 true
               end
             rescue StandardError
@@ -71,6 +72,7 @@ if defined?(::RSpec::Expectations::Version)
               syncer.synchronize do
                 @evaluator.reset
                 raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].any?
+
                 true
               end
             rescue StandardError

data/lib/capybara/rspec/matchers.rb

@@ -242,6 +242,7 @@ module Capybara
         timer = Capybara::Helpers.timer(expire_in: @wait_time)
         while window.exists?
           return false if timer.expired?
+
           sleep 0.05
         end
         true

data/lib/capybara/selector.rb

@@ -38,8 +38,11 @@ Capybara.add_selector(:id) do
 end
 
 Capybara.add_selector(:field) do
+  visible { |options| :hidden if options[:type] == 'hidden' }
   xpath do |locator, **options|
-    xpath = XPath.descendant(:input, :textarea, :select)[!XPath.attr(:type).one_of('submit', 'image', 'hidden')]
+    invalid_types = %w[submit image]
+    invalid_types << 'hidden' unless options[:type] == 'hidden'
+    xpath = XPath.descendant(:input, :textarea, :select)[!XPath.attr(:type).one_of(*invalid_types)]
     locate_field(xpath, locator, options)
   end
 
@@ -87,18 +90,7 @@ end
 Capybara.add_selector(:link) do
   xpath(:title, :alt) do |locator, href: true, alt: nil, title: nil, **|
     xpath = XPath.descendant(:a)
-    xpath = xpath[
-              case href
-              when nil, false
-                !XPath.attr(:href)
-              when true
-                XPath.attr(:href)
-              when Regexp
-                nil # needs to be handled in filter
-              else
-                XPath.attr(:href) == href.to_s
-              end
-            ]
+    xpath = xpath[@href_conditions = builder.attribute_conditions(href: href)]
 
     unless locator.nil?
       locator = locator.to_s
@@ -132,13 +124,19 @@ Capybara.add_selector(:link) do
 
   describe_expression_filters do |**options|
     desc = +''
-    desc << " with href #{options[:href].inspect}" if options[:href] && !options[:href].is_a?(Regexp)
+    if (href = options[:href])
+      if !href.is_a?(Regexp)
+        desc << " with href #{href.inspect}"
+      elsif @href_conditions
+        desc << " with href matching #{href.inspect}"
+      end
+    end
     desc << ' with no href attribute' if options.fetch(:href, true).nil?
     desc
   end
 
   describe_node_filters do |href: nil, **|
-    " with href matching #{href.inspect}" if href.is_a? Regexp
+    " with href matching #{href.inspect}" if href.is_a?(Regexp) && @href_conditions.nil?
   end
 end
 
@@ -472,18 +470,7 @@ Capybara.add_selector(:element) do
   end
 
   expression_filter(:attributes, matcher: /.+/) do |xpath, name, val|
-    case val
-    when Regexp
-      xpath
-    when true
-      xpath[XPath.attr(name)]
-    when false
-      xpath[!XPath.attr(name)]
-    when XPath::Expression
-      xpath[XPath.attr(name)[val]]
-    else
-      xpath[XPath.attr(name.to_sym) == val]
-    end
+    xpath[builder.attribute_conditions(name => val)]
   end
 
   node_filter(:attributes, matcher: /.+/) do |node, name, val|

data/lib/capybara/selector/builders/css_builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'xpath'
+
+module Capybara
+  class Selector
+    # @api private
+    class CSSBuilder
+      class << self
+        def attribute_conditions(attributes)
+          attributes.map do |attribute, value|
+            case value
+            when XPath::Expression
+              raise ArgumentError, "XPath expressions are not supported for the :#{attribute} filter with CSS based selectors"
+            when Regexp
+              Selector::RegexpDisassembler.new(value).substrings.map do |str|
+                "[#{attribute}*='#{str}'#{' i' if value.casefold?}]"
+              end.join
+            when true
+              "[#{attribute}]"
+            when false
+              ':not([attribute])'
+            else
+              if attribute == :id
+                "##{::Capybara::Selector::CSS.escape(value)}"
+              else
+                "[#{attribute}='#{value}']"
+              end
+            end
+          end.join
+        end
+
+        def class_conditions(classes)
+          case classes
+          when XPath::Expression
+            raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
+          when Regexp
+            strs = Selector::RegexpDisassembler.new(classes).substrings
+            strs.map { |str| "[class*='#{str}'#{' i' if classes.casefold?}]" }.join
+          else
+            cls = Array(classes).group_by { |cl| cl.start_with? '!' }
+            (cls[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl)}" } +
+            cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..-1))})" }).join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector/builders/xpath_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'xpath'
+
+module Capybara
+  class Selector
+    # @api private
+    class XPathBuilder
+      class << self
+        def attribute_conditions(attributes)
+          attributes.map do |attribute, value|
+            case value
+            when XPath::Expression
+              XPath.attr(attribute)[value]
+            when Regexp
+              XPath.attr(attribute)[regexp_to_xpath_conditions(value)]
+            when true
+              XPath.attr(attribute)
+            when false, nil
+              !XPath.attr(attribute)
+            else
+              XPath.attr(attribute) == value.to_s
+            end
+          end.reduce(:&)
+        end
+
+        def class_conditions(classes)
+          case classes
+          when XPath::Expression
+            XPath.attr(:class)[classes]
+          when Regexp
+            XPath.attr(:class)[regexp_to_xpath_conditions(classes)]
+          else
+            Array(classes).map do |klass|
+              if klass.start_with?('!')
+                !XPath.attr(:class).contains_word(klass.slice(1..-1))
+              else
+                XPath.attr(:class).contains_word(klass)
+              end
+            end.reduce(:&)
+          end
+        end
+
+      private
+
+        def regexp_to_xpath_conditions(regexp)
+          condition = XPath.current
+          condition = condition.uppercase if regexp.casefold?
+          Selector::RegexpDisassembler.new(regexp).substrings.map do |str|
+            condition.contains(str)
+          end.reduce(:&)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector/filter_set.rb

@@ -106,6 +106,7 @@ 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 filter_class <= Filters::ExpressionFilter
           @expression_filters[name] = filter_class.new(name, matcher, block, options)
         else

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

@@ -41,6 +41,7 @@ module Capybara
         def apply(subject, name, value, skip_value)
           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)
+
           if @block.arity == 2
             @block.call(subject, value)
           else
@@ -50,6 +51,7 @@ module Capybara
 
         def valid_value?(value)
           return true unless @options.key?(:valid_values)
+
           Array(@options[:valid_values]).any? { |valid| valid === value } # rubocop:disable Style/CaseEquality
         end
       end

data/lib/capybara/selector/regexp_disassembler.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Capybara
+  class Selector
+    # @api private
+    class RegexpDisassembler
+      def initialize(regexp)
+        @regexp = regexp
+        @regexp_source = regexp.source
+      end
+
+      def substrings
+        @substrings ||= begin
+          source = @regexp_source.dup
+          source.gsub!(/\\[^pgk]/, '.') # replace escaped characters with wildcard
+          source.gsub!(/\\[gk](?:<[^>]*>)?/, '.') # replace sub expressions and back references with wildcard
+          source.gsub!(/\\p\{[[:alpha:]]+\}?/, '.') # replace character properties with wildcard
+          source.gsub!(/\[\[:[a-z]+:\]\]/, '.') # replace posix classes with wildcard
+          while source.gsub!(/\[(?:[^\[\]]+)\]/, '.'); end # replace character classes with wildcard
+          source.gsub!(/\(\?<?[=!][^)]*\)/, '') # remove lookahead/lookbehind assertions
+          source.gsub!(/\(\?(?:<[^>]+>|>|:)/, '(') # replace named, atomic, and non-matching groups with unnamed matching groups
+
+          while source.gsub!(GROUP_REGEX) { |_m| simplify_group(Regexp.last_match) }; end
+          source.gsub!(/.[*?]\??/, '.') # replace optional character with wildcard
+          source.gsub!(/(.)\+\??/, '\1.') # replace one or more with character plus wildcard
+          source.gsub!(/(?<char>.)#{COUNTED_REP_REGEX.source}/) do |_m| # repeat counted characters
+            (Regexp.last_match[:char] * Regexp.last_match[:min_rep].to_i).tap { |str| str << '.' if Regexp.last_match[:max_rep] }
+          end
+          return [] if source.include?('|') # can't handle alternation here
+
+          strs = source.match(/\A\^?(.*?)\$?\Z/).captures[0].split('.').reject(&:empty?).uniq
+          strs = strs.map(&:upcase) if @regexp.casefold?
+          strs
+        end
+      end
+
+    private
+
+      def simplify_group(matches)
+        if matches[:group].include?('|') # no support for alternation in groups
+          '.'
+        elsif matches[:one_or_more] # required but may repeat becomes text + wildcard
+          matches[:group][1..-2] + '.'
+        elsif matches[:optional] # optional group becomes wildcard
+          '.'
+        elsif matches[:min_rep]
+          (matches[:group] * matches[:min_rep].to_i).tap { |r| r << '.' if matches[:max_rep] }
+        else
+          matches[:group][1..-2]
+        end
+      end
+
+      COUNTED_REP_REGEX = /\{(?<min_rep>\d*)(?:,(?<max_rep>\d*))?\}/
+      GROUP_REGEX = /
+        (?<group>\([^()]*\))
+          (?:
+            (?:
+             (?<optional>[*?]) |
+             (?<one_or_more>\+) |
+             (?:#{COUNTED_REP_REGEX.source})
+            )\??
+          )?
+      /x
+    end
+  end
+end

data/lib/capybara/selector/selector.rb

@@ -4,6 +4,9 @@
 
 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
   #
@@ -381,13 +384,29 @@ module Capybara
     #                                              * :all - finds visible and invisible elements.
     #                                              * :hidden - only finds invisible elements.
     #                                              * :visible - only finds visible elements.
-    def visible(default_visibility)
-      @default_visibility = default_visibility
+    def visible(default_visibility = nil, &block)
+      @default_visibility = block || default_visibility
     end
 
-    def default_visibility(fallback = Capybara.ignore_hidden_elements)
-      return @default_visibility unless @default_visibility.nil?
-      fallback
+    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
+
+    # @api private
+    def builder
+      case format
+      when :css
+        Capybara::Selector::CSSBuilder
+      when :xpath
+        Capybara::Selector::XPathBuilder
+      else
+        raise NotImplementedError, "No builder exists for selector of type #{format}"
+      end
     end
 
   private
@@ -402,6 +421,7 @@ module Capybara
 
     def locate_field(xpath, locator, **_options)
       return xpath if locator.nil?
+
       locate_xpath = xpath # Need to save original xpath for the label wrap
       locator = locator.to_s
       attr_matchers = [XPath.attr(:id) == locator,

data/lib/capybara/selenium/driver.rb

@@ -17,6 +17,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     warn "Warning: You're using an unsupported version of selenium-webdriver, please upgrade." if Gem.loaded_specs['selenium-webdriver'].version < Gem::Version.new('3.5.0')
   rescue LoadError => err
     raise err if err.message !~ /selenium-webdriver/
+
     raise LoadError, "Capybara's selenium driver is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
   end
 
@@ -117,6 +118,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       # Ensure the page is empty and trigger an UnhandledAlertError for any modals that appear during unload
       until find_xpath('/html/body/*').empty?
         raise Capybara::ExpectationNotMet, 'Timed out waiting for Selenium session reset' if timer.expired?
+
         sleep 0.05
       end
     rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
@@ -184,6 +186,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def close_window(handle)
     raise ArgumentError, 'Not allowed to close the primary window' if handle == window_handles.first
+
     within_given_window(handle) do
       browser.close
     end
@@ -260,7 +263,7 @@ private
   end
 
   def clear_browser_state
-    @browser.manage.delete_all_cookies
+    delete_all_cookies
     clear_storage
   rescue Selenium::WebDriver::Error::UnhandledError # rubocop:disable Lint/HandleExceptions
     # delete_all_cookies fails when we've previously gone
@@ -268,6 +271,10 @@ private
     # instead.
   end
 
+  def delete_all_cookies
+    @browser.manage.delete_all_cookies
+  end
+
   def clear_storage
     clear_session_storage if options[:clear_session_storage]
     clear_local_storage if options[:clear_local_storage]

data/lib/capybara/selenium/driver_specializations/chrome_driver.rb

@@ -9,7 +9,7 @@ module Capybara::Selenium::Driver::ChromeDriver
         super
       rescue NoMethodError => err
         raise unless err.message =~ /full_screen_window/
-        bridge = browser.send(:bridge)
+
         result = bridge.http.call(:post, "session/#{bridge.session_id}/window/fullscreen", {})
         result['value']
       end
@@ -20,6 +20,7 @@ module Capybara::Selenium::Driver::ChromeDriver
     super
   rescue Selenium::WebDriver::Error::UnknownError => err
     raise unless err.message =~ /failed to change window state/
+
     # Chromedriver doesn't wait long enough for state to change when coming out of fullscreen
     # and raises unnecessary error. Wait a bit and try again.
     sleep 0.5
@@ -37,7 +38,24 @@ module Capybara::Selenium::Driver::ChromeDriver
 
 private
 
+  def delete_all_cookies
+    execute_cdp('Network.clearBrowserCookies')
+  rescue Selenium::WebDriver::Error::UnhandledError, Selenium::WebDriver::Error::WebDriverError
+    # If the CDP clear isn't supported do original limited clear
+    super
+  end
+
+  def execute_cdp(cmd, params = {})
+    args = { cmd: cmd, params: params }
+    result = bridge.http.call(:post, "session/#{bridge.session_id}/goog/cdp/execute", args)
+    result['value']
+  end
+
   def build_node(native_node)
     ::Capybara::Selenium::ChromeNode.new(self, native_node)
   end
+
+  def bridge
+    browser.send(:bridge)
+  end
 end