puppeteer-ruby 0.45.6 → 0.50.0.alpha5

data/lib/puppeteer/console_patch.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+begin
+  require 'console/event/failure'
+  require 'console/terminal/formatter/failure'
+rescue LoadError
+  # Console is optional; skip patching if unavailable.
+end
+
+module Console
+  module Event
+    class Failure
+      unless method_defined?(:extract_without_cycle_guard)
+        alias extract_without_cycle_guard extract
+
+        private def extract(exception, hash)
+          seen = Thread.current[:console_failure_seen] ||= {}
+          return if seen[exception.object_id]
+
+          seen[exception.object_id] = true
+          begin
+            extract_without_cycle_guard(exception, hash)
+          ensure
+            seen.delete(exception.object_id)
+            Thread.current[:console_failure_seen] = nil if seen.empty?
+          end
+        end
+      end
+    end
+  end
+
+  module Terminal
+    module Formatter
+      class Failure
+        unless method_defined?(:format_without_nil_guard)
+          alias format_without_nil_guard format
+
+          def format(event, stream, prefix: nil, verbose: false, **options)
+            event = event.dup
+            event[:message] = event[:message].to_s
+            format_without_nil_guard(event, stream, prefix: prefix, verbose: verbose, **options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/css_coverage.rb

@@ -35,12 +35,14 @@ class Puppeteer::CSSCoverage
     @stylesheet_sources.clear
     @event_listeners = []
     @event_listeners << @client.add_event_listener('CSS.styleSheetAdded') do |event|
-      future { on_stylesheet(event) }
+      Async do
+        Puppeteer::AsyncUtils.future_with_logging { on_stylesheet(event) }.call
+      end
     end
     @event_listeners << @client.add_event_listener('Runtime.executionContextsCleared') do
       on_execution_contexts_cleared
     end
-    await_all(
+    Puppeteer::AsyncUtils.await_promise_all(
       @client.async_send_message('DOM.enable'),
       @client.async_send_message('CSS.enable'),
       @client.async_send_message('CSS.startRuleUsageTracking'),
@@ -76,7 +78,7 @@ class Puppeteer::CSSCoverage
     @enabled = false
 
     rule_tracking_response = @client.send_message('CSS.stopRuleUsageTracking')
-    await_all(
+    Puppeteer::AsyncUtils.await_promise_all(
       @client.async_send_message('CSS.disable'),
       @client.async_send_message('DOM.disable'),
     )

data/lib/puppeteer/custom_query_handler.rb

@@ -7,21 +7,23 @@ class Puppeteer::CustomQueryHandler
   end
 
   def query_one(element, selector)
-    unless @query_one
-      raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
+    if @query_one
+      return query_one_with_query_one(element, selector)
     end
 
-    handle = element.evaluate_handle(@query_one, selector)
-    element = handle.as_element
+    if @query_all
+      elements = query_all_with_query_all(element, selector)
+      return nil if elements.empty?
 
-    if element
-      return element
+      first = elements.shift
+      elements.each(&:dispose)
+      return first
     end
-    handle.dispose
-    nil
+
+    raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
   end
 
-  def wait_for(element_or_frame, selector, visible: nil, hidden: nil, timeout: nil)
+  def wait_for(element_or_frame, selector, visible: nil, hidden: nil, timeout: nil, polling: nil)
     case element_or_frame
     when Puppeteer::Frame
       frame = element_or_frame
@@ -37,42 +39,87 @@ class Puppeteer::CustomQueryHandler
       raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
     end
 
-    result = frame.puppeteer_world.send(:wait_for_selector_in_page,
-      @query_one,
-      element,
-      selector,
-      visible: visible,
-      hidden: hidden,
-      timeout: timeout,
-    )
+    begin
+      result = frame.puppeteer_world.send(:wait_for_selector_in_page,
+        @query_one,
+        element,
+        selector,
+        visible: visible,
+        hidden: hidden,
+        timeout: timeout,
+        polling: polling,
+      )
 
-    element&.dispose
-
-    if result.is_a?(Puppeteer::ElementHandle)
-      result.frame.main_world.transfer_handle(result)
-    else
-      result&.dispose
-      nil
+      if result.is_a?(Puppeteer::ElementHandle)
+        result.frame.main_world.transfer_handle(result)
+      else
+        result&.dispose
+        nil
+      end
+    rescue => err
+      wait_for_selector_error =
+        if err.is_a?(Puppeteer::TimeoutError)
+          Puppeteer::TimeoutError.new("Waiting for selector `#{selector}` failed")
+        else
+          Puppeteer::Error.new("Waiting for selector `#{selector}` failed")
+        end
+      wait_for_selector_error.cause = err
+      raise wait_for_selector_error
+    ensure
+      element&.dispose
     end
   end
 
   def query_all(element, selector)
-    unless @query_all
-      raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
+    if @query_all
+      return query_all_with_query_all(element, selector)
     end
 
-    handles = element.evaluate_handle(@query_all, selector)
-    properties = handles.properties
-    handles.dispose
-    properties.values.map(&:as_element).compact
+    if @query_one
+      element_handle = query_one_with_query_one(element, selector)
+      return element_handle ? [element_handle] : []
+    end
+
+    raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
   end
 
   def query_all_array(element, selector)
-    unless @query_all
-      raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
+    if @query_all
+      handles = element.evaluate_handle(@query_all, selector)
+      begin
+        return handles.evaluate_handle('(res) => Array.from(res)')
+      ensure
+        handles.dispose
+      end
+    end
+
+    if @query_one
+      elements = query_all(element, selector)
+      begin
+        return element.execution_context.evaluate_handle('(...elements) => elements', *elements)
+      ensure
+        elements.each(&:dispose)
+      end
+    end
+
+    raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
+  end
+
+  private def query_one_with_query_one(element, selector)
+    handle = element.evaluate_handle(@query_one, selector)
+    element = handle.as_element
+
+    if element
+      return element
     end
+    handle.dispose
+    nil
+  end
 
+  private def query_all_with_query_all(element, selector)
     handles = element.evaluate_handle(@query_all, selector)
-    handles.evaluate_handle('(res) => Array.from(res)')
+    properties = handles.properties
+    handles.dispose
+    properties.values.map(&:as_element).compact
   end
 end

data/lib/puppeteer/define_async_method.rb

@@ -17,40 +17,42 @@ module Puppeteer::DefineAsyncMethod
       if method_defined?(original_method_name) && original_method_name.start_with?('wait_for_')
         # def wait_for_xxx(xx, yy, &block)
         #
-        # -> await_all(
-        #      async_wait_for_xxx(xx, yy),
-        #      future { block.call },
-        #    ).first
+        # -> start wait_for_xxx in a child task
+        # -> run block (awaiting its result if needed)
+        # -> wait for wait_for_xxx task, cancel on block errors
         define_method(original_method_name) do |*args, **kwargs, &block|
           if block
-            async_method_call =
-              if kwargs.empty? # for Ruby 2.6
-                Concurrent::Promises.future do
+            runner = lambda do
+              parent_task = Async::Task.current
+              wait_task = parent_task.async do
+                if kwargs.empty?
                   original_method.bind(self).call(*args)
-                rescue => err
-                  Logger.new($stderr).warn(err)
-                  raise err
-                end
-              else
-                Concurrent::Promises.future do
+                else
                   original_method.bind(self).call(*args, **kwargs)
-                rescue => err
-                  Logger.new($stderr).warn(err)
-                  raise err
                 end
               end
 
-            async_block_call = Concurrent::Promises.delay do
-              block.call
-            rescue => err
-              Logger.new($stderr).warn(err)
-              raise err
+              begin
+                block_result = block.call
+                Puppeteer::AsyncUtils.await(block_result)
+              rescue Exception => err
+                begin
+                  wait_task.stop
+                  Puppeteer::AsyncUtils.async_timeout(1000, -> { wait_task.wait }).wait
+                rescue Exception
+                  # Swallow cancellation errors/timeouts; original error takes priority.
+                end
+                raise err
+              end
+
+              wait_task.wait
             end
 
-            Concurrent::Promises.zip(
-              async_method_call,
-              async_block_call,
-            ).value!.first
+            if Async::Task.current?
+              runner.call
+            else
+              Sync { runner.call }
+            end
           else
             if kwargs.empty? # for Ruby 2.6
               original_method.bind(self).call(*args)
@@ -62,20 +64,12 @@ module Puppeteer::DefineAsyncMethod
       end
 
       define_method(async_method_name) do |*args, **kwargs|
-        if kwargs.empty? # for Ruby 2.6
-          Concurrent::Promises.future do
+        Async do
+          if kwargs.empty? # for Ruby 2.6
             original_method.bind(self).call(*args)
-          rescue => err
-            Logger.new($stderr).warn(err)
-            raise err
-          end.extend(Puppeteer::ConcurrentRubyUtils::ConcurrentPromisesFutureExtension)
-        else
-          Concurrent::Promises.future do
+          else
             original_method.bind(self).call(*args, **kwargs)
-          rescue => err
-            Logger.new($stderr).warn(err)
-            raise err
-          end.extend(Puppeteer::ConcurrentRubyUtils::ConcurrentPromisesFutureExtension)
+          end
         end
       end
     end

data/lib/puppeteer/dialog.rb

@@ -1,34 +1,67 @@
+# rbs_inline: enabled
+
 class Puppeteer::Dialog
-  def initialize(client, type:, message:, default_value:)
-    @client = client
+  # @rbs type: String -- Dialog type
+  # @rbs message: String -- Dialog message
+  # @rbs default_value: String? -- Default prompt value, if any
+  # @rbs return: void -- No return value
+  def initialize(type:, message:, default_value: '')
     @type = type
     @message = message
     @default_value = default_value || ''
+    @handled = false
   end
 
-  attr_reader :type, :message, :default_value
+  attr_reader :type #: String
+  attr_reader :message #: String
+  attr_reader :default_value #: String
 
-  # @param prompt_text - optional text that will be entered in the dialog
-  # prompt. Has no effect if the dialog's type is not `prompt`.
-  #
-  # @returns A promise that resolves when the dialog has been accepted.
+  # @rbs prompt_text: String? -- Text entered into the prompt
+  # @rbs return: void -- No return value
   def accept(prompt_text = nil)
     if @handled
       raise 'Cannot accept dialog which is already handled!'
     end
     @handled = true
-    @client.send_message('Page.handleJavaScriptDialog', {
-      accept: true,
-      promptText: prompt_text,
-    }.compact)
+    handle(accept: true, text: prompt_text)
   end
 
-  # @returns A promise which will resolve once the dialog has been dismissed
+  # @rbs return: void -- No return value
   def dismiss
     if @handled
-      raise 'Cannot accept dialog which is already handled!'
+      raise 'Cannot dismiss dialog which is already handled!'
     end
     @handled = true
-    @client.send_message('Page.handleJavaScriptDialog', accept: false)
+    handle(accept: false)
+  end
+
+  # @rbs accept: bool -- Whether to accept the dialog
+  # @rbs text: String? -- Text entered into the prompt
+  # @rbs return: void -- No return value
+  protected def handle(accept:, text: nil)
+    raise NotImplementedError
+  end
+end
+
+class Puppeteer::CdpDialog < Puppeteer::Dialog
+  # @rbs client: Puppeteer::CDPSession -- CDP session used to handle dialog
+  # @rbs type: String -- Dialog type
+  # @rbs message: String -- Dialog message
+  # @rbs default_value: String? -- Default prompt value, if any
+  # @rbs return: void -- No return value
+  def initialize(client, type:, message:, default_value:)
+    super(type: type, message: message, default_value: default_value)
+    @client = client
+  end
+
+  # @rbs accept: bool -- Whether to accept the dialog
+  # @rbs text: String? -- Text entered into the prompt
+  # @rbs return: void -- No return value
+  protected def handle(accept:, text: nil)
+    @client.send_message('Page.handleJavaScriptDialog', {
+      accept: accept,
+      promptText: text,
+    }.compact)
+    nil
   end
 end