capybara 2.18.0 → 3.0.0.rc1

data/lib/capybara/selector/css.rb

@@ -2,24 +2,19 @@ module Capybara
   class Selector
     class CSS
       def self.escape(str)
-        out = String.new("")
         value = str.dup
+        out = "".dup
         out << value.slice!(0...1) if value =~ /^[-_]/
-        out << if value[0] =~ NMSTART
-          value.slice!(0...1)
-        else
-          escape_char(value.slice!(0...1))
-        end
-        out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
+        out << (value[0] =~ NMSTART ? value.slice!(0...1) : escape_char(value.slice!(0...1)))
+        out << value.gsub(/[^a-zA-Z0-9_-]/) { |c| escape_char c }
         out
       end
 
       def self.escape_char(c)
-        return "\\%06x" % c.ord() unless c =~ %r{[ -/:-~]}
-        "\\#{c}"
+        c =~ %r{[ -/:-~]} ? "\\#{c}" : format("\\%06x", c.ord)
       end
 
-      S = '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'
+      S = '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'.freeze
       H = /[0-9a-fA-F]/
       UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/
       NONASCII = /[#{S}]/
@@ -27,4 +22,4 @@ module Capybara
       NMSTART  = /[_a-zA-Z]|#{NONASCII}|#{ESCAPE}/
     end
   end
-end
+end

data/lib/capybara/selector/filter.rb

@@ -1,20 +1,4 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/node_filter'
 require 'capybara/selector/filters/expression_filter'
-
-module Capybara
-  class Selector
-    def self.const_missing(const_name)
-      case const_name
-      when :Filter
-        warn "DEPRECATED: Capybara::Selector::Filter is deprecated, please use Capybara::Selector::Filters::NodeFilter instead"
-        Filters::NodeFilter
-      when :ExpressionFilter
-        warn "DEPRECATED: Capybara::Selector::ExpressionFilter is deprecated, please use Capybara::Selector::Filters::ExpressionFilter instead"
-        Filters::ExpressionFilter
-      else
-        super
-      end
-    end
-  end
-end

data/lib/capybara/selector/filter_set.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filter'
 
 module Capybara
@@ -24,14 +25,10 @@ module Capybara
         descriptions.push block
       end
 
-      def description(options={})
-        options_with_defaults = options.dup
-        filters.each do |name, filter|
-          options_with_defaults[name] = filter.default if filter.default? && !options_with_defaults.has_key?(name)
-        end
-
+      def description(**options)
+        opts = options_with_defaults(options)
         @descriptions.map do |desc|
-          desc.call(options_with_defaults).to_s
+          desc.call(opts).to_s
         end.join
       end
 
@@ -44,11 +41,10 @@ module Capybara
       end
 
       def expression_filters
-        filters.select { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter)  }.freeze
+        filters.select { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter) }.freeze
       end
 
       class << self
-
         def all
           @filter_sets ||= {}
         end
@@ -62,13 +58,20 @@ module Capybara
         end
       end
 
-      private
+    private
+
+      def options_with_defaults(options)
+        options = options.dup
+        filters.each do |name, filter|
+          options[name] = filter.default if filter.default? && !options.key?(name)
+        end
+        options
+      end
 
-      def add_filter(name, filter_class, *types_and_options, &block)
-        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
-        types_and_options.each { |k| options[k] = true}
+      def add_filter(name, filter_class, *types, **options, &block)
+        types.each { |k| options[k] = true }
         filters[name] = filter_class.new(name, block, options)
       end
     end
   end
-end
+end

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

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
+
 module Capybara
   class Selector
     module Filters
       class Base
-        def initialize(name, block, options={})
+        def initialize(name, block, **options)
           @name = name
           @block = block
           @options = options
-          @options[:valid_values] = [true,false] if options[:boolean]
+          @options[:valid_values] = [true, false] if options[:boolean]
         end
 
         def default?
-          @options.has_key?(:default)
+          @options.key?(:default)
         end
 
         def default
@@ -19,13 +20,13 @@ module Capybara
         end
 
         def skip?(value)
-          @options.has_key?(:skip_if) && value == @options[:skip_if]
+          @options.key?(:skip_if) && value == @options[:skip_if]
         end
 
-        private
+      private
 
         def valid_value?(value)
-          !@options.has_key?(:valid_values) || Array(@options[:valid_values]).include?(value)
+          !@options.key?(:valid_values) || Array(@options[:valid_values]).include?(value)
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/base'
 
 module Capybara
@@ -7,34 +8,16 @@ module Capybara
       class ExpressionFilter < Base
         def apply_filter(expr, value)
           return expr if skip?(value)
-
-          if !valid_value?(value)
-            msg = "Invalid value #{value.inspect} passed to expression filter #{@name} - "
-            if default?
-              warn msg + "defaulting to #{default}"
-              value = default
-            else
-              warn msg + "skipping"
-              return expr
-            end
-          end
-
+          raise "ArgumentError", "Invalid value #{value.inspect} passed to expression filter #{@name}" unless valid_value?(value)
           @block.call(expr, value)
         end
       end
 
       class IdentityExpressionFilter < ExpressionFilter
-        def initialize
-        end
-
-        def default?
-          false
-        end
-
-        def apply_filter(expr, _value)
-          return expr
-        end
+        def initialize; end
+        def default?; false; end
+        def apply_filter(expr, _value); expr; end
       end
     end
   end
-end
+end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/base'
 
 module Capybara
@@ -7,18 +8,7 @@ module Capybara
       class NodeFilter < Base
         def matches?(node, value)
           return true if skip?(value)
-
-          if !valid_value?(value)
-            msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
-            if default?
-              warn msg + "defaulting to #{default}"
-              value = default
-            else
-              warn msg + "skipping"
-              return true
-            end
-          end
-
+          raise ArgumentError, "Invalid value #{value.inspect} passed to filter #{@name}" unless valid_value?(value)
           @block.call(node, value)
         end
       end

data/lib/capybara/selector/selector.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filter_set'
 require 'capybara/selector/css'
 require 'xpath'
 
-#Patch XPath to allow a nil condition in where
+# Patch XPath to allow a nil condition in where
 module XPath
   class Renderer
     undef :where if method_defined?(:where)
@@ -12,7 +13,7 @@ module XPath
       if !condition.empty?
         "#{on}[#{condition}]"
       else
-        "#{on}"
+        on.to_s
       end
     end
   end
@@ -20,7 +21,6 @@ end
 
 module Capybara
   class Selector
-
     attr_reader :name, :format
 
     class << self
@@ -43,7 +43,7 @@ module Capybara
 
     def initialize(name, &block)
       @name = name
-      @filter_set = FilterSet.add(name){}
+      @filter_set = FilterSet.add(name) {}
       @match = nil
       @label = nil
       @failure_message = nil
@@ -134,7 +134,7 @@ module Capybara
     # @overload label()
     # @return [String]                 The currently set label
     #
-    def label(label=nil)
+    def label(label = nil)
       @label = label if label
       @label
     end
@@ -146,13 +146,12 @@ module Capybara
     # @param [Hash] options            The options of the query used to generate the description
     # @return [String]                 Description of the selector when used with the options passed
     #
-    def description(options={})
+    def description(**options)
       @filter_set.description(options)
     end
 
-    def call(locator, options={})
+    def call(locator, **options)
       if format
-        # @expression.call(locator, options.select {|k,v| @expression_filters.include?(k)})
         @expression.call(locator, options)
       else
         warn "Selector has no format"
@@ -185,15 +184,11 @@ module Capybara
     #   @option options :skip_if        Value of the filter that will cause it to be skipped
     #
     def filter(name, *types_and_options, &block)
-      options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
-      types_and_options.each { |k| options[k] = true }
-      custom_filters[name] = Filters::NodeFilter.new(name, block, options)
+      add_filter(name, Filters::NodeFilter, *types_and_options, &block)
     end
 
     def expression_filter(name, *types_and_options, &block)
-      options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
-      types_and_options.each { |k| options[k] = true }
-      custom_filters[name] = Filters::ExpressionFilter.new(name, block, options)
+      add_filter(name, Filters::ExpressionFilter, *types_and_options, &block)
     end
 
     def filter_set(name, filters_to_use = nil)
@@ -205,7 +200,7 @@ module Capybara
       f_set.descriptions.each { |desc| @filter_set.describe(&desc) }
     end
 
-    def describe &block
+    def describe(&block)
       @filter_set.describe(&block)
     end
 
@@ -230,17 +225,22 @@ module Capybara
       end
     end
 
-    private
+  private
+
+    def add_filter(name, filter_class, *types, **options, &block)
+      types.each { |k| options[k] = true }
+      custom_filters[name] = filter_class.new(name, block, options)
+    end
 
-    def locate_field(xpath, locator, options={})
-      locate_xpath = xpath #need to save original xpath for the label wrap
+    def locate_field(xpath, locator, enable_aria_label: false, **_options)
+      locate_xpath = xpath # Need to save original xpath for the label wrap
       if locator
         locator = locator.to_s
-        attr_matchers =  XPath.attr(:id).equals(locator).or(
-                         XPath.attr(:name).equals(locator)).or(
-                         XPath.attr(:placeholder).equals(locator)).or(
-                         XPath.attr(:id).equals(XPath.anywhere(:label)[XPath.string.n.is(locator)].attr(:for)))
-        attr_matchers = attr_matchers.or XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
+        attr_matchers = [XPath.attr(:id) == locator,
+                         XPath.attr(:name) == locator,
+                         XPath.attr(:placeholder) == locator,
+                         XPath.attr(:id) == XPath.anywhere(:label)[XPath.string.n.is(locator)].attr(:for)].reduce(:|)
+        attr_matchers |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
 
         locate_xpath = locate_xpath[attr_matchers]
         locate_xpath = locate_xpath.union(XPath.descendant(:label)[XPath.string.n.is(locator)].descendant(xpath))
@@ -250,8 +250,8 @@ module Capybara
       locate_xpath
     end
 
-    def describe_all_expression_filters(opts={})
-      expression_filters.map { |ef| " with #{ef} #{opts[ef]}" if opts.has_key?(ef) }.join
+    def describe_all_expression_filters(**opts)
+      expression_filters.map { |ef| " with #{ef} #{opts[ef]}" if opts.key?(ef) }.join
     end
 
     def find_by_attr(attribute, value)
@@ -259,18 +259,12 @@ module Capybara
       if respond_to?(finder_name, true)
         send(finder_name, value)
       else
-        value ? XPath.attr(attribute).equals(value) : nil
+        value ? XPath.attr(attribute) == value : nil
       end
     end
 
     def find_by_class_attr(classes)
-      if classes
-        Array(classes).map do |klass|
-          "contains(concat(' ',normalize-space(@class),' '),' #{klass} ')"
-        end.join(" and ").to_sym
-      else
-        nil
-      end
+      Array(classes).map { |klass| XPath.attr(:class).contains_word(klass) }.reduce(:&)
     end
   end
 end

data/lib/capybara/selenium/driver.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 require "uri"
+require "English"
 
 class Capybara::Selenium::Driver < Capybara::Driver::Base
-
   DEFAULT_OPTIONS = {
-    :browser => :firefox,
+    browser: :firefox,
     clear_local_storage: false,
     clear_session_storage: false
-  }
-  SPECIAL_OPTIONS = [:browser, :clear_local_storage, :clear_session_storage]
+  }.freeze
+  SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage].freeze
 
   attr_reader :app, :options
 
@@ -16,10 +17,10 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     unless @browser
       if firefox?
         options[:desired_capabilities] ||= {}
-        options[:desired_capabilities].merge!({ unexpectedAlertBehaviour: "ignore" })
+        options[:desired_capabilities][:unexpectedAlertBehaviour] = "ignore"
       end
 
-      @processed_options = options.reject { |key,_val| SPECIAL_OPTIONS.include?(key) }
+      @processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
       @browser = Selenium::WebDriver.for(options[:browser], @processed_options)
 
       @w3c = ((defined?(Selenium::WebDriver::Remote::W3CCapabilities) && @browser.capabilities.is_a?(Selenium::WebDriver::Remote::W3CCapabilities)) ||
@@ -27,7 +28,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       main = Process.pid
       at_exit do
         # Store the exit status of the test run since it goes away after calling the at_exit proc...
-        @exit_status = $!.status if $!.is_a?(SystemExit)
+        @exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
         quit if Process.pid == main
         exit @exit_status if @exit_status # Force exit with stored status
       end
@@ -35,7 +36,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     @browser
   end
 
-  def initialize(app, options={})
+  def initialize(app, **options)
     load_selenium
     @session = nil
     @app = app
@@ -50,10 +51,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def refresh
-    accept_modal(nil, wait: 0.1) do
-      browser.navigate.refresh
-    end
-  rescue Capybara::ModalNotFound
+    browser.navigate.refresh
   end
 
   def go_back
@@ -88,7 +86,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   def needs_server?; true; end
 
   def execute_script(script, *args)
-    browser.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ?  arg.native : arg} )
+    browser.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg })
   end
 
   def evaluate_script(script, *args)
@@ -98,66 +96,64 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def evaluate_async_script(script, *args)
     browser.manage.timeouts.script_timeout = Capybara.default_max_wait_time
-    result = browser.execute_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg} )
+    result = browser.execute_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg })
     unwrap_script_result(result)
   end
 
-  def save_screenshot(path, _options={})
+  def save_screenshot(path, **_options)
     browser.save_screenshot(path)
   end
 
   def reset!
     # Use instance variable directly so we avoid starting the browser just to reset the session
-    if @browser
-      navigated = false
-      start_time = Capybara::Helpers.monotonic_time
+    return unless @browser
+
+    navigated = false
+    start_time = Capybara::Helpers.monotonic_time
+    begin
+      unless navigated
+        # Only trigger a navigation if we haven't done it already, otherwise it
+        # can trigger an endless series of unload modals
+        begin
+          @browser.manage.delete_all_cookies
+          clear_storage
+        rescue Selenium::WebDriver::Error::UnhandledError
+          # delete_all_cookies fails when we've previously gone
+          # to about:blank, so we rescue this error and do nothing
+          # instead.
+        end
+        @browser.navigate.to("about:blank")
+      end
+      navigated = true
+
+      # 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 (Capybara::Helpers.monotonic_time - start_time) >= 10
+        sleep 0.05
+      end
+    rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
+      # This error is thrown if an unhandled alert is on the page
+      # Firefox appears to automatically dismiss this alert, chrome does not
+      # We'll try to accept it
       begin
-        if !navigated
-          # Only trigger a navigation if we haven't done it already, otherwise it
-          # can trigger an endless series of unload modals
+        @browser.switch_to.alert.accept
+        sleep 0.25 # allow time for the modal to be handled
+      rescue modal_error
+        # The alert is now gone
+        if current_url != "about:blank"
           begin
-            @browser.manage.delete_all_cookies
-            if options[:clear_session_storage]
-              if @browser.respond_to? :session_storage
-                @browser.session_storage.clear
-              else
-                warn "sessionStorage clear requested but is not available for this driver"
-              end
-            end
-            if options[:clear_local_storage]
-              if @browser.respond_to? :local_storage
-                @browser.local_storage.clear
-              else
-                warn "localStorage clear requested but is not available for this driver"
-              end
-            end
-          rescue Selenium::WebDriver::Error::UnhandledError
-            # delete_all_cookies fails when we've previously gone
-            # to about:blank, so we rescue this error and do nothing
-            # instead.
+            # If navigation has not occurred attempt again and accept alert
+            # since FF may have dismissed the alert at first attempt
+            @browser.navigate.to("about:blank")
+            sleep 0.1 # slight wait for alert
+            @browser.switch_to.alert.accept
+          rescue modal_error # rubocop:disable Metrics/BlockNesting
+            # alert now gone, should mean navigation happened
           end
-          @browser.navigate.to("about:blank")
         end
-        navigated = true
-
-        #Ensure the page is empty and trigger an UnhandledAlertError for any modals that appear during unload
-        until find_xpath("/html/body/*").empty? do
-          raise Capybara::ExpectationNotMet.new('Timed out waiting for Selenium session reset') if (Capybara::Helpers.monotonic_time - start_time) >= 10
-          sleep 0.05
-        end
-      rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
-        # This error is thrown if an unhandled alert is on the page
-        # Firefox appears to automatically dismiss this alert, chrome does not
-        # We'll try to accept it
-        begin
-          @browser.switch_to.alert.accept
-          sleep 0.25 # allow time for the modal to be handled
-        rescue modal_error
-          # The alert is now gone - nothing to do
-        end
-        # try cleaning up the browser again
-        retry
       end
+      # try cleaning up the browser again
+      retry
     end
   end
 
@@ -226,12 +222,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.switch_to.window handle
   end
 
-  def within_window(locator)
-    handle = find_window(locator)
-    browser.switch_to.window(handle) { yield }
-  end
-
-  def accept_modal(_type, options={})
+  def accept_modal(_type, **options)
     yield if block_given?
     modal = find_modal(options)
 
@@ -242,7 +233,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     message
   end
 
-  def dismiss_modal(_type, options={})
+  def dismiss_modal(_type, **options)
     yield if block_given?
     modal = find_modal(options)
     message = modal.text
@@ -264,14 +255,15 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def invalid_element_errors
-    [::Selenium::WebDriver::Error::StaleElementReferenceError,
-     ::Selenium::WebDriver::Error::UnhandledError,
-     ::Selenium::WebDriver::Error::ElementNotVisibleError,
-     ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around a race condition that can occur with chromedriver and #go_back/#go_forward
-     ::Selenium::WebDriver::Error::ElementNotInteractableError,
-     ::Selenium::WebDriver::Error::ElementClickInterceptedError,
-     ::Selenium::WebDriver::Error::InvalidElementStateError,
-     ::Selenium::WebDriver::Error::ElementNotSelectableError,
+    [
+      ::Selenium::WebDriver::Error::StaleElementReferenceError,
+      ::Selenium::WebDriver::Error::UnhandledError,
+      ::Selenium::WebDriver::Error::ElementNotVisibleError,
+      ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around a race condition that can occur with chromedriver and #go_back/#go_forward
+      ::Selenium::WebDriver::Error::ElementNotInteractableError,
+      ::Selenium::WebDriver::Error::ElementClickInterceptedError,
+      ::Selenium::WebDriver::Error::InvalidElementStateError,
+      ::Selenium::WebDriver::Error::ElementNotSelectableError
     ]
   end
 
@@ -294,18 +286,29 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser_name == "chrome"
   end
 
-  # @deprecated This method is being removed
-  def browser_initialized?
-    super && !@browser.nil?
-  end
-
-  private
+private
 
-  # @api private
   def browser_name
     options[:browser].to_s
   end
 
+  def clear_storage
+    if options[:clear_session_storage]
+      if @browser.respond_to? :session_storage
+        @browser.session_storage.clear
+      else
+        warn "sessionStorage clear requested but is not available for this driver"
+      end
+    end
+    if options[:clear_local_storage]
+      if @browser.respond_to? :local_storage
+        @browser.local_storage.clear
+      else
+        warn "localStorage clear requested but is not available for this driver"
+      end
+    end
+  end
+
   def modal_error
     if defined?(Selenium::WebDriver::Error::NoSuchAlertError)
       Selenium::WebDriver::Error::NoSuchAlertError
@@ -314,23 +317,6 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
-  def find_window(locator)
-    handles = browser.window_handles
-    return locator if handles.include? locator
-
-    original_handle = browser.window_handle
-    handles.each do |handle|
-      switch_to_window(handle)
-      if (locator == browser.execute_script("return window.name") ||
-          browser.title.include?(locator) ||
-          browser.current_url.include?(locator))
-        switch_to_window(original_handle)
-        return handle
-      end
-    end
-    raise Capybara::ElementNotFound, "Could not find a window identified by #{locator}"
-  end
-
   def insert_modal_handlers(accept, response_text)
     prompt_response = if accept
       if response_text.nil?
@@ -386,7 +372,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def within_given_window(handle)
-    original_handle = self.current_window_handle
+    original_handle = current_window_handle
     if handle == original_handle
       yield
     else
@@ -397,39 +383,41 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
-  def find_modal(options={})
+  def find_modal(text: nil, **options)
     # Selenium has its own built in wait (2 seconds)for a modal to show up, so this wait is really the minimum time
     # Actual wait time may be longer than specified
     wait = Selenium::WebDriver::Wait.new(
-      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0 ,
-      ignore: modal_error)
+      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0,
+      ignore: modal_error
+    )
     begin
       wait.until do
         alert = @browser.switch_to.alert
-        regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
+        regexp = text.is_a?(Regexp) ? text : Regexp.escape(text.to_s)
         alert.text.match(regexp) ? alert : nil
       end
     rescue Selenium::WebDriver::Error::TimeOutError
-      raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+      raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
     end
   end
 
-  def find_headless_modal(options={})
+  def find_headless_modal(text: nil, **options)
     # Selenium has its own built in wait (2 seconds)for a modal to show up, so this wait is really the minimum time
     # Actual wait time may be longer than specified
     wait = Selenium::WebDriver::Wait.new(
-      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0 ,
-      ignore: modal_error)
+      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0,
+      ignore: modal_error
+    )
     begin
       wait.until do
         called, alert_text = evaluate_script('window.capybara && window.capybara.current_modal_status()')
         if called
           execute_script('window.capybara && window.capybara.modal_handlers.shift()')
-          regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
+          regexp = text.is_a?(Regexp) ? text : Regexp.escape(text.to_s)
           if alert_text.match(regexp)
             alert_text
           else
-            raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+            raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
           end
         elsif called.nil?
           # page changed so modal_handler data has gone away
@@ -440,7 +428,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
         end
       end
     rescue Selenium::WebDriver::Error::TimeOutError
-      raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+      raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}"
     end
   end
 
@@ -449,7 +437,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def silenced_unknown_error_messages
-    [ /Error communicating with the remote browser/ ]
+    [/Error communicating with the remote browser/]
   end
 
   def unwrap_script_result(arg)
@@ -466,21 +454,19 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def load_selenium
-    begin
-      require 'selenium-webdriver'
-      # Fix for selenium-webdriver 3.4.0 which misnamed these
-      if !defined?(::Selenium::WebDriver::Error::ElementNotInteractableError)
-        ::Selenium::WebDriver::Error.const_set('ElementNotInteractableError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
-      end
-      if !defined?(::Selenium::WebDriver::Error::ElementClickInterceptedError)
-        ::Selenium::WebDriver::Error.const_set('ElementClickInterceptedError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
-      end
-    rescue LoadError => e
-      if e.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."
-      else
-        raise e
-      end
+    require 'selenium-webdriver'
+    # Fix for selenium-webdriver 3.4.0 which misnamed these
+    unless defined?(::Selenium::WebDriver::Error::ElementNotInteractableError)
+      ::Selenium::WebDriver::Error.const_set('ElementNotInteractableError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
+    end
+    unless defined?(::Selenium::WebDriver::Error::ElementClickInterceptedError)
+      ::Selenium::WebDriver::Error.const_set('ElementClickInterceptedError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
+    end
+  rescue LoadError => e
+    if e.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."
+    else
+      raise e
     end
   end
 end