puppeteer-ruby 0.0.5 → 0.0.11

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/execution_context.rb

@@ -122,7 +122,7 @@ class Puppeteer::ExecutionContext
       remote_object = Puppeteer::RemoteObject.new(result['result'])
 
       if exception_details
-        raise EvaluationError.new("Evaluation failed: #{exceptionDetails}")
+        raise EvaluationError.new("Evaluation failed: #{exception_details}")
       end
 
       if @return_by_value
@@ -216,20 +216,39 @@ class Puppeteer::ExecutionContext
   #   return createJSHandle(this, response.objects);
   # }
 
-  # /**
-  #  * @param {Puppeteer.ElementHandle} elementHandle
-  #  * @return {Promise<Puppeteer.ElementHandle>}
-  #  */
-  # async _adoptElementHandle(elementHandle) {
-  #   assert(elementHandle.executionContext() !== this, 'Cannot adopt handle that already belongs to this execution context');
-  #   assert(this._world, 'Cannot adopt handle without DOMWorld');
-  #   const nodeInfo = await this._client.send('DOM.describeNode', {
-  #     objectId: elementHandle._remoteObject.objectId,
-  #   });
-  #   const {object} = await this._client.send('DOM.resolveNode', {
-  #     backendNodeId: nodeInfo.node.backendNodeId,
-  #     executionContextId: this._contextId,
-  #   });
-  #   return /** @type {Puppeteer.ElementHandle}*/(createJSHandle(this, object));
-  # }
+  # @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)
+    if element_handle.execution_context == self
+      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
+    end
+
+    unless @world
+      raise 'Cannot adopt handle without DOMWorld'
+    end
+
+    node_info = element_handle.remote_object.node_info(@client)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: node_info["node"]["backendNodeId"],
+      executionContextId: @context_id,
+    )
+
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
 end

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"
@@ -173,11 +191,11 @@ class Puppeteer::Frame
     @secondary_world.tap(selector)
   end
 
-  # @param {string} selector
-  # @param {string} text
-  # @param {{delay: (number|undefined)}=} options
-  def type(selector, text, delay: nil)
-    @main_world.type(selector, text, delay: delay)
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    @main_world.type_text(selector, text, delay: delay)
   end
 
   # /**
@@ -202,9 +220,10 @@ class Puppeteer::Frame
   #   return Promise.reject(new Error('Unsupported target type: ' + (typeof selectorOrFunctionOrTimeout)));
   # }
 
-  # @param {string} selector
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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.
+  # @param timeout [Integer]
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
     handle = @secondary_world.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
     if !handle
@@ -216,9 +235,10 @@ class Puppeteer::Frame
     result
   end
 
-  # @param {string} xpath
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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.
+  # @param timeout [Integer]
   def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
     handle = @secondary_world.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
     if !handle

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/chrome.rb

@@ -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,53 @@ 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);
-  # }
+  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
 
-  # /**
-  #  * @param {!{timeout?: number}=} options
-  #  * @return !Promise<!FileChooser>}
-  #  */
-  # async waitForFileChooser(options = {}) {
-  #   if (!this._fileChooserInterceptors.size)
-  #     await this._client.send('Page.setInterceptFileChooserDialog', {enabled: true});
+  class FileChooserTimeoutError < StandardError
+    def initialize(timeout:)
+      super("waiting for filechooser failed: timeout #{timeout}ms exceeded")
+    end
+  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 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 +289,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 +638,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,16 +996,21 @@ class Puppeteer::Page
     main_frame.select(selector, *values)
   end
 
-  # @param {string} selector
+  # @param selector [String]
   def tap(selector)
     main_frame.tap(selector)
   end
 
-  # @param {string} selector
-  # @param {string} text
-  # @param {{delay: (number|undefined)}=} options
-  def type(selector, text, delay: nil)
-    main_frame.type(selector, text, delay: delay)
+  # @param selector [String]
+  async def async_tap(selector)
+    tap(selector)
+  end
+
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    main_frame.type_text(selector, text, delay: delay)
   end
 
   # /**
@@ -990,20 +1023,38 @@ class Puppeteer::Page
   #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
   # }
 
-  # @param {string} selector
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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.
+  # @param timeout [Integer]
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
     main_frame.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
   end
 
-  # @param {string} xpath
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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.
+  # @param timeout [Integer]
+  async def async_wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
+  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.
+  # @param timeout [Integer]
   def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
     main_frame.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
   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.
+  # @param timeout [Integer]
+  async def async_wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
+    wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
+  end
+
   # @param {Function|string} pageFunction
   # @param {!{polling?: string|number, timeout?: number}=} options
   # @param {!Array<*>} args