puppeteer-ruby 0.0.13 → 0.0.18

data/lib/puppeteer/browser_context.rb

@@ -1,5 +1,6 @@
 class Puppeteer::BrowserContext
   include Puppeteer::EventCallbackable
+  using Puppeteer::DefineAsyncMethod
 
   # @param {!Puppeteer.Connection} connection
   # @param {!Browser} browser
@@ -10,14 +11,38 @@ class Puppeteer::BrowserContext
     @id = context_id
   end
 
+  EVENT_MAPPINGS = {
+    disconnected: 'Events.BrowserContext.Disconnected',
+    targetcreated: 'Events.BrowserContext.TargetCreated',
+    targetchanged: 'Events.BrowserContext.TargetChanged',
+    targetdestroyed: 'Events.BrowserContext.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
+
+  # @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
+
   # @return {!Array<!Target>} target
   def targets
     @browser.targets.select { |target| target.browser_context == self }
   end
 
-  # @param {function(!Target):boolean} predicate
-  # @param {{timeout?: number}=} options
-  # @return {!Promise<!Target>}
+  # @param predicate [Proc(Puppeteer::Target -> Boolean)]
+  # @return [Puppeteer::Target]
   def wait_for_target(predicate:, timeout: nil)
     @browser.wait_for_target(
       predicate: ->(target) { target.browser_context == self && predicate.call(target) },
@@ -25,13 +50,18 @@ class Puppeteer::BrowserContext
     )
   end
 
+  # @!method async_wait_for_target(predicate:, timeout: nil)
+  #
+  # @param predicate [Proc(Puppeteer::Target -> Boolean)]
+  define_async_method :async_wait_for_target
+
   # @return {!Promise<!Array<!Puppeteer.Page>>}
   def pages
     targets.select { |target| target.type == 'page' }.map(&:page).reject { |page| !page }
   end
 
   def incognito?
-    !@id
+    !!@id
   end
 
   # /**
@@ -82,7 +112,7 @@ class Puppeteer::BrowserContext
   end
 
   def close
-    if !@id
+    unless @id
       raise 'Non-incognito profiles cannot be closed!'
     end
     @browser.dispose_context(@id)

data/lib/puppeteer/cdp_session.rb

@@ -1,7 +1,7 @@
 class Puppeteer::CDPSession
   include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
-  using Puppeteer::AsyncAwaitBehavior
+  using Puppeteer::DefineAsyncMethod
 
   class Error < StandardError; end
 
@@ -13,7 +13,6 @@ class Puppeteer::CDPSession
     @connection = connection
     @target_type = target_type
     @session_id = session_id
-    @pending_messages = {}
   end
 
   attr_reader :connection
@@ -35,12 +34,7 @@ class Puppeteer::CDPSession
     id = @connection.raw_send(message: { sessionId: @session_id, method: method, params: params })
     promise = resolvable_future
     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
+    @callbacks[id] = callback
     promise
   end
 
@@ -50,17 +44,7 @@ class Puppeteer::CDPSession
       if callback = @callbacks.delete(message['id'])
         callback_with_message(callback, message)
       else
-        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
+        raise Error.new("unknown id: #{id}")
       end
     else
       emit_event message['method'], message['params']

data/lib/puppeteer/concurrent_ruby_utils.rb

@@ -1,5 +1,8 @@
 # utility methods for Concurrent::Promises.
 module Puppeteer::ConcurrentRubyUtils
+  # wait for all promises.
+  # REMARK: This method doesn't assure the order of calling.
+  # for example, await_all(async1, async2) calls calls2 -> calls1 often.
   def await_all(*args)
     if args.length == 1 && args[0].is_a?(Enumerable)
       Concurrent::Promises.zip(*(args[0])).value!
@@ -8,6 +11,9 @@ module Puppeteer::ConcurrentRubyUtils
     end
   end
 
+  # wait for first promises.
+  # REMARK: This method doesn't assure the order of calling.
+  # for example, await_all(async1, async2) calls calls2 -> calls1 often.
   def await_any(*args)
     if args.length == 1 && args[0].is_a?(Enumerable)
       Concurrent::Promises.any(*(args[0])).value!

data/lib/puppeteer/connection.rb

@@ -3,7 +3,7 @@ require 'json'
 class Puppeteer::Connection
   include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
-  using Puppeteer::AsyncAwaitBehavior
+  using Puppeteer::DefineAsyncMethod
 
   class ProtocolError < StandardError
     def initialize(method:, error_message:, error_data: nil)
@@ -49,13 +49,18 @@ class Puppeteer::Connection
       async_handle_message(message)
     end
     @transport.on_close do |reason, code|
-      handle_close(reason, code)
+      handle_close
     end
 
     @sessions = {}
     @closed = false
   end
 
+  # used only in Browser#connected?
+  def closed?
+    @closed
+  end
+
   private def sleep_before_handling_message(message)
     # Puppeteer doesn't handle any Network monitoring responses.
     # So we don't have to sleep.
@@ -210,9 +215,7 @@ class Puppeteer::Connection
     end
   end
 
-  private async def async_handle_message(message)
-    handle_message(message)
-  end
+  private define_async_method :async_handle_message
 
   private def handle_close
     return if @closed
@@ -251,16 +254,6 @@ class Puppeteer::Connection
   def create_session(target_info)
     result = send_message('Target.attachToTarget', targetId: target_info.target_id, flatten: true)
     session_id = result['sessionId']
-
-    # Target.attachedToTarget is often notified after the result of Target.attachToTarget.
-    # D, [2020-04-04T23:04:30.736311 #91875] DEBUG -- : RECV << {"id"=>2, "result"=>{"sessionId"=>"DA002F8A95B04710502CB40D8430B95A"}}
-    # D, [2020-04-04T23:04:30.736649 #91875] DEBUG -- : RECV << {"method"=>"Target.attachedToTarget", "params"=>{"sessionId"=>"DA002F8A95B04710502CB40D8430B95A", "targetInfo"=>{"targetId"=>"EBAB949A7DE63F12CB94268AD3A9976B", "type"=>"page", "title"=>"about:blank", "url"=>"about:blank", "attached"=>true, "browserContextId"=>"46D23767E9B79DD9E589101121F6DADD"}, "waitingForDebugger"=>false}}
-    # So we have to wait for "Target.attachedToTarget" a bit.
-    20.times do
-      if @sessions[session_id]
-        return @sessions[session_id]
-      end
-      sleep 0.1
-    end
+    @sessions[session_id]
   end
 end

data/lib/puppeteer/debug_print.rb

@@ -1,7 +1,7 @@
 require 'logger'
 
 module Puppeteer::DebugPrint
-  if ['1', 'true'].include?(ENV['DEBUG'])
+  if Puppeteer.env.debug?
     def debug_puts(*args, **kwargs)
       @__debug_logger ||= Logger.new(STDOUT)
       @__debug_logger.debug(*args, **kwargs)

data/lib/puppeteer/define_async_method.rb

@@ -0,0 +1,23 @@
+module Puppeteer::DefineAsyncMethod
+  refine Class do
+    def define_async_method(async_method_name)
+      unless async_method_name.to_s.start_with?('async_')
+        raise ArgumentError.new('async method name should start with "async_"')
+      end
+
+      if method_defined?(async_method_name) || private_method_defined?(async_method_name)
+        raise ArgumentError.new("#{async_method_name} is already defined")
+      end
+
+      original_method = instance_method(async_method_name[6..-1])
+      define_method(async_method_name) do |*args|
+        Concurrent::Promises.future do
+          original_method.bind(self).call(*args)
+        rescue => err
+          Logger.new(STDERR).warn(err)
+          raise err
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/dom_world.rb

@@ -2,7 +2,7 @@ require 'thread'
 
 # https://github.com/puppeteer/puppeteer/blob/master/src/DOMWorld.js
 class Puppeteer::DOMWorld
-  using Puppeteer::AsyncAwaitBehavior
+  using Puppeteer::DefineAsyncMethod
 
   # @param {!Puppeteer.FrameManager} frameManager
   # @param {!Puppeteer.Frame} frame
@@ -12,7 +12,6 @@ class Puppeteer::DOMWorld
     @frame = frame
     @timeout_settings = timeout_settings
     @context_promise = resolvable_future
-    @pending_destroy = []
     @wait_tasks = Set.new
     @detached = false
   end
@@ -24,22 +23,12 @@ class Puppeteer::DOMWorld
     @wait_tasks
   end
 
-  # @param {?Puppeteer.ExecutionContext} context
+  # @param context [Puppeteer::ExecutionContext]
   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"}
-    # D, [2020-04-12T22:45:03.938856 #46154] DEBUG -- : RECV << {"method"=>"Runtime.executionContextCreated", "params"=>{"context"=>{"id"=>4, "origin"=>"://", "name"=>"__puppeteer_utility_world__", "auxData"=>{"isDefault"=>false, "type"=>"isolated", "frameId"=>"3AD7F1E82BCBA88BFE31D03BC49FF6CB"}}}, "sessionId"=>"636CEF0C4FEAFC4FE815E9E7B5F7BA68"}
-    # D, [2020-04-12T22:45:03.938960 #46154] DEBUG -- : RECV << {"method"=>"Runtime.executionContextDestroyed", "params"=>{"executionContextId"=>1}, "sessionId"=>"636CEF0C4FEAFC4FE815E9E7B5F7BA68"}
-    # D, [2020-04-12T22:45:03.939110 #46154] DEBUG -- : RECV << {"method"=>"Page.frameNavigated", "params"=>{"frame"=>{"id"=>"3AD7F1E82BCBA88BFE31D03BC49FF6CB", "loaderId"=>"301B349884E582986C502CBE020966DF", "url"=>"https://github.com/", "securityOrigin"=>"https://github.com", "mimeType"=>"text/html"}}, "sessionId"=>"636CEF0C4FEAFC4FE815E9E7B5F7BA68"}
-    # D, [2020-04-12T22:45:03.939793 #46154] DEBUG -- : RECV << {"method"=>"Runtime.executionContextDestroyed", "params"=>{"executionContextId"=>2}, "sessionId"=>"636CEF0C4FEAFC4FE815E9E7B5F7BA68"}
-    # executionContextDestroyed is often notified after executionContextCreated.
-
     if context
-      if @context_promise.fulfilled?
-        @pending_destroy << context._context_id
-        @document = nil
-        @context_promise = resolvable_future
+      unless @context_promise.resolved?
+        @context_promise.fulfill(context)
       end
-      @context_promise.fulfill(context)
       @wait_tasks.each(&:async_rerun)
     else
       raise ArgumentError.new("context should now be nil. Use #delete_context for clearing document.")
@@ -47,12 +36,8 @@ class Puppeteer::DOMWorld
   end
 
   def delete_context(execution_context_id)
-    if @pending_destroy.include?(execution_context_id)
-      @pending_destroy.delete(execution_context_id)
-    else
-      @document = nil
-      @context_promise = resolvable_future
-    end
+    @document = nil
+    @context_promise = resolvable_future
   end
 
   def has_context?
@@ -147,45 +132,48 @@ class Puppeteer::DOMWorld
     document.SS(selector)
   end
 
-  # /**
-  #  * @return {!Promise<String>}
-  #  */
-  # async content() {
-  #   return await this.evaluate(() => {
-  #     let retVal = '';
-  #     if (document.doctype)
-  #       retVal = new XMLSerializer().serializeToString(document.doctype);
-  #     if (document.documentElement)
-  #       retVal += document.documentElement.outerHTML;
-  #     return retVal;
-  #   });
-  # }
+  # @return [String]
+  def content
+    evaluate <<-JAVASCRIPT
+    () => {
+      let retVal = '';
+      if (document.doctype)
+        retVal = new XMLSerializer().serializeToString(document.doctype);
+      if (document.documentElement)
+        retVal += document.documentElement.outerHTML;
+      return retVal;
+    }
+    JAVASCRIPT
+  end
 
-  # /**
-  #  * @param {string} html
-  #  * @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
-  #  */
-  # async setContent(html, options = {}) {
-  #   const {
-  #     waitUntil = ['load'],
-  #     timeout = this._timeoutSettings.navigationTimeout(),
-  #   } = options;
-  #   // We rely upon the fact that document.open() will reset frame lifecycle with "init"
-  #   // lifecycle event. @see https://crrev.com/608658
-  #   await this.evaluate(html => {
-  #     document.open();
-  #     document.write(html);
-  #     document.close();
-  #   }, html);
-  #   const watcher = new LifecycleWatcher(this._frameManager, this._frame, waitUntil, timeout);
-  #   const error = await Promise.race([
-  #     watcher.timeoutOrTerminationPromise(),
-  #     watcher.lifecyclePromise(),
-  #   ]);
-  #   watcher.dispose();
-  #   if (error)
-  #     throw error;
-  # }
+  # @param html [String]
+  # @param timeout [Integer]
+  # @param wait_until [String|Array<String>]
+  def set_content(html, timeout: nil, wait_until: nil)
+    option_wait_until = [wait_until || 'load'].flatten
+    option_timeout = @timeout_settings.navigation_timeout
+
+    # We rely upon the fact that document.open() will reset frame lifecycle with "init"
+    # lifecycle event. @see https://crrev.com/608658
+    js = <<-JAVASCRIPT
+    (html) => {
+      document.open();
+      document.write(html);
+      document.close();
+    }
+    JAVASCRIPT
+    evaluate(js, html)
+
+    watcher = Puppeteer::LifecycleWatcher.new(@frame_manager, @frame, option_wait_until, option_timeout)
+    begin
+      await_any(
+        watcher.timeout_or_termination_promise,
+        watcher.lifecycle_promise,
+      )
+    ensure
+      watcher.dispose
+    end
+  end
 
   # /**
   #  * @param {!{url?: string, path?: string, content?: string, type?: string}} options
@@ -326,25 +314,28 @@ class Puppeteer::DOMWorld
   #   }
   # }
 
+  class ElementNotFoundError < StandardError
+    def initialize(selector)
+      super("No node found for selector: #{selector}")
+    end
+  end
+
   # @param selector [String]
   # @param delay [Number]
   # @param button [String] "left"|"right"|"middle"
   # @param click_count [Number]
   def click(selector, delay: nil, button: nil, click_count: nil)
-    handle = S(selector)
+    handle = S(selector) or raise ElementNotFoundError.new(selector)
     handle.click(delay: delay, button: button, click_count: click_count)
     handle.dispose
   end
 
-  # /**
-  #  * @param {string} selector
-  #  */
-  # async focus(selector) {
-  #   const handle = await this.$(selector);
-  #   assert(handle, 'No node found for selector: ' + selector);
-  #   await handle.focus();
-  #   await handle.dispose();
-  # }
+  # @param selector [String]
+  def focus(selector)
+    handle = S(selector) or raise ElementNotFoundError.new(selector)
+    handle.focus
+    handle.dispose
+  end
 
   # /**
   #  * @param {string} selector
@@ -359,7 +350,7 @@ class Puppeteer::DOMWorld
   # @param selector [String]
   # @return [Array<String>]
   def select(selector, *values)
-    handle = S(selector)
+    handle = S(selector) or raise ElementNotFoundError.new(selector)
     result = handle.select(*values)
     handle.dispose
 
@@ -368,7 +359,7 @@ class Puppeteer::DOMWorld
 
   # @param selector [String]
   def tap(selector)
-    handle = S(selector)
+    handle = S(selector) or raise ElementNotFoundError.new(selector)
     handle.tap
     handle.dispose
   end
@@ -377,7 +368,7 @@ class Puppeteer::DOMWorld
   # @param text [String]
   # @param delay [Number]
   def type_text(selector, text, delay: nil)
-    handle = S(selector)
+    handle = S(selector) or raise ElementNotFoundError.new(selector)
     handle.type_text(text, delay: delay)
     handle.dispose
   end
@@ -411,6 +402,26 @@ class Puppeteer::DOMWorld
   #   return new WaitTask(this, pageFunction, 'function', polling, timeout, ...args).promise;
   # }
 
+  # @param page_function [String]
+  # @param args [Array]
+  # @param polling [Integer|String]
+  # @param timeout [Integer]
+  # @return [Puppeteer::JSHandle]
+  def wait_for_function(page_function, args: [], polling: nil, timeout: nil)
+    option_polling = polling || 'raf'
+    option_timeout = timeout || @timeout_settings.timeout
+
+    Puppeteer::WaitTask.new(
+      dom_world: self,
+      predicate_body: page_function,
+      title: 'function',
+      polling: option_polling,
+      timeout: option_timeout,
+      args: args,
+    ).await_promise
+  end
+
+
   # @return [String]
   def title
     evaluate('() => document.title')
@@ -436,7 +447,7 @@ class Puppeteer::DOMWorld
 
     wait_task = Puppeteer::WaitTask.new(
       dom_world: self,
-      predicate_body: "return (#{PREDICATE})(...args)",
+      predicate_body: PREDICATE,
       title: title,
       polling: polling,
       timeout: option_timeout,