ferrum 0.8 → 0.11

data/lib/ferrum/browser/subscriber.rb

@@ -13,7 +13,7 @@ module Ferrum
 
       def initialize
         super
-        @on = Hash.new { |h, k| h[k] = [] }
+        @on = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
       end
 
       def on(event, &block)
@@ -21,6 +21,10 @@ module Ferrum
         true
       end
 
+      def subscribed?(event)
+        @on.key?(event)
+      end
+
       def call(message)
         method, params = message.values_at("method", "params")
         total = @on[method].size

data/lib/ferrum/browser/web_socket.rb

@@ -8,6 +8,7 @@ module Ferrum
   class Browser
     class WebSocket
       WEBSOCKET_BUG_SLEEP = 0.01
+      SKIP_LOGGING_SCREENSHOTS = !ENV["FERRUM_LOGGING_SCREENSHOTS"]
 
       attr_reader :url, :messages
 
@@ -20,6 +21,10 @@ module Ferrum
         @driver   = ::WebSocket::Driver.client(self, max_length: max_receive_size)
         @messages = Queue.new
 
+        if SKIP_LOGGING_SCREENSHOTS
+          @screenshot_commands = Concurrent::Hash.new
+        end
+
         @driver.on(:open,    &method(:on_open))
         @driver.on(:message, &method(:on_message))
         @driver.on(:close,   &method(:on_close))
@@ -50,7 +55,14 @@ module Ferrum
       def on_message(event)
         data = JSON.parse(event.data)
         @messages.push(data)
-        @logger&.puts("    ◀ #{Ferrum.elapsed_time} #{event.data}\n")
+
+        output = event.data
+        if SKIP_LOGGING_SCREENSHOTS && @screenshot_commands[data["id"]]
+          @screenshot_commands.delete(data["id"])
+          output.sub!(/{"data":"(.*)"}/, %("Set FERRUM_LOGGING_SCREENSHOTS=true to see screenshots in Base64"))
+        end
+
+        @logger&.puts("    ◀ #{Ferrum.elapsed_time} #{output}\n")
       end
 
       def on_close(_event)
@@ -59,6 +71,10 @@ module Ferrum
       end
 
       def send_message(data)
+        if SKIP_LOGGING_SCREENSHOTS
+          @screenshot_commands[data[:id]] = true
+        end
+
         json = data.to_json
         @driver.text(json)
         @logger&.puts("\n\n▶ #{Ferrum.elapsed_time} #{json}")

data/lib/ferrum/browser/xvfb.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Browser
+    class Xvfb
+      NOT_FOUND = "Could not find an executable for the Xvfb. Try to install " \
+                  "it with your package manager".freeze
+
+      def self.start(*args)
+        new(*args).tap(&:start)
+      end
+
+      def self.xvfb_path
+        Cliver.detect("Xvfb")
+      end
+
+      attr_reader :screen_size, :display_id, :pid
+
+      def initialize(options)
+        @path = self.class.xvfb_path
+        raise Cliver::Dependency::NotFound.new(NOT_FOUND) unless @path
+
+        @screen_size = options.fetch(:window_size, [1024, 768]).join("x") + "x24"
+        @display_id = (Time.now.to_f * 1000).to_i % 100_000_000
+      end
+
+      def start
+        @pid = ::Process.spawn("#{@path} :#{display_id} -screen 0 #{screen_size}")
+        ::Process.detach(@pid)
+      end
+
+      def to_env
+        { "DISPLAY" => ":#{display_id}" }
+      end
+    end
+  end
+end

data/lib/ferrum/context.rb

@@ -10,7 +10,7 @@ module Ferrum
 
     def initialize(browser, contexts, id)
       @browser, @contexts, @id = browser, contexts, id
-      @targets = Concurrent::Hash.new
+      @targets = Concurrent::Map.new
       @pendings = Concurrent::MVar.new
     end
 
@@ -42,19 +42,19 @@ module Ferrum
     end
 
     def create_target
-      target_id = @browser.command("Target.createTarget",
-                                   browserContextId: @id,
-                                   url: "about:blank")["targetId"]
+      @browser.command("Target.createTarget",
+                       browserContextId: @id,
+                       url: "about:blank")
       target = @pendings.take(@browser.timeout)
       raise NoSuchTargetError unless target.is_a?(Target)
-      @targets[target.id] = target
+      @targets.put_if_absent(target.id, target)
       target
     end
 
     def add_target(params)
       target = Target.new(@browser, params)
       if target.window?
-        @targets[target.id] = target
+        @targets.put_if_absent(target.id, target)
       else
         @pendings.put(target, @browser.timeout)
       end
@@ -72,6 +72,10 @@ module Ferrum
       @contexts.dispose(@id)
     end
 
+    def has_target?(target_id)
+      !!@targets[target_id]
+    end
+
     def inspect
       %(#<#{self.class} @id=#{@id.inspect} @targets=#{@targets.inspect} @default_target=#{@default_target.inspect}>)
     end

data/lib/ferrum/contexts.rb

@@ -7,7 +7,7 @@ module Ferrum
     attr_reader :contexts
 
     def initialize(browser)
-      @contexts = Concurrent::Hash.new
+      @contexts = Concurrent::Map.new
       @browser = browser
       subscribe
       discover
@@ -18,7 +18,9 @@ module Ferrum
     end
 
     def find_by(target_id:)
-      @contexts.find { |_, c| c.targets.keys.include?(target_id) }&.last
+      context = nil
+      @contexts.each_value { |c| context = c if c.has_target?(target_id) }
+      context
     end
 
     def create

data/lib/ferrum/frame.rb

@@ -11,6 +11,7 @@ module Ferrum
     attr_accessor :id, :name
 
     def initialize(id, page, parent_id = nil)
+      @execution_id = nil
       @id, @page, @parent_id = id, page, parent_id
     end
 

data/lib/ferrum/frame/dom.rb

@@ -37,54 +37,54 @@ module Ferrum
       end
 
       def xpath(selector, within: nil)
-        code = <<~JS
-          let selector = arguments[0];
-          let within = arguments[1] || document;
-          let results = [];
+        expr = <<~JS
+          function(selector, within) {
+            let results = [];
+            within ||= document
 
-          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));
-          }
+            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);
+            return results;
+          }
         JS
 
-        evaluate_async(code, @page.timeout, selector, within)
+        evaluate_func(expr, selector, within)
       end
 
       def at_xpath(selector, within: nil)
-        code = <<~JS
-          let selector = arguments[0];
-          let within = arguments[1] || document;
-          let xpath = document.evaluate(selector, within, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-          let result = xpath.snapshotItem(0);
-          arguments[2](result);
+        expr = <<~JS
+          function(selector, within) {
+            within ||= document
+            let xpath = document.evaluate(selector, within, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            return xpath.snapshotItem(0);
+          }
         JS
-
-        evaluate_async(code, @page.timeout, selector, within)
+        evaluate_func(expr, selector, within)
       end
 
       def css(selector, within: nil)
-        code = <<~JS
-          let selector = arguments[0];
-          let within = arguments[1] || document;
-          let results = within.querySelectorAll(selector);
-          arguments[2](results);
+        expr = <<~JS
+          function(selector, within) {
+            within ||= document
+            return Array.from(within.querySelectorAll(selector));
+          }
         JS
 
-        evaluate_async(code, @page.timeout, selector, within)
+        evaluate_func(expr, selector, within)
       end
 
       def at_css(selector, within: nil)
-        code = <<~JS
-          let selector = arguments[0];
-          let within = arguments[1] || document;
-          let result = within.querySelector(selector);
-          arguments[2](result);
+        expr = <<~JS
+          function(selector, within) {
+            within ||= document
+            return within.querySelector(selector);
+          }
         JS
 
-        evaluate_async(code, @page.timeout, selector, within)
+        evaluate_func(expr, selector, within)
       end
     end
   end

data/lib/ferrum/frame/runtime.rb

@@ -1,36 +1,21 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module Ferrum
+  class CyclicObject
+    include Singleton
+
+    def inspect
+      %(#<#{self.class} JavaScript object that cannot be represented in Ruby>)
+    end
+  end
+
   class Frame
     module Runtime
       INTERMITTENT_ATTEMPTS = ENV.fetch("FERRUM_INTERMITTENT_ATTEMPTS", 6).to_i
       INTERMITTENT_SLEEP = ENV.fetch("FERRUM_INTERMITTENT_SLEEP", 0.1).to_f
 
-      EXECUTE_OPTIONS = {
-        returnByValue: true,
-        functionDeclaration: %(function() { %s })
-      }.freeze
-      DEFAULT_OPTIONS = {
-        functionDeclaration: %(function() { return %s })
-      }.freeze
-      EVALUATE_ASYNC_OPTIONS = {
-        awaitPromise: true,
-        functionDeclaration: %(
-          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
-
       SCRIPT_SRC_TAG = <<~JS
         const script = document.createElement("script");
         script.src = arguments[0];
@@ -61,37 +46,45 @@ module Ferrum
       JS
 
       def evaluate(expression, *args)
-        call(*args, expression: expression)
+        expression = "function() { return %s }" % expression
+        call(expression: expression, arguments: args)
       end
 
-      def evaluate_async(expression, wait_time, *args)
-        call(*args, expression: expression, wait_time: wait_time * 1000, **EVALUATE_ASYNC_OPTIONS)
+      def evaluate_async(expression, wait, *args)
+        template = <<~JS
+          function() {
+            return new Promise((__f, __r) => {
+              try {
+                arguments[arguments.length] = r => __f(r);
+                arguments.length = arguments.length + 1;
+                setTimeout(() => __r(new Error("timed out promise")), %s);
+                %s
+              } catch(error) {
+                __r(error);
+              }
+            });
+          }
+        JS
+
+        expression = template % [wait * 1000, expression]
+        call(expression: expression, arguments: args, awaitPromise: true)
       end
 
       def execute(expression, *args)
-        call(*args, expression: expression, handle: false, **EXECUTE_OPTIONS)
+        expression = "function() { %s }" % expression
+        call(expression: expression, arguments: args, handle: false, returnByValue: true)
         true
       end
 
-      def evaluate_on(node:, expression:, by_value: true, wait: 0)
-        errors = [NodeNotFoundError, NoExecutionContextError]
-        attempts, sleep = INTERMITTENT_ATTEMPTS, INTERMITTENT_SLEEP
-
-        Ferrum.with_attempts(errors: errors, max: attempts, wait: sleep) do
-          response = @page.command("DOM.resolveNode", nodeId: node.node_id)
-          object_id = response.dig("object", "objectId")
-          options = DEFAULT_OPTIONS.merge(objectId: object_id)
-          options[:functionDeclaration] = options[:functionDeclaration] % expression
-          options.merge!(returnByValue: by_value)
-
-          response = @page.command("Runtime.callFunctionOn",
-                                   wait: wait, slowmoable: true,
-                                   **options)
-          handle_error(response)
-          response = response["result"]
+      def evaluate_func(expression, *args, on: nil)
+        call(expression: expression, arguments: args, on: on)
+      end
 
-          by_value ? response.dig("value") : handle_response(response)
-        end
+      def evaluate_on(node:, expression:, by_value: true, wait: 0)
+        options = { handle: true }
+        expression = "function() { return %s }" % expression
+        options = { handle: false, returnByValue: true } if by_value
+        call(expression: expression, on: node, wait: wait, **options)
       end
 
       def add_script_tag(url: nil, path: nil, content: nil, type: "text/javascript")
@@ -124,27 +117,31 @@ module Ferrum
 
       private
 
-      def call(*args, expression:, wait_time: nil, handle: true, **options)
+      def call(expression:, arguments: [], on: nil, wait: 0, handle: true, **options)
         errors = [NodeNotFoundError, NoExecutionContextError]
         attempts, sleep = INTERMITTENT_ATTEMPTS, INTERMITTENT_SLEEP
 
         Ferrum.with_attempts(errors: errors, max: attempts, wait: sleep) do
-          arguments = prepare_args(args)
-          params = DEFAULT_OPTIONS.merge(options)
-          expression = [wait_time, expression] if wait_time
-          params[:functionDeclaration] = params[:functionDeclaration] % expression
-          params = params.merge(arguments: arguments)
-          unless params[:executionContextId]
+          params = options.dup
+
+          if on
+            response = @page.command("DOM.resolveNode", nodeId: on.node_id)
+            object_id = response.dig("object", "objectId")
+            params = params.merge(objectId: object_id)
+          end
+
+          if params[:executionContextId].nil? && params[:objectId].nil?
             params = params.merge(executionContextId: execution_id)
           end
 
           response = @page.command("Runtime.callFunctionOn",
-                                   slowmoable: true,
-                                   **params)
+                                   wait: wait, slowmoable: true,
+                                   **params.merge(functionDeclaration: expression,
+                                                  arguments: prepare_args(arguments)))
           handle_error(response)
           response = response["result"]
 
-          handle ? handle_response(response) : response
+          handle ? handle_response(response) : response.dig("value")
         end
       end
 
@@ -215,7 +212,7 @@ module Ferrum
 
       def reduce_props(object_id, to)
         if cyclic?(object_id).dig("result", "value")
-          return "(cyclic structure)"
+          return 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|
@@ -237,15 +234,13 @@ module Ferrum
                 return false;
               }
 
-              const seen = [];
-              function detectCycle(obj) {
+              function detectCycle(obj, seen) {
                 if (typeof obj === "object") {
                   if (seen.indexOf(obj) !== -1) {
                     return true;
                   }
-                  seen.push(obj);
                   for (let key in obj) {
-                    if (obj.hasOwnProperty(key) && detectCycle(obj[key])) {
+                    if (obj.hasOwnProperty(key) && detectCycle(obj[key], seen.concat([obj]))) {
                       return true;
                     }
                   }
@@ -254,11 +249,15 @@ module Ferrum
                 return false;
               }
 
-              return detectCycle(this);
+              return detectCycle(this, []);
             }
           JS
         )
       end
+
+      def cyclic_object
+        CyclicObject.instance
+      end
     end
   end
 end