puppeteer-ruby 0.0.10

data/lib/puppeteer/page/screenshot_options.rb

@@ -0,0 +1,78 @@
+require 'mime/types'
+
+class Puppeteer::Page
+  # /**
+  #  * @typedef {Object} ScreenshotOptions
+  #  * @property {string=} type
+  #  * @property {string=} path
+  #  * @property {boolean=} fullPage
+  #  * @property {{x: number, y: number, width: number, height: number}=} clip
+  #  * @property {number=} quality
+  #  * @property {boolean=} omitBackground
+  #  * @property {string=} encoding
+  #  */
+  class ScreenshotOptions
+    # @params options [Hash]
+    def initialize(options)
+      if options[:type]
+        unless [:png, :jpeg].include?(options[:type].to_sym)
+          raise ArgumentError.new("Unknown options.type value: #{options[:type]}")
+        end
+        @type = options[:type]
+      elsif options[:path]
+        mime_types = MIME::Types.type_for(options[:path])
+        if mime_types.include?('image/png')
+          @type = 'png'
+        elsif mime_types.include?('image/jpeg')
+          @type = 'jpeg'
+        else
+          raise ArgumentError.new("Unsupported screenshot mime type resolved: #{mime_types}, path: #{options[:path]}")
+        end
+      end
+      @type ||= 'png'
+
+      if options[:quality]
+        unless @type == 'png'
+          raise ArgumentError.new("options.quality is unsupported for the #{@type} screenshots")
+        end
+        unless options[:quality].is_a?(Numeric)
+          raise ArgumentError.new("Expected options.quality to be a number but found #{options[:quality].class}")
+        end
+        quality = options[:quality].to_i
+        unless (0..100).include?(qualizy)
+          raise ArgumentError.new("Expected options.quality to be between 0 and 100 (inclusive), got #{quality}")
+        end
+        @quality = quality
+      end
+
+      if options[:clip] && options[:full_page]
+        raise ArgumentError.new('options.clip and options.fullPage are exclusive')
+      end
+
+      # if (options.clip) {
+      #   assert(typeof options.clip.x === 'number', 'Expected options.clip.x to be a number but found ' + (typeof options.clip.x));
+      #   assert(typeof options.clip.y === 'number', 'Expected options.clip.y to be a number but found ' + (typeof options.clip.y));
+      #   assert(typeof options.clip.width === 'number', 'Expected options.clip.width to be a number but found ' + (typeof options.clip.width));
+      #   assert(typeof options.clip.height === 'number', 'Expected options.clip.height to be a number but found ' + (typeof options.clip.height));
+      #   assert(options.clip.width !== 0, 'Expected options.clip.width not to be 0.');
+      #   assert(options.clip.height !== 0, 'Expected options.clip.height not to be 0.');
+      # }
+
+      @path = options[:path]
+      @full_page = options[:full_page]
+      @clip = options[:clip]
+      @omit_background = options[:omit_background]
+      @encoding = options[:encoding]
+    end
+
+    attr_reader :type, :quality, :path, :clip, :encoding
+
+    def full_page?
+      @full_page
+    end
+
+    def omit_background?
+      @omit_background
+    end
+  end
+end

data/lib/puppeteer/remote_object.rb

@@ -0,0 +1,143 @@
+# providing #valueFromRemoteObject, #releaseObject
+class Puppeteer::RemoteObject
+  include Puppeteer::DebugPrint
+  using Puppeteer::AsyncAwaitBehavior
+
+  # @param payload [Hash]
+  def initialize(payload)
+    @object_id = payload['objectId']
+    @sub_type = payload['subtype']
+    @unserializable_value = payload['unserializableValue']
+    @value = payload['value']
+  end
+
+  attr_reader :sub_type
+
+  # @return [Future<Puppeteer::RemoteObject|nil>]
+  def evaluate_self(client)
+    # ported logic from JSHandle#json_value.
+
+    # original logic:
+    #   if (this._remoteObject.objectId) {
+    #     const response = await this._client.send('Runtime.callFunctionOn', {
+    #       functionDeclaration: 'function() { return this; }',
+    #       objectId: this._remoteObject.objectId,
+    #       returnByValue: true,
+    #       awaitPromise: true,
+    #     });
+    #     return helper.valueFromRemoteObject(response.result);
+    #   }
+
+    if @object_id
+      params = {
+        'functionDeclaration': 'function() { return this; }',
+        'objectId': @object_id,
+        'returnByValue': true,
+        'awaitPromise': true,
+      }
+      response = client.send_message('Runtime.callFunctionOn', params)
+      Puppeteer::RemoteObject.new(response['result'])
+    else
+      nil
+    end
+  end
+
+  # used in JSHandle#properties
+  def properties(client)
+    # original logic:
+    #   const response = await this._client.send('Runtime.getProperties', {
+    #     objectId: this._remoteObject.objectId,
+    #     ownProperties: true
+    #   });
+    client.send_message('Runtime.getProperties', objectId: @object_id, ownProperties: true)
+  end
+
+  # used in ElementHandle#content_frame, ElementHandle#upload_file
+  def node_info(client)
+    client.send_message('DOM.describeNode', objectId: @object_id)
+  end
+
+  # used in ElementHandle#clickable_point
+  def content_quads(client)
+    client.send_message('DOM.getContentQuads', objectId: @object_id)
+  end
+
+  # used in ElementHandle#_box_model
+  def box_model(client)
+    client.send_message('DOM.getBoxModel', objectId: @object_id)
+  rescue => err
+    debug_puts(err)
+    nil
+  end
+
+
+  # helper#valueFromRemoteObject
+  def value
+    if @unserializable_value
+      # if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined')
+      #   return BigInt(remoteObject.unserializableValue.replace('n', ''));
+      # switch (remoteObject.unserializableValue) {
+      #   case '-0':
+      #     return -0;
+      #   case 'NaN':
+      #     return NaN;
+      #   case 'Infinity':
+      #     return Infinity;
+      #   case '-Infinity':
+      #     return -Infinity;
+      #   default:
+      #     throw new Error('Unsupported unserializable value: ' + remoteObject.unserializableValue);
+      # }
+      raise NotImplementedError.new('unserializable_value is not implemented yet')
+    else
+      @value
+    end
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  def release(client)
+    return unless @object_id
+
+    begin
+      client.send_message('Runtime.releaseObject',
+        objectId: @object_id,
+      )
+    rescue => err
+      # Exceptions might happen in case of a page been navigated or closed.
+      # Swallow these since they are harmless and we don't leak anything in this case.
+      debug_puts(err)
+    end
+
+    nil
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  async def async_release(client)
+    release(client)
+  end
+
+  def converted_arg
+    # ported logic from ExecutionContext#convertArgument
+    # https://github.com/puppeteer/puppeteer/blob/master/lib/ExecutionContext.js
+    #
+    # Original logic:
+    # if (objectHandle._remoteObject.unserializableValue)
+    #   return { unserializableValue: objectHandle._remoteObject.unserializableValue };
+    # if (!objectHandle._remoteObject.objectId)
+    #   return { value: objectHandle._remoteObject.value };
+    # return { objectId: objectHandle._remoteObject.objectId };
+
+    if @unserializable_value
+      { unserializableValue: @unserializable_value }
+    elsif @object_id
+      { objectId: @object_id }
+    else
+      { value: value }
+    end
+  end
+
+  # used in ElementHandle#upload_file
+  def set_file_input_files(client, files, backend_node_id)
+    client.send_message('DOM.setFileInputFiles', objectId: @object_id, files: files, backendNodeId: backend_node_id)
+  end
+end

data/lib/puppeteer/target.rb

@@ -0,0 +1,150 @@
+# https://github.com/puppeteer/puppeteer/blob/master/lib/Target.js
+class Puppeteer::Target
+  class TargetInfo
+    def initialize(options)
+      @target_id = options['targetId']
+      @type = options['type']
+      @title = options['title']
+      @url = options['url']
+      @attached = options['attached']
+      @browser_context_id = options['browserContextId']
+      @opener_id = options['openerId']
+    end
+    attr_reader :target_id, :type, :title, :url, :attached, :browser_context_id, :opener_id
+  end
+
+  # @param {!Protocol.Target.TargetInfo} targetInfo
+  # @param {!Puppeteer.BrowserContext} browserContext
+  # @param {!function():!Promise<!Puppeteer.CDPSession>} sessionFactory
+  # @param {boolean} ignoreHTTPSErrors
+  # @param {?Puppeteer.Viewport} defaultViewport
+  # @param {!Puppeteer.TaskQueue} screenshotTaskQueue
+  def initialize(target_info:, browser_context:, session_factory:, ignore_https_errors:, default_viewport:, screenshot_task_queue:)
+    @target_info = target_info
+    @browser_context = browser_context
+    @target_id = target_info.target_id
+    @session_factory = session_factory
+    @ignore_https_errors = ignore_https_errors
+    @default_viewport = default_viewport
+    @screenshot_task_queue = screenshot_task_queue
+
+
+    #    /** @type {?Promise<!Puppeteer.Page>} */
+    #    this._pagePromise = null;
+    #    /** @type {?Promise<!Worker>} */
+    #    this._workerPromise = null;
+    @initialize_callback_promise = resolvable_future
+    @initialized_promise = @initialize_callback_promise.then do |success|
+      handle_initialized(success)
+    end
+    @is_closed_promise = resolvable_future
+
+    @is_initialized = @target_info.type != 'page' || !@target_info.url.empty?
+
+    if @is_initialized
+      @initialize_callback_promise.fulfill(true)
+    end
+  end
+
+  attr_reader :target_id, :initialized_promise, :is_closed_promise
+
+  def closed_callback
+    @is_closed_promise.fulfill(true)
+  end
+
+  class InitializeFailure < StandardError; end
+
+  def ignore_initialize_callback_promise
+    unless @initialize_callback_promise.fulfilled?
+      @initialize_callback_promise.fulfill(false)
+    end
+  end
+
+  private def handle_initialized(success)
+    unless success
+      raise InitializeFailure.new('Failed to create target for page')
+    end
+    opener_page = opener&.page
+    if opener_page.nil? || type != 'page'
+      return true
+    end
+    #      if (!openerPage.listenerCount(Events.Page.Popup))
+    #        return true;
+    popup_page = page
+    opener_page.emit_event('Events.Page.Popup', popup_page)
+
+    true
+  end
+
+  def initialized?
+    @is_initialized
+  end
+
+  def create_cdp_session
+    @session_factory.call
+  end
+
+  def page
+    if ['page', 'background_page', 'webview'].include?(@target_info.type) && @page.nil?
+      client = @session_factory.call
+      @page = Puppeteer::Page.create(client, self, @ignore_https_errors, @default_viewport, @screenshot_task_queue)
+    end
+    @page
+  end
+
+  #  /**
+  #   * @return {!Promise<?Worker>}
+  #   */
+  #  async worker() {
+  #    if (this._targetInfo.type !== 'service_worker' && this._targetInfo.type !== 'shared_worker')
+  #      return null;
+  #    if (!this._workerPromise) {
+  #      // TODO(einbinder): Make workers send their console logs.
+  #      this._workerPromise = this._sessionFactory()
+  #          .then(client => new Worker(client, this._targetInfo.url, () => {} /* consoleAPICalled */, () => {} /* exceptionThrown */));
+  #    }
+  #    return this._workerPromise;
+  #  }
+
+  # @return {string}
+  def url
+    @target_info.url
+  end
+
+  # @return {"page"|"background_page"|"service_worker"|"shared_worker"|"other"|"browser"}
+  def type
+    type = @target_info.type
+    if ['page', 'background_page', 'service_worker', 'shared_worker', 'browser'].include?(type)
+      type
+    else
+      'other'
+    end
+  end
+
+  # @return {!Puppeteer.Browser}
+  def browser
+    @browser_context.browser
+  end
+
+  # @return {!Puppeteer.BrowserContext}
+  def browser_context
+    @browser_context
+  end
+
+  # @return {?Puppeteer.Target}
+  def opener
+    opener_id = @target_info.opener_id
+    return nil if opener_id.nil?
+    browser.targets[opener_id]
+  end
+
+  # @param {!Protocol.Target.TargetInfo} targetInfo
+  def handle_target_info_changed(target_info)
+    @target_info = target_info
+
+    if !@is_initialized && (@target_info.type != 'page' || !@target_info.url.empty?)
+      @is_initialized = true
+      @initialize_callback_promise.fulfill(true)
+    end
+  end
+end

data/lib/puppeteer/timeout_settings.rb

@@ -0,0 +1,15 @@
+class Puppeteer::TimeoutSettings
+  DEFAULT_TIMEOUT = 30000
+
+  attr_writer :default_timeout, :default_navigation_timeout
+
+  # @return {number}
+  def navigation_timeout
+    @default_navigation_timeout || @default_timeout || DEFAULT_TIMEOUT
+  end
+
+  # @return {number}
+  def timeout
+    @default_timeout || DEFAULT_TIMEOUT
+  end
+end

data/lib/puppeteer/touch_screen.rb

@@ -0,0 +1,43 @@
+class Puppeteer::TouchScreen
+  using Puppeteer::AsyncAwaitBehavior
+
+  # @param {Puppeteer.CDPSession} client
+  # @param keyboard [Puppeteer::Keyboard]
+  def initialize(client, keyboard)
+    @client = client
+    @keyboard = keyboard
+  end
+
+  # @param x [number]
+  # @param y [number]
+  def tap(x, y)
+    # Touches appear to be lost during the first frame after navigation.
+    # This waits a frame before sending the tap.
+    # @see https://crbug.com/613219
+    @client.send_message('Runtime.evaluate',
+      expression: 'new Promise(x => requestAnimationFrame(() => requestAnimationFrame(x)))',
+      awaitPromise: true,
+    )
+
+    touch_points = [
+      { x: x.round, y: y.round },
+    ]
+    @client.send_message('Input.dispatchTouchEvent',
+      type: 'touchStart',
+      touchPoints: touch_points,
+      modifiers: @keyboard.modifiers,
+    )
+    @client.send_message('Input.dispatchTouchEvent',
+      type: 'touchEnd',
+      touchPoints: [],
+      modifiers: @keyboard.modifiers,
+    )
+  end
+
+  # @param x [number]
+  # @param y [number]
+  # @return [Future]
+  async def async_tap(x, y)
+    tap(x, y)
+  end
+end

data/lib/puppeteer/version.rb

@@ -0,0 +1,3 @@
+class Puppeteer
+  VERSION = '0.0.10'
+end

data/lib/puppeteer/viewport.rb

@@ -0,0 +1,54 @@
+class Puppeteer::Viewport
+  # @param width [int]
+  # @param height [int]
+  # @param device_scale_factor [double]
+  # @param is_mobile [boolean]
+  # @param has_touch [boolean]
+  # @param is_landscape [boolean]
+  def initialize(
+        width:,
+        height:,
+        device_scale_factor: 1.0,
+        is_mobile: false,
+        has_touch: false,
+        is_landscape: false)
+    @width = width
+    @height = height
+    @device_scale_factor = device_scale_factor
+    @is_mobile = is_mobile
+    @has_touch = has_touch
+    @is_landscape = is_landscape
+  end
+
+  attr_reader :width, :height, :device_scale_factor
+
+  def mobile?
+    @is_mobile
+  end
+
+  def has_touch?
+    @has_touch
+  end
+
+  def landscape?
+    @is_landscape
+  end
+
+  def merge(
+        width: nil,
+        height: nil,
+        device_scale_factor: nil,
+        is_mobile: nil,
+        has_touch: nil,
+        is_landscape: nil)
+
+    Puppeteer::Viewport.new(
+      width: width || @width,
+      height: height || @height,
+      device_scale_factor: device_scale_factor || @device_scale_factor,
+      is_mobile: is_mobile.nil? ? @is_mobile : is_mobile,
+      has_touch: has_touch.nil? ? @has_touch : has_touch,
+      is_landscape: is_landscape.nil? ? @is_landscape : is_landscape,
+    )
+  end
+end