puppeteer-ruby 0.0.5 → 0.0.11

data/docs/top-level-namespace.html

@@ -116,7 +116,7 @@
 </div>
 
       <div id="footer">
-  Generated on Sun Apr 26 15:52:55 2020 by
+  Generated on Sat Jun 20 17:15:05 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'
@@ -142,7 +143,12 @@ 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}

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

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/cdp_session.rb

@@ -1,4 +1,5 @@
 class Puppeteer::CDPSession
+  include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
   using Puppeteer::AsyncAwaitBehavior
 
@@ -12,6 +13,7 @@ class Puppeteer::CDPSession
     @connection = connection
     @target_type = target_type
     @session_id = session_id
+    @pending_messages = {}
   end
 
   attr_reader :connection
@@ -32,7 +34,13 @@ class Puppeteer::CDPSession
     end
     id = @connection.raw_send(message: { sessionId: @session_id, method: method, params: params })
     promise = resolvable_future
-    @callbacks[id] = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
+    callback = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
+    if pending_message = @pending_messages.delete(id)
+      debug_puts "Pending message (id: #{id}) is handled"
+      callback_with_message(callback, pending_message)
+    else
+      @callbacks[id] = callback
+    end
     promise
   end
 
@@ -40,23 +48,37 @@ class Puppeteer::CDPSession
   def handle_message(message)
     if message['id']
       if callback = @callbacks.delete(message['id'])
-        if message['error']
-          callback.reject(
-            Puppeteer::Connection::ProtocolError.new(
-              method: callback.method,
-              error_message: message['error']['message'],
-              error_data: message['error']['data']))
-        else
-          callback.resolve(message['result'])
-        end
+        callback_with_message(callback, message)
       else
-        raise Error.new("unknown id: #{message['id']}")
+        debug_puts "unknown id: #{id}. Store it into pending message"
+
+        # RECV is often notified before SEND.
+        # Wait about 10 frames before throwing an error.
+        message_id = message['id']
+        @pending_messages[message_id] = message
+        Concurrent::Promises.schedule(0.16, message_id) do |id|
+          if @pending_messages.delete(id)
+            raise Error.new("unknown id: #{id}")
+          end
+        end
       end
     else
       emit_event message['method'], message['params']
     end
   end
 
+  private def callback_with_message(callback, message)
+    if message['error']
+      callback.reject(
+        Puppeteer::Connection::ProtocolError.new(
+          method: callback.method,
+          error_message: message['error']['message'],
+          error_data: message['error']['data']))
+    else
+      callback.resolve(message['result'])
+    end
+  end
+
   def detach
     if !@connection
       raise Error.new("Session already detarched. Most likely the #{@target_type} has been closed.")

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

@@ -19,6 +19,11 @@ class Puppeteer::DOMWorld
 
   attr_reader :frame
 
+  # only used in Puppeteer::WaitTask#initialize
+  def _wait_tasks
+    @wait_tasks
+  end
+
   # @param {?Puppeteer.ExecutionContext} context
   def context=(context)
     # D, [2020-04-12T22:45:03.938754 #46154] DEBUG -- : RECV << {"method"=>"Runtime.executionContextCreated", "params"=>{"context"=>{"id"=>3, "origin"=>"https://github.com", "name"=>"", "auxData"=>{"isDefault"=>true, "type"=>"default", "frameId"=>"3AD7F1E82BCBA88BFE31D03BC49FF6CB"}}}, "sessionId"=>"636CEF0C4FEAFC4FE815E9E7B5F7BA68"}
@@ -35,8 +40,7 @@ class Puppeteer::DOMWorld
         @context_promise = resolvable_future
       end
       @context_promise.fulfill(context)
-    #   for (const waitTask of this._waitTasks)
-    #     waitTask.rerun();
+      @wait_tasks.each(&:async_rerun)
     else
       raise ArgumentError.new("context should now be nil. Use #delete_context for clearing document.")
     end
@@ -93,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
@@ -351,58 +356,47 @@ 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
 
-  # /**
-  #  * @param {string} selector
-  #  */
-  # async tap(selector) {
-  #   const handle = await this.$(selector);
-  #   assert(handle, 'No node found for selector: ' + selector);
-  #   await handle.tap();
-  #   await handle.dispose();
-  # }
+    result
+  end
 
-  # /**
-  #  * @param {string} selector
-  #  * @param {string} text
-  #  * @param {{delay: (number|undefined)}=} options
-  #  */
-  # async type(selector, text, options) {
-  #   const handle = await this.$(selector);
-  #   assert(handle, 'No node found for selector: ' + selector);
-  #   await handle.type(text, options);
-  #   await handle.dispose();
-  # }
+  # @param selector [String]
+  def tap(selector)
+    handle = S(selector)
+    handle.tap
+    handle.dispose
+  end
 
-  # /**
-  #  * @param {string} selector
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  #  * @return {!Promise<?Puppeteer.ElementHandle>}
-  #  */
-  # waitForSelector(selector, options) {
-  #   return this._waitForSelectorOrXPath(selector, false, options);
-  # }
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    handle = S(selector)
+    handle.type_text(text, delay: delay)
+    handle.dispose
+  end
 
-  # /**
-  #  * @param {string} xpath
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  #  * @return {!Promise<?Puppeteer.ElementHandle>}
-  #  */
-  # waitForXPath(xpath, options) {
-  #   return this._waitForSelectorOrXPath(xpath, true, options);
-  # }
+  # @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]
+  def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector_or_xpath(selector, false, 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]
+  def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector_or_xpath(xpath, true, visible: visible, hidden: hidden, timeout: timeout)
+  end
 
   # /**
   #  * @param {Function|string} pageFunction
@@ -424,57 +418,68 @@ class Puppeteer::DOMWorld
   #   return this.evaluate(() => document.title);
   # }
 
-  # /**
-  #  * @param {string} selectorOrXPath
-  #  * @param {boolean} isXPath
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  #  * @return {!Promise<?Puppeteer.ElementHandle>}
-  #  */
-  # async _waitForSelectorOrXPath(selectorOrXPath, isXPath, options = {}) {
-  #   const {
-  #     visible: waitForVisible = false,
-  #     hidden: waitForHidden = false,
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   const polling = waitForVisible || waitForHidden ? 'raf' : 'mutation';
-  #   const title = `${isXPath ? 'XPath' : 'selector'} "${selectorOrXPath}"${waitForHidden ? ' to be hidden' : ''}`;
-  #   const waitTask = new WaitTask(this, predicate, title, polling, timeout, selectorOrXPath, isXPath, waitForVisible, waitForHidden);
-  #   const handle = await waitTask.promise;
-  #   if (!handle.asElement()) {
-  #     await handle.dispose();
-  #     return null;
-  #   }
-  #   return handle.asElement();
+  # @param selector_or_xpath [String]
+  # @param is_xpath [Boolean]
+  # @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]
+  private def wait_for_selector_or_xpath(selector_or_xpath, is_xpath, visible: nil, hidden: nil, timeout: nil)
+    option_wait_for_visible = visible || false
+    option_wait_for_hidden = hidden || false
+    option_timeout = timeout || @timeout_settings.timeout
+
+    polling =
+      if option_wait_for_visible || option_wait_for_hidden
+        'raf'
+      else
+        'mutation'
+      end
+    title = "#{is_xpath ? :XPath : :selector} #{selector_or_xpath}#{option_wait_for_hidden ? 'to be hidden' : ''}"
+
+    wait_task = Puppeteer::WaitTask.new(
+      dom_world: self,
+      predicate_body: "return (#{PREDICATE})(...args)",
+      title: title,
+      polling: polling,
+      timeout: option_timeout,
+      args: [selector_or_xpath, is_xpath, option_wait_for_visible, option_wait_for_hidden],
+    )
+    handle = wait_task.await_promise
+    unless handle.as_element
+      handle.dispose
+      return nil
+    end
+    handle.as_element
+  end
 
-  #   /**
-  #    * @param {string} selectorOrXPath
-  #    * @param {boolean} isXPath
-  #    * @param {boolean} waitForVisible
-  #    * @param {boolean} waitForHidden
-  #    * @return {?Node|boolean}
-  #    */
-  #   function predicate(selectorOrXPath, isXPath, waitForVisible, waitForHidden) {
-  #     const node = isXPath
-  #       ? document.evaluate(selectorOrXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue
-  #       : document.querySelector(selectorOrXPath);
-  #     if (!node)
-  #       return waitForHidden;
-  #     if (!waitForVisible && !waitForHidden)
-  #       return node;
-  #     const element = /** @type {Element} */ (node.nodeType === Node.TEXT_NODE ? node.parentElement : node);
-
-  #     const style = window.getComputedStyle(element);
-  #     const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
-  #     const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
-  #     return success ? node : null;
-
-  #     /**
-  #      * @return {boolean}
-  #      */
-  #     function hasVisibleBoundingBox() {
-  #       const rect = element.getBoundingClientRect();
-  #       return !!(rect.top || rect.bottom || rect.width || rect.height);
-  #     }
-  #   }
-  # }
+  PREDICATE = <<~JAVASCRIPT
+  /**
+    * @param {string} selectorOrXPath
+    * @param {boolean} isXPath
+    * @param {boolean} waitForVisible
+    * @param {boolean} waitForHidden
+    * @return {?Node|boolean}
+    */
+  function _(selectorOrXPath, isXPath, waitForVisible, waitForHidden) {
+      const node = isXPath
+          ? document.evaluate(selectorOrXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue
+          : document.querySelector(selectorOrXPath);
+      if (!node)
+          return waitForHidden;
+      if (!waitForVisible && !waitForHidden)
+          return node;
+      const element = /** @type {Element} */ (node.nodeType === Node.TEXT_NODE ? node.parentElement : node);
+      const style = window.getComputedStyle(element);
+      const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
+      const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
+      return success ? node : null;
+      /**
+        * @return {boolean}
+        */
+      function hasVisibleBoundingBox() {
+          const rect = element.getBoundingClientRect();
+          return !!(rect.top || rect.bottom || rect.width || rect.height);
+      }
+  }
+  JAVASCRIPT
 end