capybara 3.6.0 → 3.7.0

data/lib/capybara/rspec/compound.rb

@@ -21,7 +21,7 @@ if defined?(::RSpec::Expectations::Version)
         class CapybaraEvaluator
           def initialize(actual)
             @actual = actual
-            @match_results = Hash.new { |h, matcher| h[matcher] = matcher.matches?(@actual) }
+            @match_results = Hash.new { |hsh, matcher| hsh[matcher] = matcher.matches?(@actual) }
           end
 
           def matcher_matches?(matcher)

data/lib/capybara/rspec/matchers.rb

@@ -27,15 +27,15 @@ module Capybara
 
       def wrap_matches?(actual)
         yield(wrap(actual))
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message = e.message
+      rescue Capybara::ExpectationNotMet => err
+        @failure_message = err.message
         false
       end
 
       def wrap_does_not_match?(actual)
         yield(wrap(actual))
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message_when_negated = e.message
+      rescue Capybara::ExpectationNotMet => err
+        @failure_message_when_negated = err.message
         false
       end
 
@@ -280,28 +280,72 @@ module Capybara
       MatchSelector.new(*args, &optional_filter_block)
     end
 
-    # RSpec matcher for whether elements(s) matching a given xpath selector exist
-    # See {Capybara::Node::Matchers#has_xpath?}
-    def have_xpath(xpath, **options, &optional_filter_block)
-      HaveSelector.new(:xpath, xpath, options, &optional_filter_block)
-    end
+    %i[css xpath].each do |selector|
+      define_method "have_#{selector}" do |expr, **options, &optional_filter_block|
+        HaveSelector.new(selector, expr, options, &optional_filter_block)
+      end
 
-    # RSpec matcher for whether the current element matches a given xpath selector
-    def match_xpath(xpath, **options, &optional_filter_block)
-      MatchSelector.new(:xpath, xpath, options, &optional_filter_block)
+      define_method "match_#{selector}" do |expr, **options, &optional_filter_block|
+        MatchSelector.new(selector, expr, options, &optional_filter_block)
+      end
     end
 
-    # RSpec matcher for whether elements(s) matching a given css selector exist
-    # See {Capybara::Node::Matchers#has_css?}
-    def have_css(css, **options, &optional_filter_block)
-      HaveSelector.new(:css, css, options, &optional_filter_block)
+    # @!method have_xpath(xpath, **options, &optional_filter_block)
+    #   RSpec matcher for whether elements(s) matching a given xpath selector exist
+    #   See {Capybara::Node::Matchers#has_xpath?}
+
+    # @!method have_css(css, **options, &optional_filter_block)
+    #   RSpec matcher for whether elements(s) matching a given css selector exist
+    #   See {Capybara::Node::Matchers#has_css?}
+
+    # @!method match_xpath(xpath, **options, &optional_filter_block)
+    #   RSpec matcher for whether the current element matches a given xpath selector
+    #   See {Capybara::Node::Matchers#matches_xpath?}
+
+    # @!method match_css(css, **options, &optional_filter_block)
+    #   RSpec matcher for whether the current element matches a given css selector
+    #   See {Capybara::Node::Matchers#matches_css?}
+
+    %i[link button field select table].each do |selector|
+      define_method "have_#{selector}" do |locator = nil, **options, &optional_filter_block|
+        HaveSelector.new(selector, locator, options, &optional_filter_block)
+      end
     end
 
-    # RSpec matcher for whether the current element matches a given css selector
-    def match_css(css, **options, &optional_filter_block)
-      MatchSelector.new(:css, css, options, &optional_filter_block)
+    # @!method have_link(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for links
+    #   See {Capybara::Node::Matchers#has_link?}
+
+    # @!method have_button(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for buttons
+    #   See {Capybara::Node::Matchers#has_button?}
+
+    # @!method have_field(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for links
+    #   See {Capybara::Node::Matchers#has_field?}
+
+    # @!method have_select(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for select elements
+    #   See {Capybara::Node::Matchers#has_select?}
+
+    # @!method have_table(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for table elements
+    #   See {Capybara::Node::Matchers#has_table?}
+
+    %i[checked unchecked].each do |state|
+      define_method "have_#{state}_field" do |locator = nil, **options, &optional_filter_block|
+        HaveSelector.new(:field, locator, options.merge(state => true), &optional_filter_block)
+      end
     end
 
+    # @!method have_checked_field(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for checked fields
+    #   See {Capybara::Node::Matchers#has_checked_field?}
+
+    # @!method have_unchecked_field(locator = nil, **options, &optional_filter_block)
+    #   RSpec matcher for unchecked fields
+    #   See {Capybara::Node::Matchers#has_unchecked_field?}
+
     # RSpec matcher for text content
     # See {Capybara::SessionMatchers#assert_text}
     def have_text(*args)
@@ -319,48 +363,6 @@ module Capybara
       HaveCurrentPath.new(path, options)
     end
 
-    # RSpec matcher for links
-    # See {Capybara::Node::Matchers#has_link?}
-    def have_link(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:link, locator, options, &optional_filter_block)
-    end
-
-    # RSpec matcher for buttons
-    # See {Capybara::Node::Matchers#has_button?}
-    def have_button(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:button, locator, options, &optional_filter_block)
-    end
-
-    # RSpec matcher for links
-    # See {Capybara::Node::Matchers#has_field?}
-    def have_field(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:field, locator, options, &optional_filter_block)
-    end
-
-    # RSpec matcher for checked fields
-    # See {Capybara::Node::Matchers#has_checked_field?}
-    def have_checked_field(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:field, locator, options.merge(checked: true), &optional_filter_block)
-    end
-
-    # RSpec matcher for unchecked fields
-    # See {Capybara::Node::Matchers#has_unchecked_field?}
-    def have_unchecked_field(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:field, locator, options.merge(unchecked: true), &optional_filter_block)
-    end
-
-    # RSpec matcher for select elements
-    # See {Capybara::Node::Matchers#has_select?}
-    def have_select(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:select, locator, options, &optional_filter_block)
-    end
-
-    # RSpec matcher for table elements
-    # See {Capybara::Node::Matchers#has_table?}
-    def have_table(locator = nil, **options, &optional_filter_block)
-      HaveSelector.new(:table, locator, options, &optional_filter_block)
-    end
-
     # RSpec matcher for element style
     # See {Capybara::Node::Matchers#has_style?}
     def have_style(styles, **options)

data/lib/capybara/selector.rb

@@ -194,8 +194,10 @@ end
 Capybara.add_selector(:fillable_field) do
   label 'field'
 
-  xpath do |locator, **options|
-    xpath = XPath.descendant(:input, :textarea)[!XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')]
+  xpath(:allow_self) do |locator, **options|
+    xpath = XPath.axis(options[:allow_self] ? :"descendant-or-self" : :descendant, :input, :textarea)[
+      !XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')
+    ]
     locate_field(xpath, locator, options)
   end
 
@@ -223,8 +225,10 @@ end
 Capybara.add_selector(:radio_button) do
   label 'radio button'
 
-  xpath do |locator, **options|
-    xpath = XPath.descendant(:input)[XPath.attr(:type) == 'radio']
+  xpath(:allow_self) do |locator, **options|
+    xpath = XPath.axis(options[:allow_self] ? :"descendant-or-self" : :descendant, :input)[
+      XPath.attr(:type) == 'radio'
+    ]
     locate_field(xpath, locator, options)
   end
 
@@ -239,8 +243,10 @@ Capybara.add_selector(:radio_button) do
 end
 
 Capybara.add_selector(:checkbox) do
-  xpath do |locator, **options|
-    xpath = XPath.descendant(:input)[XPath.attr(:type) == 'checkbox']
+  xpath(:allow_self) do |locator, **options|
+    xpath = XPath.axis(options[:allow_self] ? :"descendant-or-self" : :descendant, :input)[
+      XPath.attr(:type) == 'checkbox'
+    ]
     locate_field(xpath, locator, options)
   end
 
@@ -375,8 +381,10 @@ end
 
 Capybara.add_selector(:file_field) do
   label 'file field'
-  xpath do |locator, options|
-    xpath = XPath.descendant(:input)[XPath.attr(:type) == 'file']
+  xpath(:allow_self) do |locator, **options|
+    xpath = XPath.axis(options[:allow_self] ? :"descendant-or-self" : :descendant, :input)[
+      XPath.attr(:type) == 'file'
+    ]
     locate_field(xpath, locator, options)
   end
 
@@ -460,13 +468,17 @@ end
 
 Capybara.add_selector(:element) do
   xpath do |locator, **|
-    XPath.descendant((locator || '@').to_sym)
+    locator ? XPath.descendant(locator.to_sym) : XPath.descendant
   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
@@ -478,6 +490,12 @@ Capybara.add_selector(:element) do
     val.is_a?(Regexp) ? node[name] =~ val : true
   end
 
-  describe_expression_filters
+  describe_expression_filters do |**options|
+    booleans, values = options.partition { |_k, v| [true, false].include? v }.map(&:to_h)
+    desc = describe_all_expression_filters(values)
+    desc + booleans.map do |k, v|
+      v ? " with #{k} attribute" : "without #{k} attribute"
+    end.join
+  end
 end
 # rubocop:enable Metrics/BlockLength

data/lib/capybara/selector/css.rb

@@ -8,12 +8,12 @@ module Capybara
         out = +''
         out << value.slice!(0...1) if value =~ /^[-_]/
         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 << value.gsub(/[^a-zA-Z0-9_-]/) { |char| escape_char char }
         out
       end
 
-      def self.escape_char(c)
-        c =~ %r{[ -/:-~]} ? "\\#{c}" : format('\\%06x', c.ord)
+      def self.escape_char(char)
+        char =~ %r{[ -/:-~]} ? "\\#{char}" : format('\\%06x', char.ord)
       end
 
       def self.split(css)
@@ -32,21 +32,21 @@ module Capybara
           selectors = []
           StringIO.open(css) do |str|
             selector = ''
-            while (c = str.getc)
-              case c
+            while (char = str.getc)
+              case char
               when '['
                 selector += parse_square(str)
               when '('
                 selector += parse_paren(str)
               when '"', "'"
-                selector += parse_string(c, str)
+                selector += parse_string(char, str)
               when '\\'
-                selector += c + str.getc
+                selector += char + str.getc
               when ','
                 selectors << selector.strip
                 selector = ''
               else
-                selector += c
+                selector += char
               end
             end
             selectors << selector.strip
@@ -66,16 +66,16 @@ module Capybara
 
         def parse_block(start, final, strio)
           block = start
-          while (c = strio.getc)
-            case c
+          while (char = strio.getc)
+            case char
             when final
-              return block + c
+              return block + char
             when '\\'
-              block += c + strio.getc
+              block += char + strio.getc
             when '"', "'"
-              block += parse_string(c, strio)
+              block += parse_string(char, strio)
             else
-              block += c
+              block += char
             end
           end
           raise ArgumentError, "Invalid CSS Selector - Block end '#{final}' not found"
@@ -83,9 +83,9 @@ module Capybara
 
         def parse_string(quote, strio)
           string = quote
-          while (c = strio.getc)
-            string += c
-            case c
+          while (char = strio.getc)
+            string += char
+            case char
             when quote
               return string
             when '\\'

data/lib/capybara/selector/filter_set.rb

@@ -11,7 +11,7 @@ module Capybara
         @name = name
         @node_filters = {}
         @expression_filters = {}
-        @descriptions = Hash.new { |h, k| h[k] = [] }
+        @descriptions = Hash.new { |hsh, key| hsh[key] = [] }
         instance_eval(&block)
       end
 
@@ -39,11 +39,11 @@ module Capybara
 
       def description(node_filters: true, expression_filters: true, **options)
         opts = options_with_defaults(options)
-        d = +''
-        d += undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
-        d += expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
-        d += node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
-        d
+        description = +''
+        description += undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
+        description += expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
+        description += node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
+        description
       end
 
       def descriptions
@@ -53,7 +53,7 @@ module Capybara
 
       def import(name, filters = nil)
         f_set = self.class.all[name]
-        filter_selector = filters.nil? ? ->(*) { true } : ->(n, _) { filters.include? n }
+        filter_selector = filters.nil? ? ->(*) { true } : ->(filter_name, _) { filters.include? filter_name }
 
         expression_filters.merge!(f_set.expression_filters.select(&filter_selector))
         node_filters.merge!(f_set.node_filters.select(&filter_selector))
@@ -96,7 +96,7 @@ module Capybara
       def options_with_defaults(options)
         options = options.dup
         [expression_filters, node_filters].each do |filters|
-          filters.select { |_n, f| f.default? }.each do |name, filter|
+          filters.select { |_n, filter| filter.default? }.each do |name, filter|
             options[name] = filter.default unless options.key?(name)
           end
         end
@@ -104,7 +104,7 @@ module Capybara
       end
 
       def add_filter(name, filter_class, *types, matcher: nil, **options, &block)
-        types.each { |k| options[k] = true }
+        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)

data/lib/capybara/selector/selector.rb

@@ -185,7 +185,6 @@ module Capybara
       @match = nil
       @label = nil
       @failure_message = nil
-      @description = nil
       @format = nil
       @expression = nil
       @expression_filters = {}
@@ -337,7 +336,7 @@ module Capybara
     #
     # Define an expression filter for use with this selector
     #
-    # @!method expression_filter(name, *types, options={}, &block)
+    # @!method expression_filter(name, *types, matcher: nil, **options, &block)
     #   @param [Symbol, Regexp] name            The filter name
     #   @param [Regexp] matcher (nil)   A Regexp used to check whether a specific option is handled by this filter
     #   @param [Array<Symbol>] types    The types of the filter - currently valid types are [:boolean]
@@ -419,8 +418,8 @@ module Capybara
     def describe_all_expression_filters(**opts)
       expression_filters.map do |ef_name, ef|
         if ef.matcher?
-          opts.keys.map do |k|
-            " with #{ef_name}[#{k} => #{opts[k]}]" if ef.handles_option?(k) && !::Capybara::Queries::SelectorQuery::VALID_KEYS.include?(k)
+          opts.keys.map do |key|
+            " with #{ef_name}[#{key} => #{opts[key]}]" if ef.handles_option?(key) && !::Capybara::Queries::SelectorQuery::VALID_KEYS.include?(key)
           end.join
         elsif opts.key?(ef_name)
           " with #{ef_name} #{opts[ef_name]}"

data/lib/capybara/selenium/driver.rb

@@ -15,33 +15,19 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   def self.load_selenium
     require 'selenium-webdriver'
     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 => e
-    raise e if e.message !~ /selenium-webdriver/
+  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
 
   def browser
-    unless @browser
-      # if firefox?
-      #   options[:desired_capabilities] ||= {}
-      #   options[:desired_capabilities][:unexpectedAlertBehaviour] = "ignore"
-      # end
-
-      @processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
-      @browser = Selenium::WebDriver.for(options[:browser], @processed_options)
-
-      extend ChromeDriver if chrome?
-      extend MarionetteDriver if marionette?
-
-      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 = $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
+    @browser ||= begin
+      processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
+      Selenium::WebDriver.for(options[:browser], processed_options).tap do |driver|
+        specialize_driver(driver)
+        setup_exit_handler
       end
     end
-    @browser
   end
 
   def initialize(app, **options)
@@ -49,7 +35,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     @app = app
     @browser = nil
     @exit_status = nil
-    @frame_handles = {}
+    @frame_handles = Hash.new { |hash, handle| hash[handle] = [] }
     @options = DEFAULT_OPTIONS.merge(options)
     @node_class = ::Capybara::Selenium::Node
   end
@@ -122,18 +108,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       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::NoSuchAlertError
-        #   # Handle a bug in Firefox/Geckodriver where it thinks it needs an alert modal to exist
-        #   # for no good reason
-        #   retry
-        rescue Selenium::WebDriver::Error::UnhandledError # rubocop:disable Lint/HandleExceptions
-          # delete_all_cookies fails when we've previously gone
-          # to about:blank, so we rescue this error and do nothing
-          # instead.
-        end
+        clear_browser_state
         @browser.navigate.to('about:blank')
       end
       navigated = true
@@ -151,18 +126,10 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
         @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
-            # 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, Lint/HandleExceptions
-            # alert now gone, should mean navigation happened
-          end
-        end
+        # The alert is now gone.
+        # If navigation has not occurred attempt again and accept alert
+        # since FF may have dismissed the alert at first attempt.
+        navigate_with_accept('about:blank') if current_url != 'about:blank'
       end
       # try cleaning up the browser again
       retry
@@ -170,19 +137,19 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def switch_to_frame(frame)
+    handles = @frame_handles[current_window_handle]
     case frame
     when :top
-      @frame_handles[browser.window_handle] = []
+      handles.clear
       browser.switch_to.default_content
     when :parent
       # would love to use browser.switch_to.parent_frame here
       # but it has an issue if the current frame is removed from within it
-      @frame_handles[browser.window_handle].pop
+      handles.pop
       browser.switch_to.default_content
-      @frame_handles[browser.window_handle].each { |fh| browser.switch_to.frame(fh) }
+      handles.each { |fh| browser.switch_to.frame(fh) }
     else
-      @frame_handles[browser.window_handle] ||= []
-      @frame_handles[browser.window_handle] << frame.native
+      handles << frame.native
       browser.switch_to.frame(frame.native)
     end
   end
@@ -259,10 +226,10 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     @browser&.quit
   rescue Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED # rubocop:disable Lint/HandleExceptions
     # Browser must have already gone
-  rescue Selenium::WebDriver::Error::UnknownError => e
-    unless silenced_unknown_error_message?(e.message) # Most likely already gone
+  rescue Selenium::WebDriver::Error::UnknownError => err
+    unless silenced_unknown_error_message?(err.message) # Most likely already gone
       # probably already gone but not sure - so warn
-      warn "Ignoring Selenium UnknownError during driver quit: #{e.message}"
+      warn "Ignoring Selenium UnknownError during driver quit: #{err.message}"
     end
   ensure
     @browser = nil
@@ -290,54 +257,46 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
 private
 
-  def w3c?
-    browser && browser.capabilities.is_a?(Selenium::WebDriver::Remote::W3C::Capabilities)
-  end
-
-  def marionette?
-    firefox? && w3c?
-  end
-
-  def firefox?
-    browser_name == :firefox
-  end
-
-  def chrome?
-    browser_name == :chrome
-  end
-
-  def edge?
-    browser_name == :edge
+  def native_args(args)
+    args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg }
   end
 
-  def ie?
-    %i[internet_explorer ie].include?(browser_name)
+  def clear_browser_state
+    @browser.manage.delete_all_cookies
+    clear_storage
+  rescue Selenium::WebDriver::Error::UnhandledError # rubocop:disable Lint/HandleExceptions
+    # delete_all_cookies fails when we've previously gone
+    # to about:blank, so we rescue this error and do nothing
+    # instead.
   end
 
-  def browser_name
-    browser.browser
+  def clear_storage
+    clear_session_storage if options[:clear_session_storage]
+    clear_local_storage if options[:clear_local_storage]
   end
 
-  def native_args(args)
-    args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg }
+  def 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
 
-  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
+  def 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
 
-    if options[:clear_local_storage] # rubocop:disable Style/GuardClause
-      if @browser.respond_to? :local_storage
-        @browser.local_storage.clear
-      else
-        warn 'localStorage clear requested but is not available for this driver'
-      end
-    end
+  def navigate_with_accept(url)
+    @browser.navigate.to(url)
+    sleep 0.1 # slight wait for alert
+    @browser.switch_to.alert.accept
+  rescue modal_error # rubocop:disable Lint/HandleExceptions
+    # alert now gone, should mean navigation happened
   end
 
   def modal_error
@@ -375,7 +334,7 @@ private
   end
 
   def silenced_unknown_error_message?(msg)
-    silenced_unknown_error_messages.any? { |r| msg =~ r }
+    silenced_unknown_error_messages.any? { |regex| msg =~ regex }
   end
 
   def silenced_unknown_error_messages
@@ -385,9 +344,9 @@ private
   def unwrap_script_result(arg)
     case arg
     when Array
-      arg.map { |e| unwrap_script_result(e) }
+      arg.map { |arr| unwrap_script_result(arr) }
     when Hash
-      arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+      arg.each { |key, value| arg[key] = unwrap_script_result(value) }
     when Selenium::WebDriver::Element
       build_node(arg)
     else
@@ -398,6 +357,25 @@ private
   def build_node(native_node)
     ::Capybara::Selenium::Node.new(self, native_node)
   end
+
+  def specialize_driver(sel_driver)
+    case sel_driver.browser
+    when :chrome
+      extend ChromeDriver
+    when :firefox
+      extend MarionetteDriver if sel_driver.capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities)
+    end
+  end
+
+  def setup_exit_handler
+    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 = $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
+  end
 end
 
 require 'capybara/selenium/driver_specializations/chrome_driver'