puppeteer-ruby 0.45.6 → 0.50.0.alpha5

data/lib/puppeteer/launcher.rb

@@ -1,7 +1,6 @@
 require_relative './launcher/browser_options'
 require_relative './launcher/chrome'
 require_relative './launcher/chrome_arg_options'
-require_relative './launcher/firefox'
 require_relative './launcher/launch_options'
 
 # https://github.com/puppeteer/puppeteer/blob/main/src/node/Launcher.ts
@@ -9,19 +8,16 @@ module Puppeteer::Launcher
   # @param project_root [String]
   # @param prefereed_revision [String]
   # @param is_puppeteer_core [String]
-  # @param product [String] 'chrome' or 'firefox'
+  # @param product [String] 'chrome'
   # @return [Puppeteer::Launcher::Chrome]
   module_function def new(project_root:, preferred_revision:, is_puppeteer_core:, product:)
     unless is_puppeteer_core
       product ||= ENV['PUPPETEER_PRODUCT']
     end
 
-    if product == 'firefox'
-      return Firefox.new(
-        project_root: project_root,
-        preferred_revision: preferred_revision,
-        is_puppeteer_core: is_puppeteer_core,
-      )
+    product = product.to_s if product
+    if product && product != 'chrome'
+      raise ArgumentError.new("Unsupported product: #{product}. Only 'chrome' is supported.")
     end
 
     Chrome.new(

data/lib/puppeteer/lifecycle_watcher.rb

@@ -50,12 +50,12 @@ class Puppeteer::LifecycleWatcher
     end
   end
 
-  class FrameDetachedError < StandardError
+  class FrameDetachedError < Puppeteer::Error
     def initialize
       super('Navigating frame was detached')
     end
   end
-  class TerminatedError < StandardError; end
+  class TerminatedError < Puppeteer::Error; end
 
   #  * @param {!Puppeteer.FrameManager} frameManager
   #  * @param {!Puppeteer.Frame} frame
@@ -72,6 +72,12 @@ class Puppeteer::LifecycleWatcher
     @listener_ids['client'] = @frame_manager.client.add_event_listener(CDPSessionEmittedEvents::Disconnected) do
       terminate(TerminatedError.new('Navigation failed because browser has disconnected!'))
     end
+    connection = @frame_manager.client.respond_to?(:connection) ? @frame_manager.client.connection : nil
+    if connection
+      @listener_ids['connection'] = connection.add_event_listener(ConnectionEmittedEvents::Disconnected) do
+        terminate(TerminatedError.new('Navigation failed because browser has disconnected!'))
+      end
+    end
     @listener_ids['frame_manager'] = [
       @frame_manager.add_event_listener(FrameManagerEmittedEvents::LifecycleEvent) do |_|
         check_lifecycle_complete
@@ -87,24 +93,28 @@ class Puppeteer::LifecycleWatcher
       @frame_manager.network_manager.add_event_listener(NetworkManagerEmittedEvents::RequestFailed, &method(:handle_request_failed)),
     ]
 
-    @same_document_navigation_promise = resolvable_future
-    @lifecycle_promise = resolvable_future
-    @new_document_navigation_promise = resolvable_future
-    @termination_promise = resolvable_future
+    @same_document_navigation_promise = Async::Promise.new
+    @lifecycle_promise = Async::Promise.new
+    @new_document_navigation_promise = Async::Promise.new
+    @termination_promise = Async::Promise.new
+    @navigation_response_received = Async::Promise.new.tap { |promise| promise.resolve(nil) }
     check_lifecycle_complete
   end
 
   # @param [Puppeteer::HTTPRequest] request
   def handle_request(request)
     return if request.frame != @frame || !request.navigation_request?
+    if @navigation_request && request.redirect_chain.empty?
+      return
+    end
     @navigation_request = request
     # Resolve previous navigation response in case there are multiple
     # navigation requests reported by the backend. This generally should not
     # happen by it looks like it's possible.
-    @navigation_response_received.fulfill(nil) if @navigation_response_received && !@navigation_response_received.resolved?
-    @navigation_response_received = resolvable_future
+    @navigation_response_received.resolve(nil) if @navigation_response_received && !@navigation_response_received.resolved?
+    @navigation_response_received = Async::Promise.new
     if request.response && !@navigation_response_received.resolved?
-      @navigation_response_received.fulfill(nil)
+      @navigation_response_received.resolve(nil)
     end
   end
 
@@ -112,14 +122,14 @@ class Puppeteer::LifecycleWatcher
   def handle_request_failed(request)
     return if @navigation_request&.internal&.request_id != request.internal.request_id
 
-    @navigation_response_received.fulfill(nil) unless @navigation_response_received.resolved?
+    @navigation_response_received.resolve(nil) unless @navigation_response_received.resolved?
   end
 
   # @param [Puppeteer::HTTPResponse] response
   def handle_response(response)
     return if @navigation_request&.internal&.request_id != response.request.internal.request_id
 
-    @navigation_response_received.fulfill(nil) unless @navigation_response_received.resolved?
+    @navigation_response_received.resolve(nil) unless @navigation_response_received.resolved?
   end
 
   # @param frame [Puppeteer::Frame]
@@ -134,7 +144,7 @@ class Puppeteer::LifecycleWatcher
   # @return [Puppeteer::HTTPResponse]
   def navigation_response
     # Continue with a possibly null response.
-    @navigation_response_received.value! rescue nil
+    @navigation_response_received.wait rescue nil
     if_present(@navigation_request) do |request|
       request.response
     end
@@ -142,6 +152,8 @@ class Puppeteer::LifecycleWatcher
 
   # @param error [TerminatedError]
   private def terminate(error)
+    return if @termination_promise.resolved?
+
     @termination_promise.reject(error)
   end
 
@@ -153,12 +165,12 @@ class Puppeteer::LifecycleWatcher
 
   def timeout_or_termination_promise
     if @timeout > 0
-      future do
-        Timeout.timeout(@timeout / 1000.0) do
-          @termination_promise.value!
+      -> do
+        begin
+          Puppeteer::AsyncUtils.async_timeout(@timeout, @termination_promise).wait
+        rescue Async::TimeoutError
+          raise Puppeteer::TimeoutError.new("Navigation timeout of #{@timeout} ms exceeded")
         end
-      rescue Timeout::Error
-        raise Puppeteer::TimeoutError.new("Navigation timeout of #{@timeout}ms exceeded")
       end
     else
       @termination_promise
@@ -187,12 +199,12 @@ class Puppeteer::LifecycleWatcher
   private def check_lifecycle_complete
     # We expect navigation to commit.
     return unless @expected_lifecycle.completed?(@frame)
-    @lifecycle_promise.fulfill(true) if @lifecycle_promise.pending?
-    if @has_same_document_navigation && @same_document_navigation_promise.pending?
-      @same_document_navigation_promise.fulfill(true)
+    @lifecycle_promise.resolve(true) unless @lifecycle_promise.resolved?
+    if @has_same_document_navigation && !@same_document_navigation_promise.resolved?
+      @same_document_navigation_promise.resolve(true)
     end
-    if (@swapped || @frame.loader_id != @initial_loader_id) && @new_document_navigation_promise.pending?
-      @new_document_navigation_promise.fulfill(true)
+    if (@swapped || @frame.loader_id != @initial_loader_id) && !@new_document_navigation_promise.resolved?
+      @new_document_navigation_promise.resolve(true)
     end
   end
 
@@ -203,6 +215,10 @@ class Puppeteer::LifecycleWatcher
     if_present(@listener_ids['frame_manager']) do |ids|
       @frame_manager.remove_event_listener(*ids)
     end
+    if_present(@listener_ids['connection']) do |id|
+      connection = @frame_manager.client.respond_to?(:connection) ? @frame_manager.client.connection : nil
+      connection&.remove_event_listener(id)
+    end
     if_present(@listener_ids['network_manager']) do |ids|
       @frame_manager.network_manager.remove_event_listener(*ids)
     end

data/lib/puppeteer/mouse.rb

@@ -1,3 +1,5 @@
+# rbs_inline: enabled
+
 class Puppeteer::Mouse
   using Puppeteer::DefineAsyncMethod
 
@@ -6,124 +8,232 @@ class Puppeteer::Mouse
     LEFT = 'left'
     RIGHT = 'right'
     MIDDLE = 'middle'
+    BACK = 'back'
+    FORWARD = 'forward'
+  end
+
+  module ButtonFlag
+    NONE = 0
+    LEFT = 1
+    RIGHT = 1 << 1
+    MIDDLE = 1 << 2
+    BACK = 1 << 3
+    FORWARD = 1 << 4
   end
 
-  # @param {Puppeteer.CDPSession} client
-  # @param keyboard [Puppeteer::Keyboard]
+  # @rbs client: Puppeteer::CDPSession -- CDP session
+  # @rbs keyboard: Puppeteer::Keyboard -- Keyboard instance
+  # @rbs return: void -- No return value
   def initialize(client, keyboard)
     @client = client
     @keyboard = keyboard
 
-    @x = 0
-    @y = 0
-    @button = Button::NONE
+    @base_state = {
+      position: {
+        x: 0,
+        y: 0,
+      },
+      buttons: ButtonFlag::NONE,
+    }
+    @transactions = []
+    @state_mutex = Mutex.new
+    @dispatch_mutex = Mutex.new
+  end
+
+  # @rbs return: void -- No return value
+  def reset
+    [
+      [ButtonFlag::RIGHT, Button::RIGHT],
+      [ButtonFlag::MIDDLE, Button::MIDDLE],
+      [ButtonFlag::LEFT, Button::LEFT],
+      [ButtonFlag::FORWARD, Button::FORWARD],
+      [ButtonFlag::BACK, Button::BACK],
+    ].each do |flag, button|
+      up(button: button) if (state[:buttons] & flag) != 0
+    end
+    if state[:position][:x] != 0 || state[:position][:y] != 0
+      move(0, 0)
+    end
   end
 
-  # @param x [number]
-  # @param y [number]
-  # @param steps [number]
+  define_async_method :async_reset
+
+  # @rbs x: Numeric -- X coordinate
+  # @rbs y: Numeric -- Y coordinate
+  # @rbs steps: Integer? -- Number of intermediate steps
+  # @rbs return: void -- No return value
   def move(x, y, steps: nil)
     move_steps = (steps || 1).to_i
 
-    from_x = @x
-    from_y = @y
-    @x = x
-    @y = y
+    from = state[:position]
+    to = {
+      x: x,
+      y: y,
+    }
 
     return if move_steps <= 0
 
-    move_steps.times do |i|
-      n = i + 1
-      @client.send_message('Input.dispatchMouseEvent',
-        type: 'mouseMoved',
-        button: @button,
-        x: from_x + (@x - from_x) * n / move_steps,
-        y: from_y + (@y - from_y) * n / move_steps,
-        modifiers: @keyboard.modifiers,
-      )
+    1.upto(move_steps) do |i|
+      with_transaction do |update_state|
+        update_state.call(
+          position: {
+            x: from[:x] + (to[:x] - from[:x]) * i / move_steps.to_f,
+            y: from[:y] + (to[:y] - from[:y]) * i / move_steps.to_f,
+          },
+        )
+        current_state = state
+        buttons = current_state[:buttons]
+        position = current_state[:position]
+        @client.send_message('Input.dispatchMouseEvent',
+          type: 'mouseMoved',
+          modifiers: @keyboard.modifiers,
+          buttons: buttons,
+          button: button_from_pressed_buttons(buttons),
+          x: position[:x],
+          y: position[:y],
+        )
+      end
     end
   end
 
   define_async_method :async_move
 
-  # @param x [number]
-  # @param y [number]
-  # @param {!{delay?: number, button?: "left"|"right"|"middle", clickCount?: number}=} options
-  def click(x, y, delay: nil, button: nil, click_count: nil)
-    # await_all(async_move, async_down, async_up) often breaks the order of CDP commands.
-    # D, [2020-04-15T17:09:47.895895 #88683] DEBUG -- : RECV << {"id"=>23, "result"=>{"layoutViewport"=>{"pageX"=>0, "pageY"=>1, "clientWidth"=>375, "clientHeight"=>667}, "visualViewport"=>{"offsetX"=>0, "offsetY"=>0, "pageX"=>0, "pageY"=>1, "clientWidth"=>375, "clientHeight"=>667, "scale"=>1, "zoom"=>1}, "contentSize"=>{"x"=>0, "y"=>0, "width"=>375, "height"=>2007}}, "sessionId"=>"0B09EA5E18DEE403E525B3E7FCD7E225"}
-    # D, [2020-04-15T17:09:47.898422 #88683] DEBUG -- : SEND >> {"sessionId":"0B09EA5E18DEE403E525B3E7FCD7E225","method":"Input.dispatchMouseEvent","params":{"type":"mouseReleased","button":"left","x":0,"y":0,"modifiers":0,"clickCount":1},"id":24}
-    # D, [2020-04-15T17:09:47.899711 #88683] DEBUG -- : SEND >> {"sessionId":"0B09EA5E18DEE403E525B3E7FCD7E225","method":"Input.dispatchMouseEvent","params":{"type":"mousePressed","button":"left","x":0,"y":0,"modifiers":0,"clickCount":1},"id":25}
-    # D, [2020-04-15T17:09:47.900237 #88683] DEBUG -- : SEND >> {"sessionId":"0B09EA5E18DEE403E525B3E7FCD7E225","method":"Input.dispatchMouseEvent","params":{"type":"mouseMoved","button":"left","x":187,"y":283,"modifiers":0},"id":26}
-    # So we execute them sequential
-    move(x, y)
-    down(button: button, click_count: click_count)
-    if delay
-      sleep(delay / 1000.0)
+  # @rbs x: Numeric -- X coordinate
+  # @rbs y: Numeric -- Y coordinate
+  # @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 click repetitions
+  # @rbs return: void -- No return value
+  def click(x, y, delay: nil, button: nil, click_count: nil, count: nil)
+    warn_deprecated_click_count if !click_count.nil?
+    count ||= 1
+    click_count ||= count
+    if count < 1
+      raise Puppeteer::Error.new('Click must occur a positive number of times.')
+    end
+    # Serialize click sequences to keep event ordering stable under thread-based concurrency.
+    @dispatch_mutex.synchronize do
+      move(x, y)
+      if click_count == count
+        1.upto(count - 1) do |i|
+          down(button: button, click_count: i)
+          up(button: button, click_count: i)
+        end
+      end
+      down(button: button, click_count: click_count)
+      if !delay.nil?
+        Puppeteer::AsyncUtils.sleep_seconds(delay / 1000.0)
+      end
+      up(button: button, click_count: click_count)
     end
-    up(button: button, click_count: click_count)
   end
 
   define_async_method :async_click
 
-  # @param {!{button?: "left"|"right"|"middle", clickCount?: number}=} options
+  private def warn_deprecated_click_count
+    return if self.class.deprecated_click_count_warned
+
+    self.class.deprecated_click_count_warned = true
+    warn('DEPRECATED: `click_count` is deprecated; use `count` instead.')
+  end
+
+  class << self
+    attr_accessor :deprecated_click_count_warned
+  end
+
+  self.deprecated_click_count_warned = false
+
+  # @rbs button: String? -- Mouse button
+  # @rbs click_count: Integer? -- Click count to report
+  # @rbs return: void -- No return value
   def down(button: nil, click_count: nil)
-    @button = button || Button::LEFT
-    @client.send_message('Input.dispatchMouseEvent',
-      type: 'mousePressed',
-      button: @button,
-      x: @x,
-      y: @y,
-      modifiers: @keyboard.modifiers,
-      clickCount: click_count || 1,
-    )
+    button ||= Button::LEFT
+    flag = button_flag(button)
+    with_transaction do |update_state|
+      update_state.call(
+        buttons: state[:buttons] | flag,
+      )
+      current_state = state
+      position = current_state[:position]
+      @client.send_message('Input.dispatchMouseEvent',
+        type: 'mousePressed',
+        modifiers: @keyboard.modifiers,
+        clickCount: click_count || 1,
+        buttons: current_state[:buttons],
+        button: button,
+        x: position[:x],
+        y: position[:y],
+      )
+    end
   end
 
   define_async_method :async_down
 
-  # @param {!{button?: "left"|"right"|"middle", clickCount?: number}=} options
+  # @rbs button: String? -- Mouse button
+  # @rbs click_count: Integer? -- Click count to report
+  # @rbs return: void -- No return value
   def up(button: nil, click_count: nil)
-    @button = Button::NONE
-    @client.send_message('Input.dispatchMouseEvent',
-      type: 'mouseReleased',
-      button: button || Button::LEFT,
-      x: @x,
-      y: @y,
-      modifiers: @keyboard.modifiers,
-      clickCount: click_count || 1,
-    )
+    button ||= Button::LEFT
+    flag = button_flag(button)
+    with_transaction do |update_state|
+      update_state.call(
+        buttons: state[:buttons] & ~flag,
+      )
+      current_state = state
+      position = current_state[:position]
+      @client.send_message('Input.dispatchMouseEvent',
+        type: 'mouseReleased',
+        modifiers: @keyboard.modifiers,
+        clickCount: click_count || 1,
+        buttons: current_state[:buttons],
+        button: button,
+        x: position[:x],
+        y: position[:y],
+      )
+    end
   end
 
   define_async_method :async_up
 
   # Dispatches a `mousewheel` event.
   #
-  # @param delta_x [Integer]
-  # @param delta_y [Integer]
+  # @rbs delta_x: Numeric -- Scroll delta X
+  # @rbs delta_y: Numeric -- Scroll delta Y
+  # @rbs return: void -- No return value
   def wheel(delta_x: 0, delta_y: 0)
+    current_state = state
+    position = current_state[:position]
     @client.send_message('Input.dispatchMouseEvent',
       type: 'mouseWheel',
-      x: @x,
-      y: @y,
+      x: position[:x],
+      y: position[:y],
       deltaX: delta_x,
       deltaY: delta_y,
       modifiers: @keyboard.modifiers,
       pointerType: 'mouse',
+      buttons: current_state[:buttons],
     )
   end
 
+  # @rbs start: Puppeteer::ElementHandle::Point -- Drag start point
+  # @rbs target: Puppeteer::ElementHandle::Point -- Drag end point
+  # @rbs return: Hash[String, untyped] -- Drag data payload
   def drag(start, target)
-    promise = resolvable_future do |f|
+    promise = Async::Promise.new.tap do |future|
       @client.once('Input.dragIntercepted') do |event|
-        f.fulfill(event['data'])
+        future.resolve(event['data'])
       end
     end
     move(start.x, start.y)
     down
     move(target.x, target.y)
-    promise.value!
+    promise.wait
   end
 
+  # @rbs target: Puppeteer::ElementHandle::Point -- Drag target point
+  # @rbs data: Hash[String, untyped] -- Drag data payload
+  # @rbs return: void -- No return value
   def drag_enter(target, data)
     @client.send_message('Input.dispatchDragEvent',
       type: 'dragEnter',
@@ -134,6 +244,9 @@ class Puppeteer::Mouse
     )
   end
 
+  # @rbs target: Puppeteer::ElementHandle::Point -- Drag target point
+  # @rbs data: Hash[String, untyped] -- Drag data payload
+  # @rbs return: void -- No return value
   def drag_over(target, data)
     @client.send_message('Input.dispatchDragEvent',
       type: 'dragOver',
@@ -144,6 +257,9 @@ class Puppeteer::Mouse
     )
   end
 
+  # @rbs target: Puppeteer::ElementHandle::Point -- Drag target point
+  # @rbs data: Hash[String, untyped] -- Drag data payload
+  # @rbs return: void -- No return value
   def drop(target, data)
     @client.send_message('Input.dispatchDragEvent',
       type: 'drop',
@@ -154,14 +270,107 @@ class Puppeteer::Mouse
     )
   end
 
+  # @rbs start: Puppeteer::ElementHandle::Point -- Drag start point
+  # @rbs target: Puppeteer::ElementHandle::Point -- Drag end point
+  # @rbs delay: Numeric? -- Delay before drop (ms)
+  # @rbs return: void -- No return value
   def drag_and_drop(start, target, delay: nil)
     data = drag(start, target)
     drag_enter(target, data)
     drag_over(target, data)
     if delay
-      sleep(delay / 1000.0)
+      Puppeteer::AsyncUtils.sleep_seconds(delay / 1000.0)
     end
     drop(target, data)
     up
   end
+
+  private def state
+    @state_mutex.synchronize do
+      merged = {
+        position: {
+          x: @base_state[:position][:x],
+          y: @base_state[:position][:y],
+        },
+        buttons: @base_state[:buttons],
+      }
+      @transactions.each do |transaction|
+        if transaction.key?(:position)
+          merged[:position] = transaction[:position]
+        end
+        if transaction.key?(:buttons)
+          merged[:buttons] = transaction[:buttons]
+        end
+      end
+      merged
+    end
+  end
+
+  # @rbs block: Proc -- Block receiving state update callback
+  # @rbs return: untyped -- Block result
+  private def with_transaction(&block)
+    transaction = {}
+    @state_mutex.synchronize do
+      @transactions << transaction
+    end
+
+    begin
+      update_state = lambda do |updates|
+        @state_mutex.synchronize do
+          transaction.merge!(updates)
+        end
+      end
+      block.call(update_state)
+
+      @state_mutex.synchronize do
+        @base_state = merge_state(@base_state, transaction)
+        @transactions.delete(transaction)
+      end
+    rescue
+      @state_mutex.synchronize do
+        @transactions.delete(transaction)
+      end
+      raise
+    end
+  end
+
+  private def merge_state(base_state, transaction)
+    merged = base_state.dup
+    merged[:position] = transaction[:position] if transaction.key?(:position)
+    merged[:buttons] = transaction[:buttons] if transaction.key?(:buttons)
+    merged
+  end
+
+  private def button_flag(button)
+    case button
+    when Button::LEFT
+      ButtonFlag::LEFT
+    when Button::RIGHT
+      ButtonFlag::RIGHT
+    when Button::MIDDLE
+      ButtonFlag::MIDDLE
+    when Button::BACK
+      ButtonFlag::BACK
+    when Button::FORWARD
+      ButtonFlag::FORWARD
+    else
+      raise Puppeteer::Error.new("Unsupported mouse button: #{button}")
+    end
+  end
+
+  private def button_from_pressed_buttons(buttons)
+    if (buttons & ButtonFlag::LEFT) != 0
+      Button::LEFT
+    elsif (buttons & ButtonFlag::RIGHT) != 0
+      Button::RIGHT
+    elsif (buttons & ButtonFlag::MIDDLE) != 0
+      Button::MIDDLE
+    elsif (buttons & ButtonFlag::BACK) != 0
+      Button::BACK
+    elsif (buttons & ButtonFlag::FORWARD) != 0
+      Button::FORWARD
+    else
+      Button::NONE
+    end
+  end
 end

data/lib/puppeteer/network_event_manager.rb

@@ -44,6 +44,7 @@ class Puppeteer::NetworkEventManager
     # handle redirects, we have to make them Arrays to represent the chain of
     # events.
     @response_received_extra_info_map = {}
+    @request_will_be_sent_extra_info_map = {}
     @queued_redirect_info_map = {}
     @queued_event_group_map = {}
   end
@@ -51,11 +52,16 @@ class Puppeteer::NetworkEventManager
   def forget(network_request_id)
     @request_will_be_sent_map.delete(network_request_id)
     @request_paused_map.delete(network_request_id)
+    @request_will_be_sent_extra_info_map.delete(network_request_id)
     @queued_event_group_map.delete(network_request_id)
     @queued_redirect_info_map.delete(network_request_id)
     @response_received_extra_info_map.delete(network_request_id)
   end
 
+  def request_extra_info(network_request_id)
+    @request_will_be_sent_extra_info_map[network_request_id] ||= []
+  end
+
   def response_extra_info(network_request_id)
     @response_received_extra_info_map[network_request_id] ||= []
   end
@@ -108,6 +114,7 @@ class Puppeteer::NetworkEventManager
     @http_requests_map[network_request_id]
   end
 
+
   def forget_request(network_request_id)
     @http_requests_map.delete(network_request_id)
   end