puppeteer-ruby 0.0.11 → 0.0.16

data/lib/puppeteer/page.rb

@@ -1,11 +1,13 @@
 require 'base64'
+require "stringio"
 
+require_relative './page/pdf_options'
 require_relative './page/screenshot_options'
 
 class Puppeteer::Page
   include Puppeteer::EventCallbackable
   include Puppeteer::IfPresent
-  using Puppeteer::AsyncAwaitBehavior
+  using Puppeteer::DefineAsyncMethod
 
   # @param {!Puppeteer.CDPSession} client
   # @param {!Puppeteer.Target} target
@@ -124,6 +126,45 @@ class Puppeteer::Page
     )
   end
 
+  EVENT_MAPPINGS = {
+    close: 'Events.Page.Close',
+    # console: 'Events.Page.Console',
+    # dialog: 'Events.Page.Dialog',
+    domcontentloaded: 'Events.Page.DOMContentLoaded',
+    # error:
+    frameattached: 'Events.Page.FrameAttached',
+    framedetached: 'Events.Page.FrameDetached',
+    framenavigated: 'Events.Page.FrameNavigated',
+    load: 'Events.Page.Load',
+    # metrics: 'Events.Page.Metrics',
+    # pageerror: 'Events.Page.PageError',
+    popup: 'Events.Page.Popup',
+    request: 'Events.Page.Request',
+    requestfailed: 'Events.Page.RequestFailed',
+    requestfinished: 'Events.Page.RequestFinished',
+    response: 'Events.Page.Response',
+    # workercreated: 'Events.Page.WorkerCreated',
+    # workerdestroyed: 'Events.Page.WorkerDestroyed',
+  }
+
+  # @param event_name [Symbol]
+  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
+
+  # @param event_name [Symbol]
+  def once(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
+
+    observe_first(EVENT_MAPPINGS[event_name.to_sym], &block)
+  end
+
   def handle_file_chooser(event)
     return if @file_chooser_interceptors.empty?
 
@@ -166,12 +207,7 @@ class Puppeteer::Page
     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
-
+  define_async_method :async_wait_for_file_chooser
 
   # /**
   #  * @param {!{longitude: number, latitude: number, accuracy: (number|undefined)}} options
@@ -266,6 +302,8 @@ class Puppeteer::Page
     main_frame.S(selector)
   end
 
+  define_async_method :async_S
+
   # `$$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param {string} selector
   # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
@@ -273,6 +311,8 @@ class Puppeteer::Page
     main_frame.SS(selector)
   end
 
+  define_async_method :async_SS
+
   # @param {Function|string} pageFunction
   # @param {!Array<*>} args
   # @return {!Promise<!Puppeteer.JSHandle>}
@@ -281,6 +321,8 @@ class Puppeteer::Page
     context.evaluate_handle(page_function, *args)
   end
 
+  define_async_method :async_evaluate_handle
+
   # @param {!Puppeteer.JSHandle} prototypeHandle
   # @return {!Promise<!Puppeteer.JSHandle>}
   def query_objects(prototype_handle)
@@ -296,13 +338,7 @@ class Puppeteer::Page
     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
+  define_async_method :async_Seval
 
   # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param selector [String]
@@ -312,13 +348,7 @@ class Puppeteer::Page
     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
+  define_async_method :async_SSeval
 
   # `$x()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param {string} expression
@@ -327,6 +357,8 @@ class Puppeteer::Page
     main_frame.Sx(expression)
   end
 
+  define_async_method :async_Sx
+
   # /**
   #  * @param {!Array<string>} urls
   #  * @return {!Promise<!Array<Network.Cookie>>}
@@ -619,13 +651,14 @@ class Puppeteer::Page
     main_frame.content
   end
 
-  # @param {string} html
-  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
+  # @param html [String]
+  # @param timeout [Integer]
+  # @param wait_until [String|Array<String>]
   def set_content(html, timeout: nil, wait_until: nil)
     main_frame.set_content(html, timeout: timeout, wait_until: wait_until)
   end
 
-  # @param {string} html
+  # @param html [String]
   def content=(html)
     main_frame.set_content(html)
   end
@@ -654,48 +687,96 @@ class Puppeteer::Page
     main_frame.send(:wait_for_navigation, 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)
+  define_async_method :async_wait_for_navigation
+
+  private def wait_for_network_manager_event(event_name, predicate:, timeout:)
+    option_timeout = timeout || @timeout_settings.timeout
+
+    @wait_for_network_manager_event_listener_ids ||= {}
+    if_present(@wait_for_network_manager_event_listener_ids[event_name]) do |listener_id|
+      @frame_manager.network_manager.remove_event_listener(listener_id)
+    end
+
+    promise = resolvable_future
+
+    @wait_for_network_manager_event_listener_ids[event_name] =
+      @frame_manager.network_manager.add_event_listener(event_name) do |event_target|
+        if predicate.call(event_target)
+          promise.fulfill(nil)
+        end
+      end
+
+    begin
+      Timeout.timeout(option_timeout / 1000.0) do
+        await_any(promise, session_close_promise)
+      end
+    rescue Timeout::Error
+      raise Puppeteer::TimeoutError.new("waiting for #{event_name} failed: timeout #{timeout}ms exceeded")
+    ensure
+      @frame_manager.network_manager.remove_event_listener(@wait_for_network_manager_event_listener_ids[event_name])
+    end
   end
 
-  # /**
-  #  * @param {(string|Function)} urlOrPredicate
-  #  * @param {!{timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.Request>}
-  #  */
-  # async waitForRequest(urlOrPredicate, options = {}) {
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Request, request => {
-  #     if (helper.isString(urlOrPredicate))
-  #       return (urlOrPredicate === request.url());
-  #     if (typeof urlOrPredicate === 'function')
-  #       return !!(urlOrPredicate(request));
-  #     return false;
-  #   }, timeout, this._sessionClosePromise());
-  # }
+  private def session_close_promise
+    @disconnect_promise ||= resolvable_future do |future|
+      @client.observe_first('Events.CDPSession.Disconnected') do
+        future.reject(Puppeteer::CDPSession::Error.new('Target Closed'))
+      end
+    end
+  end
 
-  # /**
-  #  * @param {(string|Function)} urlOrPredicate
-  #  * @param {!{timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.Response>}
-  #  */
-  # async waitForResponse(urlOrPredicate, options = {}) {
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Response, response => {
-  #     if (helper.isString(urlOrPredicate))
-  #       return (urlOrPredicate === response.url());
-  #     if (typeof urlOrPredicate === 'function')
-  #       return !!(urlOrPredicate(response));
-  #     return false;
-  #   }, timeout, this._sessionClosePromise());
-  # }
+  # - Waits until request URL matches
+  #  `wait_for_request(url: 'https://example.com/awesome')`
+  # - Waits until request matches the given predicate
+  #  `wait_for_request(predicate: -> (req){ req.url.start_with?('https://example.com/search') })`
+  #
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Request -> Boolean)]
+  private def wait_for_request(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    request_predicate =
+      if url
+        -> (request) { request.url == url }
+      else
+        -> (request) { predicate.call(request) }
+      end
+
+    wait_for_network_manager_event('Events.NetworkManager.Request',
+      predicate: request_predicate,
+      timeout: timeout,
+    )
+  end
+
+  define_async_method :async_wait_for_request
+
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Request -> Boolean)]
+  private def wait_for_response(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    response_predicate =
+      if url
+        -> (response) { response.url == url }
+      else
+        -> (response) { predicate.call(response) }
+      end
+
+    wait_for_network_manager_event('Events.NetworkManager.Response',
+      predicate: response_predicate,
+      timeout: timeout,
+    )
+  end
+
+  define_async_method :async_wait_for_response
 
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
@@ -734,20 +815,19 @@ class Puppeteer::Page
     @client.send_message('Emulation.setScriptExecutionDisabled', value: !enabled)
   end
 
-  # /**
-  #  * @param {boolean} enabled
-  #  */
-  # async setBypassCSP(enabled) {
-  #   await this._client.send('Page.setBypassCSP', { enabled });
-  # }
+  # @param enabled [Boolean]
+  def bypass_csp=(enabled)
+    @client.send_message('Page.setBypassCSP', enabled: enabled)
+  end
 
-  # /**
-  #  * @param {?string} type
-  #  */
-  # async emulateMediaType(type) {
-  #   assert(type === 'screen' || type === 'print' || type === null, 'Unsupported media type: ' + type);
-  #   await this._client.send('Emulation.setEmulatedMedia', {media: type || ''});
-  # }
+  # @param media_type [String|Symbol|nil] either of (media, print, nil)
+  def emulate_media_type(media_type)
+    media_type_str = media_type.to_s
+    unless ['screen', 'print', ''].include?(media_type_str)
+      raise ArgumentError.new("Unsupported media type: #{media_type}")
+    end
+    @client.send_message('Emulation.setEmulatedMedia', media: media_type_str)
+  end
 
   # /**
   #  * @param {?Array<MediaFeature>} features
@@ -767,7 +847,7 @@ class Puppeteer::Page
 
   # @param timezone_id [String?]
   def emulate_timezone(timezone_id)
-    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezoneId || '')
+    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezone_id || '')
   rescue => err
     if err.message.include?('Invalid timezone')
       raise ArgumentError.new("Invalid timezone ID: #{timezone_id}")
@@ -792,6 +872,8 @@ class Puppeteer::Page
     main_frame.evaluate(page_function, *args)
   end
 
+  define_async_method :async_evaluate
+
   # /**
   #  * @param {Function|string} pageFunction
   #  * @param {!Array<*>} args
@@ -806,9 +888,9 @@ class Puppeteer::Page
     @frame_manager.network_manager.cache_enabled = enabled
   end
 
-  # @return {!Promise<string>}
+  # @return [String]
   def title
-    @title
+    main_frame.title
   end
 
   # /**
@@ -888,71 +970,66 @@ class Puppeteer::Page
     buffer
   end
 
-  # /**
-  #  * @param {!PDFOptions=} options
-  #  * @return {!Promise<!Buffer>}
-  #  */
-  # async pdf(options = {}) {
-  #   const {
-  #     scale = 1,
-  #     displayHeaderFooter = false,
-  #     headerTemplate = '',
-  #     footerTemplate = '',
-  #     printBackground = false,
-  #     landscape = false,
-  #     pageRanges = '',
-  #     preferCSSPageSize = false,
-  #     margin = {},
-  #     path = null
-  #   } = options;
-
-  #   let paperWidth = 8.5;
-  #   let paperHeight = 11;
-  #   if (options.format) {
-  #     const format = Page.PaperFormats[options.format.toLowerCase()];
-  #     assert(format, 'Unknown paper format: ' + options.format);
-  #     paperWidth = format.width;
-  #     paperHeight = format.height;
-  #   } else {
-  #     paperWidth = convertPrintParameterToInches(options.width) || paperWidth;
-  #     paperHeight = convertPrintParameterToInches(options.height) || paperHeight;
-  #   }
+  class ProtocolStreamReader
+    def initialize(client:, handle:, path:)
+      @client = client
+      @handle = handle
+      @path = path
+    end
 
-  #   const marginTop = convertPrintParameterToInches(margin.top) || 0;
-  #   const marginLeft = convertPrintParameterToInches(margin.left) || 0;
-  #   const marginBottom = convertPrintParameterToInches(margin.bottom) || 0;
-  #   const marginRight = convertPrintParameterToInches(margin.right) || 0;
-
-  #   const result = await this._client.send('Page.printToPDF', {
-  #     transferMode: 'ReturnAsStream',
-  #     landscape,
-  #     displayHeaderFooter,
-  #     headerTemplate,
-  #     footerTemplate,
-  #     printBackground,
-  #     scale,
-  #     paperWidth,
-  #     paperHeight,
-  #     marginTop,
-  #     marginBottom,
-  #     marginLeft,
-  #     marginRight,
-  #     pageRanges,
-  #     preferCSSPageSize
-  #   });
-  #   return await helper.readProtocolStream(this._client, result.stream, path);
-  # }
+    def read
+      out = StringIO.new
+      File.open(@path, 'w') do |file|
+        eof = false
+        until eof
+          response = @client.send_message('IO.read', handle: @handle)
+          eof = response['eof']
+          data =
+            if response['base64Encoded']
+              Base64.decode64(response['data'])
+            else
+              response['data']
+            end
+          out.write(data)
+          file.write(data)
+        end
+      end
+      @client.send_message('IO.close', handle: @handle)
+      out.read
+    end
+  end
+
+  class PrintToPdfIsNotImplementedError < StandardError
+    def initialize
+      super('pdf() is only available in headless mode. See https://github.com/puppeteer/puppeteer/issues/1829')
+    end
+  end
+
+  # @return [String]
+  def pdf(options = {})
+    pdf_options = PDFOptions.new(options)
+    result = @client.send_message('Page.printToPDF', pdf_options.page_print_args)
+    ProtocolStreamReader.new(client: @client, handle: result['stream'], path: pdf_options.path).read
+  rescue => err
+    if err.message.include?('PrintToPDF is not implemented')
+      raise PrintToPdfIsNotImplementedError.new
+    else
+      raise
+    end
+  end
 
-  # @param {!{runBeforeUnload: (boolean|undefined)}=} options
-  def close
-    # assert(!!this._client._connection, 'Protocol error: Connection closed. Most likely the page has been closed.');
-    # const runBeforeUnload = !!options.runBeforeUnload;
-    # if (runBeforeUnload) {
-    #   await this._client.send('Page.close');
-    # } else {
-    #   await this._client._connection.send('Target.closeTarget', { targetId: this._target._targetId });
-    #   await this._target._isClosedPromise;
-    # }
+  # @param run_before_unload [Boolean]
+  def close(run_before_unload: false)
+    unless @client.connection
+      raise 'Protocol error: Connection closed. Most likely the page has been closed.'
+    end
+
+    if run_before_unload
+      @client.send_message('Page.close')
+    else
+      @client.connection.send_message('Target.closeTarget', targetId: @target.target_id)
+      await @target.is_closed_promise
+    end
   end
 
   # @return [boolean]
@@ -970,20 +1047,15 @@ class Puppeteer::Page
     main_frame.click(selector, delay: delay, button: button, click_count: click_count)
   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
+  define_async_method :async_click
 
   # @param {string} selector
   def focus(selector)
     main_frame.focus(selector)
   end
 
+  define_async_method :async_focus
+
   # @param {string} selector
   def hover(selector)
     main_frame.hover(selector)
@@ -996,15 +1068,14 @@ class Puppeteer::Page
     main_frame.select(selector, *values)
   end
 
+  define_async_method :async_select
+
   # @param selector [String]
   def tap(selector)
     main_frame.tap(selector)
   end
 
-  # @param selector [String]
-  async def async_tap(selector)
-    tap(selector)
-  end
+  define_async_method :async_tap
 
   # @param selector [String]
   # @param text [String]
@@ -1013,15 +1084,7 @@ class Puppeteer::Page
     main_frame.type_text(selector, text, delay: delay)
   end
 
-  # /**
-  #  * @param {(string|number|Function)} selectorOrFunctionOrTimeout
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number, polling?: string|number}=} options
-  #  * @param {!Array<*>} args
-  #  * @return {!Promise<!Puppeteer.JSHandle>}
-  #  */
-  # waitFor(selectorOrFunctionOrTimeout, options = {}, ...args) {
-  #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
-  # }
+  define_async_method :async_type_text
 
   # @param selector [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
@@ -1031,13 +1094,7 @@ class Puppeteer::Page
     main_frame.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
   end
 
-  # @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
+  define_async_method :async_wait_for_selector
 
   # @param xpath [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
@@ -1047,13 +1104,7 @@ class Puppeteer::Page
     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
+  define_async_method :async_wait_for_xpath
 
   # @param {Function|string} pageFunction
   # @param {!{polling?: string|number, timeout?: number}=} options
@@ -1062,4 +1113,6 @@ class Puppeteer::Page
   def wait_for_function(page_function, options = {}, *args)
     main_frame.wait_for_function(page_function, options, *args)
   end
+
+  define_async_method :async_wait_for_function
 end