ferrum 0.10.1 → 0.12

data/lib/ferrum/errors.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Error               < StandardError; end
+  class NoSuchPageError     < Error; end
+  class NoSuchTargetError   < Error; end
+  class NotImplementedError < Error; end
+  class BinaryNotFoundError < Error; end
+  class EmptyPathError < Error; end
+
+  class StatusError < Error
+    def initialize(url, message = nil)
+      super(message || "Request to #{url} failed to reach server, check DNS and server status")
+    end
+  end
+
+  class PendingConnectionsError < StatusError
+    attr_reader :pendings
+
+    def initialize(url, pendings = [])
+      @pendings = pendings
+
+      message = "Request to #{url} reached server, but there are still pending connections: #{pendings.join(', ')}"
+
+      super(url, message)
+    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 ProcessTimeoutError < Error
+    attr_reader :output
+
+    def initialize(timeout, output)
+      @output = output
+      super("Browser did not produce websocket url within #{timeout} seconds, try to increase `:process_timeout`. See https://github.com/rubycdp/ferrum#customization")
+    end
+  end
+
+  class DeadBrowserError < Error
+    def initialize(message = "Browser is dead or given window is closed")
+      super
+    end
+  end
+
+  class NodeMovingError < Error
+    def initialize(node, prev, current)
+      @node = node
+      @prev = prev
+      @current = current
+      super(message)
+    end
+
+    def message
+      "#{@node.inspect} that you're trying to click is moving, hence " \
+        "we cannot. Previously it was at #{@prev.inspect} but now at " \
+        "#{@current.inspect}."
+    end
+  end
+
+  class CoordinatesNotFoundError < Error
+    def initialize(message = "Could not compute content quads")
+      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, :stack_trace
+
+    def initialize(response, stack_trace = nil)
+      @class_name, @message = response.values_at("className", "description")
+      @stack_trace = stack_trace
+      super(response.merge("message" => @message))
+    end
+  end
+end

data/lib/ferrum/frame/runtime.rb

@@ -46,7 +46,7 @@ module Ferrum
       JS
 
       def evaluate(expression, *args)
-        expression = "function() { return %s }" % expression
+        expression = format("function() { return %s }", expression)
         call(expression: expression, arguments: args)
       end
 
@@ -66,12 +66,12 @@ module Ferrum
           }
         JS
 
-        expression = template % [wait * 1000, expression]
+        expression = format(template, wait * 1000, expression)
         call(expression: expression, arguments: args, awaitPromise: true)
       end
 
       def execute(expression, *args)
-        expression = "function() { %s }" % expression
+        expression = format("function() { %s }", expression)
         call(expression: expression, arguments: args, handle: false, returnByValue: true)
         true
       end
@@ -82,7 +82,7 @@ module Ferrum
 
       def evaluate_on(node:, expression:, by_value: true, wait: 0)
         options = { handle: true }
-        expression = "function() { return %s }" % expression
+        expression = format("function() { return %s }", expression)
         options = { handle: false, returnByValue: true } if by_value
         call(expression: expression, on: node, wait: wait, **options)
       end
@@ -119,9 +119,10 @@ module Ferrum
 
       def call(expression:, arguments: [], on: nil, wait: 0, handle: true, **options)
         errors = [NodeNotFoundError, NoExecutionContextError]
-        attempts, sleep = INTERMITTENT_ATTEMPTS, INTERMITTENT_SLEEP
+        sleep = INTERMITTENT_SLEEP
+        attempts = INTERMITTENT_ATTEMPTS
 
-        Ferrum.with_attempts(errors: errors, max: attempts, wait: sleep) do
+        Utils::Attempt.with_retry(errors: errors, max: attempts, wait: sleep) do
           params = options.dup
 
           if on
@@ -141,7 +142,7 @@ module Ferrum
           handle_error(response)
           response = response["result"]
 
-          handle ? handle_response(response) : response.dig("value")
+          handle ? handle_response(response) : response["value"]
         end
       end
 
@@ -154,7 +155,7 @@ module Ferrum
         when /\AError: timed out promise/
           raise ScriptTimeoutError
         else
-          raise JavaScriptError.new(result)
+          raise JavaScriptError.new(result, response.dig("exceptionDetails", "stackTrace"))
         end
       end
 
@@ -171,16 +172,17 @@ module Ferrum
 
           case response["subtype"]
           when "node"
-              # We cannot store object_id in the node because page can be reloaded
-              # and node destroyed so we need to retrieve it each time for given id.
-              # Though we can try to subscribe to `DOM.childNodeRemoved` and
-              # `DOM.childNodeInserted` in the future.
-              node_id = @page.command("DOM.requestNode", objectId: object_id)["nodeId"]
-              description = @page.command("DOM.describeNode", nodeId: node_id)["node"]
-              Node.new(self, @page.target_id, node_id, description)
+            # We cannot store object_id in the node because page can be reloaded
+            # and node destroyed so we need to retrieve it each time for given id.
+            # Though we can try to subscribe to `DOM.childNodeRemoved` and
+            # `DOM.childNodeInserted` in the future.
+            node_id = @page.command("DOM.requestNode", objectId: object_id)["nodeId"]
+            description = @page.command("DOM.describeNode", nodeId: node_id)["node"]
+            Node.new(self, @page.target_id, node_id, description)
           when "array"
             reduce_props(object_id, []) do |memo, key, value|
-              next(memo) unless (Integer(key) rescue nil)
+              next(memo) unless Integer(key, exception: false)
+
               value = value["objectId"] ? handle_response(value) : value["value"]
               memo.insert(key.to_i, value)
             end.compact
@@ -212,11 +214,12 @@ module Ferrum
 
       def reduce_props(object_id, to)
         if cyclic?(object_id).dig("result", "value")
-          return to.is_a?(Array) ? [cyclic_object] : cyclic_object
+          to.is_a?(Array) ? [cyclic_object] : cyclic_object
         else
           props = @page.command("Runtime.getProperties", ownProperties: true, objectId: object_id)
           props["result"].reduce(to) do |memo, prop|
             next(memo) unless prop["enumerable"]
+
             yield(memo, prop["name"], prop["value"])
           end
         end

data/lib/ferrum/frame.rb

@@ -5,21 +5,28 @@ require "ferrum/frame/runtime"
 
 module Ferrum
   class Frame
-    include DOM, Runtime
+    include DOM
+    include Runtime
+
+    STATE_VALUES = %i[
+      started_loading
+      navigated
+      stopped_loading
+    ].freeze
 
-    attr_reader :page, :parent_id, :state
     attr_accessor :id, :name
+    attr_reader :page, :parent_id, :state
 
     def initialize(id, page, parent_id = nil)
-      @execution_id = nil
-      @id, @page, @parent_id = id, page, parent_id
+      @id = id
+      @page = page
+      @parent_id = parent_id
+      @execution_id = Concurrent::MVar.new
     end
 
-    # Can be one of:
-    # * started_loading
-    # * navigated
-    # * stopped_loading
     def state=(value)
+      raise ArgumentError unless STATE_VALUES.include?(value)
+
       @state = value
     end
 
@@ -35,7 +42,7 @@ module Ferrum
       @parent_id.nil?
     end
 
-    def set_content(html)
+    def content=(html)
       evaluate_async(%(
         document.open();
         document.write(arguments[0]);
@@ -43,29 +50,30 @@ module Ferrum
         arguments[1](true);
       ), @page.timeout, html)
     end
-
-    def execution_id?(execution_id)
-      @execution_id == execution_id
-    end
+    alias set_content content=
 
     def execution_id
-      raise NoExecutionContextError unless @execution_id
-      @execution_id
-    rescue NoExecutionContextError
-      @page.event.reset
-      @page.event.wait(@page.timeout) ? retry : raise
-    end
+      value = @execution_id.borrow(@page.timeout, &:itself)
+      raise NoExecutionContextError if value.instance_of?(Object)
 
-    def set_execution_id(value)
-      @execution_id ||= value
+      value
     end
 
-    def reset_execution_id
-      @execution_id = nil
+    def execution_id=(value)
+      if value.nil?
+        @execution_id.try_take!
+      else
+        @execution_id.try_put!(value)
+      end
     end
 
     def inspect
-      %(#<#{self.class} @id=#{@id.inspect} @parent_id=#{@parent_id.inspect} @name=#{@name.inspect} @state=#{@state.inspect} @execution_id=#{@execution_id.inspect}>)
+      "#<#{self.class} " \
+        "@id=#{@id.inspect} " \
+        "@parent_id=#{@parent_id.inspect} " \
+        "@name=#{@name.inspect} " \
+        "@state=#{@state.inspect} " \
+        "@execution_id=#{@execution_id.inspect}>"
     end
   end
 end

data/lib/ferrum/headers.rb

@@ -39,12 +39,12 @@ module Ferrum
     private
 
     def set_overrides(user_agent: nil, accept_language: nil, platform: nil)
-      options = Hash.new
+      options = {}
       options[:userAgent] = user_agent || @page.browser.default_user_agent
       options[:acceptLanguage] = accept_language if accept_language
       options[:platform] if platform
 
-      @page.command("Network.setUserAgentOverride", **options) if !options.empty?
+      @page.command("Network.setUserAgentOverride", **options) unless options.empty?
     end
   end
 end

data/lib/ferrum/keyboard.rb

@@ -4,14 +4,14 @@ require "json"
 
 module Ferrum
   class Keyboard
-    KEYS = JSON.parse(File.read(File.expand_path("../keyboard.json", __FILE__)))
+    KEYS = JSON.parse(File.read(File.expand_path("keyboard.json", __dir__)))
     MODIFIERS = { "alt" => 1, "ctrl" => 2, "control" => 2,
-                  "meta" => 4, "command" => 4, "shift" => 8 }
+                  "meta" => 4, "command" => 4, "shift" => 8 }.freeze
     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",
+      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",
@@ -23,8 +23,8 @@ module Ferrum
       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",
-    }
+      f10: "F10", f11: "F11", f12: "F12", meta: "Meta", command: "Meta"
+    }.freeze
 
     def initialize(page)
       @page = page
@@ -77,25 +77,25 @@ module Ferrum
           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)
+          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|
+          key = KEYS[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| MODIFIERS[k] }.reduce(0, :|)
             )
 
             modifiers = pressed.map { |k| to_options(KEYS.fetch(KEYS_MAPPING[k.to_sym])) }

data/lib/ferrum/mouse.rb

@@ -33,12 +33,14 @@ module Ferrum
     end
 
     def move(x:, y:, steps: 1)
-      from_x, from_y = @x, @y
-      @x, @y = x, y
+      from_x = @x
+      from_y = @y
+      @x = x
+      @y = y
 
       steps.times do |i|
-        new_x = from_x + (@x - from_x) * ((i + 1) / steps.to_f)
-        new_y = from_y + (@y - from_y) * ((i + 1) / steps.to_f)
+        new_x = from_x + ((@x - from_x) * ((i + 1) / steps.to_f))
+        new_y = from_y + ((@y - from_y) * ((i + 1) / steps.to_f))
 
         @page.command("Input.dispatchMouseEvent",
                       slowmoable: true,
@@ -61,9 +63,8 @@ module Ferrum
 
     def validate_button(button)
       button = button.to_s
-      unless VALID_BUTTONS.include?(button)
-        raise "Invalid button: #{button}"
-      end
+      raise "Invalid button: #{button}" unless VALID_BUTTONS.include?(button)
+
       button
     end
   end

data/lib/ferrum/network/auth_request.rb

@@ -6,7 +6,8 @@ module Ferrum
       attr_accessor :request_id, :frame_id, :resource_type
 
       def initialize(page, params)
-        @page, @params = page, params
+        @page = page
+        @params = params
         @request_id = params["requestId"]
         @frame_id = params["frameId"]
         @resource_type = params["resourceType"]
@@ -55,7 +56,11 @@ module Ferrum
       end
 
       def inspect
-        %(#<#{self.class} @request_id=#{@request_id.inspect} @frame_id=#{@frame_id.inspect} @resource_type=#{@resource_type.inspect} @request=#{@request.inspect}>)
+        "#<#{self.class} " \
+          "@request_id=#{@request_id.inspect} " \
+          "@frame_id=#{@frame_id.inspect} " \
+          "@resource_type=#{@resource_type.inspect} " \
+          "@request=#{@request.inspect}>"
       end
     end
   end

data/lib/ferrum/network/exchange.rb

@@ -4,11 +4,11 @@ module Ferrum
   class Network
     class Exchange
       attr_reader :id
-      attr_accessor :intercepted_request
-      attr_accessor :request, :response, :error
+      attr_accessor :intercepted_request, :request, :response, :error
 
       def initialize(page, id)
-        @page, @id = page, id
+        @id = id
+        @page = page
         @intercepted_request = nil
         @request = @response = @error = nil
       end
@@ -23,7 +23,7 @@ module Ferrum
       end
 
       def blocked?
-        intercepted_request && intercepted_request.status?(:aborted)
+        intercepted? && intercepted_request.status?(:aborted)
       end
 
       def finished?
@@ -34,17 +34,21 @@ module Ferrum
         !finished?
       end
 
+      def intercepted?
+        intercepted_request
+      end
+
       def to_a
         [request, response, error]
       end
 
       def inspect
-        "#<#{self.class} "\
-        "@id=#{@id.inspect} "\
-        "@intercepted_request=#{@intercepted_request.inspect} "\
-        "@request=#{@request.inspect} "\
-        "@response=#{@response.inspect} "\
-        "@error=#{@error.inspect}>"
+        "#<#{self.class} " \
+          "@id=#{@id.inspect} " \
+          "@intercepted_request=#{@intercepted_request.inspect} " \
+          "@request=#{@request.inspect} " \
+          "@response=#{@response.inspect} " \
+          "@error=#{@error.inspect}>"
       end
     end
   end

data/lib/ferrum/network/intercepted_request.rb

@@ -9,7 +9,8 @@ module Ferrum
 
       def initialize(page, params)
         @status = nil
-        @page, @params = page, params
+        @page = page
+        @params = params
         @request_id = params["requestId"]
         @frame_id = params["frameId"]
         @resource_type = params["resourceType"]
@@ -30,15 +31,12 @@ module Ferrum
       end
 
       def respond(**options)
-        has_body = options.has_key?(:body)
+        has_body = options.key?(:body)
         headers = has_body ? { "content-length" => options.fetch(:body, "").length } : {}
         headers = headers.merge(options.fetch(:responseHeaders, {}))
 
-        options = {responseCode: 200}.merge(options)
-        options = options.merge({
-          requestId: request_id,
-          responseHeaders: header_array(headers),
-        })
+        options = { responseCode: 200 }.merge(options)
+        options = options.merge(requestId: request_id, responseHeaders: header_array(headers))
         options = options.merge(body: Base64.strict_encode64(options.fetch(:body, ""))) if has_body
 
         @status = :responded
@@ -77,7 +75,11 @@ module Ferrum
       end
 
       def inspect
-        %(#<#{self.class} @request_id=#{@request_id.inspect} @frame_id=#{@frame_id.inspect} @resource_type=#{@resource_type.inspect} @request=#{@request.inspect}>)
+        "#<#{self.class} " \
+          "@request_id=#{@request_id.inspect} " \
+          "@frame_id=#{@frame_id.inspect} " \
+          "@resource_type=#{@resource_type.inspect} " \
+          "@request=#{@request.inspect}>"
       end
 
       private

data/lib/ferrum/network/request.rb

@@ -45,6 +45,11 @@ module Ferrum
       def time
         @time ||= Time.strptime(@params["wallTime"].to_s, "%s")
       end
+
+      def post_data
+        @request["postData"]
+      end
+      alias body post_data
     end
   end
 end

data/lib/ferrum/network/response.rb

@@ -3,7 +3,7 @@
 module Ferrum
   class Network
     class Response
-      attr_reader :body_size
+      attr_reader :body_size, :params
 
       def initialize(page, params)
         @page = page
@@ -34,7 +34,7 @@ module Ferrum
       def headers_size
         @response["encodedDataLength"]
       end
-      
+
       def type
         @params["type"]
       end
@@ -55,8 +55,8 @@ module Ferrum
       def body
         @body ||= begin
           body, encoded = @page
-                            .command("Network.getResponseBody", requestId: id)
-                            .values_at("body", "base64Encoded")
+                          .command("Network.getResponseBody", requestId: id)
+                          .values_at("body", "base64Encoded")
           encoded ? Base64.decode64(body) : body
         end
       end