puppeteer-ruby 0.52.1 → 0.53.0

data/lib/puppeteer/cdp_session.rb

@@ -66,9 +66,14 @@ class Puppeteer::CDPSession
   # @rbs return: Async::Promise[Hash[String, untyped]] -- Async CDP response
   def async_send_message(method, params = {})
     if !@connection
-      raise Error.new("Protocol error (#{method}): Session closed. Most likely the #{@target_type} has been closed.")
+      raise Puppeteer::TargetCloseError.new(
+        method: method,
+        error_message: "Session closed. Most likely the #{@target_type} has been closed.",
+      )
     end
 
+    @connection.ensure_command_allowed!(method)
+
     promise = Async::Promise.new
 
     @connection.generate_id do |id|
@@ -81,6 +86,12 @@ class Puppeteer::CDPSession
     promise
   end
 
+  # @rbs id: Integer -- CDP command id
+  # @rbs return: bool -- True when the session owns the callback
+  def callback?(id)
+    @callbacks_mutex.synchronize { @callbacks.key?(id) }
+  end
+
   # @rbs message: Hash[String, untyped] -- Raw CDP message
   # @rbs return: void -- No return value
   def handle_message(message)
@@ -97,11 +108,21 @@ class Puppeteer::CDPSession
 
   private def callback_with_message(callback, message)
     if message['error']
-      callback.reject(
-        Puppeteer::Connection::ProtocolError.new(
-          method: callback.method,
-          error_message: message['error']['message'],
-          error_data: message['error']['data']))
+      if message['error']['message'].include?('Session with given id not found')
+        handle_closed
+        callback.reject(
+          Puppeteer::TargetCloseError.new(
+            method: callback.method,
+            error_message: 'Session with given id not found.',
+          ),
+        )
+      else
+        callback.reject(
+          Puppeteer::Connection::ProtocolError.new(
+            method: callback.method,
+            error_message: message['error']['message'],
+            error_data: message['error']['data']))
+      end
     else
       callback.resolve(message['result'])
     end
@@ -122,9 +143,9 @@ class Puppeteer::CDPSession
     end
     callbacks.each do |callback|
       callback.reject(
-        Puppeteer::Connection::ProtocolError.new(
+        Puppeteer::TargetCloseError.new(
           method: callback.method,
-          error_message: 'Target Closed.'))
+          error_message: 'Target closed'))
     end
     @ready_promise.reject(Error.new("Session closed")) unless @ready_promise.resolved?
     @connection = nil

data/lib/puppeteer/chrome_target_manager.rb

@@ -2,7 +2,7 @@ class Puppeteer::ChromeTargetManager
   include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
 
-  def initialize(connection:, target_factory:, target_filter_callback:, block_list: nil)
+  def initialize(connection:, target_factory:, target_filter_callback:, block_list: nil, allow_list: nil)
     @discovered_targets_by_target_id = {}
     @attached_targets_by_target_id = {}
     @attached_targets_by_session_id = {}
@@ -13,10 +13,17 @@ class Puppeteer::ChromeTargetManager
     @connection = connection
     @target_filter_callback = target_filter_callback
     @target_factory = target_factory
-    @block_list = block_list
-    if @block_list && !@block_list.is_a?(Array)
+    if block_list && allow_list
+      raise ArgumentError.new('Cannot specify both blocklist and allowlist')
+    end
+    if block_list && !block_list.is_a?(Array)
       raise ArgumentError.new('block_list must be an Array of URL patterns')
     end
+    if allow_list && !allow_list.is_a?(Array)
+      raise ArgumentError.new('allow_list must be an Array of URL patterns')
+    end
+    @block_list = map_patterns(block_list)
+    @allow_list = map_patterns(allow_list)
     @target_interceptors = {}
     @initialize_promise = Async::Promise.new
     @initial_attach_done = false
@@ -44,10 +51,7 @@ class Puppeteer::ChromeTargetManager
     Async do
       @connection.async_send_message('Target.setDiscoverTargets', {
         discover: true,
-        filter: [
-          { type: 'tab', exclude: true },
-          {},
-        ],
+        filter: [{}],
       }).wait
       store_existing_targets_for_init
     rescue => err
@@ -57,7 +61,7 @@ class Puppeteer::ChromeTargetManager
 
   private def store_existing_targets_for_init
     @discovered_targets_by_target_id.each do |target_id, target_info|
-      if @target_filter_callback.call(target_info) && target_info.type != 'browser' && url_allowed?(target_info.url)
+      if @target_filter_callback.call(target_info) && target_info.type == 'tab' && url_allowed?(target_info.url)
         @target_ids_for_init << target_id
       end
     end
@@ -68,6 +72,10 @@ class Puppeteer::ChromeTargetManager
       waitForDebuggerOnStart: true,
       flatten: true,
       autoAttach: true,
+      filter: [
+        { type: 'page', exclude: true },
+        {},
+      ],
     })
     @initial_attach_done = true
     finish_initialization_if_ready
@@ -83,6 +91,19 @@ class Puppeteer::ChromeTargetManager
     @attached_targets_by_target_id
   end
 
+  def remove_extension_service_workers(extension_id)
+    extension_url = "chrome-extension://#{extension_id}/"
+    target_ids = @discovered_targets_by_target_id.filter_map do |target_id, target_info|
+      if target_info.type == 'service_worker' && target_info.url.start_with?(extension_url)
+        target_id
+      end
+    end
+    target_ids.each do |target_id|
+      @ignored_targets << target_id
+      handle_target_destroyed('targetId' => target_id)
+    end
+  end
+
   def wait_for_service_worker_detach(target_id)
     promise = @service_worker_detach_promises[target_id]
     return unless promise
@@ -171,6 +192,10 @@ class Puppeteer::ChromeTargetManager
       return
     end
     original_target = @attached_targets_by_target_id[target_info.target_id]
+    if original_target&.target_info&.subtype && !target_info.subtype
+      session = original_target.session
+      session&.parent_session&.emit_event(CDPSessionEmittedEvents::Swapped, session)
+    end
     emit_event(TargetManagerEmittedEvents::TargetChanged, original_target, target_info) if original_target
   end
 
@@ -189,7 +214,7 @@ class Puppeteer::ChromeTargetManager
         begin
           Puppeteer::AsyncUtils.await(session.async_send_message('Runtime.runIfWaitingForDebugger'))
         rescue => err
-          Logger.new($stderr).warn(err)
+          debug_puts(err)
         end
 
         # We don't use `session.detach()` because that dispatches all commands on
@@ -199,7 +224,7 @@ class Puppeteer::ChromeTargetManager
             sessionId: session.id,
           }))
         rescue => err
-          Logger.new($stderr).warn(err)
+          debug_puts(err)
         ensure
           if detached_promise && !detached_promise.resolved?
             detached_promise.resolve(true)
@@ -208,7 +233,16 @@ class Puppeteer::ChromeTargetManager
       end
     }
 
-    return unless @connection.auto_attached?(target_info.target_id)
+    unless @connection.auto_attached?(target_info.target_id)
+      Async do
+        maybe_setup_network_conditions(session, target_info)
+      rescue => err
+        debug_puts(err)
+      ensure
+        session.mark_ready
+      end
+      return
+    end
 
     if !@initial_attach_done && !url_allowed?(target_info.url)
       finish_initialization_if_ready(target_info.target_id)
@@ -225,6 +259,23 @@ class Puppeteer::ChromeTargetManager
     # CDP.
     if target_info.type == 'service_worker' && @connection.auto_attached?(target_info.target_id)
       finish_initialization_if_ready(target_info.target_id)
+      unless url_allowed?(target_info.url)
+        Async do
+          setup_task = Async do
+            maybe_setup_network_conditions(session, target_info)
+          rescue => err
+            debug_puts(err)
+          end
+          run_promise = session.async_send_message('Runtime.runIfWaitingForDebugger')
+          Puppeteer::AsyncUtils.await(run_promise)
+          Puppeteer::AsyncUtils.await(setup_task)
+        rescue => err
+          debug_puts(err)
+        ensure
+          session.mark_ready
+        end
+        return
+      end
       @service_worker_detach_promises[target_info.target_id] ||= Async::Promise.new
       silent_detach.call(@service_worker_detach_promises[target_info.target_id])
       return if @attached_targets_by_target_id.has_key?(target_info.target_id)
@@ -238,7 +289,8 @@ class Puppeteer::ChromeTargetManager
 
     unless @target_filter_callback.call(target_info)
       @ignored_targets << target_info.target_id
-      finish_initialization_if_ready(target_info.target_id)
+      parent_target = parent_session.is_a?(Puppeteer::CDPSession) ? parent_session.target : nil
+      finish_initialization_if_ready(parent_target.target_id) if parent_target&.raw_type == 'tab'
       silent_detach.call
 
       return
@@ -267,25 +319,39 @@ class Puppeteer::ChromeTargetManager
       end
     end
 
-    @target_ids_for_init.delete(target.target_id)
     unless is_existing_target
       Async do
         Puppeteer::AsyncUtils.future_with_logging { emit_event(TargetManagerEmittedEvents::TargetAvailable, target) }.call
       end
     end
+    parent_target = parent_session.is_a?(Puppeteer::CDPSession) ? parent_session.target : nil
+    finish_initialization_if_ready(parent_target.target_id) if parent_target&.raw_type == 'tab'
     finish_initialization_if_ready
     parent_session.emit_event(CDPSessionEmittedEvents::Ready, session)
 
     Async do
-      Puppeteer::AsyncUtils.await(session.async_send_message('Target.setAutoAttach', {
-        waitForDebuggerOnStart: true,
-        flatten: true,
-        autoAttach: true,
-      }))
-      maybe_setup_network_conditions(session)
-      Puppeteer::AsyncUtils.await(session.async_send_message('Runtime.runIfWaitingForDebugger'))
+      setup_task = Async do
+        maybe_setup_network_conditions(session, target_info)
+      rescue => err
+        debug_puts(err)
+      end
+      promises = [
+        session.async_send_message('Target.setAutoAttach', {
+          waitForDebuggerOnStart: true,
+          flatten: true,
+          autoAttach: true,
+          filter: [{}],
+        }),
+        session.async_send_message('Runtime.runIfWaitingForDebugger'),
+        setup_task,
+      ]
+      promises.each do |promise|
+        Puppeteer::AsyncUtils.await(promise)
+      rescue => err
+        debug_puts(err)
+      end
     rescue => err
-      Logger.new($stderr).warn(err)
+      debug_puts(err)
     ensure
       session.mark_ready
     end
@@ -307,32 +373,77 @@ class Puppeteer::ChromeTargetManager
   end
 
   private def url_allowed?(url)
-    return true if @block_list.nil? || @block_list.empty?
+    block_list = @block_list || []
+    allow_list = @allow_list || []
+    return true if block_list.empty? && allow_list.empty?
     return true if url.nil? || url.empty? || url == 'about:blank'
 
-    @block_list.none? do |pattern|
-      File.fnmatch?(pattern, url, File::FNM_EXTGLOB)
-    rescue ArgumentError
-      false
+    blocked = block_list.any? { |item| item[:pattern].test?(url) }
+    return false if blocked
+
+    return true if allow_list.empty?
+
+    allow_list.any? { |item| item[:pattern].test?(url) }
+  end
+  public :url_allowed?
+
+  private def map_patterns(rules)
+    return nil if rules.nil?
+
+    rules.map do |rule|
+      {
+        pattern: URLPattern::URLPattern.new(rule),
+        rule: rule,
+      }
     end
   end
 
-  private def maybe_setup_network_conditions(session)
-    return if @block_list.nil? || @block_list.empty?
+  private def maybe_setup_network_conditions(session, target_info)
+    block_list = @block_list || []
+    allow_list = @allow_list || []
+    return if block_list.empty? && allow_list.empty?
 
-    matched_network_conditions = @block_list.map do |pattern|
+    matched_network_conditions = block_list.map do |item|
       {
-        urlPattern: pattern,
+        urlPattern: item[:rule],
+        offline: true,
         latency: 0,
         downloadThroughput: -1,
         uploadThroughput: -1,
       }
     end
-    Puppeteer::AsyncUtils.await(session.async_send_message('Network.enable'))
-    Puppeteer::AsyncUtils.await(session.async_send_message('Network.emulateNetworkConditionsByRule', {
+    allow_list.each do |item|
+      matched_network_conditions << {
+        urlPattern: item[:rule],
+        offline: false,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1,
+      }
+    end
+    unless allow_list.empty?
+      matched_network_conditions << {
+        urlPattern: '',
+        offline: true,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1,
+      }
+    end
+
+    promises = []
+    worker_types = ['worker', 'service_worker', 'shared_worker']
+    promises << session.async_send_message('Network.enable') if worker_types.include?(target_info.type)
+    params = {
+      offline: block_list.empty? ? nil : true,
       matchedNetworkConditions: matched_network_conditions,
-      offline: true,
-    }))
+    }.compact
+    promises << session.async_send_message('Network.emulateNetworkConditionsByRule', params)
+    promises.each do |promise|
+      Puppeteer::AsyncUtils.await(promise)
+    rescue => err
+      debug_puts(err)
+    end
   rescue => err
     message = err.message.to_s.downcase
     return if message.include?('target closed') || message.include?('session closed') || message.include?('not found')

data/lib/puppeteer/connection.rb

@@ -44,6 +44,7 @@ class Puppeteer::Connection
     @callbacks_mutex = Mutex.new
     @delay = delay
     @protocol_timeout = protocol_timeout
+    @reject_emulate_network_conditions_calls = false
 
     @network_message_queue = Async::Queue.new
     @network_message_task = nil
@@ -71,6 +72,16 @@ class Puppeteer::Connection
   end
 
   attr_reader :protocol_timeout
+  attr_writer :reject_emulate_network_conditions_calls
+
+  def ensure_command_allowed!(method)
+    return unless method == 'Network.emulateNetworkConditions'
+    return unless @reject_emulate_network_conditions_calls
+
+    raise Puppeteer::Error.new(
+      'Cannot reset network conditions: rule-based emulation is enabled.',
+    )
+  end
 
   # used only in Browser#connected?
   def closed?
@@ -176,6 +187,7 @@ class Puppeteer::Connection
   end
 
   def async_send_message(method, params = {})
+    ensure_command_allowed!(method)
     promise = Async::Promise.new
 
     generate_id do |id|
@@ -332,6 +344,10 @@ class Puppeteer::Connection
         else
           callback.resolve(message['result'])
         end
+      else
+        sessions = @sessions_mutex.synchronize { @sessions.values }
+        session = sessions.find { |candidate| candidate.callback?(message['id']) }
+        session&.handle_message(message)
       end
     else
       emit_event(message['method'], message['params'])
@@ -396,3 +412,6 @@ class Puppeteer::Connection
     @sessions_mutex.synchronize { @sessions[session_id] }.tap { |session| session&.mark_ready }
   end
 end
+
+# ref: https://github.com/puppeteer/puppeteer/blob/main/packages/puppeteer-core/src/common/Errors.ts
+class Puppeteer::TargetCloseError < Puppeteer::Connection::ProtocolError; end

data/lib/puppeteer/coverage.rb

@@ -5,6 +5,11 @@ class Puppeteer::Coverage
     @css = Puppeteer::CSSCoverage.new(client)
   end
 
+  def update_client(client)
+    @js.update_client(client)
+    @css.update_client(client)
+  end
+
   def start_js_coverage(
         reset_on_navigation: nil,
         report_anonymous_scripts: nil,

data/lib/puppeteer/css_coverage.rb

@@ -20,6 +20,10 @@ class Puppeteer::CSSCoverage
     @stylesheet_sources = {}
   end
 
+  def update_client(client)
+    @client = client
+  end
+
   def start(reset_on_navigation: nil)
     raise 'CSSCoverage is already enabled' if @enabled
 

data/lib/puppeteer/dialog.rb

@@ -16,6 +16,11 @@ class Puppeteer::Dialog
   attr_reader :message #: String
   attr_reader :default_value #: String
 
+  # @rbs return: bool -- Whether the dialog has already been handled
+  def handled?
+    @handled
+  end
+
   # @rbs prompt_text: String? -- Text entered into the prompt
   # @rbs return: void -- No return value
   def accept(prompt_text = nil)

data/lib/puppeteer/element_handle.rb

@@ -374,14 +374,13 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
 
   # @rbs delay: Numeric? -- Delay between down and up (ms)
   # @rbs button: String? -- Mouse button
-  # @rbs click_count: Integer? -- Deprecated: use count (click_count only sets clickCount)
   # @rbs count: Integer? -- Number of clicks to perform
   # @rbs offset: Puppeteer::ElementHandle::Offset | Hash[Symbol, Numeric] | nil -- Click offset
   # @rbs return: void -- No return value
-  def click(delay: nil, button: nil, click_count: nil, count: nil, offset: nil)
+  def click(delay: nil, button: nil, count: nil, offset: nil)
     scroll_into_view_if_needed
     point = clickable_point(offset)
-    @page.mouse.click(point.x, point.y, delay: delay, button: button, click_count: click_count, count: count)
+    @page.mouse.click(point.x, point.y, delay: delay, button: button, count: count)
   end
 
   define_async_method :async_click

data/lib/puppeteer/emulation_manager.rb

@@ -1,4 +1,5 @@
 class Puppeteer::EmulationManager
+  include Puppeteer::DebugPrint
   using Puppeteer::DefineAsyncMethod
 
   # @param {!Puppeteer.CDPSession} client
@@ -6,11 +7,59 @@ class Puppeteer::EmulationManager
     @client = client
     @emulating_mobile = false
     @has_touch = false
+    @viewport = nil
+    @locale = nil
+    @locale_configured = false
+    @secondary_clients = Set.new
+  end
+
+  def update_client(client)
+    @client = client
+    @secondary_clients.delete(client)
+  end
+
+  def register_speculative_session(client)
+    @secondary_clients << client
+    client.once(CDPSessionEmittedEvents::Disconnected) do
+      @secondary_clients.delete(client)
+    end
+    promises = []
+    promises.concat(viewport_promises(client, @viewport)) if @viewport
+    if @locale_configured
+      promises << client.async_send_message(
+        'Emulation.setLocaleOverride',
+        { locale: @locale }.compact,
+      )
+    end
+    return if promises.empty?
+
+    Async do
+      Puppeteer::AsyncUtils.await_promise_all(*promises)
+    rescue => err
+      debug_puts(err)
+    end
   end
 
   # @param viewport [Puppeteer::Viewport]
   # @return [true|false]
   def emulate_viewport(viewport)
+    mobile = viewport.mobile?
+    has_touch = viewport.has_touch?
+
+    apply_viewport(@client, viewport)
+    @viewport = viewport
+
+    reload_needed = @emulating_mobile != mobile || @has_touch != has_touch
+    @emulating_mobile = mobile
+    @has_touch = has_touch
+    reload_needed
+  end
+
+  private def apply_viewport(client, viewport)
+    Puppeteer::AsyncUtils.await_promise_all(*viewport_promises(client, viewport))
+  end
+
+  private def viewport_promises(client, viewport)
     mobile = viewport.mobile?
     width = viewport.width
     height = viewport.height
@@ -23,24 +72,36 @@ class Puppeteer::EmulationManager
       end
     has_touch = viewport.has_touch?
 
-    Puppeteer::AsyncUtils.await_promise_all(
-      @client.async_send_message('Emulation.setDeviceMetricsOverride',
+    [
+      client.async_send_message('Emulation.setDeviceMetricsOverride',
         mobile: mobile,
         width: width,
         height: height,
         deviceScaleFactor: device_scale_factor,
         screenOrientation: screen_orientation,
       ),
-      @client.async_send_message('Emulation.setTouchEmulationEnabled',
+      client.async_send_message('Emulation.setTouchEmulationEnabled',
         enabled: has_touch,
       ),
-    )
-
-    reload_needed = @emulating_mobile != mobile || @has_touch != has_touch
-    @emulating_mobile = mobile
-    @has_touch = has_touch
-    reload_needed
+    ]
   end
 
   define_async_method :async_emulate_viewport
+
+  # @rbs locale: String? -- Locale to emulate, or nil to disable emulation
+  # @rbs return: void -- No return value
+  def emulate_locale(locale)
+    @locale = locale
+    @locale_configured = true
+    clients = [@client, *@secondary_clients]
+    promises = clients.map do |client|
+      client.async_send_message(
+        'Emulation.setLocaleOverride',
+        { locale: locale }.compact,
+      )
+    end
+    Puppeteer::AsyncUtils.await_promise_all(*promises)
+  end
+
+  define_async_method :async_emulate_locale
 end

data/lib/puppeteer/events.rb

@@ -35,6 +35,7 @@ module CDPSessionEmittedEvents ; end
 {
   Disconnected: EventsDefinitionUtils.symbol('CDPSession.Disconnected'),
   Ready: EventsDefinitionUtils.symbol('CDPSession.Ready'),
+  Swapped: EventsDefinitionUtils.symbol('CDPSession.Swapped'),
 }.define_const_into(CDPSessionEmittedEvents)
 
 # All the events a Browser may emit.
@@ -98,6 +99,7 @@ module FrameManagerEmittedEvents ; end
   FrameNavigated: EventsDefinitionUtils.symbol('FrameManager.FrameNavigated'),
   FrameDetached: EventsDefinitionUtils.symbol('FrameManager.FrameDetached'),
   FrameSwapped: EventsDefinitionUtils.symbol('FrameManager.FrameSwapped'),
+  FrameSwappedByActivation: EventsDefinitionUtils.symbol('FrameManager.FrameSwappedByActivation'),
   LifecycleEvent: EventsDefinitionUtils.symbol('FrameManager.LifecycleEvent'),
   FrameNavigatedWithinDocument: EventsDefinitionUtils.symbol('FrameManager.FrameNavigatedWithinDocument'),
   ExecutionContextCreated: EventsDefinitionUtils.symbol('FrameManager.ExecutionContextCreated'),

data/lib/puppeteer/execution_context.rb

@@ -2,6 +2,7 @@
 
 class Puppeteer::ExecutionContext
   include Puppeteer::IfPresent
+  include Puppeteer::EventCallbackable
   using Puppeteer::DefineAsyncMethod
 
   EVALUATION_SCRIPT_URL = 'pprt://__puppeteer_evaluation_script__'
@@ -19,6 +20,11 @@ class Puppeteer::ExecutionContext
 
   attr_reader :client, :world
 
+  # @rbs return: void -- Notify consumers that this context was destroyed
+  def dispose
+    emit_event('disposed')
+  end
+
   # only used in IsolaatedWorld
   private def _context_id
     @context_id
@@ -353,6 +359,7 @@ class Puppeteer::ExecutionContext
     message = error.message
     if message.end_with?('Cannot find context with specified id') ||
        message.end_with?('Inspected target navigated or closed')
+
       return Puppeteer::Error.new('Execution context was destroyed, most likely because of a navigation.')
     end
 

data/lib/puppeteer/extension.rb

@@ -38,11 +38,16 @@ class Puppeteer::Extension
     extension_targets = @browser.targets.select do |target|
       target.type == 'service_worker' && target.url.start_with?(extension_prefix)
     end
-    extension_targets.filter_map do |target|
-      target.worker
-    rescue
-      nil
+    tasks = extension_targets.map do |target|
+      proc do
+        target.worker
+      rescue => error
+        raise unless can_ignore_error?(error)
+
+        nil
+      end
     end
+    Puppeteer::AsyncUtils.await_promise_all(*tasks).compact
   end
 
   # @rbs return: Array[Puppeteer::Page] -- Extension pages
@@ -54,15 +59,24 @@ class Puppeteer::Extension
     end
     extension_targets.filter_map do |target|
       target.as_page
-    rescue
+    rescue => error
+      raise unless can_ignore_error?(error)
+
       nil
     end
   end
 
+  # @rbs error: StandardError -- Error raised while resolving an extension target
+  # @rbs return: bool -- Whether the target resolution error can be ignored
+  private def can_ignore_error?(error)
+    error.is_a?(Puppeteer::TargetCloseError) ||
+      error.message.include?('No target with given id found')
+  end
+
   # @rbs page: Puppeteer::Page -- Target page
   # @rbs return: void -- No return value
   def trigger_action(page)
-    page.browser.send(:connection).send_message('Extensions.triggerAction', {
+    @browser.send(:connection).send_message('Extensions.triggerAction', {
       id: @id,
       targetId: page._tab_id,
     })