ferrum 0.1.2 → 0.2

data/lib/ferrum/page/dom.rb

@@ -15,20 +15,32 @@ module Ferrum
         evaluate("document.documentElement.outerHTML")
       end
 
-      def property(node, name)
-        evaluate_on(node: node, expression: %Q(this["#{name}"]))
-      end
-
-      def select_file(node, value)
-        command("DOM.setFileInputFiles", nodeId: node.node_id, files: Array(value))
-      end
-
       def at_xpath(selector, within: nil)
-        raise NotImplemented
+        xpath(selector, within: within).first
       end
 
+      # FIXME: Check within
       def xpath(selector, within: nil)
-        raise NotImplemented
+        evaluate_async(%(
+          try {
+            let selector = arguments[0];
+            let within = arguments[1] || document;
+            let results = [];
+
+            let xpath = document.evaluate(selector, within, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            for (let i = 0; i < xpath.snapshotLength; i++) {
+              results.push(xpath.snapshotItem(i));
+            }
+
+            arguments[2](results);
+          } catch (error) {
+            // DOMException.INVALID_EXPRESSION_ERR is undefined, using pure code
+            if (error.code == DOMException.SYNTAX_ERR || error.code == 51) {
+              throw "Invalid Selector";
+            } else {
+              throw error;
+            }
+          }), timeout, selector, within)
       end
 
       def css(selector, within: nil)
@@ -54,8 +66,6 @@ module Ferrum
       def build_node(node_id)
         description = command("DOM.describeNode", nodeId: node_id)
         Node.new(self, target_id, node_id, description["node"])
-      rescue BrowserError => e
-        node_id.zero? ? raise(NodeError.new(nil, e.response)) : raise
       end
     end
   end

data/lib/ferrum/page/frame.rb

@@ -5,9 +5,9 @@ module Ferrum
     module Frame
       def execution_context_id
         context_id = current_execution_context_id
-        raise NoExecutionContext unless context_id
+        raise NoExecutionContextError unless context_id
         context_id
-      rescue NoExecutionContext
+      rescue NoExecutionContextError
         @event.reset
         @event.wait(timeout) ? retry : raise
       end
@@ -24,16 +24,17 @@ module Ferrum
         evaluate("document.title")
       end
 
-      def switch_to_frame(handle)
-        case handle
-        when :parent
-          @frame_stack.pop
-        when :top
-          @frame_stack = []
-        else
-          @frame_stack << handle
-          inject_extensions
+      def within_frame(frame)
+        unless frame.is_a?(Node)
+          raise ArgumentError, "Node is expected, but #{frame.class} is given"
         end
+
+        frame_id = frame.description["frameId"]
+        @frame_stack << frame_id
+        inject_extensions
+        yield
+      ensure
+        @frame_stack.pop
       end
 
       private
@@ -53,7 +54,7 @@ module Ferrum
         @client.on("Page.frameNavigated") do |params|
           id = params["frame"]["id"]
           if frame = @frames[id]
-            frame.merge!(params["frame"].select { |k, v| k == "name" || k == "url" })
+            frame.merge!(params["frame"].select { |k, _| k == "name" || k == "url" })
           end
         end
 

data/lib/ferrum/page/input.rb

@@ -5,154 +5,11 @@ 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)
+      def find_position(node, offset_x = nil, offset_y = nil)
         quads = get_content_quads(node)
         offset_x, offset_y = offset_x.to_i, offset_y.to_i
 
@@ -168,6 +25,8 @@ module Ferrum
         end
       end
 
+      private
+
       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
@@ -180,10 +39,6 @@ module Ferrum
            {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

@@ -3,27 +3,75 @@
 module Ferrum
   class Page
     module Net
+      RESOURCE_TYPES = %w[Document Stylesheet Image Media Font Script TextTrack
+                          XHR Fetch EventSource WebSocket Manifest
+                          SignedExchange Ping CSPViolationReport Other]
+
       def proxy_authorize(user, password)
+        @proxy_authorized_ids ||= []
+
         if user && password
-          @proxy_username, @proxy_password = user, password
-          intercept_request("*")
+          intercept_request do |request, index, total|
+            if request.auth_challenge?(:proxy)
+              response = authorized_response(@proxy_authorized_ids,
+                                             request.interception_id,
+                                             user, password)
+              @proxy_authorized_ids << request.interception_id
+              request.continue(authChallengeResponse: response)
+            elsif index + 1 < total
+              next # There are other callbacks that can handle this, skip
+            else
+              request.continue
+            end
+          end
         end
       end
 
       def authorize(user, password)
-        @username, @password = user, password
-        intercept_request("*")
+        @authorized_ids ||= []
+
+        intercept_request do |request, index, total|
+          if request.auth_challenge?(:server)
+            response = authorized_response(@authorized_ids,
+                                           request.interception_id,
+                                           user, password)
+
+            @authorized_ids << request.interception_id
+            request.continue(authChallengeResponse: response)
+          elsif index + 1 < total
+            next # There are other callbacks that can handle this, skip
+          else
+            request.continue
+          end
+        end
+      end
+
+      def intercept_request(pattern: "*", resource_type: nil, &block)
+        pattern = { urlPattern: pattern }
+        if resource_type && RESOURCE_TYPES.include?(resource_type.to_s)
+          pattern[:resourceType] = resource_type
+        end
+
+        command("Network.setRequestInterception", patterns: [pattern])
+
+        on_request_intercepted(&block) if block_given?
       end
 
-      def intercept_request(patterns)
-        patterns = Array(patterns).map { |p| { urlPattern: p } }
-        @client.command("Network.setRequestInterception", patterns: patterns)
+      def on_request_intercepted(&block)
+        @client.on("Network.requestIntercepted") do |params, index, total|
+          request = Network::InterceptedRequest.new(self, params)
+          block.call(request, index, total)
+        end
       end
 
       def continue_request(interception_id, options = nil)
         options ||= {}
         options = options.merge(interceptionId: interception_id)
-        @client.command("Network.continueInterceptedRequest", **options)
+        command("Network.continueInterceptedRequest", **options)
+      end
+
+      def abort_request(interception_id)
+        continue_request(interception_id, errorReason: "Aborted")
       end
 
       private
@@ -38,53 +86,17 @@ module Ferrum
             @document_id = get_document_id
           end
         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
+      def authorized_response(ids, interception_id, username, password)
+        if ids.include?(interception_id)
+          { response: "CancelAuth" }
+        elsif username && password
+          { response: "ProvideCredentials",
+            username: username,
+            password: password }
+        else
+          { response: "CancelAuth" }
         end
       end
     end

data/lib/ferrum/page/runtime.rb

@@ -5,14 +5,14 @@ module Ferrum
     module Runtime
       EXECUTE_OPTIONS = {
         returnByValue: true,
-        functionDeclaration: %Q(function() { %s })
+        functionDeclaration: %(function() { %s })
       }.freeze
       DEFAULT_OPTIONS = {
-        functionDeclaration: %Q(function() { return %s })
+        functionDeclaration: %(function() { return %s })
       }.freeze
       EVALUATE_ASYNC_OPTIONS = {
         awaitPromise: true,
-        functionDeclaration: %Q(
+        functionDeclaration: %(
           function() {
            return new Promise((__resolve, __reject) => {
              try {
@@ -42,7 +42,11 @@ module Ferrum
       end
 
       def evaluate_on(node:, expression:, by_value: true, timeout: 0)
-        rescue_intermittent_error do
+        errors = [NodeNotFoundError, NoExecutionContextError]
+        max = ENV.fetch("FERRUM_INTERMITTENT_ATTEMPTS", 6).to_i
+        wait = ENV.fetch("FERRUM_INTERMITTENT_SLEEP", 0.1).to_f
+
+        Ferrum.with_attempts(errors: errors, max: max, wait: wait) do
           response = command("DOM.resolveNode", nodeId: node.node_id)
           object_id = response.dig("object", "objectId")
           options = DEFAULT_OPTIONS.merge(objectId: object_id)
@@ -60,7 +64,11 @@ module Ferrum
       private
 
       def call(*args, expression:, wait_time: nil, handle: true, **options)
-        rescue_intermittent_error do
+        errors = [NodeNotFoundError, NoExecutionContextError]
+        max = ENV.fetch("FERRUM_INTERMITTENT_ATTEMPTS", 6).to_i
+        wait = ENV.fetch("FERRUM_INTERMITTENT_SLEEP", 0.1).to_f
+
+        Ferrum.with_attempts(errors: errors, max: max, wait: wait) do
           arguments = prepare_args(args)
           params = DEFAULT_OPTIONS.merge(options)
           expression = [wait_time, expression] if wait_time
@@ -174,20 +182,6 @@ module Ferrum
                 JS
                )
       end
-
-      def rescue_intermittent_error(max = 6)
-        attempts ||= 0
-        yield
-      rescue BrowserError => e
-        case e.message
-        when "No node with given id found",          # Node has disappeared while we were trying to get it
-             "Could not find node with given id",
-             "Cannot find context with specified id" # Context is lost, page is reloading
-          sleep 0.1
-          attempts += 1
-          attempts < max ? retry : raise
-        end
-      end
     end
   end
 end