capybara 2.18.0 → 3.0.0.rc1

data/lib/capybara/selenium/node.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-class Capybara::Selenium::Node < Capybara::Driver::Node
 
+class Capybara::Selenium::Node < Capybara::Driver::Node
   def visible_text
     # Selenium doesn't normalize Unicode whitespace.
     Capybara::Helpers.normalize_whitespace(native.text)
@@ -36,57 +36,25 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   #   :none =>  append the new value to the existing value <br/>
   #   :backspace => send backspace keystrokes to clear the field <br/>
   #   Array => an array of keys to send before the value being set, e.g. [[:command, 'a'], :backspace]
-  def set(value, options={})
-    tag_name = self.tag_name
-    type = self[:type]
-
-    if (Array === value) && !multiple?
-      raise ArgumentError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
-    end
+  def set(value, **options)
+    raise ArgumentError, "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}" if value.is_a?(Array) && !multiple?
 
     case tag_name
     when 'input'
-      case type
+      case self[:type]
       when 'radio'
         click
       when 'checkbox'
-        click if value ^ native.attribute('checked').to_s.eql?("true")
+        click if value ^ checked?
       when 'file'
-        path_names = value.to_s.empty? ? [] : value
-        if driver.chrome?
-          native.send_keys(Array(path_names).join("\n"))
-        else
-          native.send_keys(*path_names)
-        end
+        set_file(value)
       else
         set_text(value, options)
       end
     when 'textarea'
       set_text(value, options)
     else
-      if content_editable?
-        #ensure we are focused on the element
-        click
-
-        script = <<-JS
-          var range = document.createRange();
-          var sel = window.getSelection();
-          arguments[0].focus();
-          range.selectNodeContents(arguments[0]);
-          sel.removeAllRanges();
-          sel.addRange(range);
-        JS
-        driver.execute_script script, self
-
-        if driver.chrome? || driver.firefox?
-          # chromedriver raises a can't focus element for child elements if we use native.send_keys
-          # we've already focused it so just use action api
-          driver.browser.action.send_keys(value.to_s).perform
-        else
-          # action api is really slow here just use native.send_keys
-          native.send_keys(value.to_s)
-        end
-      end
+      set_content_editable(value) if content_editable?
     end
   end
 
@@ -95,32 +63,56 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def unselect_option
-    raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box." if !select_node.multiple?
+    raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box." unless select_node.multiple?
     native.click if selected?
   end
 
-  def click
-    native.click
+  def click(keys = [], options = {})
+    if keys.empty? && !(options[:x] && options[:y])
+      native.click
+    else
+      scroll_if_needed do
+        action_with_modifiers(keys, options) do |a|
+          if options[:x] && options[:y]
+            a.click
+          else
+            a.click(native)
+          end
+        end
+      end
+    end
   rescue => e
     if e.is_a?(::Selenium::WebDriver::Error::ElementClickInterceptedError) ||
        e.message =~ /Other element would receive the click/
       begin
         driver.execute_script("arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'})", self)
-      rescue
+      rescue # Swallow error if scrollIntoView with options isn't supported
       end
     end
     raise e
   end
 
-  def right_click
+  def right_click(keys = [], options = {})
     scroll_if_needed do
-      driver.browser.action.context_click(native).perform
+      action_with_modifiers(keys, options) do |a|
+        if options[:x] && options[:y]
+          a.context_click
+        else
+          a.context_click(native)
+        end
+      end
     end
   end
 
-  def double_click
+  def double_click(keys = [], options = {})
     scroll_if_needed do
-      driver.browser.action.double_click(native).perform
+      action_with_modifiers(keys, options) do |a|
+        if options[:x] && options[:y]
+          a.double_click
+        else
+          a.double_click(native)
+        end
+      end
     end
   end
 
@@ -129,55 +121,38 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def hover
-    scroll_if_needed do
-      driver.browser.action.move_to(native).perform
-    end
+    scroll_if_needed { driver.browser.action.move_to(native).perform }
   end
 
   def drag_to(element)
-    scroll_if_needed do
-      driver.browser.action.drag_and_drop(native, element.native).perform
-    end
+    scroll_if_needed { driver.browser.action.drag_and_drop(native, element.native).perform }
   end
 
   def tag_name
     native.tag_name.downcase
   end
 
-  def visible?
-    displayed = native.displayed?
-    displayed and displayed != "false"
-  end
-
-  def selected?
-    selected = native.selected?
-    selected and selected != "false"
-  end
+  def visible?; boolean_attr(native.displayed?); end
+  def readonly?; boolean_attr(self[:readonly]); end
+  def multiple?; boolean_attr(self[:multiple]); end
+  def selected?; boolean_attr(native.selected?); end
   alias :checked? :selected?
 
   def disabled?
+    return true unless native.enabled?
+
     # workaround for selenium-webdriver/geckodriver reporting elements as enabled when they are nested in disabling elements
     if driver.marionette?
-      if %w(option optgroup).include? tag_name
-        !native.enabled? || find_xpath("parent::*[self::optgroup or self::select]")[0].disabled?
+      if %w[option optgroup].include? tag_name
+        find_xpath("parent::*[self::optgroup or self::select]")[0].disabled?
       else
-        !native.enabled? || !find_xpath("parent::fieldset[@disabled] | ancestor::*[not(self::legend) or preceding-sibling::legend][parent::fieldset[@disabled]]").empty?
+        !find_xpath("parent::fieldset[@disabled] | ancestor::*[not(self::legend) or preceding-sibling::legend][parent::fieldset[@disabled]]").empty?
       end
     else
-      !native.enabled?
+      false
     end
   end
 
-  def readonly?
-    readonly = self[:readonly]
-    readonly and readonly != "false"
-  end
-
-  def multiple?
-    multiple = self[:multiple]
-    multiple and multiple != "false"
-  end
-
   def content_editable?
     native.attribute('isContentEditable')
   end
@@ -195,63 +170,57 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def path
-    path = find_xpath('ancestor::*').reverse
-    path.unshift self
+    path = find_xpath(XPath.ancestor_or_self).reverse
 
     result = []
-    while node = path.shift
+    while (node = path.shift)
       parent = path.first
-
+      selector = node.tag_name
       if parent
         siblings = parent.find_xpath(node.tag_name)
-        if siblings.size == 1
-          result.unshift node.tag_name
-        else
-          index = siblings.index(node)
-          result.unshift "#{node.tag_name}[#{index+1}]"
-        end
-      else
-        result.unshift node.tag_name
+        selector += "[#{siblings.index(node) + 1}]" unless siblings.size == 1
       end
+      result.push selector
     end
 
-    '/' + result.join('/')
+    '/' + result.reverse.join('/')
   end
 
 private
+
+  def boolean_attr(val)
+    val and val != "false"
+  end
+
   # a reference to the select node if this is an option node
   def select_node
-    find_xpath('./ancestor::select[1]').first
+    find_xpath(XPath.ancestor(:select)[1]).first
   end
 
-  def set_text(value, options)
-    if readonly?
-      warn "Attempt to set readonly element with value: #{value} \n *This will raise an exception in a future version of Capybara"
-    elsif value.to_s.empty? && options[:clear].nil?
+  def set_text(value, clear: nil, **)
+    if value.to_s.empty? && clear.nil?
       native.clear
+    elsif clear == :backspace
+      # Clear field by sending the correct number of backspace keys.
+      backspaces = [:backspace] * self.value.to_s.length
+      native.send_keys(*(backspaces + [value.to_s]))
+    elsif clear == :none
+      native.send_keys(value.to_s)
+    elsif clear.is_a? Array
+      native.send_keys(*clear, value.to_s)
     else
-      if options[:clear] == :backspace
-        # Clear field by sending the correct number of backspace keys.
-        backspaces = [:backspace] * self.value.to_s.length
-        native.send_keys(*(backspaces + [value.to_s]))
-      elsif options[:clear] == :none
-        native.send_keys(value.to_s)
-      elsif options[:clear].is_a? Array
-        native.send_keys(*options[:clear], value.to_s)
-      else
-        # Clear field by JavaScript assignment of the value property.
-        # Script can change a readonly element which user input cannot, so
-        # don't execute if readonly.
-        driver.execute_script "arguments[0].value = ''", self
-        native.send_keys(value.to_s)
-      end
+      # Clear field by JavaScript assignment of the value property.
+      # Script can change a readonly element which user input cannot, so
+      # don't execute if readonly.
+      driver.execute_script "arguments[0].value = ''", self
+      native.send_keys(value.to_s)
     end
   end
 
-  def scroll_if_needed(&block)
-    block.call
+  def scroll_if_needed
+    yield
   rescue ::Selenium::WebDriver::Error::MoveTargetOutOfBoundsError
-    script = <<-JS
+    script = <<-'JS'
       try {
         arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
       } catch(e) {
@@ -259,6 +228,72 @@ private
       }
     JS
     driver.execute_script(script, self)
-    block.call
+    yield
+  end
+
+  def set_file(value) # rubocop:disable Naming/AccessorMethodName
+    path_names = value.to_s.empty? ? [] : value
+    if driver.chrome?
+      native.send_keys(Array(path_names).join("\n"))
+    else
+      native.send_keys(*path_names)
+    end
+  end
+
+  def set_content_editable(value) # rubocop:disable Naming/AccessorMethodName
+    # Ensure we are focused on the element
+    click
+
+    script = <<-JS
+      var range = document.createRange();
+      var sel = window.getSelection();
+      arguments[0].focus();
+      range.selectNodeContents(arguments[0]);
+      sel.removeAllRanges();
+      sel.addRange(range);
+    JS
+    driver.execute_script script, self
+
+    # The action api has a speed problem but both chrome and firefox 58 raise errors
+    # if we use the faster direct send_keys.  For now just send_keys to the element
+    # we've already focused.
+    # native.send_keys(value.to_s)
+    driver.browser.action.send_keys(value.to_s).perform
+  end
+
+  def action_with_modifiers(keys, x: nil, y: nil)
+    actions = driver.browser.action
+    actions.move_to(native, x, y)
+    modifiers_down(actions, keys)
+    yield actions
+    modifiers_up(actions, keys)
+    actions.perform
+  ensure
+    a = driver.browser.action
+    a.release_actions if a.respond_to?(:release_actions)
+  end
+
+  def modifiers_down(actions, keys)
+    keys.each do |key|
+      key = case key
+      when :ctrl then :control
+      when :command, :cmd then :meta
+      else
+        key
+      end
+      actions.key_down(key)
+    end
+  end
+
+  def modifiers_up(actions, keys)
+    keys.each do |key|
+      key = case key
+      when :ctrl then :control
+      when :command, :cmd then :meta
+      else
+        key
+      end
+      actions.key_up(key)
+    end
   end
 end

data/lib/capybara/server.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'uri'
 require 'net/http'
 require 'rack'
@@ -43,7 +44,7 @@ module Capybara
           begin
             @app.call(env)
           rescue *@server_errors => e
-            @error = e unless @error
+            @error ||= e
             raise e
           ensure
             @counter.decrement
@@ -60,7 +61,7 @@ module Capybara
 
     attr_reader :app, :port, :host
 
-    def initialize(app, port=Capybara.server_port, host=Capybara.server_host, server_errors=Capybara.server_errors)
+    def initialize(app, port = Capybara.server_port, host = Capybara.server_host, server_errors = Capybara.server_errors)
       @app = app
       @server_thread = nil # suppress warnings
       @host, @port, @server_errors = host, port, server_errors

data/lib/capybara/session.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require 'capybara/session/matchers'
 require 'addressable/uri'
 
 module Capybara
-
   ##
   #
   # The Session class represents a single user's interaction with the system. The Session can use
@@ -38,64 +38,63 @@ module Capybara
   class Session
     include Capybara::SessionMatchers
 
-    NODE_METHODS = [
-      :all, :first, :attach_file, :text, :check, :choose,
-      :click_link_or_button, :click_button, :click_link, :field_labeled,
-      :fill_in, :find, :find_all, :find_button, :find_by_id, :find_field, :find_link,
-      :has_content?, :has_text?, :has_css?, :has_no_content?, :has_no_text?,
-      :has_no_css?, :has_no_xpath?, :resolve, :has_xpath?, :select, :uncheck,
-      :has_link?, :has_no_link?, :has_button?, :has_no_button?, :has_field?,
-      :has_no_field?, :has_checked_field?, :has_unchecked_field?,
-      :has_no_table?, :has_table?, :unselect, :has_select?, :has_no_select?,
-      :has_selector?, :has_no_selector?, :click_on, :has_no_checked_field?,
-      :has_no_unchecked_field?, :query, :assert_selector, :assert_no_selector,
-      :assert_all_of_selectors, :assert_none_of_selectors,
-      :refute_selector, :assert_text, :assert_no_text
-    ]
+    NODE_METHODS = %i[
+      all first attach_file text check choose
+      click_link_or_button click_button click_link
+      fill_in find find_all find_button find_by_id find_field find_link
+      has_content? has_text? has_css? has_no_content? has_no_text?
+      has_no_css? has_no_xpath? resolve has_xpath? select uncheck
+      has_link? has_no_link? has_button? has_no_button? has_field?
+      has_no_field? has_checked_field? has_unchecked_field?
+      has_no_table? has_table? unselect has_select? has_no_select?
+      has_selector? has_no_selector? click_on has_no_checked_field?
+      has_no_unchecked_field? query assert_selector assert_no_selector
+      assert_all_of_selectors assert_none_of_selectors
+      refute_selector assert_text assert_no_text
+    ].freeze
     # @api private
-    DOCUMENT_METHODS = [
-      :title, :assert_title, :assert_no_title, :has_title?, :has_no_title?
-    ]
-    SESSION_METHODS = [
-      :body, :html, :source, :current_url, :current_host, :current_path,
-      :execute_script, :evaluate_script, :visit, :refresh, :go_back, :go_forward,
-      :within, :within_element, :within_fieldset, :within_table, :within_frame, :switch_to_frame,
-      :current_window, :windows, :open_new_window, :switch_to_window, :within_window, :window_opened_by,
-      :save_page, :save_and_open_page, :save_screenshot,
-      :save_and_open_screenshot, :reset_session!, :response_headers,
-      :status_code, :current_scope,
-      :assert_current_path, :assert_no_current_path, :has_current_path?, :has_no_current_path?
-    ] + DOCUMENT_METHODS
-    MODAL_METHODS = [
-      :accept_alert, :accept_confirm, :dismiss_confirm, :accept_prompt,
-      :dismiss_prompt
-    ]
+    DOCUMENT_METHODS = %i[
+      title assert_title assert_no_title has_title? has_no_title?
+    ].freeze
+    SESSION_METHODS = %i[
+      body html source current_url current_host current_path
+      execute_script evaluate_script visit refresh go_back go_forward
+      within within_element within_fieldset within_table within_frame switch_to_frame
+      current_window windows open_new_window switch_to_window within_window window_opened_by
+      save_page save_and_open_page save_screenshot
+      save_and_open_screenshot reset_session! response_headers
+      status_code current_scope
+      assert_current_path assert_no_current_path has_current_path? has_no_current_path?
+    ].freeze + DOCUMENT_METHODS
+    MODAL_METHODS = %i[
+      accept_alert accept_confirm dismiss_confirm accept_prompt dismiss_prompt
+    ].freeze
     DSL_METHODS = NODE_METHODS + SESSION_METHODS + MODAL_METHODS
 
     attr_reader :mode, :app, :server
     attr_accessor :synchronized
 
-    def initialize(mode, app=nil)
+    def initialize(mode, app = nil)
       raise TypeError, "The second parameter to Session::new should be a rack app if passed." if app && !app.respond_to?(:call)
       @@instance_created = true
       @mode = mode
       @app = app
       if block_given?
         raise "A configuration block is only accepted when Capybara.threadsafe == true" unless Capybara.threadsafe
-        yield config if block_given?
+        yield config
       end
-      if config.run_server and @app and driver.needs_server?
-        @server = Capybara::Server.new(@app, config.server_port, config.server_host, config.server_errors).boot
+      @server = if config.run_server and @app and driver.needs_server?
+        Capybara::Server.new(@app, config.server_port, config.server_host, config.server_errors).boot
       else
-        @server = nil
+        nil
       end
       @touched = false
     end
 
     def driver
       @driver ||= begin
-        unless Capybara.drivers.has_key?(mode)
-          other_drivers = Capybara.drivers.keys.map { |key| key.inspect }
+        unless Capybara.drivers.key?(mode)
+          other_drivers = Capybara.drivers.keys.map(&:inspect)
           raise Capybara::DriverNotFoundError, "no driver called #{mode.inspect} was found, available drivers: #{other_drivers.join(', ')}"
         end
         driver = Capybara.drivers[mode].call(app)
@@ -145,7 +144,7 @@ module Capybara
             raise CapybaraError, "Your application server raised an error - It has been raised in your test code because Capybara.raise_server_errors == true"
           end
         rescue CapybaraError
-          #needed to get the cause set correctly in JRuby -- otherwise we could just do raise @server.error
+          # needed to get the cause set correctly in JRuby -- otherwise we could just do raise @server.error
           raise @server.error, @server.error.message, @server.error.backtrace
         ensure
           @server.reset_error!
@@ -196,8 +195,9 @@ module Capybara
 
       # Addressable doesn't support opaque URIs - we want nil here
       return nil if uri.scheme == "about"
+
       path = uri.path
-      path if path and not path.empty?
+      path if path && !path.empty?
     end
 
     ##
@@ -259,15 +259,15 @@ module Capybara
         if visit_uri.relative?
           uri_base.port ||= @server.port if @server && config.always_include_port
 
-          visit_uri_parts = visit_uri.to_hash.delete_if { |k,v| v.nil? }
+          visit_uri_parts = visit_uri.to_hash.delete_if { |_k, v| v.nil? }
 
           # Useful to people deploying to a subdirectory
           # and/or single page apps where only the url fragment changes
           visit_uri_parts[:path] = uri_base.path + visit_uri.path
 
           visit_uri = uri_base.merge(visit_uri_parts)
-        else
-          visit_uri.port ||= @server.port if @server && config.always_include_port
+        elsif @server && config.always_include_port
+          visit_uri.port ||= @server.port
         end
       end
 
@@ -335,7 +335,7 @@ module Capybara
     # @raise  [Capybara::ElementNotFound]      If the scope can't be found before time expires
     #
     def within(*args)
-      new_scope = if args.first.is_a?(Capybara::Node::Base) then args.first else find(*args) end
+      new_scope = args.first.respond_to?(:to_capybara_node) ? args.first.to_capybara_node : find(*args)
       begin
         scopes.push(new_scope)
         yield
@@ -352,9 +352,7 @@ module Capybara
     # @param [String] locator    Id or legend of the fieldset
     #
     def within_fieldset(locator)
-      within :fieldset, locator do
-        yield
-      end
+      within(:fieldset, locator) { yield }
     end
 
     ##
@@ -364,9 +362,7 @@ module Capybara
     # @param [String] locator    Id or caption of the table
     #
     def within_table(locator)
-      within :table, locator do
-        yield
-      end
+      within(:table, locator) { yield }
     end
 
     ##
@@ -390,15 +386,19 @@ module Capybara
         driver.switch_to_frame(frame)
         scopes.push(:frame)
       when :parent
-        raise Capybara::ScopeError, "`switch_to_frame(:parent)` cannot be called from inside a descendant frame's "\
-                                    "`within` block." if scopes.last() != :frame
+        if scopes.last != :frame
+          raise Capybara::ScopeError, "`switch_to_frame(:parent)` cannot be called from inside a descendant frame's "\
+                                      "`within` block."
+        end
         scopes.pop
         driver.switch_to_frame(:parent)
       when :top
         idx = scopes.index(:frame)
         if idx
-          raise Capybara::ScopeError, "`switch_to_frame(:top)` cannot be called from inside a descendant frame's "\
-                                      "`within` block." if scopes.slice(idx..-1).any? {|scope| ![:frame, nil].include?(scope)}
+          if scopes.slice(idx..-1).any? { |scope| ![:frame, nil].include?(scope) }
+            raise Capybara::ScopeError, "`switch_to_frame(:top)` cannot be called from inside a descendant frame's "\
+                                        "`within` block."
+          end
           scopes.slice!(idx..-1)
           driver.switch_to_frame(:top)
         end
@@ -418,29 +418,11 @@ module Capybara
     # @overload within_frame(index)
     #   @param [Integer] index         index of a frame (0 based)
     def within_frame(*args)
-      frame = _find_frame(*args)
-
+      switch_to_frame(_find_frame(*args))
       begin
-        switch_to_frame(frame)
-        begin
-          yield
-        ensure
-          switch_to_frame(:parent)
-        end
-      rescue Capybara::NotSupportedByDriverError
-        # Support older driver frame API for now
-        if driver.respond_to?(:within_frame)
-          begin
-            scopes.push(:frame)
-            driver.within_frame(frame) do
-              yield
-            end
-          ensure
-            scopes.pop
-          end
-        else
-          raise
-        end
+        yield
+      ensure
+        switch_to_frame(:parent)
       end
     end
 
@@ -493,15 +475,11 @@ module Capybara
     #   `within_frame` methods
     # @raise [ArgumentError]               if both or neither arguments were provided
     #
-    def switch_to_window(window = nil, options= {}, &window_locator)
-      options, window = window, nil if window.is_a? Hash
-
+    def switch_to_window(window = nil, **options, &window_locator)
       block_given = block_given?
-      if window && block_given
-        raise ArgumentError, "`switch_to_window` can take either a block or a window, not both"
-      elsif !window && !block_given
-        raise ArgumentError, "`switch_to_window`: either window or block should be provided"
-      elsif !scopes.last.nil?
+      raise ArgumentError, "`switch_to_window` can take either a block or a window, not both" if window && block_given
+      raise ArgumentError, "`switch_to_window`: either window or block should be provided" if !window && !block_given
+      unless scopes.last.nil?
         raise Capybara::ScopeError, "`switch_to_window` is not supposed to be invoked from "\
                                     "`within` or `within_frame` blocks."
       end
@@ -526,51 +504,30 @@ module Capybara
     #   @example
     #     within_window(->{ page.title == 'Page title' }) { click_button 'Submit' }
     #   @raise [Capybara::WindowError]         if no window matching lambda was found
-    # @overload within_window(string) { do_something }
-    #   @deprecated                            Pass window or lambda instead
-    #   @param [String]                        handle, name, url or title of the window
     #
     # @raise [Capybara::ScopeError]        if this method is invoked inside `within_frame` method
     # @return                              value returned by the block
     #
-    def within_window(window_or_handle)
-      if window_or_handle.instance_of?(Capybara::Window)
-        original = current_window
-        scopes << nil
-        begin
-          _switch_to_window(window_or_handle) unless original == window_or_handle
-          begin
-            yield
-          ensure
-            _switch_to_window(original) unless original == window_or_handle
-          end
-        ensure
-          scopes.pop
-        end
-      elsif window_or_handle.is_a?(Proc)
-        original = current_window
-        scopes << nil
-        begin
-          _switch_to_window { window_or_handle.call }
-          begin
-            yield
-          ensure
-            _switch_to_window(original)
-          end
-        ensure
-          scopes.pop
+    def within_window(window_or_proc)
+      original = current_window
+      scopes << nil
+      begin
+        case window_or_proc
+        when Capybara::Window
+          _switch_to_window(window_or_proc) unless original == window_or_proc
+        when Proc
+          _switch_to_window { window_or_proc.call }
+        else
+          raise ArgumentError("`#within_window` requires a `Capybara::Window` instance or a lambda")
         end
-      else
-        offending_line = caller.first
-        file_line = offending_line.match(/^(.+?):(\d+)/)[0]
-        warn "DEPRECATION WARNING: Passing string argument to #within_window is deprecated. "\
-             "Pass window object or lambda. (called from #{file_line})"
+
         begin
-          scopes << nil
-          driver.within_window(window_or_handle) { yield }
+          yield
         ensure
-          scopes.pop
+          _switch_to_window(original) unless original == window_or_proc
         end
+      ensure
+        scopes.pop
       end
     end
 
@@ -580,15 +537,16 @@ module Capybara
     # It's better to use this method than `windows.last`
     # {https://dvcs.w3.org/hg/webdriver/raw-file/default/webdriver-spec.html#h_note_10 as order of windows isn't defined in some drivers}
     #
-    # @param options [Hash]
-    # @option options [Numeric] :wait (Capybara.default_max_wait_time) maximum wait time
-    # @return [Capybara::Window]       the window that has been opened within a block
-    # @raise [Capybara::WindowError]   if block passed to window hasn't opened window
-    #   or opened more than one window
+    # @overload window_opened_by(**options, &block)
+    #   @param options [Hash]
+    #   @option options [Numeric] :wait (Capybara.default_max_wait_time) maximum wait time
+    #   @return [Capybara::Window]       the window that has been opened within a block
+    #   @raise [Capybara::WindowError]   if block passed to window hasn't opened window
+    #     or opened more than one window
     #
-    def window_opened_by(options = {}, &block)
+    def window_opened_by(**options)
       old_handles = driver.window_handles
-      block.call
+      yield
 
       wait_time = Capybara::Queries::BaseQuery.wait(options, config.default_max_wait_time)
       document.synchronize(wait_time, errors: [Capybara::WindowError]) do
@@ -612,12 +570,7 @@ module Capybara
     #
     def execute_script(script, *args)
       @touched = true
-      if args.empty?
-        driver.execute_script(script)
-      else
-        raise Capybara::NotSupportedByDriverError, "The current driver does not support execute_script arguments" if driver.method(:execute_script).arity == 1
-        driver.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ?  arg.base : arg} )
-      end
+      driver.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ? arg.base : arg })
     end
 
     ##
@@ -631,12 +584,7 @@ module Capybara
     #
     def evaluate_script(script, *args)
       @touched = true
-      result = if args.empty?
-        driver.evaluate_script(script)
-      else
-        raise Capybara::NotSupportedByDriverError, "The current driver does not support evaluate_script arguments" if driver.method(:evaluate_script).arity == 1
-        driver.evaluate_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ?  arg.base : arg} )
-      end
+      result = driver.evaluate_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ? arg.base : arg })
       element_script_result(result)
     end
 
@@ -649,12 +597,7 @@ module Capybara
     #
     def evaluate_async_script(script, *args)
       @touched = true
-      result = if args.empty?
-        driver.evaluate_async_script(script)
-      else
-        raise Capybara::NotSupportedByDriverError, "The current driver does not support evaluate_async_script arguments" if driver.method(:evaluate_async_script).arity == 1
-        driver.evaluate_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ?  arg.base : arg} )
-      end
+      result = driver.evaluate_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ? arg.base : arg })
       element_script_result(result)
     end
 
@@ -678,9 +621,8 @@ module Capybara
     #   @return [String]  the message shown in the modal
     #   @raise [Capybara::ModalNotFound]  if modal dialog hasn't been found
     #
-    #
-    def accept_alert(text_or_options=nil, options={}, &blk)
-      accept_modal(:alert, text_or_options, options, &blk)
+    def accept_alert(text = nil, **options, &blk)
+      accept_modal(:alert, text, options, &blk)
     end
 
     ##
@@ -689,8 +631,8 @@ module Capybara
     #
     # @macro modal_params
     #
-    def accept_confirm(text_or_options=nil, options={}, &blk)
-      accept_modal(:confirm, text_or_options, options, &blk)
+    def accept_confirm(text = nil, **options, &blk)
+      accept_modal(:confirm, text, options, &blk)
     end
 
     ##
@@ -699,8 +641,8 @@ module Capybara
     #
     # @macro modal_params
     #
-    def dismiss_confirm(text_or_options=nil, options={}, &blk)
-      dismiss_modal(:confirm, text_or_options, options, &blk)
+    def dismiss_confirm(text = nil, **options, &blk)
+      dismiss_modal(:confirm, text, options, &blk)
     end
 
     ##
@@ -710,8 +652,8 @@ module Capybara
     # @macro modal_params
     # @option options [String] :with   Response to provide to the prompt
     #
-    def accept_prompt(text_or_options=nil, options={}, &blk)
-      accept_modal(:prompt, text_or_options, options, &blk)
+    def accept_prompt(text = nil, **options, &blk)
+      accept_modal(:prompt, text, options, &blk)
     end
 
     ##
@@ -720,8 +662,8 @@ module Capybara
     #
     # @macro modal_params
     #
-    def dismiss_prompt(text_or_options=nil, options={}, &blk)
-      dismiss_modal(:prompt, text_or_options, options, &blk)
+    def dismiss_prompt(text = nil, **options, &blk)
+      dismiss_modal(:prompt, text, options, &blk)
     end
 
     ##
@@ -731,17 +673,15 @@ module Capybara
     #
     # If invoked without arguments it will save file to `Capybara.save_path`
     #   and file will be given randomly generated filename. If invoked with a relative path
-    #   the path will be relative to `Capybara.save_path`, which is different from
-    #   the previous behavior with `Capybara.save_and_open_page_path` where the relative path was
-    #   relative to Dir.pwd
+    #   the path will be relative to `Capybara.save_path`
     #
     # @param [String] path  the path to where it should be saved
     # @return [String]      the path to which the file was saved
     #
     def save_page(path = nil)
-      path = prepare_path(path, 'html')
-      File.write(path, Capybara::Helpers.inject_asset_host(body, config.asset_host), mode: 'wb')
-      path
+      prepare_path(path, 'html').tap do |p|
+        File.write(p, Capybara::Helpers.inject_asset_host(body, host: config.asset_host), mode: 'wb')
+      end
     end
 
     ##
@@ -750,15 +690,12 @@ module Capybara
     #
     # If invoked without arguments it will save file to `Capybara.save_path`
     #   and file will be given randomly generated filename. If invoked with a relative path
-    #   the path will be relative to `Capybara.save_path`, which is different from
-    #   the previous behavior with `Capybara.save_and_open_page_path` where the relative path was
-    #   relative to Dir.pwd
+    #   the path will be relative to `Capybara.save_path`
     #
     # @param [String] path  the path to where it should be saved
     #
     def save_and_open_page(path = nil)
-      path = save_page(path)
-      open_file(path)
+      save_page(path).tap { |p| open_file(p) }
     end
 
     ##
@@ -767,17 +704,13 @@ module Capybara
     #
     # If invoked without arguments it will save file to `Capybara.save_path`
     #   and file will be given randomly generated filename. If invoked with a relative path
-    #   the path will be relative to `Capybara.save_path`, which is different from
-    #   the previous behavior with `Capybara.save_and_open_page_path` where the relative path was
-    #   relative to Dir.pwd
+    #   the path will be relative to `Capybara.save_path`
     #
     # @param [String] path    the path to where it should be saved
     # @param [Hash] options   a customizable set of options
     # @return [String]        the path to which the file was saved
-    def save_screenshot(path = nil, options = {})
-      path = prepare_path(path, 'png')
-      driver.save_screenshot(path, options)
-      path
+    def save_screenshot(path = nil, **options)
+      prepare_path(path, 'png').tap { |p| driver.save_screenshot(p, options) }
     end
 
     ##
@@ -786,16 +719,15 @@ module Capybara
     #
     # If invoked without arguments it will save file to `Capybara.save_path`
     #   and file will be given randomly generated filename. If invoked with a relative path
-    #   the path will be relative to `Capybara.save_path`, which is different from
-    #   the previous behavior with `Capybara.save_and_open_page_path` where the relative path was
-    #   relative to Dir.pwd
+    #   the path will be relative to `Capybara.save_path`
     #
     # @param [String] path    the path to where it should be saved
     # @param [Hash] options   a customizable set of options
     #
-    def save_and_open_screenshot(path = nil, options = {})
-      path = save_screenshot(path, options)
-      open_file(path)
+    def save_and_open_screenshot(path = nil, **options)
+      # rubocop:disable Lint/Debugger
+      save_screenshot(path, options).tap { |p| open_file(p) }
+      # rubocop:enable Lint/Debugger
     end
 
     def document
@@ -821,8 +753,7 @@ module Capybara
 
     def current_scope
       scope = scopes.last
-      scope = document if [nil, :frame].include? scope
-      scope
+      [nil, :frame].include?(scope) ? document : scope
     end
 
     ##
@@ -864,6 +795,7 @@ module Capybara
         Capybara::ReadOnlySessionConfig.new(Capybara.session_options)
       end
     end
+
   private
 
     @@instance_created = false
@@ -876,32 +808,21 @@ module Capybara
       driver.dismiss_modal(type, modal_options(text_or_options, options), &blk)
     end
 
-    def modal_options(text_or_options, options)
-      text_or_options, options = nil, text_or_options if text_or_options.is_a?(Hash)
-      options[:text] ||= text_or_options unless text_or_options.nil?
+    def modal_options(text = nil, **options)
+      options[:text] ||= text unless text.nil?
       options[:wait] ||= config.default_max_wait_time
       options
     end
 
-
     def open_file(path)
-      begin
-        require "launchy"
-        Launchy.open(path)
-      rescue LoadError
-        warn "File saved to #{path}."
-        warn "Please install the launchy gem to open the file automatically."
-      end
+      require "launchy"
+      Launchy.open(path)
+    rescue LoadError
+      warn "File saved to #{path}.\nPlease install the launchy gem to open the file automatically."
     end
 
     def prepare_path(path, extension)
-      if config.save_path || config.save_and_open_page_path.nil?
-        path = File.expand_path(path || default_fn(extension), config.save_path)
-      else
-        path = File.expand_path(default_fn(extension), config.save_and_open_page_path) if path.nil?
-      end
-      FileUtils.mkdir_p(File.dirname(path))
-      path
+      File.expand_path(path || default_fn(extension), config.save_path).tap { |p| FileUtils.mkdir_p(File.dirname(p)) }
     end
 
     def default_fn(extension)
@@ -927,26 +848,22 @@ module Capybara
     end
 
     def _find_frame(*args)
-      within(document) do  # Previous 2.x versions ignored current scope when finding frames - consider changing in 3.0
-        case args[0]
-        when Capybara::Node::Element
-          args[0]
-        when String, Hash
-          find(:frame, *args)
-        when Symbol
-          find(*args)
-        when Integer
-          idx = args[0]
-          all(:frame, minimum: idx+1)[idx]
-        else
-          raise TypeError
-        end
+      case args[0]
+      when Capybara::Node::Element
+        args[0]
+      when String, Hash
+        find(:frame, *args)
+      when Symbol
+        find(*args)
+      when Integer
+        idx = args[0]
+        all(:frame, minimum: idx + 1)[idx]
+      else
+        raise TypeError
       end
     end
 
-    def _switch_to_window(window = nil, options= {})
-      options, window = window, nil if window.is_a? Hash
-
+    def _switch_to_window(window = nil, **options)
       raise Capybara::ScopeError, "Window cannot be switched inside a `within_frame` block" if scopes.include?(:frame)
       raise Capybara::ScopeError, "Window cannot be switch inside a `within` block" unless scopes.last.nil?
 
@@ -960,9 +877,7 @@ module Capybara
           begin
             driver.window_handles.each do |handle|
               driver.switch_to_window handle
-              if yield
-                return Window.new(self, handle)
-              end
+              return Window.new(self, handle) if yield
             end
           rescue => e
             driver.switch_to_window(original_window_handle)
@@ -974,6 +889,5 @@ module Capybara
         end
       end
     end
-
   end
 end