puppeteer-ruby 0.0.23 → 0.29.0

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

@@ -4,6 +4,47 @@ require 'thread'
 class Puppeteer::DOMWorld
   using Puppeteer::DefineAsyncMethod
 
+  class BindingFunction
+    def initialize(name:, proc:)
+      @name = name
+      @proc = proc
+    end
+
+    def call(*args)
+      @proc.call(*args)
+    end
+
+    attr_reader :name
+
+    def page_binding_init_string
+      <<~JAVASCRIPT
+      (type, bindingName) => {
+        /* Cast window to any here as we're about to add properties to it
+         * via win[bindingName] which TypeScript doesn't like.
+         */
+        const win = window;
+        const binding = win[bindingName];
+
+        win[bindingName] = (...args) => {
+          const me = window[bindingName];
+          let callbacks = me.callbacks;
+          if (!callbacks) {
+            callbacks = new Map();
+            me.callbacks = callbacks;
+          }
+          const seq = (me.lastSeq || 0) + 1;
+          me.lastSeq = seq;
+          const promise = new Promise((resolve, reject) =>
+            callbacks.set(seq, { resolve, reject })
+          );
+          binding(JSON.stringify({ type, name: bindingName, seq, args }));
+          return promise;
+        };
+      }
+      JAVASCRIPT
+    end
+  end
+
   # @param {!Puppeteer.FrameManager} frameManager
   # @param {!Puppeteer.Frame} frame
   # @param {!Puppeteer.TimeoutSettings} timeoutSettings
@@ -13,19 +54,29 @@ class Puppeteer::DOMWorld
     @timeout_settings = timeout_settings
     @context_promise = resolvable_future
     @wait_tasks = Set.new
+    @bound_functions = {}
+    @ctx_bindings = Set.new
     @detached = false
+
+    frame_manager.client.on_event('Runtime.bindingCalled', &method(:handle_binding_called))
   end
 
   attr_reader :frame
 
   # only used in Puppeteer::WaitTask#initialize
-  def _wait_tasks
+  private def _wait_tasks
     @wait_tasks
   end
 
+  # only used in Puppeteer::WaitTask#initialize
+  private def _bound_functions
+    @bound_functions
+  end
+
   # @param context [Puppeteer::ExecutionContext]
   def context=(context)
     if context
+      @ctx_bindings.clear
       unless @context_promise.resolved?
         @context_promise.fulfill(context)
       end
@@ -378,61 +429,127 @@ class Puppeteer::DOMWorld
   # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
   # @param timeout [Integer]
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
-    wait_for_selector_or_xpath(selector, false, visible: visible, hidden: hidden, timeout: timeout)
+    # call wait_for_selector_in_page with custom query selector.
+    query_selector_manager = Puppeteer::QueryHandlerManager.instance
+    query_selector_manager.detect_query_handler(selector).wait_for(self, visible: visible, hidden: hidden, timeout: timeout)
   end
 
-  # @param xpath [String]
-  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
-  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
-  # @param timeout [Integer]
-  def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
-    wait_for_selector_or_xpath(xpath, true, visible: visible, hidden: hidden, timeout: timeout)
+  private def binding_identifier(name, context)
+    "#{name}_#{context.send(:_context_id)}"
   end
 
-  # /**
-  #  * @param {Function|string} pageFunction
-  #  * @param {!{polling?: string|number, timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.JSHandle>}
-  #  */
-  # waitForFunction(pageFunction, options = {}, ...args) {
-  #   const {
-  #     polling = 'raf',
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return new WaitTask(this, pageFunction, 'function', polling, timeout, ...args).promise;
-  # }
 
-  # @param page_function [String]
-  # @param args [Array]
-  # @param polling [Integer|String]
+  def add_binding_to_context(context, binding_function)
+    return if @ctx_bindings.include?(binding_identifier(binding_function.name, context))
+
+    expression = binding_function.page_binding_init_string
+    begin
+      context.client.send_message('Runtime.addBinding',
+        name: binding_function.name,
+        executionContextName: context.send(:_context_name))
+      context.evaluate(expression, 'internal', binding_function.name)
+    rescue => err
+      # We could have tried to evaluate in a context which was already
+      # destroyed. This happens, for example, if the page is navigated while
+      # we are trying to add the binding
+      allowed = [
+        'Execution context was destroyed',
+        'Cannot find context with specified id',
+      ]
+      if allowed.any? { |msg| err.message.include?(msg) }
+        # ignore
+      else
+        raise
+      end
+    end
+    @ctx_bindings << binding_identifier(binding_function.name, context)
+  end
+
+  private def handle_binding_called(event)
+    return unless has_context?
+    payload = JSON.parse(event['payload']) rescue nil
+    name = payload['name']
+    args = payload['args']
+
+    # The binding was either called by something in the page or it was
+    # called before our wrapper was initialized.
+    return unless payload
+    return unless payload['type'] == 'internal'
+    context = execution_context
+    return unless @ctx_bindings.include?(binding_identifier(name, context))
+    return unless context.send(:_context_id) == event['executionContextId']
+
+    result = @bound_functions[name].call(*args)
+    deliver_result_js = <<~JAVASCRIPT
+    (name, seq, result) => {
+      globalThis[name].callbacks.get(seq).resolve(result);
+      globalThis[name].callbacks.delete(seq);
+    }
+    JAVASCRIPT
+
+    begin
+      context.evaluate(deliver_result_js, name, payload['seq'], result)
+    rescue => err
+      # The WaitTask may already have been resolved by timing out, or the
+      # exection context may have been destroyed.
+      # In both caes, the promises above are rejected with a protocol error.
+      # We can safely ignores these, as the WaitTask is re-installed in
+      # the next execution context if needed.
+      return if err.message.include?('Protocol error')
+      raise
+    end
+  end
+
+  # @param query_one [String] JS function (element: Element | Document, selector: string) => Element | null;
+  # @param selector [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
   # @param timeout [Integer]
-  # @return [Puppeteer::JSHandle]
-  def wait_for_function(page_function, args: [], polling: nil, timeout: nil)
-    option_polling = polling || 'raf'
+  private def wait_for_selector_in_page(query_one, selector, visible: nil, hidden: nil, timeout: nil, binding_function: nil)
+    option_wait_for_visible = visible || false
+    option_wait_for_hidden = hidden || false
     option_timeout = timeout || @timeout_settings.timeout
 
-    Puppeteer::WaitTask.new(
+    polling =
+      if option_wait_for_visible || option_wait_for_hidden
+        'raf'
+      else
+        'mutation'
+      end
+    title = "selector #{selector}#{option_wait_for_hidden ? 'to be hidden' : ''}"
+
+    selector_predicate = make_predicate_string(
+      predicate_arg_def: '(selector, waitForVisible, waitForHidden)',
+      predicate_query_handler: query_one,
+      async: true,
+      predicate_body: <<~JAVASCRIPT
+        const node = await predicateQueryHandler(document, selector)
+        return checkWaitForOptions(node, waitForVisible, waitForHidden);
+      JAVASCRIPT
+    )
+
+    wait_task = Puppeteer::WaitTask.new(
       dom_world: self,
-      predicate_body: page_function,
-      title: 'function',
-      polling: option_polling,
+      predicate_body: selector_predicate,
+      title: title,
+      polling: polling,
       timeout: option_timeout,
-      args: args,
-    ).await_promise
-  end
-
-
-  # @return [String]
-  def title
-    evaluate('() => document.title')
+      args: [selector, option_wait_for_visible, option_wait_for_hidden],
+      binding_function: binding_function,
+    )
+    handle = wait_task.await_promise
+    unless handle.as_element
+      handle.dispose
+      return nil
+    end
+    handle.as_element
   end
 
-  # @param selector_or_xpath [String]
-  # @param is_xpath [Boolean]
+  # @param xpath [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
   # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
   # @param timeout [Integer]
-  private def wait_for_selector_or_xpath(selector_or_xpath, is_xpath, visible: nil, hidden: nil, timeout: nil)
+  def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
     option_wait_for_visible = visible || false
     option_wait_for_hidden = hidden || false
     option_timeout = timeout || @timeout_settings.timeout
@@ -443,15 +560,23 @@ class Puppeteer::DOMWorld
       else
         'mutation'
       end
-    title = "#{is_xpath ? :XPath : :selector} #{selector_or_xpath}#{option_wait_for_hidden ? 'to be hidden' : ''}"
+    title = "XPath #{xpath}#{option_wait_for_hidden ? 'to be hidden' : ''}"
+
+    xpath_predicate = make_predicate_string(
+      predicate_arg_def: '(selector, waitForVisible, waitForHidden)',
+      predicate_body: <<~JAVASCRIPT
+        const node = document.evaluate(selector, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+        return checkWaitForOptions(node, waitForVisible, waitForHidden);
+      JAVASCRIPT
+    )
 
     wait_task = Puppeteer::WaitTask.new(
       dom_world: self,
-      predicate_body: PREDICATE,
+      predicate_body: xpath_predicate,
       title: title,
       polling: polling,
       timeout: option_timeout,
-      args: [selector_or_xpath, is_xpath, option_wait_for_visible, option_wait_for_hidden],
+      args: [xpath, option_wait_for_visible, option_wait_for_hidden],
     )
     handle = wait_task.await_promise
     unless handle.as_element
@@ -461,34 +586,66 @@ class Puppeteer::DOMWorld
     handle.as_element
   end
 
-  PREDICATE = <<~JAVASCRIPT
-  /**
-    * @param {string} selectorOrXPath
-    * @param {boolean} isXPath
-    * @param {boolean} waitForVisible
-    * @param {boolean} waitForHidden
-    * @return {?Node|boolean}
-    */
-  function _(selectorOrXPath, isXPath, waitForVisible, waitForHidden) {
-      const node = isXPath
-          ? document.evaluate(selectorOrXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue
-          : document.querySelector(selectorOrXPath);
-      if (!node)
-          return waitForHidden;
-      if (!waitForVisible && !waitForHidden)
-          return node;
-      const element = /** @type {Element} */ (node.nodeType === Node.TEXT_NODE ? node.parentElement : node);
-      const style = window.getComputedStyle(element);
-      const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
-      const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
-      return success ? node : null;
-      /**
-        * @return {boolean}
-        */
-      function hasVisibleBoundingBox() {
-          const rect = element.getBoundingClientRect();
-          return !!(rect.top || rect.bottom || rect.width || rect.height);
-      }
-  }
-  JAVASCRIPT
+  # @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')
+  end
+
+  private def make_predicate_string(predicate_arg_def:, predicate_body:, predicate_query_handler: nil, async: false)
+    predicate_query_handler_string =
+      if predicate_query_handler
+        "const predicateQueryHandler = #{predicate_query_handler}"
+      else
+        ""
+      end
+
+    <<~JAVASCRIPT
+    #{async ? 'async ' : ''}function _#{predicate_arg_def} {
+        #{predicate_query_handler_string}
+        #{predicate_body}
+
+        function checkWaitForOptions(node, waitForVisible, waitForHidden) {
+          if (!node) return waitForHidden;
+          if (!waitForVisible && !waitForHidden) return node;
+          const element =
+            node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
+
+          const style = window.getComputedStyle(element);
+          const isVisible =
+            style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
+          const success =
+            waitForVisible === isVisible || waitForHidden === !isVisible;
+          return success ? node : null;
+
+          /**
+          * @return {boolean}
+          */
+          function hasVisibleBoundingBox() {
+            const rect = element.getBoundingClientRect();
+            return !!(rect.top || rect.bottom || rect.width || rect.height);
+          }
+        }
+    }
+    JAVASCRIPT
+  end
 end

data/lib/puppeteer/element_handle.rb

@@ -314,32 +314,20 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     end
   end
 
+  private def query_handler_manager
+    Puppeteer::QueryHandlerManager.instance
+  end
+
   # `$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param selector [String]
   def S(selector)
-    handle = evaluate_handle(
-      '(element, selector) => element.querySelector(selector)',
-      selector,
-    )
-    element = handle.as_element
-
-    if element
-      return element
-    end
-    handle.dispose
-    nil
+    query_handler_manager.detect_query_handler(selector).query_one(self)
   end
 
   # `$$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param selector [String]
   def SS(selector)
-    handles = evaluate_handle(
-      '(element, selector) => element.querySelectorAll(selector)',
-      selector,
-    )
-    properties = handles.properties
-    handles.dispose
-    properties.values.map(&:as_element).compact
+    query_handler_manager.detect_query_handler(selector).query_all(self)
   end
 
   class ElementNotFoundError < StandardError
@@ -370,10 +358,7 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # @param page_function [String]
   # @return [Object]
   def SSeval(selector, page_function, *args)
-    handles = evaluate_handle(
-      '(element, selector) => Array.from(element.querySelectorAll(selector))',
-      selector,
-    )
+    handles = query_handler_manager.detect_query_handler(selector).query_all_array(self)
     result = handles.evaluate(page_function, *args)
     handles.dispose
 
@@ -430,4 +415,10 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     # https://en.wikipedia.org/wiki/Polygon#Simple_polygons
     quad.zip(quad.rotate).map { |p1, p2| (p1.x * p2.y - p2.x * p1.y) / 2 }.reduce(:+).abs
   end
+
+  # used in AriaQueryHandler
+  def query_ax_tree(accessible_name: nil, role: nil)
+    @remote_object.query_ax_tree(@client,
+    accessible_name: accessible_name, role: role)
+  end
 end