cuprite 0.12 → 0.14

data/lib/capybara/cuprite/node.rb

@@ -1,295 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-
-module Capybara::Cuprite
-  class Node < Capybara::Driver::Node
-    attr_reader :node
-
-    extend Forwardable
-
-    delegate %i(description) => :node
-    delegate %i(browser) => :driver
-
-    def initialize(driver, node)
-      super(driver, self)
-      @node = node
-    end
-
-    def command(name, *args)
-      browser.send(name, node, *args)
-    rescue Ferrum::NodeNotFoundError => e
-      raise ObsoleteNode.new(self, e.response)
-    rescue Ferrum::BrowserError => e
-      case e.message
-      when "Cuprite.MouseEventFailed"
-        raise MouseEventFailed.new(self, e.response)
-      else
-        raise
-      end
-    end
-
-    def parents
-      command(:parents).map do |parent|
-        self.class.new(driver, parent)
-      end
-    end
-
-    def find_xpath(selector)
-      find(:xpath, selector)
-    end
-
-    def find_css(selector)
-      find(:css, selector)
-    end
-
-    def find(method, selector)
-      command(:find_within, method, selector).map do |node|
-        self.class.new(driver, node)
-      end
-    end
-
-    def all_text
-      filter_text(command(:all_text))
-    end
-
-    def visible_text
-      if Capybara::VERSION.to_f < 3.0
-        filter_text(command(:visible_text))
-      else
-        command(:visible_text).to_s
-                              .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
-                              .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
-                              .gsub(/\n+/, "\n")
-                              .tr("\u00a0", " ")
-      end
-    end
-
-    def property(name)
-      command(:property, name)
-    end
-
-    def [](name)
-      # Although the attribute matters, the property is consistent. Return that in
-      # preference to the attribute for links and images.
-      if (tag_name == "img" && name == "src") ||
-         (tag_name == "a" && name == "href")
-        # if attribute exists get the property
-        return command(:attribute, name) && command(:property, name)
-      end
-
-      value = property(name)
-      value = command(:attribute, name) if value.nil? || value.is_a?(Hash)
-
-      value
-    end
-
-    def attributes
-      command(:attributes)
-    end
-
-    def value
-      command(:value)
-    end
-
-    def set(value, options = {})
-      warn "Options passed to Node#set but Cuprite doesn't currently support any - ignoring" unless options.empty?
-
-      if tag_name == "input"
-        case self[:type]
-        when "radio"
-          click
-        when "checkbox"
-          click if value != checked?
-        when "file"
-          files = value.respond_to?(:to_ary) ? value.to_ary.map(&:to_s) : value.to_s
-          command(:select_file, files)
-        when "color"
-          node.evaluate("this.setAttribute('value', '#{value}')")
-        else
-          command(:set, value.to_s)
-        end
-      elsif tag_name == "textarea"
-        command(:set, value.to_s)
-      elsif self[:isContentEditable]
-        command(:delete_text)
-        send_keys(value.to_s)
-      end
-    end
-
-    def select_option
-      command(:select, true)
-    end
-
-    def unselect_option
-      command(:select, false) ||
-        raise(Capybara::UnselectNotAllowed, "Cannot unselect option from single select box.")
-    end
-
-    def tag_name
-      @tag_name ||= description["nodeName"].downcase
-    end
-
-    def visible?
-      command(:visible?)
-    end
-
-    def checked?
-      self[:checked]
-    end
-
-    def selected?
-      !!self[:selected]
-    end
-
-    def disabled?
-      command(:disabled?)
-    end
-
-    def click(keys = [], **options)
-      prepare_and_click(:left, __method__, keys, options)
-    end
-
-    def right_click(keys = [], **options)
-      prepare_and_click(:right, __method__, keys, options)
-    end
-
-    def double_click(keys = [], **options)
-      prepare_and_click(:double, __method__, keys, options)
-    end
-
-    def hover
-      command(:hover)
-    end
-
-    def drag_to(other)
-      command(:drag, other)
-    end
-
-    def drag_by(x, y)
-      command(:drag_by, x, y)
-    end
-
-    def trigger(event)
-      command(:trigger, event)
-    end
-
-    def scroll_to(element, location, position = nil)
-      if element.is_a?(Node)
-        scroll_element_to_location(element, location)
-      elsif location.is_a?(Symbol)
-        scroll_to_location(location)
-      else
-        scroll_to_coords(*position)
-      end
-      self
-    end
-
-    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 ==(other)
-      node == other.native.node
-    end
-
-    def send_keys(*keys)
-      command(:send_keys, keys)
-    end
-    alias_method :send_key, :send_keys
-
-    def path
-      command(:path)
-    end
-
-    def inspect
-      %(#<#{self.class} @node=#{@node.inspect}>)
-    end
-
-    # @api private
-    def to_json(*)
-      JSON.generate(as_json)
-    end
-
-    # @api private
-    def as_json(*)
-      # FIXME: Where is this method used and why attr is called id?
-      { ELEMENT: { node: node, id: node.node_id } }
-    end
-
-    private
-
-    def prepare_and_click(mode, name, keys, options)
-      delay = options[:delay].to_i
-      x, y = options.values_at(:x, :y)
-      offset = { x: x, y: y, position: options[:offset] || :top }
-      command(:before_click, name, keys, offset)
-      node.click(mode: mode, keys: keys, offset: offset, delay: delay)
-    end
-
-    def filter_text(text)
-      if Capybara::VERSION.to_f < 3
-        Capybara::Helpers.normalize_whitespace(text.to_s)
-      else
-        text.gsub(/[\u200b\u200e\u200f]/, "")
-            .gsub(/[\ \n\f\t\v\u2028\u2029]+/, " ")
-            .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
-            .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
-            .tr("\u00a0", " ")
-      end
-    end
-
-    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
-
-    def scroll_to_location(location)
-      scroll_y = case location
-      when :top
-        '0'
-      when :bottom
-        'arguments[0].scrollHeight'
-      when :center
-        '(arguments[0].scrollHeight - arguments[0].clientHeight)/2'
-      end
-      driver.execute_script <<~JS, self
-        if (arguments[0].scrollTo){
-          arguments[0].scrollTo(0, #{scroll_y});
-        } else {
-          arguments[0].scrollTop = #{scroll_y};
-        }
-      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

data/lib/capybara/cuprite/page.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-
-module Capybara::Cuprite
-  class Page < Ferrum::Page
-    MODAL_WAIT = ENV.fetch("CUPRITE_MODAL_WAIT", 0.05).to_f
-    TRIGGER_CLICK_WAIT = ENV.fetch("CUPRITE_TRIGGER_CLICK_WAIT", 0.1).to_f
-
-    extend Forwardable
-    delegate %i[at_css at_xpath css xpath
-                current_url current_title body execution_id
-                evaluate evaluate_on evaluate_async execute] => :active_frame
-
-    def initialize(*args)
-      @frame_stack = []
-      @accept_modal = []
-      @modal_messages = []
-      super
-    end
-
-    def set(node, value)
-      object_id = command("DOM.resolveNode", nodeId: node.node_id).dig("object", "objectId")
-      evaluate("_cuprite.set(arguments[0], arguments[1])", { "objectId" => object_id }, value)
-    end
-
-    def select(node, value)
-      evaluate_on(node: node, expression: "_cuprite.select(this, #{value})")
-    end
-
-    def trigger(node, event)
-      options = {}
-      options.merge!(wait: TRIGGER_CLICK_WAIT) if event.to_s == "click" && TRIGGER_CLICK_WAIT > 0
-      evaluate_on(node: node, expression: %(_cuprite.trigger(this, "#{event}")), **options)
-    end
-
-    def hover(node)
-      evaluate_on(node: node, expression: "_cuprite.scrollIntoViewport(this)")
-      x, y = find_position(node)
-      command("Input.dispatchMouseEvent", type: "mouseMoved", x: x, y: y)
-    end
-
-    def send_keys(node, keys)
-      if !evaluate_on(node: node, expression: %(_cuprite.containsSelection(this)))
-        before_click(node, "click")
-        node.click(mode: :left, keys: keys)
-      end
-
-      keyboard.type(keys)
-    end
-
-    def accept_confirm
-      @accept_modal << true
-    end
-
-    def dismiss_confirm
-      @accept_modal << false
-    end
-
-    def accept_prompt(modal_response)
-      @accept_modal << true
-      @modal_response = modal_response
-    end
-
-    def dismiss_prompt
-      @accept_modal << false
-    end
-
-    def find_modal(options)
-      start = Ferrum.monotonic_time
-      timeout = options.fetch(:wait, browser.timeout)
-      expect_text = options[:text]
-      expect_regexp = expect_text.is_a?(Regexp) ? expect_text : Regexp.escape(expect_text.to_s)
-      not_found_msg = "Unable to find modal dialog"
-      not_found_msg += " with #{expect_text}" if expect_text
-
-      begin
-        modal_text = @modal_messages.shift
-        raise Capybara::ModalNotFound if modal_text.nil? || (expect_text && !modal_text.match(expect_regexp))
-      rescue Capybara::ModalNotFound => e
-        raise e, not_found_msg if Ferrum.timeout?(start, timeout)
-        sleep(MODAL_WAIT)
-        retry
-      end
-
-      modal_text
-    end
-
-    def reset_modals
-      @accept_modal = []
-      @modal_response = nil
-      @modal_messages = []
-    end
-
-    def before_click(node, name, keys = [], offset = {})
-      evaluate_on(node: node, expression: "_cuprite.scrollIntoViewport(this)")
-
-      # If offset is given it may go outside of the element and likely error
-      # will be raised that we detected another element at this position.
-      return true if offset[:x] || offset[:y]
-
-      x, y = find_position(node, **offset)
-      evaluate_on(node: node, expression: "_cuprite.mouseEventTest(this, '#{name}', #{x}, #{y})")
-      true
-    rescue Ferrum::JavaScriptError => e
-      raise MouseEventFailed.new(e.message) if e.class_name == "MouseEventFailed"
-    end
-
-    def switch_to_frame(handle)
-      case handle
-      when :parent
-        @frame_stack.pop
-      when :top
-        @frame_stack = []
-      else
-        @frame_stack << handle
-        inject_extensions
-      end
-    end
-
-    def frame_name
-      evaluate("window.name")
-    end
-
-    def title
-      active_frame.current_title
-    end
-
-    private
-
-    def prepare_page
-      super
-
-      network.intercept if !Array(@browser.url_whitelist).empty? ||
-                           !Array(@browser.url_blacklist).empty?
-
-      on(:request) do |request, index, total|
-        if @browser.url_blacklist && !@browser.url_blacklist.empty?
-          if @browser.url_blacklist.any? { |r| request.match?(r) }
-            request.abort and next
-          else
-            request.continue and next
-          end
-        elsif @browser.url_whitelist && !@browser.url_whitelist.empty?
-          if @browser.url_whitelist.any? { |r| request.match?(r) }
-            request.continue and next
-          else
-            request.abort and next
-          end
-        elsif index + 1 < total
-          # There are other callbacks that may handle this request
-          next
-        else
-          # If there are no callbacks then just continue
-          request.continue
-        end
-      end
-
-      on("Page.javascriptDialogOpening") do |params|
-        accept_modal = @accept_modal.last
-        if accept_modal == true || accept_modal == false
-          @accept_modal.pop
-          @modal_messages << params["message"]
-          options = { accept: accept_modal }
-          response = @modal_response || params["defaultPrompt"]
-          options.merge!(promptText: response) if response
-          command("Page.handleJavaScriptDialog", **options)
-        else
-          with_text = params["message"] ? "with text `#{params["message"]}` " : ""
-          warn "Modal window #{with_text}has been opened, but you didn't wrap "\
-               "your code into (`accept_prompt` | `dismiss_prompt` | "\
-               "`accept_confirm` | `dismiss_confirm` | `accept_alert`), "\
-               "accepting by default"
-          options = { accept: true }
-          response = params["defaultPrompt"]
-          options.merge!(promptText: response) if response
-          command("Page.handleJavaScriptDialog", **options)
-        end
-      end
-    end
-
-    def find_position(node, **options)
-      x, y = node.find_position(**options)
-    rescue Ferrum::BrowserError => e
-      if e.message == "Could not compute content quads."
-        raise MouseEventFailed.new("MouseEventFailed: click, none, 0, 0")
-      else
-        raise
-      end
-    end
-
-    def active_frame
-      if @frame_stack.empty?
-        main_frame
-      else
-        @frames[@frame_stack.last]
-      end
-    end
-  end
-end

data/lib/capybara/cuprite/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Capybara
-  module Cuprite
-    VERSION = "0.12"
-  end
-end

data/lib/capybara/cuprite.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "ferrum"
-require "capybara"
-require "capybara/cuprite/driver"
-require "capybara/cuprite/browser"
-require "capybara/cuprite/page"
-require "capybara/cuprite/node"
-require "capybara/cuprite/errors"
-
-Capybara.register_driver(:cuprite) do |app|
-  Capybara::Cuprite::Driver.new(app)
-end