puppeteer-ruby 0.45.6 → 0.50.0.alpha5

data/lib/puppeteer/touch_handle.rb

@@ -0,0 +1,39 @@
+# rbs_inline: enabled
+
+class Puppeteer::TouchHandle
+  # @rbs touchscreen: Puppeteer::TouchScreen -- Touchscreen instance
+  # @rbs touch_point: Hash[Symbol, Numeric] -- Touch point payload
+  # @rbs return: void -- No return value
+  def initialize(touchscreen, touch_point)
+    @touchscreen = touchscreen
+    @touch_point = touch_point
+    @started = false
+  end
+
+  attr_reader :touch_point
+
+  # @rbs return: void -- No return value
+  def start
+    if @started
+      raise Puppeteer::TouchError.new('Touch has already started')
+    end
+
+    @touchscreen.send(:dispatch_touch_event, 'touchStart', [@touch_point])
+    @started = true
+  end
+
+  # @rbs x: Numeric -- New X coordinate
+  # @rbs y: Numeric -- New Y coordinate
+  # @rbs return: void -- No return value
+  def move(x, y)
+    @touch_point[:x] = x.round
+    @touch_point[:y] = y.round
+    @touchscreen.send(:dispatch_touch_event, 'touchMove', [@touch_point])
+  end
+
+  # @rbs return: void -- No return value
+  def end
+    @touchscreen.send(:dispatch_touch_event, 'touchEnd', [@touch_point])
+    @touchscreen.send(:remove_handle, self)
+  end
+end

data/lib/puppeteer/touch_screen.rb

@@ -1,38 +1,88 @@
+# rbs_inline: enabled
+
 class Puppeteer::TouchScreen
   using Puppeteer::DefineAsyncMethod
 
-  # @param {Puppeteer.CDPSession} client
-  # @param keyboard [Puppeteer::Keyboard]
+  # @rbs client: Puppeteer::CDPSession -- CDP session
+  # @rbs keyboard: Puppeteer::Keyboard -- Keyboard state for modifiers
+  # @rbs return: void -- No return value
   def initialize(client, keyboard)
     @client = client
     @keyboard = keyboard
+    @touch_id_counter = 0
+    @touches = []
   end
 
-  # @param x [number]
-  # @param y [number]
+  # @rbs x: Numeric -- X coordinate
+  # @rbs y: Numeric -- Y coordinate
+  # @rbs return: void -- No return value
   def tap(x, y)
-    # Touches appear to be lost during the first frame after navigation.
-    # This waits a frame before sending the tap.
-    # @see https://crbug.com/613219
-    @client.send_message('Runtime.evaluate',
-      expression: 'new Promise(x => requestAnimationFrame(() => requestAnimationFrame(x)))',
-      awaitPromise: true,
-    )
+    touch = touch_start(x, y)
+    touch.end
+  end
+
+  define_async_method :async_tap
+
+  # @rbs x: Numeric -- X coordinate
+  # @rbs y: Numeric -- Y coordinate
+  # @rbs return: Puppeteer::TouchHandle -- Touch handle
+  def touch_start(x, y)
+    @touch_id_counter += 1
+    touch_point = {
+      x: x.round,
+      y: y.round,
+      radiusX: 0.5,
+      radiusY: 0.5,
+      force: 0.5,
+      id: @touch_id_counter,
+    }
+    touch = Puppeteer::TouchHandle.new(self, touch_point)
+    touch.start
+    @touches << touch
+    touch
+  end
+
+  define_async_method :async_touch_start
+
+  # @rbs x: Numeric -- X coordinate
+  # @rbs y: Numeric -- Y coordinate
+  # @rbs return: void -- No return value
+  def touch_move(x, y)
+    touch = @touches.first
+    raise Puppeteer::TouchError.new('Must start a new Touch first') unless touch
+
+    touch.move(x, y)
+  end
+
+  define_async_method :async_touch_move
 
-    touch_points = [
-      { x: x.round, y: y.round },
-    ]
+  # @rbs return: void -- No return value
+  def touch_end
+    touch = @touches.shift
+    raise Puppeteer::TouchError.new('Must start a new Touch first') unless touch
+
+    touch.end
+  end
+
+  define_async_method :async_touch_end
+
+  # @rbs touch: Puppeteer::TouchHandle -- Touch handle to remove
+  # @rbs return: void -- No return value
+  private def remove_handle(touch)
+    index = @touches.index(touch)
+    return unless index
+
+    @touches.delete_at(index)
+  end
+
+  # @rbs type: String -- Touch event type
+  # @rbs touch_points: Array[Hash[Symbol, Numeric]] -- Touch points payload
+  # @rbs return: void -- No return value
+  private def dispatch_touch_event(type, touch_points)
     @client.send_message('Input.dispatchTouchEvent',
-      type: 'touchStart',
+      type: type,
       touchPoints: touch_points,
       modifiers: @keyboard.modifiers,
     )
-    @client.send_message('Input.dispatchTouchEvent',
-      type: 'touchEnd',
-      touchPoints: [],
-      modifiers: @keyboard.modifiers,
-    )
   end
-
-  define_async_method :async_tap
 end

data/lib/puppeteer/tracing.rb

@@ -41,15 +41,15 @@ class Puppeteer::Tracing
   end
 
   def stop
-    stream_promise = resolvable_future do |f|
+    stream_promise = Async::Promise.new.tap do |future|
       @client.once('Tracing.tracingComplete') do |event|
-        f.fulfill(event['stream'])
+        future.resolve(event['stream'])
       end
     end
     @client.send_message('Tracing.end')
     @recording = false
 
-    stream = await stream_promise
+    stream = stream_promise.wait
     chunks = Puppeteer::ProtocolStreamReader.new(client: @client, handle: stream).read_as_chunks
 
     StringIO.open do |stringio|

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 module Puppeteer
-  VERSION = '0.45.6'
+  VERSION = '0.50.0.alpha5'
 end

data/lib/puppeteer/wait_task.rb

@@ -1,11 +1,11 @@
 class Puppeteer::WaitTask
   using Puppeteer::DefineAsyncMethod
 
-  class TerminatedError < StandardError; end
+  class TerminatedError < Puppeteer::Error; end
 
   class TimeoutError < ::Puppeteer::TimeoutError
-    def initialize(title:, timeout:)
-      super("waiting for #{title} failed: timeout #{timeout}ms exceeded")
+    def initialize(timeout:)
+      super("Waiting failed: #{timeout}ms exceeded")
     end
   end
 
@@ -15,7 +15,7 @@ class Puppeteer::WaitTask
         raise ArgumentError.new("Unknown polling option: #{polling}")
       end
     elsif polling.is_a?(Numeric)
-      unless polling.positive?
+      if polling < 0
         raise ArgumentError.new("Cannot poll with non-positive interval: #{polling}")
       end
     else
@@ -26,7 +26,7 @@ class Puppeteer::WaitTask
     @polling = polling
     @timeout = timeout
     @root = root
-    @predicate_body = "return (#{predicate_body})(...args);"
+    @predicate_body = build_predicate_body(predicate_body)
     @args = args
     @binding_function = binding_function
     @run_count = 0
@@ -34,163 +34,326 @@ class Puppeteer::WaitTask
     if binding_function
       @dom_world.send(:_bound_functions)[binding_function.name] = binding_function
     end
-    @promise = resolvable_future
+    @promise = Async::Promise.new
+    @poller_handle = nil
+    @generic_error = Puppeteer::Error.new('Waiting failed')
 
     # Since page navigation requires us to re-install the pageScript, we should track
     # timeout on our end.
     if timeout && timeout > 0
-      timeout_error = TimeoutError.new(title: title, timeout: timeout)
-      Concurrent::Promises.schedule(timeout / 1000.0) { terminate(timeout_error) unless @timeout_cleared }
+      timeout_error = TimeoutError.new(timeout: timeout)
+      @timeout_task = Async do |task|
+        task.sleep(timeout / 1000.0)
+        # Avoid stopping the timeout task from inside terminate/cleanup.
+        @timeout_task = nil
+        terminate(timeout_error) unless @timeout_cleared
+      end
     end
+
     async_rerun
   end
 
   # @return [Puppeteer::JSHandle]
   def await_promise
-    @promise.value!
+    @promise.wait
   end
 
-  def terminate(error)
+  def terminate(error = nil)
+    return if @terminated
+
     @terminated = true
-    @promise.reject(error)
+    if error && !@promise.resolved?
+      @promise.reject(error)
+    end
     cleanup
   end
 
   def rerun
     run_count = (@run_count += 1)
-    context = @dom_world.execution_context
+    context = nil
+    success = nil
+    error = nil
 
     return if @terminated || run_count != @run_count
-    if @binding_function
-      @dom_world.add_binding_to_context(context, @binding_function)
-    end
-    return if @terminated || run_count != @run_count
-
+    reset_poller
     begin
-      success = context.evaluate_handle(
+      context = @dom_world.execution_context
+      if @binding_function
+        @dom_world.add_binding_to_context(context, @binding_function)
+      end
+      return if @terminated || run_count != @run_count
+
+      @poller_handle = context.evaluate_handle(
         WAIT_FOR_PREDICATE_PAGE_FUNCTION,
         @root,
         @predicate_body,
         @polling,
-        @timeout,
         *@args,
       )
+      success = @poller_handle.evaluate_handle('poller => poller.result()')
     rescue => err
       error = err
     end
 
-    if @terminated || run_count != @run_count
-      if success
-        success.dispose
+    return if @terminated || run_count != @run_count
+
+    if error
+      bad_error = get_bad_error(error)
+      if bad_error
+        @generic_error.cause = bad_error
+        terminate(@generic_error)
+      else
+        reset_poller
       end
       return
     end
 
-    # Ignore timeouts in pageScript - we track timeouts ourselves.
-    # If the frame's execution context has already changed, `frame.evaluate` will
-    # throw an error - ignore this predicate run altogether.
-    if !error && (@dom_world.evaluate("s => !s", success) rescue true)
-      success.dispose
-      return
-    end
+    @promise.resolve(success) unless @promise.resolved?
+    cleanup
+  end
 
-    # When the page is navigated, the promise is rejected.
-    # We will try again in the new execution context.
-    if error && error.message.include?('Execution context was destroyed')
-      return
+  private def cleanup
+    @timeout_cleared = true
+    begin
+      @timeout_task&.stop
+    rescue StandardError
+      # Ignore errors during timeout task cleanup.
     end
+    reset_poller
+    @dom_world.task_manager.delete(self)
+  end
 
-    # We could have tried to evaluate in a context which was already
-    # destroyed.
-    if error && error.message.include?('Cannot find context with specified id')
-      return
+  private def reset_poller
+    poller = @poller_handle
+    @poller_handle = nil
+    return unless poller
+
+    return if @dom_world.respond_to?(:detached?) && @dom_world.detached?
+
+    begin
+      poller.evaluate('poller => poller.stop()')
+    rescue StandardError
+      # Ignore errors during poller cleanup.
+    end
+    begin
+      poller.dispose
+    rescue StandardError
+      # Ignore errors during poller cleanup.
     end
+  end
 
-    if error
-      @promise.reject(error)
+  private def build_predicate_body(predicate_body)
+    stripped = predicate_body.to_s.strip
+    is_function =
+      stripped.start_with?('function') ||
+      stripped.start_with?('async function') ||
+      stripped.include?('=>')
+
+    if is_function
+      "return (#{predicate_body})(...args);"
     else
-      @promise.fulfill(success)
+      "return (#{predicate_body});"
     end
-
-    cleanup
   end
 
-  private def cleanup
-    @timeout_cleared = true
-    @dom_world.task_manager.delete(self)
+  private def get_bad_error(error)
+    message = error.message.to_s
+    if message.include?('Execution context is not available in detached frame')
+      return Puppeteer::Error.new('Waiting failed: Frame detached')
+    end
+    return nil if message.include?('Execution context was destroyed')
+    return nil if message.include?('Cannot find context with specified id')
+    return nil if message.include?('DiscardedBrowsingContextError')
+    return nil if message.include?('Inspected target navigated or closed')
+
+    error
   end
 
   define_async_method :async_rerun
 
   WAIT_FOR_PREDICATE_PAGE_FUNCTION = <<~JAVASCRIPT
-  async function _(root, predicateBody, polling, timeout, ...args) {
+  function _(root, predicateBody, polling, ...args) {
       const predicate = new Function('...args', predicateBody);
-      root = root || document
-      let timedOut = false;
-      if (timeout)
-          setTimeout(() => (timedOut = true), timeout);
-      if (polling === 'raf')
-          return await pollRaf();
-      if (polling === 'mutation')
-          return await pollMutation();
-      if (typeof polling === 'number')
-          return await pollInterval(polling);
-      /**
-       * @return {!Promise<*>}
-       */
-      async function pollMutation() {
-          const success = await predicate(root, ...args);
-          if (success) return Promise.resolve(success);
-          let fulfill;
-          const result = new Promise((x) => (fulfill = x));
-          const observer = new MutationObserver(async () => {
-              if (timedOut) {
-                  observer.disconnect();
-                  fulfill();
+      const observedRoot = root || document;
+      if (polling === 'mutation' && typeof MutationObserver === 'undefined') {
+          polling = 'raf';
+      }
+
+      function createDeferred() {
+          let resolve;
+          let reject;
+          let finished = false;
+          const promise = new Promise((res, rej) => {
+              resolve = res;
+              reject = rej;
+          });
+          return {
+              promise,
+              resolve: (value) => {
+                  if (finished) return;
+                  finished = true;
+                  resolve(value);
+              },
+              reject: (error) => {
+                  if (finished) return;
+                  finished = true;
+                  reject(error);
+              },
+              finished: () => finished,
+          };
+      }
+
+      class MutationPoller {
+          constructor(fn, root) {
+              this.fn = fn;
+              this.root = root;
+              this.observer = null;
+              this.deferred = null;
+          }
+          async start() {
+              this.deferred = createDeferred();
+              const result = await this.fn();
+              if (result) {
+                  this.deferred.resolve(result);
+                  return;
               }
-              const success = await predicate(root, ...args);
-              if (success) {
-                  observer.disconnect();
-                  fulfill(success);
+              this.observer = new MutationObserver(async () => {
+                  const result = await this.fn();
+                  if (!result) {
+                      return;
+                  }
+                  this.deferred.resolve(result);
+                  await this.stop();
+              });
+              this.observer.observe(this.root, {
+                  childList: true,
+                  subtree: true,
+                  attributes: true,
+              });
+          }
+          async stop() {
+              if (!this.deferred) {
+                  return;
               }
-          });
-          observer.observe(root, {
-              childList: true,
-              subtree: true,
-              attributes: true,
-          });
-          return result;
+              if (!this.deferred.finished()) {
+                  this.deferred.reject(new Error('Polling stopped'));
+              }
+              if (this.observer) {
+                  this.observer.disconnect();
+                  this.observer = null;
+              }
+          }
+          result() {
+              if (!this.deferred) {
+                  return Promise.reject(new Error('Polling never started'));
+              }
+              return this.deferred.promise;
+          }
       }
-      async function pollRaf() {
-          let fulfill;
-          const result = new Promise((x) => (fulfill = x));
-          await onRaf();
-          return result;
-          async function onRaf() {
-              if (timedOut) {
-                  fulfill();
+
+      class RAFPoller {
+          constructor(fn) {
+              this.fn = fn;
+              this.deferred = null;
+              this.rafId = null;
+          }
+          async start() {
+              this.deferred = createDeferred();
+              const result = await this.fn();
+              if (result) {
+                  this.deferred.resolve(result);
                   return;
               }
-              const success = await predicate(root, ...args);
-              if (success) fulfill(success);
-              else requestAnimationFrame(onRaf);
+              const poll = async () => {
+                  if (!this.deferred || this.deferred.finished()) {
+                      return;
+                  }
+                  const result = await this.fn();
+                  if (result) {
+                      this.deferred.resolve(result);
+                      await this.stop();
+                  } else {
+                      this.rafId = requestAnimationFrame(poll);
+                  }
+              };
+              this.rafId = requestAnimationFrame(poll);
+          }
+          async stop() {
+              if (!this.deferred) {
+                  return;
+              }
+              if (!this.deferred.finished()) {
+                  this.deferred.reject(new Error('Polling stopped'));
+              }
+              if (this.rafId) {
+                  cancelAnimationFrame(this.rafId);
+                  this.rafId = null;
+              }
+          }
+          result() {
+              if (!this.deferred) {
+                  return Promise.reject(new Error('Polling never started'));
+              }
+              return this.deferred.promise;
           }
       }
-      async function pollInterval(pollInterval) {
-          let fulfill;
-          const result = new Promise((x) => (fulfill = x));
-          await onTimeout();
-          return result;
-          async function onTimeout() {
-              if (timedOut) {
-                  fulfill();
+
+      class IntervalPoller {
+          constructor(fn, ms) {
+              this.fn = fn;
+              this.ms = ms;
+              this.interval = null;
+              this.deferred = null;
+          }
+          async start() {
+              this.deferred = createDeferred();
+              const result = await this.fn();
+              if (result) {
+                  this.deferred.resolve(result);
                   return;
               }
-              const success = await predicate(root, ...args);
-              if (success) fulfill(success);
-              else setTimeout(onTimeout, pollInterval);
+              this.interval = setInterval(async () => {
+                  const result = await this.fn();
+                  if (!result) {
+                      return;
+                  }
+                  this.deferred.resolve(result);
+                  await this.stop();
+              }, this.ms);
           }
+          async stop() {
+              if (!this.deferred) {
+                  return;
+              }
+              if (!this.deferred.finished()) {
+                  this.deferred.reject(new Error('Polling stopped'));
+              }
+              if (this.interval) {
+                  clearInterval(this.interval);
+                  this.interval = null;
+              }
+          }
+          result() {
+              if (!this.deferred) {
+                  return Promise.reject(new Error('Polling never started'));
+              }
+              return this.deferred.promise;
+          }
+      }
+
+      const runner = () => predicate(...args);
+      let poller;
+      if (polling === 'raf') {
+          poller = new RAFPoller(runner);
+      } else if (polling === 'mutation') {
+          poller = new MutationPoller(runner, observedRoot);
+      } else if (typeof polling === 'number') {
+          poller = new IntervalPoller(runner, polling);
+      } else {
+          throw new Error('Unknown polling option: ' + polling);
       }
+      poller.start();
+      return poller;
   }
   JAVASCRIPT
 end

data/lib/puppeteer/web_socket.rb

@@ -45,7 +45,7 @@ class Puppeteer::WebSocket
     rescue Errno::ECONNRESET
       raise EOFError.new('closed by remote')
     end
-    
+
     def dispose
       @socket.close
     end
@@ -75,7 +75,7 @@ class Puppeteer::WebSocket
     end
   end
 
-  class TransportError < StandardError; end
+  class TransportError < Puppeteer::Error; end
 
   private def setup
     @ready_state = STATE_CONNECTING