puppeteer-ruby 0.0.13 → 0.0.18

data/lib/puppeteer/page/pdf_options.rb

@@ -0,0 +1,166 @@
+require 'mime/types'
+
+class Puppeteer::Page
+  # /**
+  # * @typedef {Object} PDFOptions
+  # * @property {number=} scale
+  # * @property {boolean=} displayHeaderFooter
+  # * @property {string=} headerTemplate
+  # * @property {string=} footerTemplate
+  # * @property {boolean=} printBackground
+  # * @property {boolean=} landscape
+  # * @property {string=} pageRanges
+  # * @property {string=} format
+  # * @property {string|number=} width
+  # * @property {string|number=} height
+  # * @property {boolean=} preferCSSPageSize
+  # * @property {!{top?: string|number, bottom?: string|number, left?: string|number, right?: string|number}=} margin
+  # * @property {string=} path
+  # */
+  class PDFOptions
+    # @params options [Hash]
+    def initialize(options)
+      unless options[:path]
+        # Original puppeteer allows path = nil, however nothing to do without path actually.
+        # Also in most case, users forget to specify path parameter. So let's raise ArgumentError.
+        raise ArgumentError('"path" parameter must be specified.')
+      end
+
+      @scale = options[:scale]
+      @display_header_footer = options[:display_header_footer]
+      @header_template = options[:header_template]
+      @footer_template = options[:footer_template]
+      @print_background = options[:print_background]
+      @landscape = options[:landscape]
+      @page_ranges = options[:page_ranges]
+      @format = options[:format]
+      @width = options[:width]
+      @height = options[:height]
+      @prefer_css_page_size = options[:prefer_css_page_size]
+      @margin = Margin.new(options[:margin] || {})
+      @path = options[:path]
+    end
+
+    attr_reader :path
+
+    class PaperSize
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+      attr_reader :width, :height
+    end
+
+    PAPER_FORMATS = {
+      letter: PaperSize.new(width: 8.5, height: 11),
+      legal: PaperSize.new(width: 8.5, height: 14),
+      tabloid: PaperSize.new(width: 11, height: 17),
+      ledger: PaperSize.new(width: 17, height: 11),
+      a0: PaperSize.new(width: 33.1, height: 46.8),
+      a1: PaperSize.new(width: 23.4, height: 33.1),
+      a2: PaperSize.new(width: 16.54, height: 23.4),
+      a3: PaperSize.new(width: 11.7, height: 16.54),
+      a4: PaperSize.new(width: 8.27, height: 11.7),
+      a5: PaperSize.new(width: 5.83, height: 8.27),
+      a6: PaperSize.new(width: 4.13, height: 5.83),
+    }
+
+    UNIT_TO_PIXELS = {
+      px: 1,
+      in: 96,
+      cm: 37.8,
+      mm: 3.78,
+    }
+
+    # @param parameter [String|Integer|nil]
+    private def convert_print_parameter_to_inches(parameter)
+      return nil if parameter.nil?
+
+      pixels =
+        if parameter.is_a?(Numeric)
+          parameter.to_i
+        elsif parameter.is_a?(String)
+          unit = parameter[-2..-1].downcase
+          value =
+            if UNIT_TO_PIXELS.has_key?(unit)
+              parameter[0...-2].to_i
+            else
+              unit = 'px'
+              parameter.to_i
+            end
+
+          value * UNIT_TO_PIXELS[unit]
+        else
+          raise ArgumentError.new("page.pdf() Cannot handle parameter type: #{parameter.class}")
+        end
+
+      pixels / 96
+    end
+
+    private def paper_size
+      @paper_size ||= calc_paper_size
+    end
+
+    # @return [PaperSize]
+    private def calc_paper_size
+      if @format
+        PAPER_FORMATS[@format.downcase] or raise ArgumentError.new("Unknown paper format: #{@format}")
+      else
+        PaperSize.new(
+          width: convert_print_parameter_to_inches(@width) || 8.5,
+          height: convert_print_parameter_to_inches(@height) || 11.0,
+        )
+      end
+    end
+
+    class Margin
+      def initialize(options)
+        @top = options[:top]
+        @bottom = options[:bottom]
+        @left = options[:left]
+        @right = options[:right]
+      end
+
+      def translate(&block)
+        new_margin ={
+          top: block.call(@top),
+          bottom: block.call(@bottom),
+          left: block.call(@left),
+          right: block.call(@right),
+        }
+        Margin.new(new_margin)
+      end
+      attr_reader :top, :bottom, :left, :right
+    end
+
+    private def margin
+      @__margin ||= calc_margin
+    end
+
+    private def calc_margin
+      @margin.translate do |value|
+        convert_print_parameter_to_inches(value) || 0
+      end
+    end
+
+    def page_print_args
+      {
+        transferMode: 'ReturnAsStream',
+        landscape: @landscape || false,
+        displayHeaderFooter: @display_header_footer || false,
+        headerTemplate: @header_template || '',
+        footerTemplate: @footer_template || '',
+        printBackground: @print_background || false,
+        scale: @scale || 1,
+        paperWidth: paper_size.width,
+        paperHeight: paper_size.height,
+        marginTop: margin.top,
+        marginBottom: margin.bottom,
+        marginLeft: margin.left,
+        marginRight: margin.right,
+        pageRanges: @page_ranges || '',
+        preferCSSPageSize: @prefer_css_page_size || false,
+      }
+    end
+  end
+end

data/lib/puppeteer/remote_object.rb

@@ -1,11 +1,12 @@
 # providing #valueFromRemoteObject, #releaseObject
 class Puppeteer::RemoteObject
   include Puppeteer::DebugPrint
-  using Puppeteer::AsyncAwaitBehavior
+  using Puppeteer::DefineAsyncMethod
 
   # @param payload [Hash]
   def initialize(payload)
     @object_id = payload['objectId']
+    @type = payload['type']
     @sub_type = payload['subtype']
     @unserializable_value = payload['unserializableValue']
     @value = payload['value']
@@ -42,6 +43,21 @@ class Puppeteer::RemoteObject
     end
   end
 
+  # @return [String]
+  def type_str
+    # used in JSHandle#to_s
+    # original logic:
+    #   if (this._remoteObject.objectId) {
+    #     const type =  this._remoteObject.subtype || this._remoteObject.type;
+    #     return 'JSHandle@' + type;
+    #   }
+    if @object_id
+      @sub_type || @type
+    else
+      nil
+    end
+  end
+
   # used in JSHandle#properties
   def properties(client)
     # original logic:
@@ -111,10 +127,7 @@ class Puppeteer::RemoteObject
     nil
   end
 
-  # @param client [Puppeteer::CDPSession]
-  async def async_release(client)
-    release(client)
-  end
+  define_async_method :async_release
 
   def converted_arg
     # ported logic from ExecutionContext#convertArgument

data/lib/puppeteer/request.rb

@@ -0,0 +1,330 @@
+class Puppeteer::Request
+  include Puppeteer::DebugPrint
+  include Puppeteer::IfPresent
+
+  # defines some methods used only in NetworkManager, Response
+  class InternalAccessor
+    def initialize(request)
+      @request = request
+    end
+
+    def request_id
+      @request.instance_variable_get(:@request_id)
+    end
+
+    def interception_id
+      @request.instance_variable_get(:@interception_id)
+    end
+
+    # @param response [Puppeteer::Response]
+    def response=(response)
+      @request.instance_variable_set(:@response, response)
+    end
+
+    def redirect_chain
+      @request.instance_variable_get(:@redirect_chain)
+    end
+
+    def failure_text=(failure_text)
+      @request.instance_variable_set(:@failure_text, failure_text)
+    end
+
+    def from_memory_cache=(from_memory_cache)
+      @request.instance_variable_set(:@from_memory_cache, from_memory_cache)
+    end
+
+    def from_memory_cache?
+      @request.instance_variable_get(:@from_memory_cache)
+    end
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  # @param frame [Puppeteer::Frame]
+  # @param interception_id [string|nil]
+  # @param allow_interception [boolean]
+  # @param event [Hash]
+  # @param redirect_chain Array<Request>
+  def initialize(client, frame, interception_id, allow_interception, event, redirect_chain)
+    @client = client
+    @request_id = event['requestId']
+    @is_navigation_request = event['requestId'] == event['loaderId'] && event['type'] == 'Document'
+    @interception_id = interception_id
+    @allow_interception = allow_interception
+    @url = event['request']['url']
+    @resource_type = event['type'].downcase
+    @method = event['request']['method']
+    @post_data = event['request']['postData']
+    @frame = frame
+    @redirect_chain = redirect_chain
+    @headers = {}
+    event['request']['headers'].each do |key, value|
+      @headers[key.downcase] = value
+    end
+    @from_memory_cache = false
+
+    @internal = InternalAccessor.new(self)
+  end
+
+  attr_reader :internal
+  attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame
+
+  def navigation_request?
+    @is_navigation_request
+  end
+
+  def redirect_chain
+    @redirect_chain.dup
+  end
+
+  def failure
+    if_present(@failure_text) do |failure_text|
+      { errorText: @failure_text }
+    end
+  end
+
+  private def headers_to_array(headers)
+    return nil unless headers
+
+    headers.map do |key, value|
+      { name: key, value: value.to_s }
+    end
+  end
+
+  class InterceptionNotEnabledError < StandardError
+    def initialize
+      super('Request Interception is not enabled!')
+    end
+  end
+
+  class AlreadyHandledError < StandardError
+    def initialize
+      super('Request is already handled!')
+    end
+  end
+
+  # proceed request on request interception.
+  #
+  # Example:
+  #
+  #   page.on 'request' do |req|
+  #     # Override headers
+  #     headers = req.headers.merge(
+  #       foo: 'bar', # set "foo" header
+  #       origin: nil, # remove "origin" header
+  #     )
+  #     req.continue(headers: headers)
+  #   end
+  #
+  # @param error_code [String|Symbol]
+  def continue(url: nil, method: nil, post_data: nil, headers: nil)
+    # Request interception is not supported for data: urls.
+    return if @url.start_with?('data:')
+
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+    @interception_handled = true
+
+    overrides = {
+      url: url,
+      method: method,
+      post_data: post_data,
+      headers: headers_to_array(headers),
+    }.compact
+    begin
+      @client.send_message('Fetch.continueRequest',
+        requestId: @interception_id,
+        **overrides,
+      )
+    rescue => err
+      # In certain cases, protocol will return error if the request was already canceled
+      # or the page was closed. We should tolerate these errors.
+      debug_puts(err)
+    end
+  end
+
+  # Mocking response.
+  #
+  # Example:
+  #
+  #   page.on 'request' do |req|
+  #     req.respond(
+  #       status: 404,
+  #       content_type: 'text/plain',
+  #       body: 'Not Found!'
+  #     )
+  #   end
+  #
+  # @param status [Integer]
+  # @param headers [Hash<String, String>]
+  # @param content_type [String]
+  # @param body [String]
+  def respond(status: nil, headers: nil, content_type: nil, body: nil)
+    # Mocking responses for dataURL requests is not currently supported.
+    return if @url.start_with?('data:')
+
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+    @interception_handled = true
+
+    mock_response_headers = {}
+    headers&.each do |key, value|
+      mock_response_headers[key.downcase] = value
+    end
+    if content_type
+      mock_response_headers['content-type'] = content_type
+    end
+    if body
+      mock_response_headers['content-length'] = body.length
+    end
+
+    mock_response = {
+      responseCode: status || 200,
+      responsePhrase: STATUS_TEXTS[(status || 200).to_s],
+      responseHeaders: headers_to_array(mock_response_headers),
+      body: if_present(body) { |mock_body| Base64.strict_encode64(mock_body) },
+    }.compact
+    begin
+      @client.send_message('Fetch.fulfillRequest',
+        requestId: @interception_id,
+        **mock_response,
+      )
+    rescue => err
+      # In certain cases, protocol will return error if the request was already canceled
+      # or the page was closed. We should tolerate these errors.
+      debug_puts(err)
+    end
+  end
+
+  # abort request on request interception.
+  #
+  # Example:
+  #
+  #   page.on 'request' do |req|
+  #     if req.url.include?("porn")
+  #       req.abort
+  #     else
+  #       req.continue
+  #     end
+  #   end
+  #
+  # @param error_code [String|Symbol]
+  def abort(error_code: :failed)
+    # Request interception is not supported for data: urls.
+    return if @url.start_with?('data:')
+
+    error_reason = ERROR_REASONS[error_code.to_s]
+    unless error_reason
+      raise ArgumentError.new("Unknown error code: #{error_code}")
+    end
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+    @interception_handled = true
+
+    begin
+      @client.send_message('Fetch.failRequest',
+        requestId: @interception_id,
+        errorReason: error_reason,
+      )
+    rescue => err
+      # In certain cases, protocol will return error if the request was already canceled
+      # or the page was closed. We should tolerate these errors.
+      debug_puts(err)
+    end
+  end
+
+  ERROR_REASONS = {
+    'aborted' => 'Aborted',
+    'accessdenied' => 'AccessDenied',
+    'addressunreachable' => 'AddressUnreachable',
+    'blockedbyclient' => 'BlockedByClient',
+    'blockedbyresponse' => 'BlockedByResponse',
+    'connectionaborted' => 'ConnectionAborted',
+    'connectionclosed' => 'ConnectionClosed',
+    'connectionfailed' => 'ConnectionFailed',
+    'connectionrefused' => 'ConnectionRefused',
+    'connectionreset' => 'ConnectionReset',
+    'internetdisconnected' => 'InternetDisconnected',
+    'namenotresolved' => 'NameNotResolved',
+    'timedout' => 'TimedOut',
+    'failed' => 'Failed',
+  }.freeze
+
+  # List taken from https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml with extra 306 and 418 codes.
+  STATUS_TEXTS = {
+    '100' => 'Continue',
+    '101' => 'Switching Protocols',
+    '102' => 'Processing',
+    '103' => 'Early Hints',
+    '200' => 'OK',
+    '201' => 'Created',
+    '202' => 'Accepted',
+    '203' => 'Non-Authoritative Information',
+    '204' => 'No Content',
+    '205' => 'Reset Content',
+    '206' => 'Partial Content',
+    '207' => 'Multi-Status',
+    '208' => 'Already Reported',
+    '226' => 'IM Used',
+    '300' => 'Multiple Choices',
+    '301' => 'Moved Permanently',
+    '302' => 'Found',
+    '303' => 'See Other',
+    '304' => 'Not Modified',
+    '305' => 'Use Proxy',
+    '306' => 'Switch Proxy',
+    '307' => 'Temporary Redirect',
+    '308' => 'Permanent Redirect',
+    '400' => 'Bad Request',
+    '401' => 'Unauthorized',
+    '402' => 'Payment Required',
+    '403' => 'Forbidden',
+    '404' => 'Not Found',
+    '405' => 'Method Not Allowed',
+    '406' => 'Not Acceptable',
+    '407' => 'Proxy Authentication Required',
+    '408' => 'Request Timeout',
+    '409' => 'Conflict',
+    '410' => 'Gone',
+    '411' => 'Length Required',
+    '412' => 'Precondition Failed',
+    '413' => 'Payload Too Large',
+    '414' => 'URI Too Long',
+    '415' => 'Unsupported Media Type',
+    '416' => 'Range Not Satisfiable',
+    '417' => 'Expectation Failed',
+    '418' => 'I\'m a teapot',
+    '421' => 'Misdirected Request',
+    '422' => 'Unprocessable Entity',
+    '423' => 'Locked',
+    '424' => 'Failed Dependency',
+    '425' => 'Too Early',
+    '426' => 'Upgrade Required',
+    '428' => 'Precondition Required',
+    '429' => 'Too Many Requests',
+    '431' => 'Request Header Fields Too Large',
+    '451' => 'Unavailable For Legal Reasons',
+    '500' => 'Internal Server Error',
+    '501' => 'Not Implemented',
+    '502' => 'Bad Gateway',
+    '503' => 'Service Unavailable',
+    '504' => 'Gateway Timeout',
+    '505' => 'HTTP Version Not Supported',
+    '506' => 'Variant Also Negotiates',
+    '507' => 'Insufficient Storage',
+    '508' => 'Loop Detected',
+    '510' => 'Not Extended',
+    '511' => 'Network Authentication Required',
+  }.freeze
+end