ferrum 0.1.2 → 0.2

data/lib/ferrum.rb

@@ -1,13 +1,84 @@
 # frozen_string_literal: true
 
+require "ferrum/browser"
+require "ferrum/node"
+
 Thread.abort_on_exception = true
 Thread.report_on_exception = true if Thread.respond_to?(:report_on_exception=)
 
 module Ferrum
-  require "ferrum/browser"
-  require "ferrum/node"
-  require "ferrum/errors"
-  require "ferrum/cookie"
+  class Error               < StandardError; end
+  class NoSuchWindowError   < Error; end
+  class ModalNotFoundError  < Error; end
+  class NotImplementedError < Error; end
+
+  class EmptyTargetsError < Error
+    def initialize
+      super("There aren't targets available")
+    end
+  end
+
+  class StatusError < Error
+    def initialize(url)
+      super("Request to #{url} failed to reach server, check DNS and/or server status")
+    end
+  end
+
+  class TimeoutError < Error
+    def message
+      "Timed out waiting for response. It's possible that this happened " \
+      "because something took a very long time (for example a page load " \
+      "was slow). If so, setting the :timeout option to a higher value might " \
+      "help."
+    end
+  end
+
+  class ScriptTimeoutError < Error
+    def message
+      "Timed out waiting for evaluated script to return a value"
+    end
+  end
+
+  class DeadBrowserError < Error
+    def initialize(message = "Browser is dead")
+      super
+    end
+  end
+
+  class BrowserError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(response["message"])
+    end
+
+    def code
+      response["code"]
+    end
+
+    def data
+      response["data"]
+    end
+  end
+
+  class NodeNotFoundError < BrowserError; end
+
+  class NoExecutionContextError < BrowserError
+    def initialize(response = nil)
+      response ||= { "message" => "There's no context available" }
+      super(response)
+    end
+  end
+
+  class JavaScriptError < BrowserError
+    attr_reader :class_name, :message
+
+    def initialize(response)
+      super
+      @class_name, @message = response.values_at("className", "description")
+    end
+  end
 
   class << self
     def windows?
@@ -21,5 +92,15 @@ module Ferrum
     def mri?
       defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
     end
+
+    def with_attempts(errors:, max:, wait:)
+      attempts ||= 1
+      yield
+    rescue *Array(errors)
+      raise if attempts >= max
+      attempts += 1
+      sleep(wait)
+      retry
+    end
   end
 end

data/lib/ferrum/browser.rb

@@ -4,7 +4,6 @@ require "base64"
 require "forwardable"
 require "ferrum/page"
 require "ferrum/targets"
-require "ferrum/browser/api"
 require "ferrum/browser/process"
 require "ferrum/browser/client"
 
@@ -14,26 +13,25 @@ module Ferrum
     WINDOW_SIZE = [1024, 768].freeze
     BASE_URL_SCHEMA = %w[http https].freeze
 
-    include API
     extend Forwardable
 
-    attr_reader :headers, :window_size
+    attr_reader :window_size
 
     delegate on: :@client
-    delegate %i(window_handle window_handles switch_to_window open_new_window
-                close_window within_window page) => :targets
-    delegate %i(goto status body at_css at_xpath css xpath text property attributes attribute select_file
-                value visible? disabled? network_traffic clear_network_traffic
-                path response_headers refresh click right_click double_click
-                hover set click_coordinates select trigger scroll_to send_keys
-                evaluate evaluate_on evaluate_async execute frame_url
-                frame_title switch_to_frame current_url title go_back
-                go_forward find_modal accept_confirm dismiss_confirm
-                accept_prompt dismiss_prompt reset_modals authorize
-                proxy_authorize) => :page
-
-    attr_reader :process, :logger, :js_errors, :slowmo, :base_url,
-                :url_blacklist, :url_whitelist, :options
+    delegate %i[window_handle window_handles switch_to_window
+                open_new_window close_window within_window page] => :targets
+    delegate %i[goto back forward refresh status
+                at_css at_xpath css xpath current_url title body
+                headers cookies network_traffic clear_network_traffic response_headers
+                intercept_request on_request_intercepted continue_request abort_request
+                mouse keyboard scroll_to
+                screenshot pdf
+                evaluate evaluate_on evaluate_async execute
+                frame_url frame_title within_frame
+                find_modal accept_confirm dismiss_confirm accept_prompt dismiss_prompt reset_modals
+                authorize proxy_authorize] => :page
+
+    attr_reader :process, :logger, :js_errors, :slowmo, :base_url, :options
     attr_writer :timeout
 
     def initialize(options = nil)
@@ -52,9 +50,6 @@ module Ferrum
         self.base_url = @options[:base_url]
       end
 
-      self.url_blacklist = @options[:url_blacklist]
-      self.url_whitelist = @options[:url_whitelist]
-
       if ENV["FERRUM_DEBUG"] && !@logger
         STDOUT.sync = true
         @logger = STDOUT
@@ -85,27 +80,16 @@ module Ferrum
 
     def command(*args)
       @client.command(*args)
-    rescue DeadBrowser
+    rescue DeadBrowserError
       restart
       raise
     end
 
-    def set_overrides(user_agent: nil, accept_language: nil, platform: nil)
-      options = Hash.new
-      options[:userAgent] = user_agent if user_agent
-      options[:acceptLanguage] = accept_language if accept_language
-      options[:platform] if platform
-
-      page.command("Network.setUserAgentOverride", **options) if !options.empty?
-    end
-
     def clear_memory_cache
       page.command("Network.clearBrowserCache")
     end
 
     def reset
-      @headers = {}
-      @zoom_factor = nil
       @window_size = @original_window_size
       targets.reset
     end
@@ -137,7 +121,6 @@ module Ferrum
     private
 
     def start
-      @headers = {}
       @process = Process.start(@options)
       @client = Client.new(self, @process.ws_url, 0, false)
     end

data/lib/ferrum/browser/client.rb

@@ -35,10 +35,10 @@ module Ferrum
         data = pending.value!(@browser.timeout)
         @pendings.delete(message[:id])
 
-        raise DeadBrowser if data.nil? && @ws.messages.closed?
+        raise DeadBrowserError if data.nil? && @ws.messages.closed?
         raise TimeoutError unless data
         error, response = data.values_at("error", "result")
-        raise BrowserError.new(error) if error
+        raise_browser_error(error) if error
         response
       end
 
@@ -64,6 +64,22 @@ module Ferrum
       def next_command_id
         @command_id += 1
       end
+
+      def raise_browser_error(error)
+        case error["message"]
+        # Node has disappeared while we were trying to get it
+        when "No node with given id found",
+             "Could not find node with given id"
+          raise NodeNotFoundError.new(error)
+        # Context is lost, page is reloading
+        when "Cannot find context with specified id"
+          raise NoExecutionContextError.new(error)
+        when "No target with given id found"
+          raise NoSuchWindowError
+        else
+          raise BrowserError.new(error)
+        end
+      end
     end
   end
 end

data/lib/ferrum/browser/subscriber.rb

@@ -19,7 +19,11 @@ module Ferrum
 
       def call(message)
         method, params = message.values_at("method", "params")
-        @on[method].each { |b| b.call(params) }
+        total = @on[method].size
+        @on[method].each_with_index do |block, index|
+          # If there are a few callback we provide current index and total
+          block.call(params, index, total)
+        end
       end
     end
   end

data/lib/ferrum/cookies.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Cookies
+    class Cookie
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def name
+        @attributes["name"]
+      end
+
+      def value
+        @attributes["value"]
+      end
+
+      def domain
+        @attributes["domain"]
+      end
+
+      def path
+        @attributes["path"]
+      end
+
+      def size
+        @attributes["size"]
+      end
+
+      def secure?
+        @attributes["secure"]
+      end
+
+      def httponly?
+        @attributes["httpOnly"]
+      end
+
+      def session?
+        @attributes["session"]
+      end
+
+      def expires
+        if @attributes["expires"] > 0
+          Time.at(@attributes["expires"])
+        end
+      end
+    end
+
+    def initialize(page)
+      @page = page
+    end
+
+    def all
+      cookies = @page.command("Network.getAllCookies")["cookies"]
+      cookies.map { |c| [c["name"], Cookie.new(c)] }.to_h
+    end
+
+    def [](name)
+      all[name]
+    end
+
+    def set(name: nil, value: nil, **options)
+      cookie = options.dup
+      cookie[:name]   ||= name
+      cookie[:value]  ||= value
+      cookie[:domain] ||= default_domain
+
+      expires = cookie.delete(:expires).to_i
+      cookie[:expires] = expires if expires > 0
+
+      @page.command("Network.setCookie", **cookie)["success"]
+    end
+
+    # Supports :url, :domain and :path options
+    def remove(name:, **options)
+      raise "Specify :domain or :url option" if !options[:domain] && !options[:url] && !default_domain
+
+      options = options.merge(name: name)
+      options[:domain] ||= default_domain
+
+      @page.command("Network.deleteCookies", **options)
+
+      true
+    end
+
+    def clear
+      @page.command("Network.clearBrowserCookies")
+      true
+    end
+
+    private
+
+    def default_domain
+      URI.parse(@page.browser.base_url).host if @page.browser.base_url
+    end
+  end
+end

data/lib/ferrum/headers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Headers
+    def initialize(page)
+      @page = page
+      @headers = {}
+    end
+
+    def get
+      @headers
+    end
+
+    def set(headers)
+      clear
+      add(headers)
+    end
+
+    def clear
+      @headers = {}
+      true
+    end
+
+    def add(headers, permanent: true)
+      if headers["Referer"]
+        @page.referrer = headers["Referer"]
+        headers.delete("Referer") unless permanent
+      end
+
+      @headers.merge!(headers)
+      user_agent = @headers["User-Agent"]
+      accept_language = @headers["Accept-Language"]
+
+      set_overrides(user_agent: user_agent, accept_language: accept_language)
+      @page.command("Network.setExtraHTTPHeaders", headers: @headers)
+      true
+    end
+
+    private
+
+    def set_overrides(user_agent: nil, accept_language: nil, platform: nil)
+      options = Hash.new
+      options[:userAgent] = user_agent if user_agent
+      options[:acceptLanguage] = accept_language if accept_language
+      options[:platform] if platform
+
+      @page.command("Network.setUserAgentOverride", **options) if !options.empty?
+    end
+  end
+end

data/lib/ferrum/keyboard.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ferrum
+  class Keyboard
+    KEYS = JSON.parse(File.read(File.expand_path("../keyboard.json", __FILE__)))
+    MODIFIERS = { "alt" => 1, "ctrl" => 2, "control" => 2,
+                  "meta" => 4, "command" => 4, "shift" => 8 }
+    KEYS_MAPPING = {
+      cancel: "Cancel", help: "Help", backspace: "Backspace", tab: "Tab",
+      clear: "Clear", return: "Enter", enter: "Enter", shift: "Shift",
+      ctrl: "Control", control: "Control", alt: "Alt", pause: "Pause",
+      escape: "Escape", space: "Space",  pageup: "PageUp", page_up: "PageUp",
+      pagedown: "PageDown", page_down: "PageDown", end: "End", home: "Home",
+      left: "ArrowLeft", up: "ArrowUp", right: "ArrowRight",
+      down: "ArrowDown", insert: "Insert", delete: "Delete",
+      semicolon: "Semicolon", equals: "Equal", numpad0: "Numpad0",
+      numpad1: "Numpad1", numpad2: "Numpad2", numpad3: "Numpad3",
+      numpad4: "Numpad4", numpad5: "Numpad5", numpad6: "Numpad6",
+      numpad7: "Numpad7", numpad8: "Numpad8", numpad9: "Numpad9",
+      multiply: "NumpadMultiply", add: "NumpadAdd",
+      separator: "NumpadDecimal", subtract: "NumpadSubtract",
+      decimal: "NumpadDecimal", divide: "NumpadDivide", f1: "F1", f2: "F2",
+      f3: "F3", f4: "F4", f5: "F5", f6: "F6", f7: "F7", f8: "F8", f9: "F9",
+      f10: "F10", f11: "F11", f12: "F12", meta: "Meta", command: "Meta",
+    }
+
+    def initialize(page)
+      @page = page
+    end
+
+    def down(key)
+      key = normalize_keys(Array(key))
+      type = key[:text] ? "keyDown" : "rawKeyDown"
+      @page.command("Input.dispatchKeyEvent", type: type, **key)
+      self
+    end
+
+    def up(key)
+      key = normalize_keys(Array(key))
+      @page.command("Input.dispatchKeyEvent", type: "keyUp", **key)
+      self
+    end
+
+    def type(*keys)
+      keys = normalize_keys(Array(keys))
+
+      keys.each do |key|
+        type = key[:text] ? "keyDown" : "rawKeyDown"
+        @page.command("Input.dispatchKeyEvent", type: type, **key)
+        @page.command("Input.dispatchKeyEvent", type: "keyUp", **key)
+      end
+
+      self
+    end
+
+    def modifiers(keys)
+      keys.map { |k| MODIFIERS[k.to_s] }.compact.reduce(0, :|)
+    end
+
+    private
+
+    def normalize_keys(keys, pressed_keys = [], memo = [])
+      case keys
+      when Array
+        pressed_keys.push([])
+        memo += combine_strings(keys).map do |key|
+          normalize_keys(key, pressed_keys, memo)
+        end
+        pressed_keys.pop
+        memo.flatten.compact
+      when Symbol
+        key = keys.to_s.downcase
+
+        if MODIFIERS.keys.include?(key)
+          pressed_keys.last.push(key)
+          nil
+        else
+          _key = KEYS.fetch(KEYS_MAPPING[key.to_sym] || key.to_sym)
+          _key[:modifiers] = pressed_keys.flatten.map { |k| MODIFIERS[k] }.reduce(0, :|)
+          to_options(_key)
+        end
+      when String
+        pressed = pressed_keys.flatten
+        keys.each_char.map do |char|
+          if pressed.empty?
+            key = KEYS[char] || {}
+            key = key.merge(text: char, unmodifiedText: char)
+            [to_options(key)]
+          else
+            key = KEYS[char] || {}
+            text = pressed == ["shift"] ? char.upcase : char
+            key = key.merge(
+              text: text,
+              unmodifiedText: text,
+              isKeypad: key["location"] == 3,
+              modifiers: pressed.map { |k| MODIFIERS[k] }.reduce(0, :|),
+            )
+
+            modifiers = pressed.map { |k| to_options(KEYS.fetch(KEYS_MAPPING[k.to_sym])) }
+            modifiers + [to_options(key)]
+          end.flatten
+        end
+      end
+    end
+
+    def combine_strings(keys)
+      keys
+        .chunk { |k| k.is_a?(String) }
+        .map { |s, k| s ? [k.reduce(&:+)] : k }
+        .reduce(&:+)
+    end
+
+    def to_options(hash)
+      hash.inject({}) { |memo, (k, v)| memo.merge(k.to_sym => v) }
+    end
+  end
+end