puppeteer-ruby 0.0.18 → 0.0.23

data/lib/puppeteer/lifecycle_watcher.rb

@@ -69,17 +69,17 @@ class Puppeteer::LifecycleWatcher
     @timeout = timeout
 
     @listener_ids = {}
-    @listener_ids['client'] = @frame_manager.client.add_event_listener('Events.CDPSession.Disconnected') do
+    @listener_ids['client'] = @frame_manager.client.add_event_listener(CDPSessionEmittedEvents::Disconnected) do
       terminate(TerminatedError.new('Navigation failed because browser has disconnected!'))
     end
     @listener_ids['frame_manager'] = [
-      @frame_manager.add_event_listener('Events.FrameManager.LifecycleEvent') do |_|
+      @frame_manager.add_event_listener(FrameManagerEmittedEvents::LifecycleEvent) do |_|
         check_lifecycle_complete
       end,
-      @frame_manager.add_event_listener('Events.FrameManager.FrameNavigatedWithinDocument', &method(:navigated_within_document)),
-      @frame_manager.add_event_listener('Events.FrameManager.FrameDetached', &method(:handle_frame_detached)),
+      @frame_manager.add_event_listener(FrameManagerEmittedEvents::FrameNavigatedWithinDocument, &method(:navigated_within_document)),
+      @frame_manager.add_event_listener(FrameManagerEmittedEvents::FrameDetached, &method(:handle_frame_detached)),
     ]
-    @listener_ids['network_manager'] = @frame_manager.network_manager.add_event_listener('Events.NetworkManager.Request', &method(:handle_request))
+    @listener_ids['network_manager'] = @frame_manager.network_manager.add_event_listener(NetworkManagerEmittedEvents::Request, &method(:handle_request))
 
     @same_document_navigation_promise = resolvable_future
     @lifecycle_promise = resolvable_future
@@ -128,7 +128,7 @@ class Puppeteer::LifecycleWatcher
           @termination_promise.value!
         end
       rescue Timeout::Error
-        raise Puppeteer::FrameManager::NavigationError.new("Navigation timeout of #{@timeout}ms exceeded")
+        raise Puppeteer::TimeoutError.new("Navigation timeout of #{@timeout}ms exceeded")
       end
     else
       @termination_promise

data/lib/puppeteer/network_manager.rb

@@ -212,7 +212,7 @@ class Puppeteer::NetworkManager
     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
+    emit_event(NetworkManagerEmittedEvents::Request, request)
   end
 
   private def handle_request_served_from_cache(event)
@@ -230,8 +230,8 @@ class Puppeteer::NetworkManager
     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
+    emit_event(NetworkManagerEmittedEvents::Response, response)
+    emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
   # @param event [Hash]
@@ -242,7 +242,7 @@ class Puppeteer::NetworkManager
 
     response = Puppeteer::Response.new(@client, request, event['response'])
     request.internal.response = response
-    emit_event 'Events.NetworkManager.Response', response
+    emit_event(NetworkManagerEmittedEvents::Response, response)
   end
 
   private def handle_loading_finished(event)
@@ -260,7 +260,7 @@ class Puppeteer::NetworkManager
 
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
-    emit_event 'Events.NetworkManager.RequestFinished', request
+    emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
   private def handle_loading_failed(event)
@@ -275,6 +275,6 @@ class Puppeteer::NetworkManager
     end
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
-    emit_event 'Events.NetworkManager.RequestFailed', request
+    emit_event(NetworkManagerEmittedEvents::RequestFailed, request)
   end
 end

data/lib/puppeteer/page.rb

@@ -46,7 +46,7 @@ class Puppeteer::Page
     @screenshot_task_queue = screenshot_task_queue
 
     @workers = {}
-    @client.on_event 'Target.attachedToTarget' do |event|
+    @client.on_event('Target.attachedToTarget') do |event|
       if event['targetInfo']['type'] != 'worker'
         # If we don't detach from service workers, they will never die.
         await @client.send_message('Target.detachFromTarget', sessionId: event['sessionId'])
@@ -56,63 +56,69 @@ class Puppeteer::Page
       session = Puppeteer::Connection.from_session(@client).session(event['sessionId']) # rubocop:disable Lint/UselessAssignment
       #   const worker = new Worker(session, event.targetInfo.url, this._addConsoleMessage.bind(this), this._handleException.bind(this));
       #   this._workers.set(event.sessionId, worker);
-      #   this.emit(Events.Page.WorkerCreated, worker);
+      #   this.emit(PageEmittedEvents::WorkerCreated, worker);
     end
-    @client.on_event 'Target.detachedFromTarget' do |event|
+    @client.on_event('Target.detachedFromTarget') do |event|
       session_id = event['sessionId']
       worker = @workers[session_id]
       next unless worker
 
-      emit_event('Events.Page.WorkerDestroyed', worker)
+      emit_event(PageEmittedEvents::WorkerDestroyed, worker)
       @workers.delete(session_id)
     end
 
-    @frame_manager.on_event 'Events.FrameManager.FrameAttached' do |event|
-      emit_event 'Events.Page.FrameAttached', event
+    @frame_manager.on_event(FrameManagerEmittedEvents::FrameAttached) do |event|
+      emit_event(PageEmittedEvents::FrameAttached, event)
     end
-    @frame_manager.on_event 'Events.FrameManager.FrameDetached' do |event|
-      emit_event 'Events.Page.FrameDetached', event
+    @frame_manager.on_event(FrameManagerEmittedEvents::FrameDetached) do |event|
+      emit_event(PageEmittedEvents::FrameDetached, event)
     end
-    @frame_manager.on_event 'Events.FrameManager.FrameNavigated' do |event|
-      emit_event 'Events.Page.FrameNavigated', event
+    @frame_manager.on_event(FrameManagerEmittedEvents::FrameNavigated) do |event|
+      emit_event(PageEmittedEvents::FrameNavigated, event)
     end
 
     network_manager = @frame_manager.network_manager
-    network_manager.on_event 'Events.NetworkManager.Request' do |event|
-      emit_event 'Events.Page.Request', event
+    network_manager.on_event(NetworkManagerEmittedEvents::Request) do |event|
+      emit_event(PageEmittedEvents::Request, event)
     end
-    network_manager.on_event 'Events.NetworkManager.Response' do |event|
-      emit_event 'Events.Page.Response', event
+    network_manager.on_event(NetworkManagerEmittedEvents::Response) do |event|
+      emit_event(PageEmittedEvents::Response, event)
     end
-    network_manager.on_event 'Events.NetworkManager.RequestFailed' do |event|
-      emit_event 'Events.Page.RequestFailed', event
+    network_manager.on_event(NetworkManagerEmittedEvents::RequestFailed) do |event|
+      emit_event(PageEmittedEvents::RequestFailed, event)
     end
-    network_manager.on_event 'Events.NetworkManager.RequestFinished' do |event|
-      emit_event 'Events.Page.RequestFinished', event
+    network_manager.on_event(NetworkManagerEmittedEvents::RequestFinished) do |event|
+      emit_event(PageEmittedEvents::RequestFinished, event)
     end
     @file_chooser_interception_is_disabled = false
     @file_chooser_interceptors = Set.new
 
-    @client.on_event 'Page.domContentEventFired' do |event|
-      emit_event 'Events.Page.DOMContentLoaded'
+    @client.on_event('Page.domContentEventFired') do |event|
+      emit_event(PageEmittedEvents::DOMContentLoaded)
     end
-    @client.on_event 'Page.loadEventFired' do |event|
-      emit_event 'Events.Page.Load'
+    @client.on_event('Page.loadEventFired') do |event|
+      emit_event(PageEmittedEvents::Load)
     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('Runtime.exceptionThrown', exception => this._handleException(exception.exceptionDetails));
-    # client.on('Inspector.targetCrashed', event => this._onTargetCrashed());
+    @client.on_event('Page.javascriptDialogOpening') do |event|
+      handle_dialog_opening(event)
+    end
+    @client.on_event('Runtime.exceptionThrown') do |exception|
+      handle_exception(exception['exceptionDetails'])
+    end
+    @client.on_event('Inspector.targetCrashed') do |event|
+      handle_target_crashed
+    end
     # client.on('Performance.metrics', event => this._emitMetrics(event));
-    @client.on_event 'Log.entryAdded' do |event|
+    @client.on_event('Log.entryAdded') do |event|
       handle_log_entry_added(event)
     end
-    @client.on_event 'Page.fileChooserOpened' do |event|
+    @client.on_event('Page.fileChooserOpened') do |event|
       handle_file_chooser(event)
     end
     @target.is_closed_promise.then do
-      emit_event 'Events.Page.Close'
+      emit_event(PageEmittedEvents::Close)
       @closed = true
     end
   end
@@ -126,43 +132,22 @@ class Puppeteer::Page
     )
   end
 
-  EVENT_MAPPINGS = {
-    close: 'Events.Page.Close',
-    # console: 'Events.Page.Console',
-    # dialog: 'Events.Page.Dialog',
-    domcontentloaded: 'Events.Page.DOMContentLoaded',
-    # error:
-    frameattached: 'Events.Page.FrameAttached',
-    framedetached: 'Events.Page.FrameDetached',
-    framenavigated: 'Events.Page.FrameNavigated',
-    load: 'Events.Page.Load',
-    # metrics: 'Events.Page.Metrics',
-    # pageerror: 'Events.Page.PageError',
-    popup: 'Events.Page.Popup',
-    request: 'Events.Page.Request',
-    requestfailed: 'Events.Page.RequestFailed',
-    requestfinished: 'Events.Page.RequestFinished',
-    response: 'Events.Page.Response',
-    # workercreated: 'Events.Page.WorkerCreated',
-    # workerdestroyed: 'Events.Page.WorkerDestroyed',
-  }
-
   # @param event_name [Symbol]
   def on(event_name, &block)
-    unless EVENT_MAPPINGS.has_key?(event_name.to_sym)
-      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{EVENT_MAPPINGS.keys.join(", ")}")
+    unless PageEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{PageEmittedEvents.values.to_a.join(", ")}")
     end
 
-    add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &block)
   end
 
   # @param event_name [Symbol]
   def once(event_name, &block)
-    unless EVENT_MAPPINGS.has_key?(event_name.to_sym)
-      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{EVENT_MAPPINGS.keys.join(", ")}")
+    unless PageEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{PageEmittedEvents.values.to_a.join(", ")}")
     end
 
-    observe_first(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &block)
   end
 
   def handle_file_chooser(event)
@@ -209,19 +194,10 @@ class Puppeteer::Page
 
   define_async_method :async_wait_for_file_chooser
 
-  # /**
-  #  * @param {!{longitude: number, latitude: number, accuracy: (number|undefined)}} options
-  #  */
-  # async setGeolocation(options) {
-  #   const { longitude, latitude, accuracy = 0} = options;
-  #   if (longitude < -180 || longitude > 180)
-  #     throw new Error(`Invalid longitude "${longitude}": precondition -180 <= LONGITUDE <= 180 failed.`);
-  #   if (latitude < -90 || latitude > 90)
-  #     throw new Error(`Invalid latitude "${latitude}": precondition -90 <= LATITUDE <= 90 failed.`);
-  #   if (accuracy < 0)
-  #     throw new Error(`Invalid accuracy "${accuracy}": precondition 0 <= ACCURACY failed.`);
-  #   await this._client.send('Emulation.setGeolocationOverride', {longitude, latitude, accuracy});
-  # }
+  # @param [Puppeteer::Geolocation]
+  def geolocation=(geolocation)
+    @client.send_message('Emulation.setGeolocationOverride', geolocation.to_h)
+  end
 
   attr_reader :javascript_enabled, :target
 
@@ -236,7 +212,7 @@ class Puppeteer::Page
   class TargetCrashedError < StandardError; end
 
   private def handle_target_crashed
-    emit_event 'error', TargetCrashedError.new('Page crashed!')
+    emit_event(PageEmittedEvents::Error, TargetCrashedError.new('Page crashed!'))
   end
 
   private def handle_log_entry_added(event)
@@ -257,7 +233,7 @@ class Puppeteer::Page
         url: url,
         line_number: line_number,
       )
-      emit_event('Events.Page.Console',
+      emit_event(PageEmittedEvents::Console,
         Puppeteer::ConsoleMessage.new(level, text, [], console_message_location))
     end
   end
@@ -266,7 +242,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
@@ -494,7 +476,7 @@ class Puppeteer::Page
   #  * @param {!Protocol.Performance.metricsPayload} event
   #  */
   # _emitMetrics(event) {
-  #   this.emit(Events.Page.Metrics, {
+  #   this.emit(PageEmittedEvents::Metrics, {
   #     title: event.title,
   #     metrics: this._buildMetricsObject(event.metrics)
   #   });
@@ -513,15 +495,14 @@ class Puppeteer::Page
   #   return result;
   # }
 
-  # /**
-  #  * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
-  #  */
-  # _handleException(exceptionDetails) {
-  #   const message = helper.getExceptionMessage(exceptionDetails);
-  #   const err = new Error(message);
-  #   err.stack = ''; // Don't report clientside error with a node stack attached
-  #   this.emit(Events.Page.PageError, err);
-  # }
+  class PageError < StandardError ; end
+
+  private def handle_exception(exception_details)
+    message = Puppeteer::ExceptionDetails.new(exception_details).message
+    err = PageError.new(message)
+    #   err.stack = ''; // Don't report clientside error with a node stack attached
+    emit_event(PageEmittedEvents::PageError, err)
+  end
 
   # /**
   #  * @param {!Protocol.Runtime.consoleAPICalledPayload} event
@@ -605,7 +586,7 @@ class Puppeteer::Page
   #  * @param {Protocol.Runtime.StackTrace=} stackTrace
   #  */
   # _addConsoleMessage(type, args, stackTrace) {
-  #   if (!this.listenerCount(Events.Page.Console)) {
+  #   if (!this.listenerCount(PageEmittedEvents::Console)) {
   #     args.forEach(arg => arg.dispose());
   #     return;
   #   }
@@ -623,23 +604,20 @@ class Puppeteer::Page
   #     columnNumber: stackTrace.callFrames[0].columnNumber,
   #   } : {};
   #   const message = new ConsoleMessage(type, textTokens.join(' '), args, location);
-  #   this.emit(Events.Page.Console, message);
+  #   this.emit(PageEmittedEvents::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(PageEmittedEvents::Dialog, dialog)
+  end
 
   # @return [String]
   def url
@@ -721,7 +699,7 @@ class Puppeteer::Page
 
   private def session_close_promise
     @disconnect_promise ||= resolvable_future do |future|
-      @client.observe_first('Events.CDPSession.Disconnected') do
+      @client.observe_first(CDPSessionEmittedEvents::Disconnected) do
         future.reject(Puppeteer::CDPSession::Error.new('Target Closed'))
       end
     end
@@ -741,7 +719,7 @@ class Puppeteer::Page
         -> (request) { predicate.call(request) }
       end
 
-    wait_for_network_manager_event('Events.NetworkManager.Request',
+    wait_for_network_manager_event(NetworkManagerEmittedEvents::Request,
       predicate: request_predicate,
       timeout: timeout,
     )
@@ -775,7 +753,7 @@ class Puppeteer::Page
         -> (response) { predicate.call(response) }
       end
 
-    wait_for_network_manager_event('Events.NetworkManager.Response',
+    wait_for_network_manager_event(NetworkManagerEmittedEvents::Response,
       predicate: response_predicate,
       timeout: timeout,
     )
@@ -934,16 +912,16 @@ class Puppeteer::Page
       clip = { x: 0, y: 0, width: width, height: height, scale: 1 }
 
       screen_orientation =
-        if @viewport.landscape?
+        if @viewport&.landscape?
           { angle: 90, type: 'landscapePrimary' }
         else
           { angle: 0, type: 'portraitPrimary' }
         end
       @client.send_message('Emulation.setDeviceMetricsOverride',
-        mobile: @viewport.mobile?,
+        mobile: @viewport&.mobile? || false,
         width: width,
         height: height,
-        deviceScaleFactor: @viewport.device_scale_factor,
+        deviceScaleFactor: @viewport&.device_scale_factor || 1,
         screenOrientation: screen_orientation)
     end
 
@@ -1038,6 +1016,12 @@ class Puppeteer::Page
     else
       @client.connection.send_message('Target.closeTarget', targetId: @target.target_id)
       await @target.is_closed_promise
+
+      # @closed sometimes remains false, so wait for @closed = true with 100ms timeout.
+      25.times do
+        break if @closed
+        sleep 0.004
+      end
     end
   end
 

data/lib/puppeteer/remote_object.rb

@@ -80,7 +80,18 @@ class Puppeteer::RemoteObject
 
   # used in ElementHandle#_box_model
   def box_model(client)
-    client.send_message('DOM.getBoxModel', objectId: @object_id)
+    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)
+    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.')
+      return nil
+    end
+    result
   rescue => err
     debug_puts(err)
     nil

data/lib/puppeteer/target.rb

@@ -68,10 +68,10 @@ class Puppeteer::Target
     if opener_page.nil? || type != 'page'
       return true
     end
-    #      if (!openerPage.listenerCount(Events.Page.Popup))
+    #      if (!openerPage.listenerCount(PageEmittedEvents::Popup))
     #        return true;
     popup_page = page
-    opener_page.emit_event('Events.Page.Popup', popup_page)
+    opener_page.emit_event(PageEmittedEvents::Popup, popup_page)
 
     true
   end