puppeteer-ruby 0.0.8 → 0.0.13

data/docs/top-level-namespace.html

@@ -116,7 +116,7 @@
 </div>
 
       <div id="footer">
-  Generated on Thu Jun  4 23:54:40 2020 by
+  Generated on Wed Jun 24 03:07:58 2020 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.9.24 (ruby-2.6.3).
 </div>

data/lib/puppeteer.rb

@@ -63,17 +63,33 @@ class Puppeteer
     end
   end
 
-  # @param {string} projectRoot
-  # @param {string} preferredRevision
-  # @param {boolean} isPuppeteerCore
+  # @param project_root [String]
+  # @param prefereed_revision [String]
+  # @param is_puppeteer_core [String]
   def initialize(project_root:, preferred_revision:, is_puppeteer_core:)
     @project_root = project_root
     @preferred_revision = preferred_revision
     @is_puppeteer_core = is_puppeteer_core
   end
 
-  # @param {!(Launcher.LaunchOptions & Launcher.ChromeArgOptions & Launcher.BrowserOptions & {product?: string, extraPrefsFirefox?: !object})=} options
-  # @return {!Promise<!Puppeteer.Browser>}
+  # @param product [String]
+  # @param executable_path [String]
+  # @param ignore_default_args [Array<String>|nil]
+  # @param handle_SIGINT [Boolean]
+  # @param handle_SIGTERM [Boolean]
+  # @param handle_SIGHUP [Boolean]
+  # @param timeout [Integer]
+  # @param dumpio [Boolean]
+  # @param env [Hash]
+  # @param pipe [Boolean]
+  # @param args [Array<String>]
+  # @param user_data_dir [String]
+  # @param devtools [Boolean]
+  # @param headless [Boolean]
+  # @param ignore_https_errors [Boolean]
+  # @param default_viewport [Puppeteer::Viewport|nil]
+  # @param slow_mo [Integer]
+  # @return [Puppeteer::Browser]
   def launch(
     product: nil,
     executable_path: nil,
@@ -125,8 +141,13 @@ class Puppeteer
     end
   end
 
-  # @param {!(Launcher.BrowserOptions & {browserWSEndpoint?: string, browserURL?: string, transport?: !Puppeteer.ConnectionTransport})} options
-  # @return {!Promise<!Puppeteer.Browser>}
+  # @param browser_ws_endpoint [String]
+  # @param browser_url [String]
+  # @param transport [Puppeteer::WebSocketTransport]
+  # @param ignore_https_errors [Boolean]
+  # @param default_viewport [Puppeteer::Viewport|nil]
+  # @param slow_mo [Integer]
+  # @return [Puppeteer::Browser]
   def connect(
     browser_ws_endpoint: nil,
     browser_url: nil,
@@ -151,7 +172,7 @@ class Puppeteer
     end
   end
 
-  # @return {string}
+  # @return [String]
   def executable_path
     launcher.executable_path
   end
@@ -165,12 +186,12 @@ class Puppeteer
     )
   end
 
-  # @return {string}
+  # @return [String]
   def product
     launcher.product
   end
 
-  # @return {Puppeteer::Devices}
+  # @return [Puppeteer::Devices]
   def devices
     Puppeteer::Devices
   end
@@ -180,8 +201,11 @@ class Puppeteer
   #   # ???
   # end
 
-  # @param {!Launcher.ChromeArgOptions=} options
-  # @return {!Array<string>}
+  # @param args [Array<String>]
+  # @param user_data_dir [String]
+  # @param devtools [Boolean]
+  # @param headless [Boolean]
+  # @return [Array<String>]
   def default_args(args: nil, user_data_dir: nil, devtools: nil, headless: nil)
     options = {
       args: args,

data/lib/puppeteer/browser.rb

@@ -46,7 +46,7 @@ class Puppeteer::Browser
       @contexts[context_id] = Puppeteer::BrowserContext.new(@connection, self. context_id)
     end
     @targets = {}
-    @connection.on_event 'Events.CDPSession.Disconnected' do
+    @connection.on_event 'Events.Connection.Disconnected' do
       emit_event 'Events.Browser.Disconnected'
     end
     @connection.on_event 'Target.targetCreated', &method(:handle_target_created)
@@ -54,6 +54,22 @@ class Puppeteer::Browser
     @connection.on_event 'Target.targetInfoChanged', &method(:handle_target_info_changed)
   end
 
+  EVENT_MAPPINGS = {
+    disconnected: 'Events.Browser.Disconnected',
+    targetcreated: 'Events.Browser.TargetCreated',
+    targetchanged: 'Events.Browser.TargetChanged',
+    targetdestroyed: 'Events.Browser.TargetDestroyed',
+  }
+
+  # @param event_name [Symbol] either of :disconnected, :targetcreated, :targetchanged, :targetdestroyed
+  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
+
+    add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
+  end
+
   # @return [Puppeteer::BrowserRunner::BrowserProcess]
   def process
     @process
@@ -102,8 +118,7 @@ class Puppeteer::Browser
     )
     #   assert(!this._targets.has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
     @targets[target_info.target_id] = target
-
-    target.on_initialize_succeeded do
+    if await target.initialized_promise
       emit_event 'Events.Browser.TargetCreated', target
       context.emit_event 'Events.BrowserContext.TargetCreated', target
     end
@@ -118,10 +133,10 @@ class Puppeteer::Browser
   def handle_target_destroyed(event)
     target_id = event['targetId']
     target = @targets[target_id]
-    target.handle_initialized(false)
+    target.ignore_initialize_callback_promise
     @targets.delete(target_id)
-    target.handle_closed
-    target.on_initialize_succeeded do
+    target.closed_callback
+    if await target.initialized_promise
       emit_event 'Events.Browser.TargetDestroyed', target
       target.browser_context.emit_event 'Events.BrowserContext.TargetDestroyed', target
     end
@@ -192,6 +207,11 @@ class Puppeteer::Browser
     targets.first { |target| target.type == 'browser' }
   end
 
+  # used only in Target#opener
+  private def find_target_by_id(target_id)
+    @targets[target_id]
+  end
+
   # @param {function(!Target):boolean} predicate
   # @param {{timeout?: number}=} options
   # @return {!Promise<!Target>}

data/lib/puppeteer/concurrent_ruby_utils.rb

@@ -29,8 +29,12 @@ module Puppeteer::ConcurrentRubyUtils
     Concurrent::Promises.future(&block)
   end
 
-  def resolvable_future
-    Concurrent::Promises.resolvable_future
+  def resolvable_future(&block)
+    future = Concurrent::Promises.resolvable_future
+    if block
+      block.call(future)
+    end
+    future
   end
 end
 

data/lib/puppeteer/connection.rb

@@ -44,7 +44,9 @@ class Puppeteer::Connection
 
     @transport = transport
     @transport.on_message do |data|
-      async_handle_message(JSON.parse(data))
+      message = JSON.parse(data)
+      sleep_before_handling_message(message)
+      async_handle_message(message)
     end
     @transport.on_close do |reason, code|
       handle_close(reason, code)
@@ -54,6 +56,16 @@ class Puppeteer::Connection
     @closed = false
   end
 
+  private def sleep_before_handling_message(message)
+    # Puppeteer doesn't handle any Network monitoring responses.
+    # So we don't have to sleep.
+    return if message['method']&.start_with?('Network.')
+
+    # For some reasons, sleeping a bit reduces trivial errors...
+    # 4ms is an interval of internal shared timer of WebKit.
+    sleep 0.004
+  end
+
   def self.from_session(session)
     session.connection
   end

data/lib/puppeteer/dom_world.rb

@@ -97,17 +97,18 @@ class Puppeteer::DOMWorld
     document.S(selector)
   end
 
-  class DocumentEvaluationError < StandardError; end
-
   private def evaluate_document
     # sometimes execution_context.evaluate_handle('document') returns null object.
     # D, [2020-04-24T02:17:51.023631 #220] DEBUG -- : RECV << {"id"=>20, "result"=>{"result"=>{"type"=>"object", "subtype"=>"null", "value"=>nil}}, "sessionId"=>"78E9CF1E14D81294E320E7C20E5CDE06"}
     # retry if so.
-    5.times do
-      handle = execution_context.evaluate_handle('document')
-      return handle if handle.is_a?(Puppeteer::ElementHandle)
+    Timeout.timeout(3) do
+      loop do
+        handle = execution_context.evaluate_handle('document')
+        return handle if handle.is_a?(Puppeteer::ElementHandle)
+      end
     end
-    raise DocumentEvaluationError.new("'document' object cannot be evaluated as an Element")
+  rescue Timeout::Error
+    raise 'Bug of puppeteer-ruby...'
   end
 
   private def document
@@ -410,12 +411,10 @@ class Puppeteer::DOMWorld
   #   return new WaitTask(this, pageFunction, 'function', polling, timeout, ...args).promise;
   # }
 
-  # /**
-  #  * @return {!Promise<string>}
-  #  */
-  # async title() {
-  #   return this.evaluate(() => document.title);
-  # }
+  # @return [String]
+  def title
+    evaluate('() => document.title')
+  end
 
   # @param selector_or_xpath [String]
   # @param is_xpath [Boolean]

data/lib/puppeteer/element_handle.rb

@@ -1,4 +1,6 @@
-require 'mime/types'
+require_relative './element_handle/bounding_box'
+require_relative './element_handle/box_model'
+require_relative './element_handle/point'
 
 class Puppeteer::ElementHandle < Puppeteer::JSHandle
   include Puppeteer::IfPresent
@@ -53,29 +55,6 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     sleep 0.16
   end
 
-  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
-
   class ElementNotVisibleError < StandardError
     def initialize
       super("Node is either not visible or not an HTMLElement")
@@ -105,15 +84,6 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     quads.first.reduce(:+) / 4
   end
 
-  #  /**
-  #   * @return {!Promise<void|Protocol.DOM.getBoxModelReturnValue>}
-  #   */
-  #  _getBoxModel() {
-  #    return this._client.send('DOM.getBoxModel', {
-  #      objectId: this._remoteObject.objectId
-  #    }).catch(error => debugError(error));
-  #  }
-
   # @param quad [Array<number>]
   # @return [Array<Point>]
   private def from_protocol_quad(quad)
@@ -265,89 +235,77 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     press(key, delay: delay)
   end
 
-  #  /**
-  #   * @return {!Promise<?{x: number, y: number, width: number, height: number}>}
-  #   */
-  #  async boundingBox() {
-  #    const result = await this._getBoxModel();
-
-  #    if (!result)
-  #      return null;
-
-  #    const quad = result.model.border;
-  #    const x = Math.min(quad[0], quad[2], quad[4], quad[6]);
-  #    const y = Math.min(quad[1], quad[3], quad[5], quad[7]);
-  #    const width = Math.max(quad[0], quad[2], quad[4], quad[6]) - x;
-  #    const height = Math.max(quad[1], quad[3], quad[5], quad[7]) - y;
-
-  #    return {x, y, width, height};
-  #  }
-
-  #  /**
-  #   * @return {!Promise<?BoxModel>}
-  #   */
-  #  async boxModel() {
-  #    const result = await this._getBoxModel();
-
-  #    if (!result)
-  #      return null;
-
-  #    const {content, padding, border, margin, width, height} = result.model;
-  #    return {
-  #      content: this._fromProtocolQuad(content),
-  #      padding: this._fromProtocolQuad(padding),
-  #      border: this._fromProtocolQuad(border),
-  #      margin: this._fromProtocolQuad(margin),
-  #      width,
-  #      height
-  #    };
-  #  }
-
-  #  /**
-  #   *
-  #   * @param {!Object=} options
-  #   * @returns {!Promise<string|!Buffer>}
-  #   */
-  #  async screenshot(options = {}) {
-  #    let needsViewportReset = false;
-
-  #    let boundingBox = await this.boundingBox();
-  #    assert(boundingBox, 'Node is either not visible or not an HTMLElement');
-
-  #    const viewport = this._page.viewport();
-
-  #    if (viewport && (boundingBox.width > viewport.width || boundingBox.height > viewport.height)) {
-  #      const newViewport = {
-  #        width: Math.max(viewport.width, Math.ceil(boundingBox.width)),
-  #        height: Math.max(viewport.height, Math.ceil(boundingBox.height)),
-  #      };
-  #      await this._page.setViewport(Object.assign({}, viewport, newViewport));
+  # @return [BoundingBox|nil]
+  def bounding_box
+    if_present(box_model) do |result_model|
+      quads = result_model.border
+
+      x = quads.map(&:x).min
+      y = quads.map(&:y).min
+      BoundingBox.new(
+        x: x,
+        y: y,
+        width: quads.map(&:x).max - x,
+        height: quads.map(&:y).max - y,
+      )
+    end
+  end
 
-  #      needsViewportReset = true;
-  #    }
+  # @return [BoxModel|nil]
+  def box_model
+    if_present(@remote_object.box_model(@client)) do |result|
+      BoxModel.new(result['model'])
+    end
+  end
 
-  #    await this._scrollIntoViewIfNeeded();
+  def screenshot(options = {})
+    needs_viewport_reset = false
 
-  #    boundingBox = await this.boundingBox();
-  #    assert(boundingBox, 'Node is either not visible or not an HTMLElement');
-  #    assert(boundingBox.width !== 0, 'Node has 0 width.');
-  #    assert(boundingBox.height !== 0, 'Node has 0 height.');
+    box = bounding_box
+    unless box
+      raise ElementNotVisibleError.new
+    end
 
-  #    const { layoutViewport: { pageX, pageY } } = await this._client.send('Page.getLayoutMetrics');
+    viewport = @page.viewport
+    if viewport && (box.width > viewport.width || box.height > viewport.height)
+      new_viewport = viewport.merge(
+        width: [viewport.width, box.width.to_i].min,
+        height: [viewport.height, box.height.to_i].min,
+      )
+      @page.viewport = new_viewport
 
-  #    const clip = Object.assign({}, boundingBox);
-  #    clip.x += pageX;
-  #    clip.y += pageY;
+      needs_viewport_reset = true
+    end
+    scroll_into_view_if_needed
 
-  #    const imageData = await this._page.screenshot(Object.assign({}, {
-  #      clip
-  #    }, options));
+    box = bounding_box
+    unless box
+      raise ElementNotVisibleError.new
+    end
+    if box.width == 0
+      raise 'Node has 0 width.'
+    end
+    if box.height == 0
+      raise 'Node has 0 height.'
+    end
 
-  #    if (needsViewportReset)
-  #      await this._page.setViewport(viewport);
+    layout_metrics = @client.send_message('Page.getLayoutMetrics')
+    page_x = layout_metrics["layoutViewport"]["pageX"]
+    page_y = layout_metrics["layoutViewport"]["pageY"]
+
+    clip = {
+      x: page_x + box.x,
+      y: page_y + box.y,
+      width: box.width,
+      height: box.height,
+    }
 
-  #    return imageData;
-  #  }
+    @page.screenshot({ clip: clip }.merge(options))
+  ensure
+    if needs_viewport_reset
+      @page.viewport = viewport
+    end
+  end
 
   # `$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param selector [String]