puppeteer-ruby 0.0.6 → 0.0.12

data/lib/puppeteer/element_handle/bounding_box.rb

@@ -0,0 +1,12 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  class BoundingBox
+    def initialize(x:, y:, width:, height:)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+
+    attr_reader :x, :y, :width, :height
+  end
+end

data/lib/puppeteer/element_handle/box_model.rb

@@ -0,0 +1,19 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  class BoxModel
+    QUAD_ATTRIBUTE_NAMES = %i(content padding border margin)
+    # @param result [Hash]
+    def initialize(result_model)
+      QUAD_ATTRIBUTE_NAMES.each do |attr_name|
+        quad = result_model[attr_name.to_s]
+        instance_variable_set(
+          :"@#{attr_name}",
+          quad.each_slice(2).map { |x, y| Point.new(x: x, y: y) },
+        )
+      end
+      @width = result_model['width']
+      @height = result_model['height']
+    end
+    attr_reader(*QUAD_ATTRIBUTE_NAMES)
+    attr_reader :width, :height
+  end
+end

data/lib/puppeteer/element_handle/point.rb

@@ -0,0 +1,26 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  # A class to represent (x, y)-coordinates
+  # supporting + and / operators.
+  class Point
+    def initialize(x:, y:)
+      @x = x
+      @y = y
+    end
+
+    def +(other)
+      Point.new(
+        x: @x + other.x,
+        y: @y + other.y,
+      )
+    end
+
+    def /(num)
+      Point.new(
+        x: @x / num,
+        y: @y / num,
+      )
+    end
+
+    attr_reader :x, :y
+  end
+end

data/lib/puppeteer/errors.rb

@@ -1,4 +1,2 @@
-# ref: https://github.com/puppeteer/puppeteer/blob/master/lib/Errors.js
+# ref: https://github.com/puppeteer/puppeteer/blob/master/src/Errors.ts
 class Puppeteer::TimeoutError < StandardError; end
-
-class Puppeteer::WebSocktTransportError < StandardError; end

data/lib/puppeteer/event_callbackable.rb

@@ -39,6 +39,17 @@ module Puppeteer::EventCallbackable
     end
   end
 
+  def observe_first(event_name, &block)
+    listener_id = add_event_listener(event_name) do |*args, **kwargs|
+      if kwargs.empty?
+        block.call(*args)
+      else
+        block.call(*args, **kwargs)
+      end
+      remove_event_listener(listener_id)
+    end
+  end
+
   def on_event(event_name, &block)
     @event_callbackable_handlers ||= {}
     @event_callbackable_handlers[event_name] = block

data/lib/puppeteer/execution_context.rb

@@ -216,6 +216,19 @@ class Puppeteer::ExecutionContext
   #   return createJSHandle(this, response.objects);
   # }
 
+  # @param backend_node_id [Integer]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_backend_node_id(backend_node_id)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: backend_node_id,
+      executionContextId: @context_id,
+    )
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
+
   # @param element_handle [Puppeteer::ElementHandle]
   # @return [Puppeteer::ElementHandle]
   def adopt_element_handle(element_handle)

data/lib/puppeteer/file_chooser.rb

@@ -0,0 +1,29 @@
+class Puppeteer::FileChooser
+  # @param element [Puppeteer::ElementHandle]
+  # @param event [Hash]
+  def initialize(element, event)
+    @element = element
+    @multiple = event['mode'] != 'selectSingle'
+    @handled = false
+  end
+
+  def multiple?
+    @multiple
+  end
+
+  # @param file_paths [Array<String>]
+  def accept(file_paths)
+    if @handled
+      raise 'Cannot accept FileChooser which is already handled!'
+    end
+    @handled = true
+    @element.upload_file(*file_paths)
+  end
+
+  def cancel
+    if @handled
+      raise 'Cannot cancel FileChooser which is already handled!'
+    end
+    @handled = true
+  end
+end

data/lib/puppeteer/frame.rb

@@ -1,4 +1,6 @@
 class Puppeteer::Frame
+  using Puppeteer::AsyncAwaitBehavior
+
   # @param {!FrameManager} frameManager
   # @param {!Puppeteer.CDPSession} client
   # @param {?Frame} parentFrame
@@ -33,10 +35,17 @@ class Puppeteer::Frame
 
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
-  def wait_for_navigation(timeout: nil, wait_until: nil)
+  private def wait_for_navigation(timeout: nil, wait_until: nil)
     @frame_manager.wait_for_frame_navigation(self, timeout: timeout, wait_until: wait_until)
   end
 
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  # @return [Future]
+  async def async_wait_for_navigation(timeout: nil, wait_until: nil)
+    wait_for_navigation(timeout: timeout, wait_until: wait_until)
+  end
+
   def execution_context
     @main_world.execution_context
   end
@@ -143,6 +152,15 @@ class Puppeteer::Frame
     @main_world.add_style_tag(style_tag)
   end
 
+  # @param selector [String]
+  # @param delay [Number]
+  # @param button [String] "left"|"right"|"middle"
+  # @param click_count [Number]
+  # @return [Future]
+  async def async_click(selector, delay: nil, button: nil, click_count: nil)
+    click(selector, delay: delay, button: button, click_count: click_count)
+  end
+
   # @param selector [String]
   # @param delay [Number]
   # @param button [String] "left"|"right"|"middle"

data/lib/puppeteer/frame_manager.rb

@@ -285,8 +285,6 @@ class Puppeteer::FrameManager
     frame.navigated_within_document(url)
     emit_event 'Events.FrameManager.FrameNavigatedWithinDocument', frame
     emit_event 'Events.FrameManager.FrameNavigated', frame
-    handle_frame_manager_frame_navigated_within_document(frame)
-    handle_frame_manager_frame_navigated(frame)
   end
 
   # @param frame_id [String]

data/lib/puppeteer/launcher.rb

@@ -4,13 +4,13 @@ require_relative './launcher/chrome'
 require_relative './launcher/chrome_arg_options'
 require_relative './launcher/launch_options'
 
-# https://github.com/puppeteer/puppeteer/blob/master/lib/Launcher.js
+# https://github.com/puppeteer/puppeteer/blob/main/src/node/Launcher.ts
 module Puppeteer::Launcher
-  # @param {string} projectRoot
-  # @param {string} preferredRevision
-  # @param {boolean} isPuppeteerCore
-  # @param {string=} product
-  # @return {!Puppeteer.ProductLauncher}
+  # @param project_root [String]
+  # @param prefereed_revision [String]
+  # @param is_puppeteer_core [String]
+  # @param product [String] 'chrome' or 'firefox' (not implemented yet)
+  # @return [Puppeteer::Launcher::Chrome]
   module_function def new(project_root:, preferred_revision:, is_puppeteer_core:, product:)
     if product == 'firefox'
       raise NotImplementedError.new('FirefoxLauncher is not implemented yet.')

data/lib/puppeteer/launcher/chrome.rb

@@ -1,6 +1,6 @@
 require 'tmpdir'
 
-# https://github.com/puppeteer/puppeteer/blob/master/lib/Launcher.js
+# https://github.com/puppeteer/puppeteer/blob/main/src/node/Launcher.ts
 module Puppeteer::Launcher
   class Chrome < Base
     # @param {!(Launcher.LaunchOptions & Launcher.ChromeArgOptions & Launcher.BrowserOptions)=} options
@@ -149,8 +149,54 @@ module Puppeteer::Launcher
 
     # @param {!(Launcher.BrowserOptions & {browserWSEndpoint?: string, browserURL?: string, transport?: !Puppeteer.ConnectionTransport})} options
     # @return {!Promise<!Browser>}
-    def connect(options)
-      raise NotImplementedError.new('Puppeteer.connect is not implemented yet')
+    def connect(options = {})
+      @browser_options = BrowserOptions.new(options)
+      browser_ws_endpoint = options[:browser_ws_endpoint]
+      browser_url = options[:browser_url]
+      transport = options[:transport]
+
+      connection =
+        if browser_ws_endpoint && browser_url.nil? && transport.nil?
+          connect_with_browser_ws_endpoint(browser_ws_endpoint)
+        elsif browser_ws_endpoint.nil? && browser_url && transport.nil?
+          connect_with_browser_url(browser_url)
+        elsif browser_ws_endpoint.nil? && browser_url.nil? && transport
+          connect_with_transport(transport)
+        else
+          raise ArgumentError.new("Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect")
+        end
+
+      result = connection.send_message('Target.getBrowserContexts')
+      browser_context_ids = result['browserContextIds']
+
+      Puppeteer::Browser.create(
+        connection: connection,
+        context_ids: browser_context_ids,
+        ignore_https_errors: @browser_options.ignore_https_errors?,
+        default_viewport: @browser_options.default_viewport,
+        process: nil,
+        close_callback: -> { connection.send_message('Browser.close') },
+      )
+    end
+
+    # @return [Puppeteer::Connection]
+    private def connect_with_browser_ws_endpoint(browser_ws_endpoint)
+      transport = Puppeteer::WebSocketTransport.create(browser_ws_endpoint)
+      Puppeteer::Connection.new(browser_ws_endpoint, transport, @browser_options.slow_mo)
+    end
+
+    # @return [Puppeteer::Connection]
+    private def connect_with_browser_url(browser_url)
+      raise NotImplementedError.new('Puppeteer#connect with browserUrl is not implemented yet.')
+      # const connectionURL = await getWSEndpoint(browserURL);
+      # const connectionTransport = await WebSocketTransport.create(
+      #   connectionURL
+      # );
+    end
+
+    # @return [Puppeteer::Connection]
+    private def connect_with_transport(transport)
+      Puppeteer::Connection.new('', transport, @browser_options.slow_mo)
     end
 
     # @return {string}

data/lib/puppeteer/mouse.rb

@@ -61,18 +61,13 @@ class Puppeteer::Mouse
     # 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 move in advance.
+    # So we execute them sequential
     move(x, y)
+    down(button: button, click_count: click_count)
     if delay
-      down(button: button, click_count: click_count)
       sleep(delay / 1000.0)
-      up(button: button, click_count: click_count)
-    else
-      await_all(
-        async_down(button: button, click_count: click_count),
-        async_up(button: button, click_count: click_count),
-      )
     end
+    up(button: button, click_count: click_count)
   end
 
   # @param x [number]

data/lib/puppeteer/page.rb

@@ -88,8 +88,8 @@ class Puppeteer::Page
     network_manager.on_event 'Events.NetworkManager.RequestFinished' do |event|
       emit_event 'Events.Page.RequestFinished', event
     end
-    # this._fileChooserInterceptionIsDisabled = false;
-    # this._fileChooserInterceptors = new Set();
+    @file_chooser_interception_is_disabled = false
+    @file_chooser_interceptors = Set.new
 
     @client.on_event 'Page.domContentEventFired' do |event|
       emit_event 'Events.Page.DOMContentLoaded'
@@ -106,8 +106,10 @@ class Puppeteer::Page
     @client.on_event 'Log.entryAdded' do |event|
       handle_log_entry_added(event)
     end
-    # client.on('Page.fileChooserOpened', event => this._onFileChooser(event));
-    @target.on_close do
+    @client.on_event 'Page.fileChooserOpened' do |event|
+      handle_file_chooser(event)
+    end
+    @target.is_closed_promise.then do
       emit_event 'Events.Page.Close'
       @closed = true
     end
@@ -122,41 +124,92 @@ class Puppeteer::Page
     )
   end
 
-  # /**
-  #  * @param {!Protocol.Page.fileChooserOpenedPayload} event
-  #  */
-  # async _onFileChooser(event) {
-  #   if (!this._fileChooserInterceptors.size)
-  #     return;
-  #   const frame = this._frameManager.frame(event.frameId);
-  #   const context = await frame.executionContext();
-  #   const element = await context._adoptBackendNodeId(event.backendNodeId);
-  #   const interceptors = Array.from(this._fileChooserInterceptors);
-  #   this._fileChooserInterceptors.clear();
-  #   const fileChooser = new FileChooser(this._client, element, event);
-  #   for (const interceptor of interceptors)
-  #     interceptor.call(null, fileChooser);
-  # }
+  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(", ")}")
+    end
 
-  # /**
-  #  * @param {!{timeout?: number}=} options
-  #  * @return !Promise<!FileChooser>}
-  #  */
-  # async waitForFileChooser(options = {}) {
-  #   if (!this._fileChooserInterceptors.size)
-  #     await this._client.send('Page.setInterceptFileChooserDialog', {enabled: true});
+    add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
+  end
 
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   let callback;
-  #   const promise = new Promise(x => callback = x);
-  #   this._fileChooserInterceptors.add(callback);
-  #   return helper.waitWithTimeout(promise, 'waiting for file chooser', timeout).catch(e => {
-  #     this._fileChooserInterceptors.delete(callback);
-  #     throw e;
-  #   });
-  # }
+  # @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(", ")}")
+    end
+
+    observe_first(EVENT_MAPPINGS[event_name.to_sym], &block)
+  end
+
+  def handle_file_chooser(event)
+    return if @file_chooser_interceptors.empty?
+
+    frame = @frame_manager.frame(event['frameId'])
+    context = frame.execution_context
+    element = context.adopt_backend_node_id(event['backendNodeId'])
+    interceptors = @file_chooser_interceptors.to_a
+    @file_chooser_interceptors.clear
+    file_chooser = Puppeteer::FileChooser.new(element, event)
+    interceptors.each do |promise|
+      promise.fulfill(file_chooser)
+    end
+  end
+
+  class FileChooserTimeoutError < StandardError
+    def initialize(timeout:)
+      super("waiting for filechooser failed: timeout #{timeout}ms exceeded")
+    end
+  end
+
+  # @param timeout [Integer]
+  # @return [Puppeteer::FileChooser]
+  def wait_for_file_chooser(timeout: nil)
+    if @file_chooser_interceptors.empty?
+      @client.send_message('Page.setInterceptFileChooserDialog', enabled: true)
+    end
+
+    option_timeout = timeout || @timeout_settings.timeout
+    promise = resolvable_future
+    @file_chooser_interceptors << promise
+
+    begin
+      Timeout.timeout(option_timeout / 1000.0) do
+        promise.value!
+      end
+    rescue Timeout::Error
+      raise FileChooserTimeoutError.new(timeout: option_timeout)
+    ensure
+      @file_chooser_interceptors.delete(promise)
+    end
+  end
+
+  # @param timeout [Integer]
+  # @return [Future<Puppeteer::FileChooser>]
+  async def async_wait_for_file_chooser(timeout: nil)
+    wait_for_file_chooser(timeout: timeout)
+  end
 
 
   # /**
@@ -275,23 +328,37 @@ class Puppeteer::Page
   end
 
   # `$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
-  # @param {string} selector
-  # @param {Function|string} pageFunction
-  # @param {!Array<*>} args
-  # @return {!Promise<(!Object|undefined)>}
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Object]
   def Seval(selector, page_function, *args)
     main_frame.Seval(selector, page_function, *args)
   end
 
+  # `$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Future]
+  async def async_Seval(selector, page_function, *args)
+    Seval(selector, page_function, *args)
+  end
+
   # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
-  # @param {string} selector
-  # @param {Function|string} pageFunction
-  # @param {!Array<*>} args
-  # @return {!Promise<(!Object|undefined)>}
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Object]
   def SSeval(selector, page_function, *args)
     main_frame.SSeval(selector, page_function, *args)
   end
 
+  # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Future]
+  async def async_SSeval(selector, page_function, *args)
+    SSeval(selector, page_function, *args)
+  end
+
   # `$x()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param {string} expression
   # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
@@ -610,20 +677,20 @@ class Puppeteer::Page
     main_frame.goto(url, referer: referer, timeout: timeout, wait_until: wait_until)
   end
 
-  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
-  # @return {!Promise<?Puppeteer.Response>}
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  # @return [Puppeteer::Response]
   def reload(timeout: nil, wait_until: nil)
-    # const [response] = await Promise.all([
-    #   this.waitForNavigation(options),
-    #   this._client.send('Page.reload')
-    # ]);
-    # return response;
+    await_all(
+      async_wait_for_navigation(timeout: timeout, wait_until: wait_until),
+      @client.async_send_message('Page.reload'),
+    ).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.wait_for_navigation(timeout: timeout, wait_until: wait_until)
+    main_frame.send(:wait_for_navigation, timeout: timeout, wait_until: wait_until)
   end
 
   # @param timeout [number|nil]
@@ -968,11 +1035,16 @@ class Puppeteer::Page
     main_frame.select(selector, *values)
   end
 
-  # @param {string} selector
+  # @param selector [String]
   def tap(selector)
     main_frame.tap(selector)
   end
 
+  # @param selector [String]
+  async def async_tap(selector)
+    tap(selector)
+  end
+
   # @param selector [String]
   # @param text [String]
   # @param delay [Number]