puppeteer-ruby 0.0.21 → 0.0.27

data/lib/puppeteer/browser_runner.rb

@@ -14,16 +14,24 @@ class Puppeteer::BrowserRunner
     @proc = nil
     @connection = nil
     @closed = true
-    @listeners = []
   end
 
   attr_reader :proc, :connection
 
   class BrowserProcess
     def initialize(env, executable_path, args)
+      @spawnargs =
+        if args && !args.empty?
+          [executable_path] + args
+        else
+          [executable_path]
+        end
+
       stdin, @stdout, @stderr, @thread = Open3.popen3(env, executable_path, *args)
       stdin.close
       @pid = @thread.pid
+    rescue Errno::ENOENT => err
+      raise LaunchError.new(err.message)
     end
 
     def kill
@@ -37,7 +45,13 @@ class Puppeteer::BrowserRunner
       @thread.join
     end
 
-    attr_reader :stdout, :stderr
+    attr_reader :stdout, :stderr, :spawnargs
+  end
+
+  class LaunchError < StandardError
+    def initialize(reason)
+      super("Failed to launch browser! #{reason}")
+    end
   end
 
   # @param {!(Launcher.LaunchOptions)=} options
@@ -123,12 +137,12 @@ class Puppeteer::BrowserRunner
 
   # @return {Promise}
   def kill
-    unless @closed
-      @proc.kill
-    end
     if @temp_directory
       FileUtils.rm_rf(@temp_directory)
     end
+    unless @closed
+      @proc.kill
+    end
   end
 
 

data/lib/puppeteer/cdp_session.rb

@@ -9,7 +9,7 @@ class Puppeteer::CDPSession
   # @param {string} targetType
   # @param {string} sessionId
   def initialize(connection, target_type, session_id)
-    @callbacks = {}
+    @callbacks = Concurrent::Hash.new
     @connection = connection
     @target_type = target_type
     @session_id = session_id
@@ -31,10 +31,14 @@ class Puppeteer::CDPSession
     if !@connection
       raise Error.new("Protocol error (#{method}): Session closed. Most likely the #{@target_type} has been closed.")
     end
-    id = @connection.raw_send(message: { sessionId: @session_id, method: method, params: params })
+
     promise = resolvable_future
-    callback = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
-    @callbacks[id] = callback
+
+    @connection.generate_id do |id|
+      @callbacks[id] = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
+      @connection.raw_send(id: id, message: { sessionId: @session_id, method: method, params: params })
+    end
+
     promise
   end
 
@@ -44,10 +48,10 @@ class Puppeteer::CDPSession
       if callback = @callbacks.delete(message['id'])
         callback_with_message(callback, message)
       else
-        raise Error.new("unknown id: #{id}")
+        raise Error.new("unknown id: #{message['id']}")
       end
     else
-      emit_event message['method'], message['params']
+      emit_event(message['method'], message['params'])
     end
   end
 
@@ -79,7 +83,7 @@ class Puppeteer::CDPSession
     end
     @callbacks.clear
     @connection = nil
-    emit_event 'Events.CDPSession.Disconnected'
+    emit_event(CDPSessionEmittedEvents::Disconnected)
   end
 
   # @param event_name [String]

data/lib/puppeteer/concurrent_ruby_utils.rb

@@ -4,9 +4,13 @@ module Puppeteer::ConcurrentRubyUtils
   # 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!
+    if args.length == 1 && args.first.is_a?(Enumerable)
+      await_all(*args.first)
     else
+      if args.any? { |arg| !arg.is_a?(Concurrent::Promises::Future) }
+        raise ArgumentError.new("All argument must be a Future: #{args}")
+      end
+
       Concurrent::Promises.zip(*args).value!
     end
   end
@@ -15,9 +19,13 @@ module Puppeteer::ConcurrentRubyUtils
   # 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!
+    if args.length == 1 && args.first.is_a?(Enumerable)
+      await_any(*args.first)
     else
+      if args.any? { |arg| !arg.is_a?(Concurrent::Promises::Future) }
+        raise ArgumentError.new("All argument must be a Future: #{args}")
+      end
+
       Concurrent::Promises.any(*args).value!
     end
   end
@@ -31,8 +39,16 @@ module Puppeteer::ConcurrentRubyUtils
     end
   end
 
-  def future(&block)
-    Concurrent::Promises.future(&block)
+  def future(*args, &block)
+    Concurrent::Promises.future(*args) do |*block_args|
+      block.call(*block_args)
+    rescue Puppeteer::TimeoutError
+      # suppress error logging
+      raise
+    rescue => err
+      Logger.new($stderr).warn(err)
+      raise err
+    end
   end
 
   def resolvable_future(&block)

data/lib/puppeteer/connection.rb

@@ -39,7 +39,7 @@ class Puppeteer::Connection
   def initialize(url, transport, delay = 0)
     @url = url
     @last_id = 0
-    @callbacks = {}
+    @callbacks = Concurrent::Hash.new
     @delay = delay
 
     @transport = transport
@@ -52,7 +52,7 @@ class Puppeteer::Connection
       handle_close
     end
 
-    @sessions = {}
+    @sessions = Concurrent::Hash.new
     @closed = false
   end
 
@@ -92,22 +92,41 @@ class Puppeteer::Connection
   end
 
   def async_send_message(method, params = {})
-    id = raw_send(message: { method: method, params: params })
     promise = resolvable_future
-    @callbacks[id] = MessageCallback.new(method: method, promise: promise)
+
+    generate_id do |id|
+      @callbacks[id] = MessageCallback.new(method: method, promise: promise)
+      raw_send(id: id, message: { method: method, params: params })
+    end
+
     promise
   end
 
-  private def generate_id
-    @last_id += 1
+  # package private. not intended to use externally.
+  #
+  # ```usage
+  # connection.generate_id do |generated_id|
+  #   # play with generated_id
+  # end
+  # ````
+  #
+  def generate_id(&block)
+    block.call(@last_id += 1)
   end
 
-  def raw_send(message:)
-    id = generate_id
+  # package private. not intended to use externally.
+  def raw_send(id:, message:)
+    # In original puppeteer (JS) implementation,
+    # id is generated here using #generate_id and the id argument is not passed to #raw_send.
+    #
+    # However with concurrent-ruby, '#handle_message' is sometimes called
+    # just soon after @transport.send_text and **before returning the id.**
+    #
+    # So we have to know the message id in advance before send_text.
+    #
     payload = JSON.fast_generate(message.compact.merge(id: id))
     @transport.send_text(payload)
     request_debug_printer.handle_payload(payload)
-    id
   end
 
   # Just for effective debugging :)
@@ -211,7 +230,7 @@ class Puppeteer::Connection
         end
       end
     else
-      emit_event message['method'], message['params']
+      emit_event(message['method'], message['params'])
     end
   end
 
@@ -233,7 +252,7 @@ class Puppeteer::Connection
       session.handle_closed
     end
     @sessions.clear
-    emit_event 'Events.Connection.Disconnected'
+    emit_event(ConnectionEmittedEvents::Disconnected)
   end
 
   def on_close(&block)

data/lib/puppeteer/define_async_method.rb

@@ -10,12 +10,21 @@ module Puppeteer::DefineAsyncMethod
       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
+      define_method(async_method_name) do |*args, **kwargs|
+        if kwargs.empty? # for Ruby < 2.7
+          Concurrent::Promises.future do
+            original_method.bind(self).call(*args)
+          rescue => err
+            Logger.new($stderr).warn(err)
+            raise err
+          end
+        else
+          Concurrent::Promises.future do
+            original_method.bind(self).call(*args, **kwargs)
+          rescue => err
+            Logger.new($stderr).warn(err)
+            raise err
+          end
         end
       end
     end

data/lib/puppeteer/dom_world.rb

@@ -134,7 +134,7 @@ class Puppeteer::DOMWorld
 
   # @return [String]
   def content
-    evaluate <<-JAVASCRIPT
+    evaluate(<<-JAVASCRIPT)
     () => {
       let retVal = '';
       if (document.doctype)
@@ -151,7 +151,7 @@ class Puppeteer::DOMWorld
   # @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
+    option_timeout = 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

data/lib/puppeteer/event_callbackable.rb

@@ -31,6 +31,8 @@ module Puppeteer::EventCallbackable
     (@event_listeners[event_name] ||= EventListeners.new).add(&block)
   end
 
+  alias_method :on, :add_event_listener
+
   def remove_event_listener(*id_args)
     (@event_listeners ||= {}).each do |event_name, listeners|
       id_args.each do |id|
@@ -50,6 +52,8 @@ module Puppeteer::EventCallbackable
     end
   end
 
+  alias_method :once, :observe_first
+
   def on_event(event_name, &block)
     @event_callbackable_handlers ||= {}
     @event_callbackable_handlers[event_name] = block

data/lib/puppeteer/events.rb

@@ -0,0 +1,184 @@
+require 'digest/md5'
+
+module EventsDefinitionUtils
+  refine Kernel do
+    # Symbol is used to prevent external parties listening to these events
+    def Symbol(str)
+      Digest::MD5.hexdigest(str)
+    end
+  end
+
+  refine Hash do
+    def define_const_into(target_module)
+      each do |key, value|
+        target_module.const_set(key, value)
+        target_module.define_singleton_method(key) { value }
+      end
+      keyset = Set.new(keys)
+      valueset = Set.new(values)
+      target_module.define_singleton_method(:keys) { keyset }
+      target_module.define_singleton_method(:values) { valueset }
+    end
+  end
+end
+
+using EventsDefinitionUtils
+
+# Internal events that the Connection class emits.
+module ConnectionEmittedEvents ; end
+
+{
+  Disconnected: Symbol('Connection.Disconnected'),
+}.define_const_into(ConnectionEmittedEvents)
+
+# Internal events that the CDPSession class emits.
+module CDPSessionEmittedEvents ; end
+
+{
+  Disconnected: Symbol('CDPSession.Disconnected'),
+}.define_const_into(CDPSessionEmittedEvents)
+
+# All the events a Browser may emit.
+module BrowserEmittedEvents ; end
+
+{
+  # Emitted when Puppeteer gets disconnected from the Chromium instance. This might happen because of one of the following:
+  # - Chromium is closed or crashed
+  # - The Browser#disconnect method was called.
+  Disconnected: 'disconnected',
+
+  # Emitted when the url of a target changes. Contains a {@link Target} instance.
+  TargetChanged: 'targetchanged',
+
+  # Emitted when a target is created, for example when a new page is opened by
+  # window.open or by Browser#newPage
+  # Contains a Target instance.
+  TargetCreated: 'targetcreated',
+
+  # Emitted when a target is destroyed, for example when a page is closed.
+  # Contains a Target instance.
+  TargetDestroyed: 'targetdestroyed',
+}.define_const_into(BrowserEmittedEvents)
+
+module BrowserContextEmittedEvents ; end
+
+{
+  # Emitted when the url of a target inside the browser context changes.
+  # Contains a Target instance.
+  TargetChanged: 'targetchanged',
+
+  # Emitted when a target is created, for example when a new page is opened by
+  # window.open or by BrowserContext#newPage
+  # Contains a Target instance.
+  TargetCreated: 'targetcreated',
+
+  # Emitted when a target is destroyed within the browser context, for example when a page is closed.
+  # Contains a Target instance.
+  TargetDestroyed: 'targetdestroyed',
+}.define_const_into(BrowserContextEmittedEvents)
+
+# We use symbols to prevent any external parties listening to these events.
+# They are internal to Puppeteer.
+module NetworkManagerEmittedEvents ; end
+
+{
+  Request: Symbol('NetworkManager.Request'),
+  Response: Symbol('NetworkManager.Response'),
+  RequestFailed: Symbol('NetworkManager.RequestFailed'),
+  RequestFinished: Symbol('NetworkManager.RequestFinished'),
+}.define_const_into(NetworkManagerEmittedEvents)
+
+
+# We use symbols to prevent external parties listening to these events.
+# They are internal to Puppeteer.
+module FrameManagerEmittedEvents ; end
+
+{
+  FrameAttached: Symbol('FrameManager.FrameAttached'),
+  FrameNavigated: Symbol('FrameManager.FrameNavigated'),
+  FrameDetached: Symbol('FrameManager.FrameDetached'),
+  LifecycleEvent: Symbol('FrameManager.LifecycleEvent'),
+  FrameNavigatedWithinDocument: Symbol('FrameManager.FrameNavigatedWithinDocument'),
+  ExecutionContextCreated: Symbol('FrameManager.ExecutionContextCreated'),
+  ExecutionContextDestroyed: Symbol('FrameManager.ExecutionContextDestroyed'),
+}.define_const_into(FrameManagerEmittedEvents)
+
+# All the events that a page instance may emit.
+module PageEmittedEvents ; end
+
+{
+  # Emitted when the page closes.
+  Close: 'close',
+
+  # Emitted when JavaScript within the page calls one of console API methods,
+  # e.g. `console.log` or `console.dir`. Also emitted if the page throws an
+  # error or a warning.
+  Console: 'console',
+
+  # Emitted when a JavaScript dialog appears, such as `alert`, `prompt`,
+  # `confirm` or `beforeunload`. Puppeteer can respond to the dialog via
+  # Dialog#accept or Dialog#dismiss.
+  Dialog: 'dialog',
+
+  # Emitted when the JavaScript
+  # {https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded DOMContentLoaded} event is dispatched.
+  DOMContentLoaded: 'domcontentloaded',
+
+  # Emitted when the page crashes. Will contain an `Error`.
+  Error: 'error',
+
+  # Emitted when a frame is attached. Will contain a Frame.
+  FrameAttached: 'frameattached',
+  # Emitted when a frame is detached. Will contain a Frame.
+  FrameDetached: 'framedetached',
+  # Emitted when a frame is navigated to a new URL. Will contain a {@link Frame}.
+  FrameNavigated: 'framenavigated',
+
+  # Emitted when the JavaScript
+  # {https://developer.mozilla.org/en-US/docs/Web/Events/load | load} event is dispatched.
+  Load: 'load',
+
+  # Emitted when the JavaScript code makes a call to `console.timeStamp`. For
+  # the list of metrics see {@link Page.metrics | page.metrics}.
+  #
+  # Contains an object with two properties:
+  # - `title`: the title passed to `console.timeStamp`
+  # - `metrics`: objec containing metrics as key/value pairs. The values will be `number`s.
+  Metrics: 'metrics',
+
+  # Emitted when an uncaught exception happens within the page.
+  # Contains an `Error`.
+  PageError: 'pageerror',
+
+  # Emitted when the page opens a new tab or window.
+  # Contains a Page corresponding to the popup window.
+  Popup: 'popup',
+
+  # Emitted when a page issues a request and contains a HTTPRequest.
+  #
+  # The object is readonly. See Page#setRequestInterception for intercepting and mutating requests.
+  Request: 'request',
+
+  # Emitted when a request fails, for example by timing out.
+  #
+  # Contains a HTTPRequest.
+  #
+  # NOTE: HTTP Error responses, such as 404 or 503, are still successful
+  # responses from HTTP standpoint, so request will complete with
+  # `requestfinished` event and not with `requestfailed`.
+  RequestFailed: 'requestfailed',
+
+  # Emitted when a request finishes successfully. Contains a HTTPRequest.
+  RequestFinished: 'requestfinished',
+
+  # Emitted when a response is received. Contains a HTTPResponse.
+  Response: 'response',
+
+  # Emitted when a dedicated
+  # {https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API WebWorker} is spawned by the page.
+  WorkerCreated: 'workercreated',
+
+  # Emitted when a dedicated
+  # {https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API WebWorker} is destroyed by the page.
+  WorkerDestroyed: 'workerdestroyed',
+}.define_const_into(PageEmittedEvents)