puppeteer-ruby 0.0.19 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e6a29713aa4dd143bdd6c4fd1cc84df1bd7037aa920b0d660a62267f6321515
-  data.tar.gz: 46a433d484dfabd019cc0874b8dd6c17182e374fb53d6f6905fde7c1d120d5e6
+  metadata.gz: 73958c6fad7b569150344ee3cc43d20ca6eeaf82898bd1b20d8c9f40772e66f3
+  data.tar.gz: 3d39e319ed9e21aeff3868255ae956e16c9ef63f507a8bb591ea9693084110df
 SHA512:
-  metadata.gz: 9c5796c2331a9218c1191e1c2869aa5b02c6affdd19f5af23324ee1b257e93d3f328688b19ac14b4060f050c3649a82f6074f0a2b5d66c4bb71f34f46d51557a
-  data.tar.gz: 70bfa15d8c788ab11dbf8cf240a3967a906a15777294b1f8be2be22a64d5f2123a3c4bf44226c35c58bed0614a9b7703d6db498ce283309aa36bb30c5587cea6
+  metadata.gz: e15df5c9f1114cbc599c81d541a4abcb90c6470a37ebfbeeca5c18152b4f034b55ce5af99d7f00ddc717ddf6abdf854dd7a80828deb15ec306b7c2b3e336791e
+  data.tar.gz: 0e51a01f8e02c3bdfea8bd0c13f781a4c101d638aacf30bc7bcb21429820326ac1cd2ae186586f49116a6791d046416ef92b59e8ec5121e2bc61097155686c38

data/.rubocop.yml

@@ -116,6 +116,43 @@ Style/DefWithParentheses:
 Style/MethodDefParentheses:
   Enabled: true
 
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  IgnoredMethods:
+    # Gemfile, gemspec
+    - source
+    - add_dependency
+    - add_development_dependency
+
+    # include/require
+    - require
+    - require_relative
+    - include
+
+    # fundamental methods
+    - raise
+    - sleep
+
+    # RSpec
+    - describe
+    - it
+    - to
+    - not_to
+    - be
+    - eq
+
+    # async/await
+    - define_async_method
+    - await
+    - future
+
+    # utils
+    - debug_print
+    - debug_puts
+
+Style/MethodCallWithoutArgsParentheses:
+  Enabled: true
+
 Style/RedundantFreeze:
   Enabled: true
 

data/README.md

@@ -47,8 +47,46 @@ Puppeteer.launch(headless: false, slow_mo: 50, args: ['--guest', '--window-size=
 end
 ```
 
+### Evaluate JavaScript
+
+```ruby
+Puppeteer.launch do |browser|
+  page = browser.pages.last || browser.new_page
+  page.goto 'https://github.com/YusukeIwaki'
+
+  # Get the "viewport" of the page, as reported by the page.
+  dimensions = page.evaluate(<<~JAVASCRIPT)
+  () => {
+    return {
+      width: document.documentElement.clientWidth,
+      height: document.documentElement.clientHeight,
+      deviceScaleFactor: window.devicePixelRatio
+    };
+  }
+  JAVASCRIPT
+
+  puts "dimensions: #{dimensions}"
+  # => dimensions: {"width"=>800, "height"=>600, "deviceScaleFactor"=>1}
+end
+```
+
 More usage examples can be found [here](https://github.com/YusukeIwaki/puppeteer-ruby-example)
 
+## :whale: Running in Docker
+
+Following packages are required.
+
+* Google Chrome or Chromium
+  * In Debian-based images, `google-chrome-stable`
+  * In Alpine-based images, `chromium`
+
+Also, CJK font will be required for Chinese, Japanese, Korean sites.
+
+### References
+
+* Puppeteer official README: https://github.com/puppeteer/puppeteer/blob/main/docs/troubleshooting.md#running-puppeteer-in-docker
+* puppeteer-ruby example: https://github.com/YusukeIwaki/puppeteer-ruby-example/tree/master/docker_chromium
+
 ## :bulb: Collaboration with Selenium or Capybara
 
 It is really remarkable that we can use puppeteer functions in existing Selenium or Capybara codes, with a few configuration in advance.

data/lib/puppeteer.rb

@@ -6,7 +6,9 @@ require 'puppeteer/env'
 
 # Custom data types.
 require 'puppeteer/device'
+require 'puppeteer/events'
 require 'puppeteer/errors'
+require 'puppeteer/geolocation'
 require 'puppeteer/viewport'
 
 # Modules
@@ -24,8 +26,10 @@ require 'puppeteer/cdp_session'
 require 'puppeteer/connection'
 require 'puppeteer/console_message'
 require 'puppeteer/devices'
+require 'puppeteer/dialog'
 require 'puppeteer/dom_world'
 require 'puppeteer/emulation_manager'
+require 'puppeteer/exception_details'
 require 'puppeteer/execution_context'
 require 'puppeteer/file_chooser'
 require 'puppeteer/frame'
@@ -60,7 +64,11 @@ class Puppeteer
       is_puppeteer_core: true,
     )
 
-    @puppeteer.send(method, *args, **kwargs, &block)
+    if kwargs.empty? # for Ruby < 2.7
+      @puppeteer.public_send(method, *args, &block)
+    else
+      @puppeteer.public_send(method, *args, **kwargs, &block)
+    end
   end
 
   # @param project_root [String]
@@ -126,7 +134,7 @@ class Puppeteer
       ignore_https_errors: ignore_https_errors,
       default_viewport: default_viewport,
       slow_mo: slow_mo,
-    }.compact
+    }
 
     @product_name ||= product
     browser = launcher.launch(options)

data/lib/puppeteer/browser.rb

@@ -46,37 +46,30 @@ class Puppeteer::Browser
       @contexts[context_id] = Puppeteer::BrowserContext.new(@connection, self, context_id)
     end
     @targets = {}
-    @connection.on_event 'Events.Connection.Disconnected' do
-      emit_event 'Events.Browser.Disconnected'
+    @connection.on_event(ConnectionEmittedEvents::Disconnected) do
+      emit_event(BrowserEmittedEvents::Disconnected)
     end
-    @connection.on_event 'Target.targetCreated', &method(:handle_target_created)
-    @connection.on_event 'Target.targetDestroyed', &method(:handle_target_destroyed)
-    @connection.on_event 'Target.targetInfoChanged', &method(:handle_target_info_changed)
+    @connection.on_event('Target.targetCreated', &method(:handle_target_created))
+    @connection.on_event('Target.targetDestroyed', &method(:handle_target_destroyed))
+    @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(", ")}")
+    unless BrowserEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{BrowserEmittedEvents.values.to_a.join(", ")}")
     end
 
-    add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &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(", ")}")
+    unless BrowserEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{BrowserEmittedEvents.values.to_a.join(", ")}")
     end
 
-    observe_first(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &block)
   end
 
   # @return [Puppeteer::BrowserRunner::BrowserProcess]
@@ -137,8 +130,8 @@ class Puppeteer::Browser
     #   assert(!this._targets.has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
     @targets[target_info.target_id] = target
     if await target.initialized_promise
-      emit_event 'Events.Browser.TargetCreated', target
-      context.emit_event 'Events.BrowserContext.TargetCreated', target
+      emit_event(BrowserEmittedEvents::TargetCreated, target)
+      context.emit_event(BrowserContextEmittedEvents::TargetCreated, target)
     end
   end
 
@@ -150,8 +143,8 @@ class Puppeteer::Browser
     @targets.delete(target_id)
     target.closed_callback
     if await target.initialized_promise
-      emit_event 'Events.Browser.TargetDestroyed', target
-      target.browser_context.emit_event 'Events.BrowserContext.TargetDestroyed', target
+      emit_event(BrowserEmittedEvents::TargetDestroyed, target)
+      target.browser_context.emit_event(BrowserContextEmittedEvents::TargetDestroyed, target)
     end
   end
 
@@ -169,8 +162,8 @@ class Puppeteer::Browser
     was_initialized = target.initialized?
     target.handle_target_info_changed(target_info)
     if was_initialized && previous_url != target.url
-      emit_event 'Events.Browser.TargetChanged', target
-      target.browser_context.emit_event 'Events.BrowserContext.TargetChanged', target
+      emit_event(BrowserEmittedEvents::TargetChanged, target)
+      target.browser_context.emit_event(BrowserContextEmittedEvents::TargetChanged, target)
     end
   end
 
@@ -222,12 +215,12 @@ class Puppeteer::Browser
 
     event_listening_ids = []
     target_promise = resolvable_future
-    event_listening_ids << add_event_listener('Events.Browser.TargetCreated') do |target|
+    event_listening_ids << add_event_listener(BrowserEmittedEvents::TargetCreated) do |target|
       if predicate.call(target)
         target_promise.fulfill(target)
       end
     end
-    event_listening_ids << add_event_listener('Events.Browser.TargetChanged') do |target|
+    event_listening_ids << add_event_listener(BrowserEmittedEvents::TargetChanged) do |target|
       if predicate.call(target)
         target_promise.fulfill(target)
       end

data/lib/puppeteer/browser_context.rb

@@ -11,29 +11,22 @@ 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(", ")}")
+    unless BrowserContextEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{BrowserContextEmittedEvents.values.to_a.join(", ")}")
     end
 
-    add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &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(", ")}")
+    unless BrowserContextEmittedEvents.values.include?(event_name.to_s)
+      raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{BrowserContextEmittedEvents.values.to_a.join(", ")}")
     end
 
-    observe_first(EVENT_MAPPINGS[event_name.to_sym], &block)
+    super(event_name.to_s, &block)
   end
 
   # @return {!Array<!Target>} target
@@ -64,42 +57,48 @@ class Puppeteer::BrowserContext
     !!@id
   end
 
-  # /**
-  #  * @param {string} origin
-  #  * @param {!Array<string>} permissions
-  #  */
-  # async overridePermissions(origin, permissions) {
-  #   const webPermissionToProtocol = new Map([
-  #     ['geolocation', 'geolocation'],
-  #     ['midi', 'midi'],
-  #     ['notifications', 'notifications'],
-  #     ['push', 'push'],
-  #     ['camera', 'videoCapture'],
-  #     ['microphone', 'audioCapture'],
-  #     ['background-sync', 'backgroundSync'],
-  #     ['ambient-light-sensor', 'sensors'],
-  #     ['accelerometer', 'sensors'],
-  #     ['gyroscope', 'sensors'],
-  #     ['magnetometer', 'sensors'],
-  #     ['accessibility-events', 'accessibilityEvents'],
-  #     ['clipboard-read', 'clipboardRead'],
-  #     ['clipboard-write', 'clipboardWrite'],
-  #     ['payment-handler', 'paymentHandler'],
-  #     // chrome-specific permissions we have.
-  #     ['midi-sysex', 'midiSysex'],
-  #   ]);
-  #   permissions = permissions.map(permission => {
-  #     const protocolPermission = webPermissionToProtocol.get(permission);
-  #     if (!protocolPermission)
-  #       throw new Error('Unknown permission: ' + permission);
-  #     return protocolPermission;
-  #   });
-  #   await this._connection.send('Browser.grantPermissions', {origin, browserContextId: this._id || undefined, permissions});
-  # }
-
-  # async clearPermissionOverrides() {
-  #   await this._connection.send('Browser.resetPermissions', {browserContextId: this._id || undefined});
-  # }
+  WEB_PERMISSION_TO_PROTOCOL = {
+    'geolocation' => 'geolocation',
+    'midi' => 'midi',
+    'notifications' => 'notifications',
+    # TODO: push isn't a valid type?
+    # 'push' => 'push',
+    'camera' => 'videoCapture',
+    'microphone' => 'audioCapture',
+    'background-sync' => 'backgroundSync',
+    'ambient-light-sensor' => 'sensors',
+    'accelerometer' => 'sensors',
+    'gyroscope' => 'sensors',
+    'magnetometer' => 'sensors',
+    'accessibility-events' => 'accessibilityEvents',
+    'clipboard-read' => 'clipboardReadWrite',
+    'clipboard-write' => 'clipboardReadWrite',
+    'payment-handler' => 'paymentHandler',
+    'idle-detection' => 'idleDetection',
+    # chrome-specific permissions we have.
+    'midi-sysex' => 'midiSysex',
+  }.freeze
+
+  # @param origin [String]
+  # @param permissions [Array<String>]
+  def override_permissions(origin, permissions)
+    protocol_permissions = permissions.map do |permission|
+      WEB_PERMISSION_TO_PROTOCOL[permission] or raise ArgumentError.new("Unknown permission: #{permission}")
+    end
+    @connection.send_message('Browser.grantPermissions', {
+      origin: origin,
+      browserContextId: @id,
+      permissions: protocol_permissions,
+    }.compact)
+  end
+
+  def clear_permission_overrides
+    if @id
+      @connection.send_message('Browser.resetPermissions', browserContextId: @id)
+    else
+      @connection.send_message('Browser.resetPermissions')
+    end
+  end
 
   # @return [Future<Puppeteer::Page>]
   def new_page

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,6 +83,16 @@ class Puppeteer::CDPSession
     end
     @callbacks.clear
     @connection = nil
-    emit_event 'Events.CDPSession.Disconnected'
+    emit_event(CDPSessionEmittedEvents::Disconnected)
+  end
+
+  # @param event_name [String]
+  def on(event_name, &block)
+    add_event_listener(event_name, &block)
+  end
+
+  # @param event_name [String]
+  def once(event_name, &block)
+    observe_first(event_name, &block)
   end
 end