puppeteer-ruby 0.0.6 → 0.0.12

data/docs/top-level-namespace.html

@@ -116,7 +116,7 @@
 </div>
 
       <div id="footer">
-  Generated on Mon May 25 23:22:48 2020 by
+  Generated on Tue Jun 23 10:24: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

@@ -25,6 +25,7 @@ require 'puppeteer/devices'
 require 'puppeteer/dom_world'
 require 'puppeteer/emulation_manager'
 require 'puppeteer/execution_context'
+require 'puppeteer/file_chooser'
 require 'puppeteer/frame'
 require 'puppeteer/frame_manager'
 require 'puppeteer/js_handle'
@@ -62,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,
@@ -124,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,
@@ -142,10 +164,15 @@ class Puppeteer
       default_viewport: default_viewport,
       slow_mo: slow_mo,
     }.compact
-    launcher.connect(options)
+    browser = launcher.connect(options)
+    if block_given?
+      yield(browser)
+    else
+      browser
+    end
   end
 
-  # @return {string}
+  # @return [String]
   def executable_path
     launcher.executable_path
   end
@@ -159,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
@@ -174,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/browser_runner.rb

@@ -147,7 +147,7 @@ class Puppeteer::BrowserRunner
   end
 
   private def wait_for_ws_endpoint(browser_process, timeout, preferred_revision)
-    Timeout.timeout(timeout / 1000) do
+    Timeout.timeout(timeout / 1000.0) do
       loop do
         line = browser_process.stderr.readline
         /^DevTools listening on (ws:\/\/.*)$/.match(line) do |m|

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
@@ -355,18 +356,15 @@ class Puppeteer::DOMWorld
   #   await handle.dispose();
   # }
 
-  # /**
-  #  * @param {string} selector
-  #  * @param {!Array<string>} values
-  #  * @return {!Promise<!Array<string>>}
-  #  */
-  # async select(selector, ...values) {
-  #   const handle = await this.$(selector);
-  #   assert(handle, 'No node found for selector: ' + selector);
-  #   const result = await handle.select(...values);
-  #   await handle.dispose();
-  #   return result;
-  # }
+  # @param selector [String]
+  # @return [Array<String>]
+  def select(selector, *values)
+    handle = S(selector)
+    result = handle.select(*values)
+    handle.dispose
+
+    result
+  end
 
   # @param selector [String]
   def tap(selector)

data/lib/puppeteer/element_handle.rb

@@ -1,3 +1,7 @@
+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
   using Puppeteer::AsyncAwaitBehavior
@@ -51,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")
@@ -103,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)
@@ -155,74 +127,77 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     click(delay: delay, button: button, click_count: click_count)
   end
 
-  #  /**
-  #   * @param {!Array<string>} values
-  #   * @return {!Promise<!Array<string>>}
-  #   */
-  #  async select(...values) {
-  #    for (const value of values)
-  #      assert(helper.isString(value), 'Values must be strings. Found value "' + value + '" of type "' + (typeof value) + '"');
-  #    return this.evaluate((element, values) => {
-  #      if (element.nodeName.toLowerCase() !== 'select')
-  #        throw new Error('Element is not a <select> element.');
-
-  #      const options = Array.from(element.options);
-  #      element.value = undefined;
-  #      for (const option of options) {
-  #        option.selected = values.includes(option.value);
-  #        if (option.selected && !element.multiple)
-  #          break;
-  #      }
-  #      element.dispatchEvent(new Event('input', { bubbles: true }));
-  #      element.dispatchEvent(new Event('change', { bubbles: true }));
-  #      return options.filter(option => option.selected).map(option => option.value);
-  #    }, values);
-  #  }
+  # @return [Array<String>]
+  def select(*values)
+    if nonstring = values.find { |value| !value.is_a?(String) }
+      raise ArgumentError.new("Values must be strings. Found value \"#{nonstring}\" of type \"#{nonstring.class}\"")
+    end
 
-  #  /**
-  #   * @param {!Array<string>} filePaths
-  #   */
-  #  async uploadFile(...filePaths) {
-  #    const isMultiple = await this.evaluate(element => element.multiple);
-  #    assert(filePaths.length <= 1 || isMultiple, 'Multiple file uploads only work with <input type=file multiple>');
-  #    // These imports are only needed for `uploadFile`, so keep them
-  #    // scoped here to avoid paying the cost unnecessarily.
-  #    const path = require('path');
-  #    const mime = require('mime-types');
-  #    const fs = require('fs');
-  #    const readFileAsync = helper.promisify(fs.readFile);
-
-  #    const promises = filePaths.map(filePath => readFileAsync(filePath));
-  #    const files = [];
-  #    for (let i = 0; i < filePaths.length; i++) {
-  #      const buffer = await promises[i];
-  #      const filePath = path.basename(filePaths[i]);
-  #      const file = {
-  #        name: filePath,
-  #        content: buffer.toString('base64'),
-  #        mimeType: mime.lookup(filePath),
-  #      };
-  #      files.push(file);
-  #    }
-  #    await this.evaluateHandle(async(element, files) => {
-  #      const dt = new DataTransfer();
-  #      for (const item of files) {
-  #        const response = await fetch(`data:${item.mimeType};base64,${item.content}`);
-  #        const file = new File([await response.blob()], item.name);
-  #        dt.items.add(file);
-  #      }
-  #      element.files = dt.files;
-  #      element.dispatchEvent(new Event('input', { bubbles: true }));
-  #      element.dispatchEvent(new Event('change', { bubbles: true }));
-  #    }, files);
-  #  }
+    fn = <<~JAVASCRIPT
+    (element, values) => {
+      if (element.nodeName.toLowerCase() !== 'select') {
+        throw new Error('Element is not a <select> element.');
+      }
+
+      const options = Array.from(element.options);
+      element.value = undefined;
+      for (const option of options) {
+        option.selected = values.includes(option.value);
+        if (option.selected && !element.multiple) {
+          break;
+        }
+      }
+      element.dispatchEvent(new Event('input', { bubbles: true }));
+      element.dispatchEvent(new Event('change', { bubbles: true }));
+      return options.filter(option => option.selected).map(option => option.value);
+    }
+    JAVASCRIPT
+    evaluate(fn, values)
+  end
+
+  # @param file_paths [Array<String>]
+  def upload_file(*file_paths)
+    is_multiple = evaluate("el => el.multiple")
+    if !is_multiple && file_paths.length >= 2
+      raise ArgumentError.new('Multiple file uploads only work with <input type=file multiple>')
+    end
+
+    if error_path = file_paths.find { |file_path| !File.exist?(file_path) }
+      raise ArgmentError.new("#{error_path} does not exist or is not readable")
+    end
+
+    backend_node_id = @remote_object.node_info(@client)["node"]["backendNodeId"]
+
+    # The zero-length array is a special case, it seems that DOM.setFileInputFiles does
+    # not actually update the files in that case, so the solution is to eval the element
+    # value to a new FileList directly.
+    if file_paths.empty?
+      fn = <<~JAVASCRIPT
+      (element) => {
+        element.files = new DataTransfer().files;
+
+        // Dispatch events for this case because it should behave akin to a user action.
+        element.dispatchEvent(new Event('input', { bubbles: true }));
+        element.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+      JAVASCRIPT
+      await this.evaluate(fn)
+    else
+      @remote_object.set_file_input_files(@client, file_paths, backend_node_id)
+    end
+  end
+
+  def tap(&block)
+    return super(&block) if block
 
-  def tap
     scroll_into_view_if_needed
     point = clickable_point
     @page.touchscreen.tap(point.x, point.y)
   end
 
+  async def async_tap
+    tap
+  end
 
   def focus
     evaluate('element => element.focus()')
@@ -260,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]
@@ -393,6 +356,14 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     result
   end
 
+  # `$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Object]
+  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 selector [String]
   # @param page_function [String]
@@ -408,6 +379,14 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     result
   end
 
+  # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Object]
+  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 expression [String]
   # @return [Array<ElementHandle>]