puppeteer-ruby 0.37.1 → 0.38.0

data/lib/puppeteer/{request.rb → http_request.rb}

@@ -1,4 +1,4 @@
-class Puppeteer::Request
+class Puppeteer::HTTPRequest
   include Puppeteer::DebugPrint
   include Puppeteer::IfPresent
 
@@ -16,7 +16,7 @@ class Puppeteer::Request
       @request.instance_variable_get(:@interception_id)
     end
 
-    # @param response [Puppeteer::Response]
+    # @param response [Puppeteer::HTTPResponse]
     def response=(response)
       @request.instance_variable_set(:@response, response)
     end
@@ -56,6 +56,12 @@ class Puppeteer::Request
     @post_data = event['request']['postData']
     @frame = frame
     @redirect_chain = redirect_chain
+    @continue_request_overrides = {}
+    @current_strategy = 'none'
+    @current_priority = nil
+    @intercept_actions = []
+    @initiator = event['initiator']
+
     @headers = {}
     event['request']['headers'].each do |key, value|
       @headers[key.downcase] = value
@@ -66,7 +72,85 @@ class Puppeteer::Request
   end
 
   attr_reader :internal
-  attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame
+  attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame, :initiator
+
+  def inspect
+    values = %i[request_id method url].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::HTTPRequest #{values.join(' ')}>"
+  end
+
+  private def assert_interception_allowed
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+  end
+
+  private def assert_interception_not_handled
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+  end
+
+  # @returns the `ContinueRequestOverrides` that will be used
+  # if the interception is allowed to continue (ie, `abort()` and
+  # `respond()` aren't called).
+  def continue_request_overrides
+    assert_interception_allowed
+    @continue_request_overrides
+  end
+
+  # @returns The `ResponseForRequest` that gets used if the
+  # interception is allowed to respond (ie, `abort()` is not called).
+  def response_for_request
+    assert_interception_allowed
+    @response_for_request
+  end
+
+  # @returns the most recent reason for aborting the request
+  def abort_error_reason
+    assert_interception_allowed
+    @abort_error_reason
+  end
+
+  # @returns An array of the current intercept resolution strategy and priority
+  # `[strategy,priority]`. Strategy is one of: `abort`, `respond`, `continue`,
+  #  `disabled`, `none`, or `already-handled`.
+  def intercept_resolution
+    if !@allow_interception
+      ['disabled']
+    elsif @interception_handled
+      ['already-handled']
+    else
+      [@current_strategy, @current_priority]
+    end
+  end
+
+  # Adds an async request handler to the processing queue.
+  # Deferred handlers are not guaranteed to execute in any particular order,
+  # but they are guarnateed to resolve before the request interception
+  # is finalized.
+  #
+  # @param pending_handler [Proc]
+  def enqueue_intercept_action(pending_handler)
+    @intercept_actions << pending_handler
+  end
+
+  # Awaits pending interception handlers and then decides how to fulfill
+  # the request interception.
+  def finalize_interceptions
+    @intercept_actions.each(&:call)
+    case @intercept_resolution
+    when :abort
+      abort_impl(**@abort_error_reason)
+    when :respond
+      respond_impl(**@response_for_request)
+    when :continue
+      continue_impl(@continue_request_overrides)
+    end
+  end
 
   def navigation_request?
     @is_navigation_request
@@ -116,24 +200,43 @@ class Puppeteer::Request
   #   end
   #
   # @param error_code [String|Symbol]
-  def continue(url: nil, method: nil, post_data: nil, headers: nil)
+  def continue(url: nil, method: nil, post_data: nil, headers: nil, priority: nil)
     # Request interception is not supported for data: urls.
     return if @url.start_with?('data:')
 
-    unless @allow_interception
-      raise InterceptionNotEnabledError.new
-    end
-    if @interception_handled
-      raise AlreadyHandledError.new
-    end
-    @interception_handled = true
+    assert_interception_allowed
+    assert_interception_not_handled
 
     overrides = {
       url: url,
       method: method,
-      post_data: post_data,
+      postData: post_data,
       headers: headers_to_array(headers),
     }.compact
+
+    if priority.nil?
+      continue_impl(overrides)
+      return
+    end
+
+    @continue_request_overrides = overrides
+    if @current_priority.nil? || priority > @current_priority
+      @current_strategy = :continue
+      @current_priority = priority
+      return
+    end
+
+    if priority == @current_priority
+      if @current_strategy == :abort || @current_strategy == :respond
+        return
+      end
+      @current_strategy = :continue
+    end
+  end
+
+  private def continue_impl(overrides)
+    @interception_handled = true
+
     begin
       @client.send_message('Fetch.continueRequest',
         requestId: @interception_id,
@@ -162,16 +265,40 @@ class Puppeteer::Request
   # @param headers [Hash<String, String>]
   # @param content_type [String]
   # @param body [String]
-  def respond(status: nil, headers: nil, content_type: nil, body: nil)
+  def respond(status: nil, headers: nil, content_type: nil, body: nil, priority: nil)
     # Mocking responses for dataURL requests is not currently supported.
     return if @url.start_with?('data:')
 
-    unless @allow_interception
-      raise InterceptionNotEnabledError.new
+    assert_interception_allowed
+    assert_interception_not_handled
+
+    if priority.nil?
+      respond_impl(status: status, headers: headers, content_type: content_type, body: body)
+      return
     end
-    if @interception_handled
-      raise AlreadyHandledError.new
+
+    @response_for_request = {
+      status: status,
+      headers: headers,
+      content_type: content_type,
+      body: body,
+    }
+
+    if @current_priority.nil? || priority > @current_priority
+      @current_strategy = :respond
+      @current_priority = priority
+      return
+    end
+
+    if priority == @current_priority
+      if @current_strategy == :abort
+        return
+      end
+      @current_strategy = :respond
     end
+  end
+
+  private def respond_impl(status: nil, headers: nil, content_type: nil, body: nil)
     @interception_handled = true
 
     mock_response_headers = {}
@@ -191,6 +318,7 @@ class Puppeteer::Request
       responseHeaders: headers_to_array(mock_response_headers),
       body: if_present(body) { |mock_body| Base64.strict_encode64(mock_body) },
     }.compact
+
     begin
       @client.send_message('Fetch.fulfillRequest',
         requestId: @interception_id,
@@ -216,7 +344,7 @@ class Puppeteer::Request
   #   end
   #
   # @param error_code [String|Symbol]
-  def abort(error_code: :failed)
+  def abort(error_code: :failed, priority: nil)
     # Request interception is not supported for data: urls.
     return if @url.start_with?('data:')
 
@@ -224,12 +352,21 @@ class Puppeteer::Request
     unless error_reason
       raise ArgumentError.new("Unknown error code: #{error_code}")
     end
-    unless @allow_interception
-      raise InterceptionNotEnabledError.new
+    assert_interception_allowed
+    assert_interception_not_handled
+
+    if priority.nil?
+      abort_impl(error_reason)
     end
-    if @interception_handled
-      raise AlreadyHandledError.new
+    @abort_error_reason = error_reason
+
+    if @current_priority.nil? || priority > @current_priority
+      @current_strategy = :abort
+      @current_priority = priority
     end
+  end
+
+  private def abort_impl(error_reason)
     @interception_handled = true
 
     begin

data/lib/puppeteer/{response.rb → http_response.rb}

@@ -1,6 +1,6 @@
 require 'json'
 
-class Puppeteer::Response
+class Puppeteer::HTTPResponse
   include Puppeteer::IfPresent
 
   class Redirected < StandardError
@@ -29,7 +29,7 @@ class Puppeteer::Response
   end
 
   # @param client [Puppeteer::CDPSession]
-  # @param request [Puppeteer::Request]
+  # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
   def initialize(client, request, response_payload)
     @client = client

data/lib/puppeteer/launcher/chrome.rb

@@ -34,13 +34,13 @@ module Puppeteer::Launcher
         if @launch_options.pipe?
           chrome_arguments << '--remote-debugging-pipe'
         else
-          chrome_arguments << '--remote-debugging-port=0'
+          chrome_arguments << "--remote-debugging-port=#{@chrome_arg_options.debugging_port}"
         end
       end
 
       temporary_user_data_dir = nil
       if chrome_arguments.none? { |arg| arg.start_with?('--user-data-dir') }
-        temporary_user_data_dir = Dir.mktmpdir('puppeteer_dev_chrome_profile-')
+        temporary_user_data_dir = Dir.mktmpdir('puppeteer_dev_chrome_profile-', ENV['PUPPETEER_TMP_DIR'])
         chrome_arguments << "--user-data-dir=#{temporary_user_data_dir}"
       end
 
@@ -48,7 +48,7 @@ module Puppeteer::Launcher
         if @launch_options.channel
           executable_path_for_channel(@launch_options.channel.to_s)
         else
-          @launch_options.executable_path || executable_path_for_channel('chrome')
+          @launch_options.executable_path || fallback_executable_path
         end
       use_pipe = chrome_arguments.include?('--remote-debugging-pipe')
       runner = Puppeteer::BrowserRunner.new(chrome_executable, chrome_arguments, temporary_user_data_dir)
@@ -78,7 +78,10 @@ module Puppeteer::Launcher
           close_callback: -> { runner.close },
         )
 
-        browser.wait_for_target(predicate: ->(target) { target.type == 'page' })
+        browser.wait_for_target(
+          predicate: ->(target) { target.type == 'page' },
+          timeout: @launch_options.timeout,
+        )
 
         browser
       rescue
@@ -216,10 +219,14 @@ module Puppeteer::Launcher
       if channel
         executable_path_for_channel(channel.to_s)
       else
-        executable_path_for_channel('chrome')
+        fallback_executable_path
       end
     end
 
+    private def fallback_executable_path
+      executable_path_for_channel('chrome')
+    end
+
     CHROMIUM_CHANNELS = {
       windows: {
         'chrome' => "#{ENV['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe",
@@ -236,7 +243,16 @@ module Puppeteer::Launcher
         'msedge' => '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
       },
       linux: {
-        'chrome' => '/opt/google/chrome/chrome',
+        'chrome' => -> {
+          Puppeteer::ExecutablePathFinder.new(
+            'google-chrome-stable',
+            'google-chrome',
+            'chrome',
+            'chromium-freeworld',
+            'chromium-browser',
+            'chromium',
+          ).find_first
+        },
         'chrome-beta' => '/opt/google/chrome-beta/chrome',
         'chrome-dev' => '/opt/google/chrome-unstable/chrome',
       },
@@ -254,6 +270,10 @@ module Puppeteer::Launcher
         end
 
       chrome_path = chrome_path_map[channel]
+      if chrome_path.is_a?(Proc)
+        chrome_path = chrome_path.call
+      end
+
       unless chrome_path
         raise ArgumentError.new("Invalid channel: '#{channel}'. Allowed channel is #{chrome_path_map.keys}")
       end

data/lib/puppeteer/launcher/chrome_arg_options.rb

@@ -34,9 +34,10 @@ module Puppeteer::Launcher
       if @headless.nil?
         @headless = !@devtools
       end
+      @debugging_port = options[:debugging_port] || 0
     end
 
-    attr_reader :args, :user_data_dir
+    attr_reader :args, :user_data_dir, :debugging_port
 
     def headless?
       @headless

data/lib/puppeteer/launcher/firefox.rb

@@ -28,7 +28,7 @@ module Puppeteer::Launcher
         end
 
       if firefox_arguments.none? { |arg| arg.start_with?('--remote-debugging-') }
-        firefox_arguments << '--remote-debugging-port=0'
+        firefox_arguments << "--remote-debugging-port=#{@chrome_arg_options.debugging_port}"
       end
 
       temporary_user_data_dir = nil
@@ -42,7 +42,7 @@ module Puppeteer::Launcher
         if @launch_options.channel
           executable_path_for_channel(@launch_options.channel.to_s)
         else
-          @launch_options.executable_path || executable_path_for_channel('nightly')
+          @launch_options.executable_path || fallback_executable_path
         end
       runner = Puppeteer::BrowserRunner.new(firefox_executable, firefox_arguments, temporary_user_data_dir)
       runner.start(
@@ -71,7 +71,10 @@ module Puppeteer::Launcher
           close_callback: -> { runner.close },
         )
 
-        browser.wait_for_target(predicate: ->(target) { target.type == 'page' })
+        browser.wait_for_target(
+          predicate: ->(target) { target.type == 'page' },
+          timeout: @launch_options.timeout,
+        )
 
         browser
       rescue
@@ -138,14 +141,18 @@ module Puppeteer::Launcher
       if channel
         executable_path_for_channel(channel.to_s)
       else
-        executable_path_for_channel('firefox')
+        fallback_executable_path
       end
     end
 
+    private def fallback_executable_path
+      executable_path_for_channel('firefox')
+    end
+
     FIREFOX_EXECUTABLE_PATHS = {
       windows: "#{ENV['PROGRAMFILES']}\\Firefox Nightly\\firefox.exe",
       darwin: '/Applications/Firefox Nightly.app/Contents/MacOS/firefox',
-      linux: '/usr/bin/firefox',
+      linux: -> { Puppeteer::ExecutablePathFinder.new('firefox').find_first },
     }.freeze
 
     # @param channel [String]
@@ -163,6 +170,9 @@ module Puppeteer::Launcher
         else
           FIREFOX_EXECUTABLE_PATHS[:linux]
         end
+      if firefox_path.is_a?(Proc)
+        firefox_path = firefox_path.call
+      end
 
       unless File.exist?(firefox_path)
         raise "Nightly version of Firefox is not installed on this system.\nExpected path: #{firefox_path}"
@@ -221,7 +231,7 @@ module Puppeteer::Launcher
     end
 
     private def create_profile(extra_prefs = {})
-      Dir.mktmpdir('puppeteer_dev_firefox_profile-').tap do |profile_path|
+      Dir.mktmpdir('puppeteer_dev_firefox_profile-', ENV['PUPPETEER_TMP_DIR']).tap do |profile_path|
         server = 'dummy.test'
         default_preferences = {
           # Make sure Shield doesn't hit the network.

data/lib/puppeteer/lifecycle_watcher.rb

@@ -88,7 +88,7 @@ class Puppeteer::LifecycleWatcher
     check_lifecycle_complete
   end
 
-  # @param [Puppeteer::Request] request
+  # @param [Puppeteer::HTTPRequest] request
   def handle_request(request)
     return if request.frame != @frame || !request.navigation_request?
     @navigation_request = request
@@ -103,7 +103,7 @@ class Puppeteer::LifecycleWatcher
     check_lifecycle_complete
   end
 
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def navigation_response
     if_present(@navigation_request) do |request|
       request.response

data/lib/puppeteer/network_manager.rb

@@ -251,9 +251,14 @@ class Puppeteer::NetworkManager
       end
     end
     frame = if_present(event['frameId']) { |frame_id| @frame_manager.frame(frame_id) }
-    request = Puppeteer::Request.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
+    request = Puppeteer::HTTPRequest.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
     @request_id_to_request[event['requestId']] = request
     emit_event(NetworkManagerEmittedEvents::Request, request)
+    begin
+      request.finalize_interceptions
+    rescue => err
+      debug_puts(err)
+    end
   end
 
   private def handle_request_served_from_cache(event)
@@ -262,13 +267,13 @@ class Puppeteer::NetworkManager
     end
   end
 
-  # @param request [Puppeteer::Request]
+  # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
   private def handle_request_redirect(request, response_payload)
-    response = Puppeteer::Response.new(@client, request, response_payload)
+    response = Puppeteer::HTTPResponse.new(@client, request, response_payload)
     request.internal.response = response
     request.internal.redirect_chain << request
-    response.internal.body_loaded_promise.reject(Puppeteer::Response::Redirected.new)
+    response.internal.body_loaded_promise.reject(Puppeteer::HTTPResponse::Redirected.new)
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
     emit_event(NetworkManagerEmittedEvents::Response, response)
@@ -281,7 +286,7 @@ class Puppeteer::NetworkManager
     # FileUpload sends a response without a matching request.
     return unless request
 
-    response = Puppeteer::Response.new(@client, request, event['response'])
+    response = Puppeteer::HTTPResponse.new(@client, request, event['response'])
     request.internal.response = response
     emit_event(NetworkManagerEmittedEvents::Response, response)
   end

data/lib/puppeteer/page/screenshot_options.rb

@@ -34,7 +34,7 @@ class Puppeteer::Page
       @type ||= 'png'
 
       if options[:quality]
-        unless @type == 'jpeg'
+        if @type != 'jpeg' && @type != 'webp'
           raise ArgumentError.new("options.quality is unsupported for the #{@type} screenshots")
         end
         unless options[:quality].is_a?(Numeric)