puppeteer-ruby 0.0.15 → 0.0.20

data/lib/puppeteer/mouse.rb

@@ -94,5 +94,21 @@ class Puppeteer::Mouse
     )
   end
 
+  # Dispatches a `mousewheel` event.
+  #
+  # @param delta_x [Integer]
+  # @param delta_y [Integer]
+  def wheel(delta_x: 0, delta_y: 0)
+    @client.send_message('Input.dispatchMouseEvent',
+      type: 'mouseWheel',
+      x: @x,
+      y: @y,
+      deltaX: delta_x,
+      deltaY: delta_y,
+      modifiers: @keyboard.modifiers,
+      pointerType: 'mouse',
+    )
+  end
+
   define_async_method :async_up
 end

data/lib/puppeteer/network_manager.rb

@@ -1,5 +1,7 @@
 class Puppeteer::NetworkManager
+  include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
+  include Puppeteer::IfPresent
 
   class Credentials
     # @param username [String|NilClass]
@@ -23,19 +25,39 @@ class Puppeteer::NetworkManager
     @request_id_to_request = {}
 
     # @type {!Map<string, !Protocol.Network.requestWillBeSentPayload>}
-    @request_id_to_request_with_be_sent_event
+    @request_id_to_request_with_be_sent_event = {}
 
     @extra_http_headers = {}
 
     @offline = false
 
-    # /** @type {!Set<string>} */
-    # this._attemptedAuthentications = new Set();
+    @attempted_authentications = Set.new
     @user_request_interception_enabled = false
     @protocol_request_interception_enabled = false
     @user_cache_disabled = false
-    # /** @type {!Map<string, string>} */
-    # this._requestIdToInterceptionId = new Map();
+    @request_id_to_interception_id = {}
+
+    @client.on_event('Fetch.requestPaused') do |event|
+      handle_request_paused(event)
+    end
+    @client.on_event('Fetch.authRequired') do |event|
+      handle_auth_required(event)
+    end
+    @client.on_event('Network.requestWillBeSent') do |event|
+      handle_request_will_be_sent(event)
+    end
+    @client.on_event('Network.requestServedFromCache') do |event|
+      handle_request_served_from_cache(event)
+    end
+    @client.on_event('Network.responseReceived') do |event|
+      handle_response_received(event)
+    end
+    @client.on_event('Network.loadingFinished') do |event|
+      handle_loading_finished(event)
+    end
+    @client.on_event('Network.loadingFailed') do |event|
+      handle_loading_failed(event)
+    end
   end
 
   def init
@@ -119,4 +141,140 @@ class Puppeteer::NetworkManager
     cache_disabled = @user_cache_disabled || @protocol_request_interception_enabled
     @client.send_message('Network.setCacheDisabled', cacheDisabled: cache_disabled)
   end
+
+  private def handle_request_will_be_sent(event)
+    # Request interception doesn't happen for data URLs with Network Service.
+    if @protocol_request_interception_enabled && !event['request']['url'].start_with?('data:')
+      request_id = event['requestId']
+      interception_id = @request_id_to_interception_id.delete(request_id)
+      if interception_id
+        handle_request(event, interception_id)
+      else
+        @request_id_to_request_with_be_sent_event[request_id] = event
+      end
+      return
+    end
+    handle_request(event, nil)
+  end
+
+  private def handle_auth_required(event)
+    response = 'Default'
+    if @attempted_authentications.include?(event['requestId'])
+      response = 'CancelAuth'
+    elsif @credentials
+      response = 'ProvideCredentials'
+      @attempted_authentications << event['requestId']
+    end
+
+    username = @credentials&.username
+    password = @credentials&.password
+
+    begin
+      @client.send_message('Fetch.continueWithAuth',
+        requestId: event['requestId'],
+        authChallengeResponse: {
+          response: response,
+          username: username,
+          password: password,
+        },
+      )
+    rescue => err
+      debug_puts(err)
+    end
+  end
+
+  private def handle_request_paused(event)
+    if !@user_request_interception_enabled && @protocol_request_interception_enabled
+      begin
+        @client.send_message('Fetch.continueRequest', requestId: event['requestId'])
+      rescue => err
+        debug_puts(err)
+      end
+    end
+
+    request_id = event['networkId']
+    interception_id = event['requestId']
+    if request_id && (request_will_be_sent_event = @request_id_to_request_with_be_sent_event.delete(request_id))
+      handle_request(request_will_be_sent_event, interception_id)
+    else
+      @request_id_to_interception_id[request_id] = interception_id
+    end
+  end
+
+  private def handle_request(event, interception_id)
+    redirect_chain = []
+    if event['redirectResponse']
+      if_present(@request_id_to_request[event['requestId']]) do |request|
+        handle_request_redirect(request, event['redirectResponse'])
+        redirect_chain = request.internal.redirect_chain
+      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_id_to_request[event['requestId']] = request
+    emit_event 'Events.NetworkManager.Request', request
+  end
+
+  private def handle_request_served_from_cache(event)
+    if_present(@request_id_to_request[event['requestId']]) do |request|
+      request.internal.from_memory_cache = true
+    end
+  end
+
+  # @param request [Puppeteer::Request]
+  # @param response_payload [Hash]
+  private def handle_request_redirect(request, response_payload)
+    response = Puppeteer::Response.new(@client, request, response_payload)
+    request.internal.response = response
+    request.internal.redirect_chain << request
+    response.internal.body_loaded_promise.reject(Puppeteer::Response::Redirected.new)
+    @request_id_to_request.delete(request.internal.request_id)
+    @attempted_authentications.delete(request.internal.interception_id)
+    emit_event 'Events.NetworkManager.Response', response
+    emit_event 'Events.NetworkManager.RequestFinished', request
+  end
+
+  # @param event [Hash]
+  private def handle_response_received(event)
+    request = @request_id_to_request[event['requestId']]
+    # FileUpload sends a response without a matching request.
+    return unless request
+
+    response = Puppeteer::Response.new(@client, request, event['response'])
+    request.internal.response = response
+    emit_event 'Events.NetworkManager.Response', response
+  end
+
+  private def handle_loading_finished(event)
+    request = @request_id_to_request[event['requestId']]
+    # For certain requestIds we never receive requestWillBeSent event.
+    # @see https://crbug.com/750469
+    return unless request
+
+
+    # Under certain conditions we never get the Network.responseReceived
+    # event from protocol. @see https://crbug.com/883475
+    if_present(request.response) do |response|
+      response.internal.body_loaded_promise.fulfill(nil)
+    end
+
+    @request_id_to_request.delete(request.internal.request_id)
+    @attempted_authentications.delete(request.internal.interception_id)
+    emit_event 'Events.NetworkManager.RequestFinished', request
+  end
+
+  private def handle_loading_failed(event)
+    request = @request_id_to_request[event['requestId']]
+    # For certain requestIds we never receive requestWillBeSent event.
+    # @see https://crbug.com/750469
+    return unless request
+
+    request.internal.failure_text = event['errorText']
+    if_present(request.response) do |response|
+      response.internal.body_loaded_promise.fulfill(nil)
+    end
+    @request_id_to_request.delete(request.internal.request_id)
+    @attempted_authentications.delete(request.internal.interception_id)
+    emit_event 'Events.NetworkManager.RequestFailed', request
+  end
 end

data/lib/puppeteer/page.rb

@@ -101,7 +101,9 @@ class Puppeteer::Page
     end
     # client.on('Runtime.consoleAPICalled', event => this._onConsoleAPI(event));
     # client.on('Runtime.bindingCalled', event => this._onBindingCalled(event));
-    # client.on('Page.javascriptDialogOpening', event => this._onDialog(event));
+    @client.on_event 'Page.javascriptDialogOpening' do |event|
+      handle_dialog_opening(event)
+    end
     # client.on('Runtime.exceptionThrown', exception => this._handleException(exception.exceptionDetails));
     # client.on('Inspector.targetCrashed', event => this._onTargetCrashed());
     # client.on('Performance.metrics', event => this._emitMetrics(event));
@@ -129,7 +131,7 @@ class Puppeteer::Page
   EVENT_MAPPINGS = {
     close: 'Events.Page.Close',
     # console: 'Events.Page.Console',
-    # dialog: 'Events.Page.Dialog',
+    dialog: 'Events.Page.Dialog',
     domcontentloaded: 'Events.Page.DOMContentLoaded',
     # error:
     frameattached: 'Events.Page.FrameAttached',
@@ -266,7 +268,13 @@ class Puppeteer::Page
     @frame_manager.main_frame
   end
 
-  attr_reader :keyboard, :touch_screen, :coverage, :accessibility
+  attr_reader :touch_screen, :coverage, :accessibility
+
+  def keyboard(&block)
+    @keyboard.instance_eval(&block) unless block.nil?
+
+    @keyboard
+  end
 
   def frames
     @frame_manager.frames
@@ -626,20 +634,17 @@ class Puppeteer::Page
   #   this.emit(Events.Page.Console, message);
   # }
 
-  # _onDialog(event) {
-  #   let dialogType = null;
-  #   if (event.type === 'alert')
-  #     dialogType = Dialog.Type.Alert;
-  #   else if (event.type === 'confirm')
-  #     dialogType = Dialog.Type.Confirm;
-  #   else if (event.type === 'prompt')
-  #     dialogType = Dialog.Type.Prompt;
-  #   else if (event.type === 'beforeunload')
-  #     dialogType = Dialog.Type.BeforeUnload;
-  #   assert(dialogType, 'Unknown javascript dialog type: ' + event.type);
-  #   const dialog = new Dialog(this._client, dialogType, event.message, event.defaultPrompt);
-  #   this.emit(Events.Page.Dialog, dialog);
-  # }
+  private def handle_dialog_opening(event)
+    dialog_type = event['type']
+    unless %w(alert confirm prompt beforeunload).include?(dialog_type)
+      raise ArgumentError.new("Unknown javascript dialog type: #{dialog_type}")
+    end
+    dialog = Puppeteer::Dialog.new(@client,
+              type: dialog_type,
+              message: event['message'],
+              default_value: event['defaultPrompt'])
+    emit_event('Events.Page.Dialog', dialog)
+  end
 
   # @return [String]
   def url
@@ -681,49 +686,111 @@ class Puppeteer::Page
     ).first
   end
 
-  # @param timeout [number|nil]
-  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
   private def wait_for_navigation(timeout: nil, wait_until: nil)
     main_frame.send(:wait_for_navigation, timeout: timeout, wait_until: wait_until)
   end
 
+  # @!method async_wait_for_navigation(timeout: nil, wait_until: nil)
+  #
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
   define_async_method :async_wait_for_navigation
 
-  # /**
-  #  * @param {(string|Function)} urlOrPredicate
-  #  * @param {!{timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.Request>}
-  #  */
-  # async waitForRequest(urlOrPredicate, options = {}) {
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Request, request => {
-  #     if (helper.isString(urlOrPredicate))
-  #       return (urlOrPredicate === request.url());
-  #     if (typeof urlOrPredicate === 'function')
-  #       return !!(urlOrPredicate(request));
-  #     return false;
-  #   }, timeout, this._sessionClosePromise());
-  # }
+  private def wait_for_network_manager_event(event_name, predicate:, timeout:)
+    option_timeout = timeout || @timeout_settings.timeout
 
-  # /**
-  #  * @param {(string|Function)} urlOrPredicate
-  #  * @param {!{timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.Response>}
-  #  */
-  # async waitForResponse(urlOrPredicate, options = {}) {
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Response, response => {
-  #     if (helper.isString(urlOrPredicate))
-  #       return (urlOrPredicate === response.url());
-  #     if (typeof urlOrPredicate === 'function')
-  #       return !!(urlOrPredicate(response));
-  #     return false;
-  #   }, timeout, this._sessionClosePromise());
-  # }
+    @wait_for_network_manager_event_listener_ids ||= {}
+    if_present(@wait_for_network_manager_event_listener_ids[event_name]) do |listener_id|
+      @frame_manager.network_manager.remove_event_listener(listener_id)
+    end
+
+    promise = resolvable_future
+
+    @wait_for_network_manager_event_listener_ids[event_name] =
+      @frame_manager.network_manager.add_event_listener(event_name) do |event_target|
+        if predicate.call(event_target)
+          promise.fulfill(nil)
+        end
+      end
+
+    begin
+      Timeout.timeout(option_timeout / 1000.0) do
+        await_any(promise, session_close_promise)
+      end
+    rescue Timeout::Error
+      raise Puppeteer::TimeoutError.new("waiting for #{event_name} failed: timeout #{timeout}ms exceeded")
+    ensure
+      @frame_manager.network_manager.remove_event_listener(@wait_for_network_manager_event_listener_ids[event_name])
+    end
+  end
+
+  private def session_close_promise
+    @disconnect_promise ||= resolvable_future do |future|
+      @client.observe_first('Events.CDPSession.Disconnected') do
+        future.reject(Puppeteer::CDPSession::Error.new('Target Closed'))
+      end
+    end
+  end
+
+  private def wait_for_request(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    request_predicate =
+      if url
+        -> (request) { request.url == url }
+      else
+        -> (request) { predicate.call(request) }
+      end
+
+    wait_for_network_manager_event('Events.NetworkManager.Request',
+      predicate: request_predicate,
+      timeout: timeout,
+    )
+  end
+
+  # @!method async_wait_for_request(url: nil, predicate: nil, timeout: nil)
+  #
+  # Waits until request URL matches or request matches the given predicate.
+  #
+  # Waits until request URL matches
+  #  wait_for_request(url: 'https://example.com/awesome')
+  #
+  # Waits until request matches the given predicate
+  #  wait_for_request(predicate: -> (req){ req.url.start_with?('https://example.com/search') })
+  #
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Request -> Boolean)]
+  define_async_method :async_wait_for_request
+
+  private def wait_for_response(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    response_predicate =
+      if url
+        -> (response) { response.url == url }
+      else
+        -> (response) { predicate.call(response) }
+      end
+
+    wait_for_network_manager_event('Events.NetworkManager.Response',
+      predicate: response_predicate,
+      timeout: timeout,
+    )
+  end
+
+  # @!method async_wait_for_response(url: nil, predicate: nil, timeout: nil)
+  #
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Request -> Boolean)]
+  define_async_method :async_wait_for_response
 
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
@@ -762,20 +829,19 @@ class Puppeteer::Page
     @client.send_message('Emulation.setScriptExecutionDisabled', value: !enabled)
   end
 
-  # /**
-  #  * @param {boolean} enabled
-  #  */
-  # async setBypassCSP(enabled) {
-  #   await this._client.send('Page.setBypassCSP', { enabled });
-  # }
+  # @param enabled [Boolean]
+  def bypass_csp=(enabled)
+    @client.send_message('Page.setBypassCSP', enabled: enabled)
+  end
 
-  # /**
-  #  * @param {?string} type
-  #  */
-  # async emulateMediaType(type) {
-  #   assert(type === 'screen' || type === 'print' || type === null, 'Unsupported media type: ' + type);
-  #   await this._client.send('Emulation.setEmulatedMedia', {media: type || ''});
-  # }
+  # @param media_type [String|Symbol|nil] either of (media, print, nil)
+  def emulate_media_type(media_type)
+    media_type_str = media_type.to_s
+    unless ['screen', 'print', ''].include?(media_type_str)
+      raise ArgumentError.new("Unsupported media type: #{media_type}")
+    end
+    @client.send_message('Emulation.setEmulatedMedia', media: media_type_str)
+  end
 
   # /**
   #  * @param {?Array<MediaFeature>} features
@@ -795,7 +861,7 @@ class Puppeteer::Page
 
   # @param timezone_id [String?]
   def emulate_timezone(timezone_id)
-    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezoneId || '')
+    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezone_id || '')
   rescue => err
     if err.message.include?('Invalid timezone')
       raise ArgumentError.new("Invalid timezone ID: #{timezone_id}")
@@ -1019,8 +1085,19 @@ class Puppeteer::Page
   define_async_method :async_select
 
   # @param selector [String]
-  def tap(selector)
-    main_frame.tap(selector)
+  def tap(selector: nil, &block)
+    # resolves double meaning of tap.
+    if selector.nil? && block
+      # Original usage of Object#tap.
+      #
+      # browser.new_page.tap do |page|
+      #   ...
+      # end
+      super(&block)
+    else
+      # Puppeteer's Page#tap.
+      main_frame.tap(selector)
+    end
   end
 
   define_async_method :async_tap
@@ -1034,16 +1111,6 @@ class Puppeteer::Page
 
   define_async_method :async_type_text
 
-  # /**
-  #  * @param {(string|number|Function)} selectorOrFunctionOrTimeout
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number, polling?: string|number}=} options
-  #  * @param {!Array<*>} args
-  #  * @return {!Promise<!Puppeteer.JSHandle>}
-  #  */
-  # waitFor(selectorOrFunctionOrTimeout, options = {}, ...args) {
-  #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
-  # }
-
   # @param selector [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
   # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
@@ -1054,6 +1121,11 @@ class Puppeteer::Page
 
   define_async_method :async_wait_for_selector
 
+  # @param milliseconds [Integer] the number of milliseconds to wait.
+  def wait_for_timeout(milliseconds)
+    main_frame.wait_for_timeout(milliseconds)
+  end
+
   # @param xpath [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
   # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
@@ -1064,12 +1136,13 @@ class Puppeteer::Page
 
   define_async_method :async_wait_for_xpath
 
-  # @param {Function|string} pageFunction
-  # @param {!{polling?: string|number, timeout?: number}=} options
-  # @param {!Array<*>} args
-  # @return {!Promise<!Puppeteer.JSHandle>}
-  def wait_for_function(page_function, options = {}, *args)
-    main_frame.wait_for_function(page_function, options, *args)
+  # @param page_function [String]
+  # @param args [Integer|Array]
+  # @param polling [String]
+  # @param timeout [Integer]
+  # @return [Puppeteer::JSHandle]
+  def wait_for_function(page_function, args: [], polling: nil, timeout: nil)
+    main_frame.wait_for_function(page_function, args: args, polling: polling, timeout: timeout)
   end
 
   define_async_method :async_wait_for_function