ferrum 0.1.2 → 0.2

data/lib/ferrum/mouse.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Mouse
+    VALID_BUTTONS = %w[none left middle right back forward].freeze
+
+    def initialize(page)
+      @page = page
+      @x = @y = 0
+    end
+
+    def click(x:, y:, delay: 0, timeout: 0, **options)
+      move(x: x, y: y)
+      down(**options)
+      sleep(delay)
+      # Potential wait because if network event is triggered then we have to wait until it's over.
+      up(timeout: timeout, **options)
+      self
+    end
+
+    def down(**options)
+      tap { mouse_event(type: "mousePressed", **options) }
+    end
+
+    def up(**options)
+      tap { mouse_event(type: "mouseReleased", **options) }
+    end
+
+    # FIXME: steps
+    def move(x:, y:, steps: 1)
+      @x, @y = x, y
+      @page.command("Input.dispatchMouseEvent", type: "mouseMoved", x: @x, y: @y)
+      self
+    end
+
+    private
+
+    def mouse_event(type:, button: :left, count: 1, modifiers: nil, timeout: 0)
+      button = validate_button(button)
+      options = { x: @x, y: @y, type: type, button: button, clickCount: count }
+      options.merge!(modifiers: modifiers) if modifiers
+      @page.command("Input.dispatchMouseEvent", timeout: timeout, **options)
+    end
+
+    def validate_button(button)
+      button = button.to_s
+      unless VALID_BUTTONS.include?(button)
+        raise "Invalid button: #{button}"
+      end
+      button
+    end
+  end
+end

data/lib/ferrum/network/intercepted_request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ferrum::Network
+  class InterceptedRequest
+    attr_accessor :interception_id, :frame_id, :resource_type,
+                  :is_navigation_request
+
+    def initialize(page, params)
+      @page, @params = page, params
+      @interception_id = params["interceptionId"]
+      @frame_id = params["frameId"]
+      @resource_type = params["resourceType"]
+      @is_navigation_request = params["isNavigationRequest"]
+      @request = params.dig("request")
+    end
+
+    def auth_challenge?(source)
+      @params.dig("authChallenge", "source")&.downcase&.to_s == source.to_s
+    end
+
+    def match?(regexp)
+      url.match?(regexp)
+    end
+
+    def abort
+      @page.abort_request(interception_id)
+    end
+
+    def continue(**options)
+      @page.continue_request(interception_id, **options)
+    end
+
+    def url
+      @request["url"]
+    end
+
+    def method
+      @request["method"]
+    end
+
+    def headers
+      @request["headers"]
+    end
+
+    def initial_priority
+      @request["initialPriority"]
+    end
+
+    def referrer_policy
+      @request["referrerPolicy"]
+    end
+  end
+end

data/lib/ferrum/node.rb

@@ -2,153 +2,99 @@
 
 module Ferrum
   class Node
-    attr_reader :page, :target_id, :node_id, :description
+    attr_reader :page, :target_id, :node_id, :description, :tag_name
 
     def initialize(page, target_id, node_id, description)
-      @page, @target_id, @node_id, @description =
-        page, target_id, node_id, description
+      @page, @target_id = page, target_id
+      @node_id, @description = node_id, description
+      @tag_name = description["nodeName"].downcase
     end
 
     def node?
       description["nodeType"] == 1 # nodeType: 3, nodeName: "#text" e.g.
     end
 
-    def page_send(name, *args)
-      page.send(name, self, *args)
-    rescue BrowserError => e
-      case e.message
-      when "No node with given id found"
-        raise ObsoleteNode.new(self, e.response)
-      else
-        raise
-      end
+    def focus
+      tap { page.command("DOM.focus", nodeId: node_id) }
     end
 
-    def at_xpath(selector)
-      page.at_xpath(selector, within: self)
+    def blur
+      tap { evaluate("this.blur()") }
     end
 
-    def at_css(selector)
-      page.at_css(selector, within: self)
+    def type(*keys)
+      tap { page.keyboard.type(*keys) }
     end
 
-    def xpath(selector)
-      page.xpath(selector, within: self)
-    end
-
-    def css(selector)
-      page.css(selector, within: self)
-    end
+    # mode: (:left | :right | :double)
+    # keys: (:alt, (:ctrl | :control), (:meta | :command), :shift)
+    # offset: { :x, :y }
+    def click(mode: :left, keys: [], offset: {})
+      x, y = page.find_position(self, offset[:x], offset[:y])
+      modifiers = page.keyboard.modifiers(keys)
 
-    def text
-      page.evaluate_on(node: self, expression: "this.textContent")
-    end
-
-    def property(name)
-      page_send(: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 page_send(:attribute, name) && page_send(:property, name)
+      case mode
+      when :right
+        page.mouse.move(x: x, y: y)
+        page.mouse.down(button: :right, modifiers: modifiers)
+        page.mouse.up(button: :right, modifiers: modifiers)
+      when :double
+        page.mouse.move(x: x, y: y)
+        page.mouse.down(modifiers: modifiers, count: 2)
+        page.mouse.up(modifiers: modifiers, count: 2)
+      when :left
+        page.mouse.click(x: x, y: y, modifiers: modifiers, timeout: 0.05)
       end
 
-      value = property(name)
-      value = page_send(:attribute, name) if value.nil? || value.is_a?(Hash)
-
-      value
-    end
-
-    def attributes
-      page_send(:attributes)
-    end
-
-    def value
-      page.evaluate_on(node: self, expression: "this.value")
-    end
-
-    def set(value)
-      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
-          page_send(:select_file, files)
-        else
-          page_send(:set, value.to_s)
-        end
-      elsif tag_name == "textarea"
-        page_send(:set, value.to_s)
-      elsif self[:isContentEditable]
-        # FIXME:
-        page_send(:delete_text)
-        send_keys(value.to_s)
-      end
-    end
-
-    def select_option
-      page_send(:select, true)
+      self
     end
 
-    def unselect_option
-      raise NotImplemented
+    def hover
+      raise NotImplementedError
     end
 
-    def tag_name
-      @tag_name ||= description["nodeName"].downcase
+    def trigger(event)
+      raise NotImplementedError
     end
 
-    def visible?
-      page_send(:visible?)
+    def select_file(value)
+      page.command("DOM.setFileInputFiles", nodeId: node_id, files: Array(value))
     end
 
-    def checked?
-      self[:checked]
+    def at_xpath(selector)
+      page.at_xpath(selector, within: self)
     end
 
-    def selected?
-      !!self[:selected]
+    def at_css(selector)
+      page.at_css(selector, within: self)
     end
 
-    def disabled?
-      page_send(:disabled?)
+    def xpath(selector)
+      page.xpath(selector, within: self)
     end
 
-    def click(keys = [], offset = {})
-      page_send(:click, keys, offset)
+    def css(selector)
+      page.css(selector, within: self)
     end
 
-    def right_click(keys = [], offset = {})
-      page_send(:right_click, keys, offset)
+    def text
+      evaluate("this.textContent")
     end
 
-    def double_click(keys = [], offset = {})
-      page_send(:double_click, keys, offset)
+    def value
+      evaluate("this.value")
     end
 
-    def hover
-      page_send(:hover)
+    def property(name)
+      evaluate("this['#{name}']")
     end
 
-    def trigger(event)
-      page_send(:trigger, event)
+    def attribute(name)
+      evaluate("this.getAttribute('#{name}')")
     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
+    def evaluate(expression)
+      page.evaluate_on(node: self, expression: expression)
     end
 
     def ==(other)
@@ -159,15 +105,6 @@ module Ferrum
       target_id == other.target_id && description["backendNodeId"] == other.description["backendNodeId"]
     end
 
-    def send_keys(*keys)
-      page_send(:send_keys, keys)
-    end
-    alias_method :send_key, :send_keys
-
-    def path
-      page_send(:path)
-    end
-
     def inspect
       %(#<#{self.class} @target_id=#{@target_id.inspect} @node_id=#{@node_id} @description=#{@description.inspect}>)
     end

data/lib/ferrum/page.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
+require "ferrum/mouse"
+require "ferrum/keyboard"
+require "ferrum/headers"
+require "ferrum/cookies"
 require "ferrum/page/dom"
 require "ferrum/page/input"
 require "ferrum/page/runtime"
 require "ferrum/page/frame"
 require "ferrum/page/net"
+require "ferrum/page/screenshot"
 require "ferrum/browser/client"
 require "ferrum/network/error"
 require "ferrum/network/request"
 require "ferrum/network/response"
+require "ferrum/network/intercepted_request"
 
 # RemoteObjectId is from a JavaScript world, and corresponds to any JavaScript
 # object, including JS wrappers for DOM nodes. There is a way to convert between
@@ -31,10 +37,13 @@ module Ferrum
   class Page
     NEW_WINDOW_BUG_SLEEP = 0.3
 
-    include Input, DOM, Runtime, Frame, Net
+    include Input, DOM, Runtime, Frame, Net, Screenshot
 
     attr_accessor :referrer
-    attr_reader :target_id, :status, :response_headers
+    attr_reader :target_id, :status,
+                :headers, :cookies, :response_headers,
+                :mouse, :keyboard,
+                :browser
 
     def initialize(target_id, browser, new_window = false)
       @target_id, @browser = target_id, browser
@@ -50,22 +59,16 @@ module Ferrum
       # Dirty hack because new window doesn't have events at all
       sleep(NEW_WINDOW_BUG_SLEEP) if new_window
 
-      begin
-        @session_id = @browser.command("Target.attachToTarget", targetId: @target_id)["sessionId"]
-      rescue BrowserError => e
-        case e.message
-        when "No target with given id found"
-          raise NoSuchWindowError
-        else
-          raise
-        end
-      end
+      @session_id = @browser.command("Target.attachToTarget", targetId: @target_id)["sessionId"]
 
       host = @browser.process.host
       port = @browser.process.port
       ws_url = "ws://#{host}:#{port}/devtools/page/#{@target_id}"
       @client = Browser::Client.new(browser, ws_url, 1000)
 
+      @mouse, @keyboard = Mouse.new(self), Keyboard.new(self)
+      @headers, @cookies = Headers.new(self), Cookies.new(self)
+
       subscribe
       prepare_page
     end
@@ -83,12 +86,13 @@ module Ferrum
             net::ERR_NAME_RESOLUTION_FAILED
             net::ERR_INTERNET_DISCONNECTED
             net::ERR_CONNECTION_TIMED_OUT].include?(response["errorText"])
-        raise StatusFailError, "url" => options[:url]
+        raise StatusError, options[:url]
       end
       response["frameId"]
     end
 
     def close
+      @headers.clear
       @browser.command("Target.detachFromTarget", sessionId: @session_id)
       @browser.command("Target.closeTarget", targetId: @target_id)
       close_connection
@@ -130,12 +134,12 @@ module Ferrum
       @network_traffic = []
     end
 
-    def go_back
-      go(-1)
+    def back
+      history_navigate(delta: -1)
     end
 
-    def go_forward
-      go(1)
+    def forward
+      history_navigate(delta: 1)
     end
 
     def accept_confirm
@@ -165,8 +169,8 @@ module Ferrum
 
       begin
         modal_text = @modal_messages.shift
-        raise ModalNotFound if modal_text.nil? || (expect_text && !modal_text.match(expect_regexp))
-      rescue ModalNotFound => e
+        raise ModalNotFoundError if modal_text.nil? || (expect_text && !modal_text.match(expect_regexp))
+      rescue ModalNotFoundError => e
         raise e, not_found_msg if (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time) >= timeout_sec
         sleep(0.05)
         retry
@@ -217,13 +221,13 @@ module Ferrum
           options = { accept: accept_modal }
           response = @modal_response || params["defaultPrompt"]
           options.merge!(promptText: response) if response
-          @client.command("Page.handleJavaScriptDialog", **options)
+          command("Page.handleJavaScriptDialog", **options)
         else
           warn "Modal window 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
-          @client.command("Page.handleJavaScriptDialog", **options)
+          command("Page.handleJavaScriptDialog", **options)
         end
       end
 
@@ -310,7 +314,7 @@ module Ferrum
       end
 
       @browser.extensions.each do |extension|
-        @client.command("Page.addScriptToEvaluateOnNewDocument", source: extension)
+        command("Page.addScriptToEvaluateOnNewDocument", source: extension)
       end
 
       inject_extensions
@@ -318,10 +322,6 @@ module Ferrum
       width, height = @browser.window_size
       resize(width: width, height: height)
 
-      url_whitelist = Array(@browser.url_whitelist)
-      url_blacklist = Array(@browser.url_blacklist)
-      intercept_request("*") if !url_whitelist.empty? || !url_blacklist.empty?
-
       response = command("Page.getNavigationHistory")
       if response.dig("entries", 0, "transitionType") != "typed"
         # If we create page by clicking links, submiting forms and so on it
@@ -340,13 +340,13 @@ module Ferrum
         # https://github.com/cyrus-and/chrome-remote-interface/issues/319
         # We also evaluate script just in case because
         # `Page.addScriptToEvaluateOnNewDocument` doesn't work in popups.
-        @client.command("Runtime.evaluate", expression: extension,
-                                            contextId: execution_context_id,
-                                            returnByValue: true)
+        command("Runtime.evaluate", expression: extension,
+                                    contextId: execution_context_id,
+                                    returnByValue: true)
       end
     end
 
-    def go(delta)
+    def history_navigate(delta:)
       history = command("Page.getNavigationHistory")
       index, entries = history.values_at("currentIndex", "entries")