puppeteer-ruby 0.45.6 → 0.50.0.alpha5

data/lib/puppeteer/reactor_runner.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/promise"
+require "delegate"
+require "thread"
+
+module Puppeteer
+  # Runs a dedicated Async reactor in a background thread and proxies calls into it.
+  class ReactorRunner
+    class Finalizer
+      def initialize(queue, thread)
+        @queue = queue
+        @thread = thread
+      end
+
+      def call(_id)
+        @queue.close
+        @thread.join unless ::Thread.current == @thread
+      end
+    end
+
+    class Proxy < SimpleDelegator
+      # @param runner [ReactorRunner]
+      # @param target [Object]
+      # @param owns_runner [Boolean]
+      def initialize(runner, target, owns_runner: false)
+        super(target)
+        @runner = runner
+        @owns_runner = owns_runner
+      end
+
+      # Override tap to distinguish between Ruby's Object#tap and Puppeteer's tap method.
+      # When called with a block only (Ruby's tap), delegate to super.
+      # When called with args (Puppeteer's tap), route through the reactor.
+      def tap(*args, **kwargs, &block)
+        if args.empty? && kwargs.empty? && block
+          super(&block)
+        else
+          @runner.sync do
+            args = args.map { |arg| @runner.unwrap(arg) }
+            kwargs = kwargs.transform_values { |value| @runner.unwrap(value) }
+            result = __getobj__.public_send(:tap, *args, **kwargs, &block)
+            @runner.wrap(result)
+          end
+        end
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        if @runner.closed?
+          return false if name == :connected?
+          return nil if @owns_runner && close_like?(name)
+        end
+
+        begin
+          @runner.sync do
+            args = args.map { |arg| @runner.unwrap(arg) }
+            kwargs = kwargs.transform_values { |value| @runner.unwrap(value) }
+            result = __getobj__.public_send(name, *args, **kwargs, &block)
+            @runner.wrap(result)
+          end
+        ensure
+          if @owns_runner && close_like?(name)
+            @runner.wait_until_idle
+            @runner.close
+          end
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        __getobj__.respond_to?(name, include_private) || super
+      end
+
+      def class
+        __getobj__.class
+      end
+
+      def is_a?(klass)
+        return true if klass == Proxy || klass == self.class
+
+        __getobj__.is_a?(klass)
+      end
+
+      alias kind_of? is_a?
+
+      def instance_of?(klass)
+        return true if klass == Proxy || klass == self.class
+
+        __getobj__.instance_of?(klass)
+      end
+
+      def ==(other)
+        __getobj__ == @runner.unwrap(other)
+      end
+
+      def eql?(other)
+        __getobj__.eql?(@runner.unwrap(other))
+      end
+
+      def hash
+        __getobj__.hash
+      end
+
+      private def close_like?(name)
+        name == :close || name == :disconnect
+      end
+    end
+
+    def initialize
+      @queue = Thread::Queue.new
+      @ready = Queue.new
+      @closed = false
+      @thread = Thread.new do
+        Sync do |task|
+          barrier = Async::Barrier.new(parent: task)
+          @barrier = barrier
+          @ready << true
+          begin
+            while (job = @queue.pop)
+              barrier.async do
+                job.call
+              end
+            end
+          rescue ClosedQueueError
+            # Queue closed; exit the reactor loop.
+          ensure
+            barrier.stop
+          end
+        end
+      ensure
+        @barrier = nil
+        @closed = true
+      end
+
+      ObjectSpace.define_finalizer(self, Finalizer.new(@queue, @thread))
+      @ready.pop
+    end
+
+    def sync(&block)
+      return block.call if runner_thread?
+      raise ::Puppeteer::Error.new("ReactorRunner is closed") if closed?
+
+      promise = Async::Promise.new
+      job = lambda do
+        begin
+          promise.resolve(block.call)
+        rescue Exception => err
+          promise.reject(err)
+        end
+      end
+
+      begin
+        @queue << job
+      rescue ClosedQueueError
+        raise ::Puppeteer::Error.new("ReactorRunner is closed")
+      end
+
+      promise.wait
+    end
+
+    def close
+      return if closed?
+
+      @closed = true
+      @queue.close
+      @thread.join unless runner_thread?
+    end
+
+    def wait_until_idle(timeout: 1.0)
+      return if closed?
+
+      sync do
+        return unless @barrier
+
+        deadline = timeout ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout : nil
+        loop do
+          break if @barrier.empty?
+          break if deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          Async::Task.current.sleep(0.01)
+        end
+      end
+    rescue Puppeteer::Error
+      # Runner closed while waiting; ignore.
+    end
+
+    def closed?
+      @closed
+    end
+
+    def wrap(value)
+      return value if value.nil? || value.is_a?(Proxy)
+
+      if value.is_a?(Array)
+        return value.map { |item| wrap(item) }
+      end
+
+      return Proxy.new(self, value) if proxyable?(value)
+
+      value
+    end
+
+    def unwrap(value, seen = nil)
+      seen ||= {}
+
+      case value
+      when Proxy
+        value.__getobj__
+      when Array
+        object_id = value.object_id
+        return seen[object_id] if seen.key?(object_id)
+
+        result = []
+        seen[object_id] = result
+        value.each { |item| result << unwrap(item, seen) }
+        result
+      when Hash
+        object_id = value.object_id
+        return seen[object_id] if seen.key?(object_id)
+
+        result = {}
+        seen[object_id] = result
+        value.each do |key, item|
+          result[unwrap(key, seen)] = unwrap(item, seen)
+        end
+        result
+      else
+        value
+      end
+    end
+
+    private def runner_thread?
+      Thread.current == @thread
+    end
+
+    private def proxyable?(value)
+      return false if value.is_a?(Module) || value.is_a?(Class)
+
+      name = value.class.name
+      return false unless name&.start_with?("Puppeteer")
+      return false if name.start_with?("Puppeteer::Bidi")
+      return false if value.is_a?(ReactorRunner) || value.is_a?(Proxy)
+
+      true
+    end
+  end
+end

data/lib/puppeteer/remote_object.rb

@@ -1,8 +1,16 @@
+# rbs_inline: enabled
+
+require 'time'
+
 # providing #valueFromRemoteObject, #releaseObject
 class Puppeteer::RemoteObject
   include Puppeteer::DebugPrint
   using Puppeteer::DefineAsyncMethod
 
+  UNSERIALIZABLE_SENTINEL_KEY = '__puppeteer_unserializable__'
+  NUMBER_SENTINEL_KEY = '__puppeteer_number__'
+  REGEXP_SENTINEL_KEY = '__puppeteer_regexp__'
+
   # @param payload [Hash]
   def initialize(payload)
     @object_id = payload['objectId']
@@ -10,37 +18,19 @@ class Puppeteer::RemoteObject
     @sub_type = payload['subtype']
     @unserializable_value = payload['unserializableValue']
     @value = payload['value']
+    @description = payload['description']
   end
 
-  attr_reader :sub_type
+  attr_reader :sub_type, :type, :description
 
-  # @return [Future<Puppeteer::RemoteObject|nil>]
-  def evaluate_self(client)
-    # ported logic from JSHandle#json_value.
-
-    # original logic:
-    #   if (this._remoteObject.objectId) {
-    #     const response = await this._client.send('Runtime.callFunctionOn', {
-    #       functionDeclaration: 'function() { return this; }',
-    #       objectId: this._remoteObject.objectId,
-    #       returnByValue: true,
-    #       awaitPromise: true,
-    #     });
-    #     return helper.valueFromRemoteObject(response.result);
-    #   }
+  # @rbs return: bool
+  def object_id?
+    !@object_id.nil?
+  end
 
-    if @object_id
-      params = {
-        'functionDeclaration': 'function() { return this; }',
-        'objectId': @object_id,
-        'returnByValue': true,
-        'awaitPromise': true,
-      }
-      response = client.send_message('Runtime.callFunctionOn', params)
-      Puppeteer::RemoteObject.new(response['result'])
-    else
-      nil
-    end
+  # @rbs return: String?
+  def object_id_value
+    @object_id
   end
 
   # @return [String]
@@ -52,7 +42,10 @@ class Puppeteer::RemoteObject
     #     return 'JSHandle@' + type;
     #   }
     if @object_id
-      @sub_type || @type
+      return @sub_type if @sub_type
+      return 'window' if @type == 'object' && @description == 'Window'
+
+      @type
     else
       nil
     end
@@ -82,13 +75,12 @@ class Puppeteer::RemoteObject
   def box_model(client)
     result = client.send_message('DOM.getBoxModel', objectId: @object_id)
 
-    # Firefox returns width/height = 0, content/padding/border/margin = [nil, nil, nil, nil, nil, nil, nil, nil]
-    # while Chrome throws Error(Could not compute box model)
+    # Some browsers return zeroed box model data instead of throwing errors.
     model = result['model']
     if model['width'] == 0 && model['height'] == 0 &&
       %w(content padding border margin).all? { |key| model[key].all?(&:nil?) }
 
-      debug_puts('Could not compute box model in Firefox.')
+      debug_puts('Could not compute box model.')
       return nil
     end
     result
@@ -113,24 +105,112 @@ class Puppeteer::RemoteObject
   # helper#valueFromRemoteObject
   def value
     if @unserializable_value
-      # if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined')
-      #   return BigInt(remoteObject.unserializableValue.replace('n', ''));
-      # switch (remoteObject.unserializableValue) {
-      #   case '-0':
-      #     return -0;
-      #   case 'NaN':
-      #     return NaN;
-      #   case 'Infinity':
-      #     return Infinity;
-      #   case '-Infinity':
-      #     return -Infinity;
-      #   default:
-      #     throw new Error('Unsupported unserializable value: ' + remoteObject.unserializableValue);
-      # }
-      raise NotImplementedError.new('unserializable_value is not implemented yet')
+      if @type == 'bigint' || @unserializable_value.end_with?('n')
+        return Integer(@unserializable_value.delete_suffix('n'))
+      end
+
+      case @unserializable_value
+      when '-0'
+        -0.0
+      when 'NaN'
+        Float::NAN
+      when 'Infinity'
+        Float::INFINITY
+      when '-Infinity'
+        -Float::INFINITY
+      else
+        raise NotImplementedError.new("Unsupported unserializable value: #{@unserializable_value}")
+      end
+    end
+
+    if @sub_type == 'date'
+      return parse_date_value(@value)
+    end
+
+    if @sub_type == 'regexp' && @description
+      source, flags = parse_regexp(@description)
+      return Regexp.new(source, regexp_options(flags))
+    end
+
+    normalize_serialized_value(@value)
+  end
+
+  # @rbs value: untyped -- Serialized value from JavaScript
+  # @rbs return: untyped -- Normalized Ruby value
+  private def normalize_serialized_value(value)
+    case value
+    when Array
+      value.map { |item| normalize_serialized_value(item) }
+    when Hash
+      if value.keys == [UNSERIALIZABLE_SENTINEL_KEY] && value[UNSERIALIZABLE_SENTINEL_KEY] == true
+        nil
+      elsif value.keys == [NUMBER_SENTINEL_KEY]
+        unserializable_number(value[NUMBER_SENTINEL_KEY])
+      elsif value.keys == [REGEXP_SENTINEL_KEY] && value[REGEXP_SENTINEL_KEY].is_a?(Hash)
+        regexp_value = value[REGEXP_SENTINEL_KEY]
+        source = regexp_value['source'].to_s
+        flags = regexp_value['flags'].to_s
+        Regexp.new(source, regexp_options(flags))
+      else
+        value.transform_values { |item| normalize_serialized_value(item) }
+      end
+    else
+      value
+    end
+  end
+
+  # @rbs value: String -- Special number string
+  # @rbs return: Float | String -- Parsed number or original value
+  private def unserializable_number(value)
+    case value
+    when '-0'
+      -0.0
+    when 'NaN'
+      Float::NAN
+    when 'Infinity'
+      Float::INFINITY
+    when '-Infinity'
+      -Float::INFINITY
+    else
+      value
+    end
+  end
+
+  # @rbs description: String -- Regexp description string
+  # @rbs return: [String, String] -- Source and flags tuple
+  private def parse_regexp(description)
+    return [description, ''] unless description.start_with?('/')
+
+    last_slash = description.rindex('/')
+    return [description, ''] unless last_slash && last_slash > 0
+
+    source = description[1...last_slash] || ''
+    flags = description[(last_slash + 1)..] || ''
+    [source, flags]
+  end
+
+  # @rbs value: untyped -- Date value from CDP
+  # @rbs return: Time? -- Parsed Ruby time
+  private def parse_date_value(value)
+    case value
+    when String
+      Time.iso8601(value)
+    when Numeric
+      Time.at(value / 1000.0)
     else
-      @value
+      nil
     end
+  rescue ArgumentError
+    value
+  end
+
+  # @rbs flags: String -- Regexp flags string
+  # @rbs return: Integer -- Ruby Regexp options
+  private def regexp_options(flags)
+    options = 0
+    options |= Regexp::IGNORECASE if flags.include?('i')
+    options |= Regexp::MULTILINE if flags.include?('m')
+    options
   end
 
   # @param client [Puppeteer::CDPSession]

data/lib/puppeteer/target.rb

@@ -18,6 +18,7 @@ class Puppeteer::Target
   # @param {!function():!Promise<!Puppeteer.CDPSession>} sessionFactory
   # @param {boolean} ignoreHTTPSErrors
   # @param {?Puppeteer.Viewport} defaultViewport
+  # @param {boolean} networkEnabled
   def initialize(target_info:,
                  session:,
                  browser_context:,
@@ -25,6 +26,7 @@ class Puppeteer::Target
                  session_factory:,
                  ignore_https_errors:,
                  default_viewport:,
+                 network_enabled:,
                  is_page_target_callback:)
     @session = session
     @target_manager = target_manager
@@ -34,36 +36,59 @@ class Puppeteer::Target
     @session_factory = session_factory
     @ignore_https_errors = ignore_https_errors
     @default_viewport = default_viewport
+    @network_enabled = network_enabled
     @is_page_target_callback = is_page_target_callback
+    @worker = nil
 
     #    /** @type {?Promise<!Puppeteer.Page>} */
     #    this._pagePromise = null;
     #    /** @type {?Promise<!Worker>} */
     #    this._workerPromise = null;
-    @initialize_callback_promise = resolvable_future
-    @initialized_promise = @initialize_callback_promise.then do |success|
-      handle_initialized(success)
+    @initialize_callback_promise = Async::Promise.new
+    @initialized_promise = Async::Promise.new
+    @is_closed_promise = Async::Promise.new
+
+    Async do
+      @initialized_promise.resolve(handle_initialized(@initialize_callback_promise.wait))
+    rescue => err
+      @initialized_promise.reject(err)
     end
-    @is_closed_promise = resolvable_future
 
     @is_initialized = !@is_page_target_callback.call(@target_info) || !@target_info.url.empty?
 
     if @is_initialized
-      @initialize_callback_promise.fulfill(true)
+      @initialize_callback_promise.resolve(true)
     end
   end
 
   attr_reader :target_id, :target_info, :initialized_promise, :is_closed_promise
 
+  def ==(other)
+    other = other.__getobj__ if other.is_a?(Puppeteer::ReactorRunner::Proxy)
+    return true if equal?(other)
+    return false unless other.is_a?(Puppeteer::Target)
+    return false if target_id.nil? || other.target_id.nil?
+
+    target_id == other.target_id
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    target_id ? target_id.hash : super
+  end
+
   def closed_callback
-    @is_closed_promise.fulfill(true)
+    @is_closed_promise.resolve(true) unless @is_closed_promise.resolved?
   end
 
-  class InitializeFailure < StandardError; end
+  class InitializeFailure < Puppeteer::Error; end
 
   def ignore_initialize_callback_promise
-    unless @initialize_callback_promise.fulfilled?
-      @initialize_callback_promise.fulfill(false)
+    unless @initialize_callback_promise.resolved?
+      @initialize_callback_promise.resolve(false)
     end
   end
 
@@ -93,7 +118,9 @@ class Puppeteer::Target
   end
 
   def create_cdp_session
-    @session_factory.call(false)
+    session = @session_factory.call(false)
+    session.target = self if session.respond_to?(:target=)
+    session
   end
 
   def target_manager
@@ -103,34 +130,54 @@ class Puppeteer::Target
   def page
     if @is_page_target_callback.call(@target_info) && @page.nil?
       client = @session || @session_factory.call(true)
-      @page = Puppeteer::Page.create(client, self, @ignore_https_errors, @default_viewport)
+      client.wait_for_ready if client.respond_to?(:wait_for_ready)
+      @page = Puppeteer::Page.create(
+        client,
+        self,
+        @ignore_https_errors,
+        @default_viewport,
+        network_enabled: @network_enabled,
+      )
     end
     @page
   end
 
-  #  /**
-  #   * @return {!Promise<?Worker>}
-  #   */
-  #  async worker() {
-  #    if (this._targetInfo.type !== 'service_worker' && this._targetInfo.type !== 'shared_worker')
-  #      return null;
-  #    if (!this._workerPromise) {
-  #      // TODO(einbinder): Make workers send their console logs.
-  #      this._workerPromise = this._sessionFactory()
-  #          .then(client => new Worker(client, this._targetInfo.url, () => {} /* consoleAPICalled */, () => {} /* exceptionThrown */));
-  #    }
-  #    return this._workerPromise;
-  #  }
+  # @return [Puppeteer::CdpWebWorker|nil]
+  def worker
+    return nil unless ['service_worker', 'shared_worker'].include?(@target_info.type)
+    return @worker if @worker
+
+    if @target_info.type == 'service_worker'
+      @target_manager&.wait_for_service_worker_detach(@target_id)
+    end
+
+    client =
+      if @target_info.type == 'service_worker'
+        @session_factory.call(false)
+      else
+        @session || @session_factory.call(false)
+      end
+    client.target = self if client.respond_to?(:target=)
+    client.wait_for_ready if client.respond_to?(:wait_for_ready)
+    @worker = Puppeteer::CdpWebWorker.new(
+      client,
+      @target_info.url,
+      @target_id,
+      @target_info.type,
+      nil,
+      nil,
+    )
+  end
 
   # @return {string}
   def url
     @target_info.url
   end
 
-  # @return {"page"|"background_page"|"service_worker"|"shared_worker"|"other"|"browser"}
+  # @return {"page"|"background_page"|"service_worker"|"shared_worker"|"webview"|"tab"|"other"|"browser"}
   def type
     type = @target_info.type
-    if ['page', 'background_page', 'service_worker', 'shared_worker', 'browser'].include?(type)
+    if ['page', 'background_page', 'service_worker', 'shared_worker', 'webview', 'tab', 'browser'].include?(type)
       type
     else
       'other'
@@ -165,7 +212,7 @@ class Puppeteer::Target
 
     if !@is_initialized && (!@is_page_target_callback.call(@target_info) || !@target_info.url.empty?)
       @is_initialized = true
-      @initialize_callback_promise.fulfill(true)
+      @initialize_callback_promise.resolve(true)
     end
   end
 end

data/lib/puppeteer/task_manager.rb

@@ -19,6 +19,8 @@ class Puppeteer::TaskManager
   end
 
   def async_rerun_all
-    Concurrent::Promises.zip(*@tasks.map(&:async_rerun))
+    Async do
+      Puppeteer::AsyncUtils.await_promise_all(*@tasks.map(&:async_rerun))
+    end
   end
 end

data/lib/puppeteer/timeout_helper.rb

@@ -1,5 +1,3 @@
-require 'timeout'
-
 class Puppeteer::TimeoutHelper
   # @param timeout_ms [String|Integer|nil]
   # @param default_timeout_ms [Integer]
@@ -9,14 +7,12 @@ class Puppeteer::TimeoutHelper
   end
 
   def with_timeout(&block)
-    if @timeout_ms > 0
-      begin
-        Timeout.timeout(@timeout_ms / 1000.0, &block)
-      rescue Timeout::Error
-        raise Puppeteer::TimeoutError.new("waiting for #{@task_name} failed: timeout #{@timeout_ms}ms exceeded")
-      end
-    else
-      block.call
+    return block.call if @timeout_ms <= 0
+
+    begin
+      Puppeteer::AsyncUtils.async_timeout(@timeout_ms, &block).wait
+    rescue Async::TimeoutError
+      raise Puppeteer::TimeoutError.new("waiting for #{@task_name} failed: timeout #{@timeout_ms}ms exceeded")
     end
   end
 end