ferrum 0.1.0

data/lib/ferrum/page/input.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ferrum
+  class Page
+    module Input
+      KEYS = JSON.parse(File.read(File.expand_path("../input.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 click(node, keys = [], offset = {})
+        x, y, modifiers = prepare_before_click(__method__, node, keys, offset)
+        command("Input.dispatchMouseEvent", type: "mousePressed", modifiers: modifiers, button: "left", x: x, y: y, clickCount: 1)
+        # Potential wait because if network event is triggered then we have to wait until it's over.
+        command("Input.dispatchMouseEvent", timeout: 0.05, type: "mouseReleased", modifiers: modifiers, button: "left", x: x, y: y, clickCount: 1)
+      end
+
+      def right_click(node, keys = [], offset = {})
+        x, y, modifiers = prepare_before_click(__method__, node, keys, offset)
+        command("Input.dispatchMouseEvent", type: "mousePressed", modifiers: modifiers, button: "right", x: x, y: y, clickCount: 1)
+        command("Input.dispatchMouseEvent", type: "mouseReleased", modifiers: modifiers, button: "right", x: x, y: y, clickCount: 1)
+      end
+
+      def double_click(node, keys = [], offset = {})
+        x, y, modifiers = prepare_before_click(__method__, node, keys, offset)
+        command("Input.dispatchMouseEvent", type: "mousePressed", modifiers: modifiers, button: "left", x: x, y: y, clickCount: 2)
+        command("Input.dispatchMouseEvent", type: "mouseReleased", modifiers: modifiers, button: "left", x: x, y: y, clickCount: 2)
+      end
+
+      def click_coordinates(x, y)
+        command("Input.dispatchMouseEvent", type: "mousePressed", button: "left", x: x, y: y, clickCount: 1)
+        # Potential wait because if network event is triggered then we have to wait until it's over.
+        command("Input.dispatchMouseEvent", timeout: 0.05, type: "mouseReleased", button: "left", x: x, y: y, clickCount: 1)
+      end
+
+      def focus(node)
+        command("DOM.focus", nodeId: node.node_id)
+      end
+
+      def hover(node)
+        raise NotImplemented
+      end
+
+      def set(node, value)
+        raise NotImplemented
+      end
+
+      def select(node, value)
+        raise NotImplemented
+      end
+
+      def trigger(node, event)
+        raise NotImplemented
+      end
+
+      def scroll_to(top, left)
+        execute("window.scrollTo(#{top}, #{left})")
+      end
+
+      def send_keys(node, keys)
+        # click(node)
+        # focus(node)
+
+        keys = normalize_keys(Array(keys))
+
+        keys.each do |key|
+          type = key[:text] ? "keyDown" : "rawKeyDown"
+          command("Input.dispatchKeyEvent", type: type, **key)
+          command("Input.dispatchKeyEvent", type: "keyUp", **key)
+        end
+      end
+
+      def normalize_keys(keys, pressed_keys = [], memo = [])
+        case keys
+        when Array
+          pressed_keys.push([])
+          memo += combine_strings(keys).map { |k| normalize_keys(k, pressed_keys, memo) }
+          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
+
+      private
+
+      def prepare_before_click(name, node, keys, offset)
+        # FIXME: scrollIntoViewport
+        # evaluate_on(node: node, expression: "this.scrollIntoView({block: 'center', inline: 'center', behavior: 'instant'})")
+
+        x, y = calculate_quads(node, offset[:x], offset[:y])
+
+        modifiers = keys.map { |k| MODIFIERS[k.to_s] }.compact.reduce(0, :|)
+
+        command("Input.dispatchMouseEvent", type: "mouseMoved", x: x, y: y)
+
+        [x, y, modifiers]
+      end
+
+      def calculate_quads(node, offset_x = nil, offset_y = nil)
+        quads = get_content_quads(node)
+        offset_x, offset_y = offset_x.to_i, offset_y.to_i
+
+        if offset_x > 0 || offset_y > 0
+          point = quads.first
+          [point[:x] + offset_x, point[:y] + offset_y]
+        else
+          x, y = quads.inject([0, 0]) do |memo, point|
+            [memo[0] + point[:x],
+             memo[1] + point[:y]]
+          end
+          [x / 4, y / 4]
+        end
+      end
+
+      def get_content_quads(node)
+        result = command("DOM.getContentQuads", nodeId: node.node_id)
+        raise "Node is either not visible or not an HTMLElement" if result["quads"].size == 0
+
+        # FIXME: Case when a few quads returned
+        result["quads"].map do |quad|
+          [{x: quad[0], y: quad[1]},
+           {x: quad[2], y: quad[3]},
+           {x: quad[4], y: quad[5]},
+           {x: quad[6], y: quad[7]}]
+        end.first
+      end
+
+      def to_options(hash)
+        hash.inject({}) { |memo, (k, v)| memo.merge(k.to_sym => v) }
+      end
+    end
+  end
+end

data/lib/ferrum/page/net.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Page
+    module Net
+      def proxy_authorize(user, password)
+        if user && password
+          @proxy_username, @proxy_password = user, password
+          intercept_request("*")
+        end
+      end
+
+      def authorize(user, password)
+        @username, @password = user, password
+        intercept_request("*")
+      end
+
+      def intercept_request(patterns)
+        patterns = Array(patterns).map { |p| { urlPattern: p } }
+        @client.command("Network.setRequestInterception", patterns: patterns)
+      end
+
+      def continue_request(interception_id, options = nil)
+        options ||= {}
+        options = options.merge(interceptionId: interception_id)
+        @client.command("Network.continueInterceptedRequest", **options)
+      end
+
+      private
+
+      def subscribe
+        super if defined?(super)
+
+        @client.on("Network.loadingFailed") do |params|
+          # Free mutex as we aborted main request we are waiting for
+          if params["requestId"] == @request_id && params["canceled"] == true
+            @event.set
+            @document_id = get_document_id
+          end
+        end
+
+        @client.on("Network.requestIntercepted") do |params|
+          @authorized_ids ||= []
+          @proxy_authorized_ids ||= []
+          url = params.dig("request", "url")
+          interception_id = params["interceptionId"]
+
+          if params["authChallenge"]
+            response = if params.dig("authChallenge", "source") == "Proxy"
+              if @proxy_authorized_ids.include?(interception_id)
+                { response: "CancelAuth" }
+              elsif @proxy_username && @proxy_password
+                { response: "ProvideCredentials",
+                  username: @proxy_username,
+                  password: @proxy_password }
+              else
+                { response: "CancelAuth" }
+              end
+            else
+              if @authorized_ids.include?(interception_id)
+                { response: "CancelAuth" }
+              elsif @username && @password
+                { response: "ProvideCredentials",
+                  username: @username,
+                  password: @password }
+              else
+                { response: "CancelAuth" }
+              end
+            end
+
+            @authorized_ids << interception_id
+            continue_request(interception_id, authChallengeResponse: response)
+          elsif @browser.url_blacklist && !@browser.url_blacklist.empty?
+            if @browser.url_blacklist.any? { |r| r.match(url) }
+              continue_request(interception_id, errorReason: "Aborted")
+            else
+              continue_request(interception_id)
+            end
+          elsif @browser.url_whitelist && !@browser.url_whitelist.empty?
+            if @browser.url_whitelist.any? { |r| r.match(url) }
+              continue_request(interception_id)
+            else
+              continue_request(interception_id, errorReason: "Aborted")
+            end
+          else
+            continue_request(interception_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ferrum/page/runtime.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Page
+    module Runtime
+      EXECUTE_OPTIONS = {
+        returnByValue: true,
+        functionDeclaration: %Q(function() { %s })
+      }.freeze
+      DEFAULT_OPTIONS = {
+        functionDeclaration: %Q(function() { return %s })
+      }.freeze
+      EVALUATE_ASYNC_OPTIONS = {
+        awaitPromise: true,
+        functionDeclaration: %Q(
+          function() {
+           return new Promise((__resolve, __reject) => {
+             try {
+               arguments[arguments.length] = r => __resolve(r);
+               arguments.length = arguments.length + 1;
+               setTimeout(() => __reject(new Error("timed out promise")), %s);
+               %s
+             } catch(error) {
+               __reject(error);
+             }
+           });
+          }
+        )
+      }.freeze
+
+      def evaluate(expression, *args)
+        response = call(expression, nil, nil, *args)
+        handle(response)
+      end
+
+      def evaluate_in(context_id, expression)
+        response = call(expression, nil, { executionContextId: context_id })
+        handle(response)
+      end
+
+      def evaluate_on(node:, expression:, by_value: true, timeout: 0)
+        object_id = command("DOM.resolveNode", nodeId: node.node_id).dig("object", "objectId")
+        options = DEFAULT_OPTIONS.merge(objectId: object_id)
+        options[:functionDeclaration] = options[:functionDeclaration] % expression
+        options.merge!(returnByValue: by_value)
+
+        response = command("Runtime.callFunctionOn", timeout: timeout, **options)
+          .dig("result").tap { |r| handle_error(r) }
+
+        by_value ? response.dig("value") : handle(response)
+      end
+
+      def evaluate_async(expression, wait_time, *args)
+        response = call(expression, wait_time * 1000, EVALUATE_ASYNC_OPTIONS, *args)
+        handle(response)
+      end
+
+      def execute(expression, *args)
+        call(expression, nil, EXECUTE_OPTIONS, *args)
+        true
+      end
+
+      private
+
+      def call(expression, wait_time, options = nil, *args)
+        options ||= {}
+        args = prepare_args(args)
+
+        options = DEFAULT_OPTIONS.merge(options)
+        expression = [wait_time, expression] if wait_time
+        options[:functionDeclaration] = options[:functionDeclaration] % expression
+        options = options.merge(arguments: args)
+        unless options[:executionContextId]
+          options = options.merge(executionContextId: execution_context_id)
+        end
+
+        begin
+          attempts ||= 1
+          response = command("Runtime.callFunctionOn", **options)
+          response.dig("result").tap { |r| handle_error(r) }
+        rescue BrowserError => e
+          case e.message
+          when "No node with given id found",
+               "Could not find node with given id",
+               "Cannot find context with specified id"
+            sleep 0.1
+            attempts += 1
+            options = options.merge(executionContextId: execution_context_id)
+            retry if attempts <= 3
+          end
+        end
+      end
+
+      # FIXME: We should have a central place to handle all type of errors
+      def handle_error(result)
+        return if result["subtype"] != "error"
+
+        case result["description"]
+        when /\AError: timed out promise/
+          raise ScriptTimeoutError
+        else
+          raise JavaScriptError.new(result)
+        end
+      end
+
+      def prepare_args(args)
+        args.map do |arg|
+          if arg.is_a?(Node)
+            resolved = command("DOM.resolveNode", nodeId: arg.node_id)
+            { objectId: resolved["object"]["objectId"] }
+          elsif arg.is_a?(Hash) && arg["objectId"]
+            { objectId: arg["objectId"] }
+          else
+            { value: arg }
+          end
+        end
+      end
+
+      def handle(response)
+        case response["type"]
+        when "boolean", "number", "string"
+          response["value"]
+        when "undefined"
+          nil
+        when "function"
+          {}
+        when "object"
+          object_id = response["objectId"]
+
+          case response["subtype"]
+          when "node"
+            begin
+              node_id = command("DOM.requestNode", objectId: object_id)["nodeId"]
+              desc = command("DOM.describeNode", nodeId: node_id)["node"]
+              Node.new(self, target_id, node_id, desc)
+            rescue BrowserError => e
+              # Node has disappeared while we were trying to get it
+              raise if e.message != "Could not find node with given id"
+            end
+          when "array"
+            reduce_props(object_id, []) do |memo, key, value|
+              next(memo) unless (Integer(key) rescue nil)
+              value = value["objectId"] ? handle(value) : value["value"]
+              memo.insert(key.to_i, value)
+            end.compact
+          when "date"
+            response["description"]
+          when "null"
+            nil
+          else
+            reduce_props(object_id, {}) do |memo, key, value|
+              value = value["objectId"] ? handle(value) : value["value"]
+              memo.merge(key => value)
+            end
+          end
+        end
+      end
+
+      def reduce_props(object_id, to)
+        if cyclic?(object_id).dig("result", "value")
+          return "(cyclic structure)"
+        else
+          props = command("Runtime.getProperties", objectId: object_id)
+          props["result"].reduce(to) do |memo, prop|
+            next(memo) unless prop["enumerable"]
+            yield(memo, prop["name"], prop["value"])
+          end
+        end
+      end
+
+      def cyclic?(object_id)
+        command("Runtime.callFunctionOn",
+                objectId: object_id,
+                returnByValue: true,
+                functionDeclaration: <<~JS
+                  function() {
+                    if (Array.isArray(this) &&
+                        this.every(e => e instanceof Node)) {
+                      return false;
+                    }
+
+                    try {
+                      JSON.stringify(this);
+                      return false;
+                    } catch (e) {
+                      return true;
+                    }
+                  }
+                JS
+               )
+      end
+    end
+  end
+end