capybara 2.15.1 → 3.35.3

data/lib/capybara/selenium/extensions/html5_drag.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+class Capybara::Selenium::Node
+  module Html5Drag
+    # Implement methods to emulate HTML5 drag and drop
+
+    def drag_to(element, html5: nil, delay: 0.05, drop_modifiers: [])
+      drop_modifiers = Array(drop_modifiers)
+
+      driver.execute_script MOUSEDOWN_TRACKER
+      scroll_if_needed { browser_action.click_and_hold(native).perform }
+      html5 = !driver.evaluate_script(LEGACY_DRAG_CHECK, self) if html5.nil?
+      if html5
+        perform_html5_drag(element, delay, drop_modifiers)
+      else
+        perform_legacy_drag(element, drop_modifiers)
+      end
+    end
+
+  private
+
+    def perform_legacy_drag(element, drop_modifiers)
+      element.scroll_if_needed do
+        # browser_action.move_to(element.native).release.perform
+        keys_down = modifiers_down(browser_action, drop_modifiers)
+        keys_up = modifiers_up(keys_down.move_to(element.native).release, drop_modifiers)
+        keys_up.perform
+      end
+    end
+
+    def perform_html5_drag(element, delay, drop_modifiers)
+      driver.evaluate_async_script HTML5_DRAG_DROP_SCRIPT, self, element, delay * 1000, normalize_keys(drop_modifiers)
+      browser_action.release.perform
+    end
+
+    def html5_drop(*args)
+      if args[0].is_a? String
+        input = driver.evaluate_script ATTACH_FILE
+        input.set_file(args)
+        driver.execute_script DROP_FILE, self, input
+      else
+        items = args.each_with_object([]) do |arg, arr|
+          arg.each_with_object(arr) do |(type, data), arr_|
+            arr_ << { type: type, data: data }
+          end
+        end
+        driver.execute_script DROP_STRING, items, self
+      end
+    end
+
+    DROP_STRING = <<~JS
+      var strings = arguments[0],
+          el = arguments[1],
+          dt = new DataTransfer(),
+          opts = { cancelable: true, bubbles: true, dataTransfer: dt };
+      for (var i=0; i < strings.length; i++){
+        if (dt.items) {
+          dt.items.add(strings[i]['data'], strings[i]['type']);
+        } else {
+          dt.setData(strings[i]['type'], strings[i]['data']);
+        }
+      }
+      var dropEvent = new DragEvent('drop', opts);
+      el.dispatchEvent(dropEvent);
+    JS
+
+    DROP_FILE = <<~JS
+      var el = arguments[0],
+          input = arguments[1],
+          files = input.files,
+          dt = new DataTransfer(),
+          opts = { cancelable: true, bubbles: true, dataTransfer: dt };
+      input.parentElement.removeChild(input);
+      if (dt.items){
+        for (var i=0; i<files.length; i++){
+          dt.items.add(files[i]);
+        }
+      } else {
+        Object.defineProperty(dt, "files", {
+          value: files,
+          writable: false
+        });
+      }
+      var dropEvent = new DragEvent('drop', opts);
+      el.dispatchEvent(dropEvent);
+    JS
+
+    ATTACH_FILE = <<~JS
+      (function(){
+        var input = document.createElement('INPUT');
+        input.type = "file";
+        input.id = "_capybara_drop_file";
+        input.multiple = true;
+        document.body.appendChild(input);
+        return input;
+      })()
+    JS
+
+    MOUSEDOWN_TRACKER = <<~JS
+      window.capybara_mousedown_prevented = null;
+      document.addEventListener('mousedown', ev => {
+        window.capybara_mousedown_prevented = ev.defaultPrevented;
+      }, { once: true, passive: true })
+    JS
+
+    LEGACY_DRAG_CHECK = <<~JS
+      (function(el){
+        if ([true, null].indexOf(window.capybara_mousedown_prevented) >= 0){
+          return true;
+        }
+
+        do {
+          if (el.draggable) return false;
+        } while (el = el.parentElement );
+        return true;
+      })(arguments[0])
+    JS
+
+    HTML5_DRAG_DROP_SCRIPT = <<~JS
+      function rectCenter(rect){
+        return new DOMPoint(
+          (rect.left + rect.right)/2,
+          (rect.top + rect.bottom)/2
+        );
+      }
+
+      function pointOnRect(pt, rect) {
+      	var rectPt = rectCenter(rect);
+      	var slope = (rectPt.y - pt.y) / (rectPt.x - pt.x);
+
+      	if (pt.x <= rectPt.x) { // left side
+      		var minXy = slope * (rect.left - pt.x) + pt.y;
+      		if (rect.top <= minXy && minXy <= rect.bottom)
+            return new DOMPoint(rect.left, minXy);
+      	}
+
+      	if (pt.x >= rectPt.x) { // right side
+      		var maxXy = slope * (rect.right - pt.x) + pt.y;
+      		if (rect.top <= maxXy && maxXy <= rect.bottom)
+            return new DOMPoint(rect.right, maxXy);
+      	}
+
+      	if (pt.y <= rectPt.y) { // top side
+      		var minYx = (rectPt.top - pt.y) / slope + pt.x;
+      		if (rect.left <= minYx && minYx <= rect.right)
+            return new DOMPoint(minYx, rect.top);
+      	}
+
+      	if (pt.y >= rectPt.y) { // bottom side
+      		var maxYx = (rect.bottom - pt.y) / slope + pt.x;
+      		if (rect.left <= maxYx && maxYx <= rect.right)
+            return new DOMPoint(maxYx, rect.bottom);
+      	}
+
+        return new DOMPoint(pt.x,pt.y);
+      }
+
+      function dragEnterTarget() {
+        target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+        var targetRect = target.getBoundingClientRect();
+        var sourceCenter = rectCenter(source.getBoundingClientRect());
+
+        for (var i = 0; i < drop_modifier_keys.length; i++) {
+          key = drop_modifier_keys[i];
+          if (key == "control"){
+            key = "ctrl"
+          }
+          opts[key + 'Key'] = true;
+        }
+
+        // fire 2 dragover events to simulate dragging with a direction
+        var entryPoint = pointOnRect(sourceCenter, targetRect)
+        var dragOverOpts = Object.assign({clientX: entryPoint.x, clientY: entryPoint.y}, opts);
+        var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+        target.dispatchEvent(dragOverEvent);
+        window.setTimeout(dragOnTarget, step_delay);
+      }
+
+      function dragOnTarget() {
+        var targetCenter = rectCenter(target.getBoundingClientRect());
+        var dragOverOpts = Object.assign({clientX: targetCenter.x, clientY: targetCenter.y}, opts);
+        var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+        target.dispatchEvent(dragOverEvent);
+        window.setTimeout(dragLeave, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
+      }
+
+      function dragLeave(drop, dragOverOpts) {
+        var dragLeaveOptions = Object.assign({}, opts, dragOverOpts);
+        var dragLeaveEvent = new DragEvent('dragleave', dragLeaveOptions);
+        target.dispatchEvent(dragLeaveEvent);
+        if (drop) {
+          var dropEvent = new DragEvent('drop', dragLeaveOptions);
+          target.dispatchEvent(dropEvent);
+        }
+        var dragEndEvent = new DragEvent('dragend', dragLeaveOptions);
+        source.dispatchEvent(dragEndEvent);
+        callback.call(true);
+      }
+
+      var source = arguments[0],
+          target = arguments[1],
+          step_delay = arguments[2],
+          drop_modifier_keys = arguments[3],
+          callback = arguments[4];
+
+      var dt = new DataTransfer();
+      var opts = { cancelable: true, bubbles: true, dataTransfer: dt };
+
+      while (source && !source.draggable) {
+        source = source.parentElement;
+      }
+
+      if (source.tagName == 'A'){
+        dt.setData('text/uri-list', source.href);
+        dt.setData('text', source.href);
+      }
+      if (source.tagName == 'IMG'){
+        dt.setData('text/uri-list', source.src);
+        dt.setData('text', source.src);
+      }
+
+      var dragEvent = new DragEvent('dragstart', opts);
+      source.dispatchEvent(dragEvent);
+
+      window.setTimeout(dragEnterTarget, step_delay);
+    JS
+  end
+end

data/lib/capybara/selenium/extensions/modifier_keys_stack.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Capybara::Selenium::Node
+  #
+  # @api private
+  #
+  class ModifierKeysStack
+    def initialize
+      @stack = []
+    end
+
+    def include?(key)
+      @stack.flatten.include?(key)
+    end
+
+    def press(key)
+      @stack.last.push(key)
+    end
+
+    def push
+      @stack.push []
+    end
+
+    def pop
+      @stack.pop
+    end
+  end
+end

data/lib/capybara/selenium/extensions/scroll.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module Scroll
+      def scroll_by(x, y)
+        driver.execute_script <<~JS, self, x, y
+          var el = arguments[0];
+          if (el.scrollBy){
+            el.scrollBy(arguments[1], arguments[2]);
+          } else {
+            el.scrollTop = el.scrollTop + arguments[2];
+            el.scrollLeft = el.scrollLeft + arguments[1];
+          }
+        JS
+      end
+
+      def scroll_to(element, location, position = nil)
+        # location, element = element, nil if element.is_a? Symbol
+        if element.is_a? Capybara::Selenium::Node
+          scroll_element_to_location(element, location)
+        elsif location.is_a? Symbol
+          scroll_to_location(location)
+        else
+          scroll_to_coords(*position)
+        end
+        self
+      end
+
+    private
+
+      def scroll_element_to_location(element, location)
+        scroll_opts = case location
+        when :top
+          'true'
+        when :bottom
+          'false'
+        when :center
+          "{behavior: 'instant', block: 'center'}"
+        else
+          raise ArgumentError, "Invalid scroll_to location: #{location}"
+        end
+        driver.execute_script <<~JS, element
+          arguments[0].scrollIntoView(#{scroll_opts})
+        JS
+      end
+
+      SCROLL_POSITIONS = {
+        top: '0',
+        bottom: 'arguments[0].scrollHeight',
+        center: '(arguments[0].scrollHeight - arguments[0].clientHeight)/2'
+      }.freeze
+
+      def scroll_to_location(location)
+        driver.execute_script <<~JS, self
+          if (arguments[0].scrollTo){
+            arguments[0].scrollTo(0, #{SCROLL_POSITIONS[location]});
+          } else {
+            arguments[0].scrollTop = #{SCROLL_POSITIONS[location]};
+          }
+        JS
+      end
+
+      def scroll_to_coords(x, y)
+        driver.execute_script <<~JS, self, x, y
+          if (arguments[0].scrollTo){
+            arguments[0].scrollTo(arguments[1], arguments[2]);
+          } else {
+            arguments[0].scrollTop = arguments[2];
+            arguments[0].scrollLeft = arguments[1];
+          }
+        JS
+      end
+    end
+  end
+end

data/lib/capybara/selenium/logger_suppressor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module DeprecationSuppressor
+      def initialize(*)
+        @suppress_for_capybara = false
+        super
+      end
+
+      def deprecate(*args, **opts, &block)
+        return if @suppress_for_capybara
+
+        if opts.empty?
+          super(*args, &block) # support Selenium 3
+        else
+          super
+        end
+      end
+
+      def suppress_deprecations
+        prev_suppress_for_capybara, @suppress_for_capybara = @suppress_for_capybara, true
+        yield
+      ensure
+        @suppress_for_capybara = prev_suppress_for_capybara
+      end
+    end
+
+    module ErrorSuppressor
+      def for_code(*)
+        ::Selenium::WebDriver.logger.suppress_deprecations do
+          super
+        end
+      end
+    end
+  end
+end
+
+Selenium::WebDriver::Logger.prepend Capybara::Selenium::DeprecationSuppressor
+Selenium::WebDriver::Error.singleton_class.prepend Capybara::Selenium::ErrorSuppressor

data/lib/capybara/selenium/node.rb

@@ -1,13 +1,25 @@
 # frozen_string_literal: true
+
+# Selenium specific implementation of the Capybara::Driver::Node API
+
+require 'capybara/selenium/extensions/find'
+require 'capybara/selenium/extensions/scroll'
+
 class Capybara::Selenium::Node < Capybara::Driver::Node
+  include Capybara::Selenium::Find
+  include Capybara::Selenium::Scroll
+
   def visible_text
-    # Selenium doesn't normalize Unicode whitespace.
-    Capybara::Helpers.normalize_whitespace(native.text)
+    native.text
   end
 
   def all_text
-    text = driver.execute_script("return arguments[0].textContent", self)
-    Capybara::Helpers.normalize_whitespace(text)
+    text = driver.evaluate_script('arguments[0].textContent', self)
+    text.gsub(/[\u200b\u200e\u200f]/, '')
+        .gsub(/[\ \n\f\t\v\u2028\u2029]+/, ' ')
+        .gsub(/\A[[:space:]&&[^\u00a0]]+/, '')
+        .gsub(/[[:space:]&&[^\u00a0]]+\z/, '')
+        .tr("\u00a0", ' ')
   end
 
   def [](name)
@@ -17,13 +29,19 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def value
-    if tag_name == "select" and multiple?
-      native.find_elements(:css, "option:checked").map { |n| n[:value] || n.text }
+    if tag_name == 'select' && multiple?
+      native.find_elements(:css, 'option:checked').map { |el| el[:value] || el.text }
     else
       native[:value]
     end
   end
 
+  def style(styles)
+    styles.each_with_object({}) do |style, result|
+      result[style] = native.css_value(style)
+    end
+  end
+
   ##
   #
   # Set the value of the form element to the given value.
@@ -35,79 +53,104 @@ 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}"
+  def set(value, **options)
+    if value.is_a?(Array) && !multiple?
+      raise ArgumentError, "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
     end
 
+    tag_name, type = attrs(:tagName, :type).map { |val| val&.downcase }
+    @tag_name ||= tag_name
+
     case tag_name
     when 'input'
       case 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)
+      when 'date'
+        set_date(value)
+      when 'time'
+        set_time(value)
+      when 'datetime-local'
+        set_datetime_local(value)
+      when 'color'
+        set_color(value)
+      when 'range'
+        set_range(value)
       else
-        set_text(value, options)
+        set_text(value, **options)
       end
     when 'textarea'
-      set_text(value, options)
+      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? && !driver.marionette?)
-          # 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)
     end
   end
 
   def select_option
-    native.click unless selected? || disabled?
+    click unless selected? || disabled?
   end
 
   def unselect_option
-    raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box." if !select_node.multiple?
-    native.click if selected?
+    raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node.multiple?
+
+    click if selected?
   end
 
-  def click
-    native.click
+  def click(keys = [], **options)
+    click_options = ClickOptions.new(keys, options)
+    return native.click if click_options.empty?
+
+    perform_with_options(click_options) do |action|
+      target = click_options.coords? ? nil : native
+      if click_options.delay.zero?
+        action.click(target)
+      else
+        action.click_and_hold(target)
+        if w3c?
+          action.pause(action.pointer_inputs.first, click_options.delay)
+        else
+          action.pause(click_options.delay)
+        end
+        action.release
+      end
+    end
+  rescue StandardError => e
+    if e.is_a?(::Selenium::WebDriver::Error::ElementClickInterceptedError) ||
+       e.message.include?('Other element would receive the click')
+      scroll_to_center
+    end
+
+    raise e
   end
 
-  def right_click
-    driver.browser.action.context_click(native).perform
+  def right_click(keys = [], **options)
+    click_options = ClickOptions.new(keys, options)
+    perform_with_options(click_options) do |action|
+      target = click_options.coords? ? nil : native
+      if click_options.delay.zero?
+        action.context_click(target)
+      elsif w3c?
+        action.move_to(target) if target
+        action.pointer_down(:right)
+              .pause(action.pointer_inputs.first, click_options.delay)
+              .pointer_up(:right)
+      else
+        raise ArgumentError, 'Delay is not supported when right clicking with legacy (non-w3c) selenium driver'
+      end
+    end
   end
 
-  def double_click
-    driver.browser.action.double_click(native).perform
+  def double_click(keys = [], **options)
+    click_options = ClickOptions.new(keys, options)
+    raise ArgumentError, "double_click doesn't support a delay option" unless click_options.delay.zero?
+
+    perform_with_options(click_options) do |action|
+      click_options.coords? ? action.double_click : action.double_click(native)
+    end
   end
 
   def send_keys(*args)
@@ -115,118 +158,457 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def hover
-    driver.browser.action.move_to(native).perform
+    scroll_if_needed { browser_action.move_to(native).perform }
   end
 
-  def drag_to(element)
-    driver.browser.action.drag_and_drop(native, element.native).perform
+  def drag_to(element, drop_modifiers: [], **)
+    drop_modifiers = Array(drop_modifiers)
+    # Due to W3C spec compliance - The Actions API no longer scrolls to elements when necessary
+    # which means Seleniums `drag_and_drop` is now broken - do it manually
+    scroll_if_needed { browser_action.click_and_hold(native).perform }
+    # element.scroll_if_needed { browser_action.move_to(element.native).release.perform }
+    element.scroll_if_needed do
+      keys_down = modifiers_down(browser_action, drop_modifiers)
+      keys_up = modifiers_up(keys_down.move_to(element.native).release, drop_modifiers)
+      keys_up.perform
+    end
   end
 
-  def tag_name
-    native.tag_name.downcase
+  def drop(*_)
+    raise NotImplementedError, 'Out of browser drop emulation is not implemented for the current browser'
   end
 
-  def visible?
-    displayed = native.displayed?
-    displayed and displayed != "false"
+  def tag_name
+    @tag_name ||= native.tag_name.downcase
   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?
-    # 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?
+    return true unless native.enabled?
+
+    # WebDriver only defines `disabled?` for form controls but fieldset makes sense too
+    find_xpath('self::fieldset/ancestor-or-self::fieldset[@disabled]').any?
+  end
+
+  def content_editable?
+    native.attribute('isContentEditable') == 'true'
+  end
+
+  def ==(other)
+    native == other.native
+  end
+
+  def path
+    driver.evaluate_script GET_XPATH_SCRIPT, self
+  end
+
+  def obscured?(x: nil, y: nil)
+    res = driver.evaluate_script(OBSCURED_OR_OFFSET_SCRIPT, self, x, y)
+    return true if res == true
+
+    driver.frame_obscured_at?(x: res['x'], y: res['y'])
+  end
+
+  def rect
+    native.rect
+  end
+
+protected
+
+  def scroll_if_needed
+    yield
+  rescue ::Selenium::WebDriver::Error::MoveTargetOutOfBoundsError
+    scroll_to_center
+    yield
+  end
+
+  def scroll_to_center
+    script = <<-'JS'
+      try {
+        arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+      } catch(e) {
+        arguments[0].scrollIntoView(true);
+      }
+    JS
+    begin
+      driver.execute_script(script, self)
+    rescue StandardError
+      # Swallow error if scrollIntoView with options isn't supported
+    end
+  end
+
+private
+
+  def sibling_index(parent, node, selector)
+    siblings = parent.find_xpath(selector)
+    case siblings.size
+    when 0
+      '[ERROR]' # IE doesn't support full XPath (namespace-uri, etc)
+    when 1
+      '' # index not necessary when only one matching element
+    else
+      idx = siblings.index(node)
+      # Element may not be found in the siblings if it has gone away
+      idx.nil? ? '[ERROR]' : "[#{idx + 1}]"
+    end
+  end
+
+  def boolean_attr(val)
+    val && (val != 'false')
+  end
+
+  # a reference to the select node if this is an option node
+  def select_node
+    find_xpath(XPath.ancestor(:select)[1]).first
+  end
+
+  def set_text(value, clear: nil, rapid: nil, **_unused)
+    value = value.to_s
+    if value.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
+      send_keys(*([:end] + backspaces + [value]))
+    elsif clear.is_a? Array
+      send_keys(*clear, value)
+    else
+      driver.execute_script 'arguments[0].select()', self unless clear == :none
+      if rapid == true || ((value.length > auto_rapid_set_length) && rapid != false)
+        send_keys(value[0..3])
+        driver.execute_script RAPID_APPEND_TEXT, self, value[4...-3]
+        send_keys(value[-3..-1])
       else
-        !native.enabled? || !find_xpath("parent::fieldset[@disabled] | ancestor::*[not(self::legend) or preceding-sibling::legend][parent::fieldset[@disabled]]").empty?
+        send_keys(value)
       end
-    else
-      !native.enabled?
     end
   end
 
-  def readonly?
-    readonly = self[:readonly]
-    readonly and readonly != "false"
+  def auto_rapid_set_length
+    30
+  end
+
+  def perform_with_options(click_options, &block)
+    raise ArgumentError, 'A block must be provided' unless block
+
+    scroll_if_needed do
+      action_with_modifiers(click_options) do |action|
+        if block_given?
+          yield action
+        else
+          click_options.coords? ? action.click : action.click(native)
+        end
+      end
+    end
   end
 
-  def multiple?
-    multiple = self[:multiple]
-    multiple and multiple != "false"
+  def set_date(value) # rubocop:disable Naming/AccessorMethodName
+    value = SettableValue.new(value)
+    return set_text(value) unless value.dateable?
+
+    # TODO: this would be better if locale can be detected and correct keystrokes sent
+    update_value_js(value.to_date_str)
   end
 
-  def content_editable?
-    native.attribute('isContentEditable')
+  def set_time(value) # rubocop:disable Naming/AccessorMethodName
+    value = SettableValue.new(value)
+    return set_text(value) unless value.timeable?
+
+    # TODO: this would be better if locale can be detected and correct keystrokes sent
+    update_value_js(value.to_time_str)
   end
 
-  def find_xpath(locator)
-    native.find_elements(:xpath, locator).map { |n| self.class.new(driver, n) }
+  def set_datetime_local(value) # rubocop:disable Naming/AccessorMethodName
+    value = SettableValue.new(value)
+    return set_text(value) unless value.timeable?
+
+    # TODO: this would be better if locale can be detected and correct keystrokes sent
+    update_value_js(value.to_datetime_str)
   end
 
-  def find_css(locator)
-    native.find_elements(:css, locator).map { |n| self.class.new(driver, n) }
+  def set_color(value) # rubocop:disable Naming/AccessorMethodName
+    update_value_js(value)
   end
 
-  def ==(other)
-    native == other.native
+  def set_range(value) # rubocop:disable Naming/AccessorMethodName
+    update_value_js(value)
   end
 
-  def path
-    path = find_xpath('ancestor::*').reverse
-    path.unshift self
+  def update_value_js(value)
+    driver.execute_script(<<-JS, self, value)
+      if (arguments[0].readOnly) { return };
+      if (document.activeElement !== arguments[0]){
+        arguments[0].focus();
+      }
+      if (arguments[0].value != arguments[1]) {
+        arguments[0].value = arguments[1]
+        arguments[0].dispatchEvent(new InputEvent('input'));
+        arguments[0].dispatchEvent(new Event('change', { bubbles: true }));
+      }
+    JS
+  end
 
-    result = []
-    while node = path.shift
-      parent = path.first
+  def set_file(value) # rubocop:disable Naming/AccessorMethodName
+    with_file_detector do
+      path_names = value.to_s.empty? ? [] : value
+      file_names = Array(path_names).map do |pn|
+        Pathname.new(pn).absolute? ? pn : File.expand_path(pn)
+      end.join("\n")
+      native.send_keys(file_names)
+    end
+  end
 
-      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}]"
+  def with_file_detector
+    if driver.options[:browser] == :remote &&
+       bridge.respond_to?(:file_detector) &&
+       bridge.file_detector.nil?
+      begin
+        bridge.file_detector = lambda do |(fn, *)|
+          str = fn.to_s
+          str if File.exist?(str)
         end
+        yield
+      ensure
+        bridge.file_detector = nil
+      end
+    else
+      yield
+    end
+  end
+
+  def set_content_editable(value) # rubocop:disable Naming/AccessorMethodName
+    # Ensure we are focused on the element
+    click
+
+    editable = driver.execute_script <<-JS, self
+      if (arguments[0].isContentEditable) {
+        var range = document.createRange();
+        var sel = window.getSelection();
+        arguments[0].focus();
+        range.selectNodeContents(arguments[0]);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        return true;
+      }
+      return false;
+    JS
+
+    # 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)
+    browser_action.send_keys(value.to_s).perform if editable
+  end
+
+  def action_with_modifiers(click_options)
+    actions = browser_action.tap do |acts|
+      if click_options.center_offset? && click_options.coords?
+        acts.move_to(native).move_by(*click_options.coords)
       else
-        result.unshift node.tag_name
+        acts.move_to(native, *click_options.coords)
       end
     end
+    modifiers_down(actions, click_options.keys)
+    yield actions
+    modifiers_up(actions, click_options.keys)
+    actions.perform
+  ensure
+    act = browser_action
+    act.release_actions if act.respond_to?(:release_actions)
+  end
 
-    '/' + result.join('/')
+  def modifiers_down(actions, keys)
+    each_key(keys) { |key| actions.key_down(key) }
+    actions
   end
 
-private
-  # a reference to the select node if this is an option node
-  def select_node
-    find_xpath('./ancestor::select[1]').first
+  def modifiers_up(actions, keys)
+    each_key(keys) { |key| actions.key_up(key) }
+    actions
   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?
-      native.clear
-    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)
+  def browser
+    driver.browser
+  end
+
+  def bridge
+    browser.send(:bridge)
+  end
+
+  def browser_action
+    browser.action
+  end
+
+  def capabilities
+    browser.capabilities
+  end
+
+  def w3c?
+    (defined?(Selenium::WebDriver::VERSION) && (Selenium::WebDriver::VERSION.to_f >= 4)) ||
+      capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities)
+  end
+
+  def normalize_keys(keys)
+    keys.map do |key|
+      case key
+      when :ctrl then :control
+      when :command, :cmd then :meta
       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)
+        key
       end
     end
   end
+
+  def each_key(keys, &block)
+    normalize_keys(keys).each(&block)
+  end
+
+  def find_context
+    native
+  end
+
+  def build_node(native_node, initial_cache = {})
+    self.class.new(driver, native_node, initial_cache)
+  end
+
+  def attrs(*attr_names)
+    return attr_names.map { |name| self[name.to_s] } if ENV['CAPYBARA_THOROUGH']
+
+    driver.evaluate_script <<~'JS', self, attr_names.map(&:to_s)
+      (function(el, names){
+        return names.map(function(name){
+          return el[name]
+        });
+      })(arguments[0], arguments[1]);
+    JS
+  end
+
+  GET_XPATH_SCRIPT = <<~'JS'
+    (function(el, xml){
+      var xpath = '';
+    	var pos, tempitem2;
+
+      if (el.getRootNode && el.getRootNode() instanceof ShadowRoot) {
+        return "(: Shadow DOM element - no XPath :)";
+      };
+      while(el !== xml.documentElement) {
+        pos = 0;
+        tempitem2 = el;
+        while(tempitem2) {
+          if (tempitem2.nodeType === 1 && tempitem2.nodeName === el.nodeName) { // If it is ELEMENT_NODE of the same name
+            pos += 1;
+          }
+          tempitem2 = tempitem2.previousSibling;
+        }
+
+        if (el.namespaceURI != xml.documentElement.namespaceURI) {
+          xpath = "*[local-name()='"+el.nodeName+"' and namespace-uri()='"+(el.namespaceURI===null?'':el.namespaceURI)+"']["+pos+']'+'/'+xpath;
+        } else {
+          xpath = el.nodeName.toUpperCase()+"["+pos+"]/"+xpath;
+        }
+
+        el = el.parentNode;
+      }
+      xpath = '/'+xml.documentElement.nodeName.toUpperCase()+'/'+xpath;
+      xpath = xpath.replace(/\/$/, '');
+      return xpath;
+    })(arguments[0], document)
+  JS
+
+  OBSCURED_OR_OFFSET_SCRIPT = <<~'JS'
+    (function(el, x, y) {
+      var box = el.getBoundingClientRect();
+      if (x == null) x = box.width/2;
+      if (y == null) y = box.height/2 ;
+
+      var px = box.left + x,
+          py = box.top + y,
+          e = document.elementFromPoint(px, py);
+
+      if (!el.contains(e))
+        return true;
+
+      return { x: px, y: py };
+    })(arguments[0], arguments[1], arguments[2])
+  JS
+
+  RAPID_APPEND_TEXT = <<~'JS'
+    (function(el, value) {
+      value = el.value + value;
+      if (el.maxLength && el.maxLength != -1){
+        value = value.slice(0, el.maxLength);
+      }
+      el.value = value;
+    })(arguments[0], arguments[1])
+  JS
+
+  # SettableValue encapsulates time/date field formatting
+  class SettableValue
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def dateable?
+      !value.is_a?(String) && value.respond_to?(:to_date)
+    end
+
+    def to_date_str
+      value.to_date.iso8601
+    end
+
+    def timeable?
+      !value.is_a?(String) && value.respond_to?(:to_time)
+    end
+
+    def to_time_str
+      value.to_time.strftime('%H:%M')
+    end
+
+    def to_datetime_str
+      value.to_time.strftime('%Y-%m-%dT%H:%M')
+    end
+  end
+  private_constant :SettableValue
+
+  # ClickOptions encapsulates click option logic
+  class ClickOptions
+    attr_reader :keys, :options
+
+    def initialize(keys, options)
+      @keys = keys
+      @options = options
+    end
+
+    def coords?
+      options[:x] && options[:y]
+    end
+
+    def coords
+      [options[:x], options[:y]]
+    end
+
+    def center_offset?
+      options[:offset] == :center
+    end
+
+    def empty?
+      keys.empty? && !coords? && delay.zero?
+    end
+
+    def delay
+      options[:delay] || 0
+    end
+  end
+  private_constant :ClickOptions
 end