puppeteer-ruby 0.43.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da17d477ad97a3197fa0eacf237e784204439efdca104e2a304d5cfb58c449d3
-  data.tar.gz: f56c151a8d7ebd8ac0ff71feafe5a90dcdd14ed997aaa9ea8e198ddd345b93dd
+  metadata.gz: 6ade25ba8f8e99240ed29fdad9300af7b65cc12ddf09e45c43f7b672c6324ed4
+  data.tar.gz: 97d3bfc48b3a2e3729dd8857c2bb6deca7babd4d0b055195f2dbe7c01c941e97
 SHA512:
-  metadata.gz: 3db33eea6388dd6c743395c9e3cd583d95a3f2147627ae371390e40bf6269f32d689687e8adf0fdaef8b99134b6bad2ee55061ca66c037407ec681ee62b61188
-  data.tar.gz: 2b169890fd8c5dde6850fff2439e5d43c03fa1b65e906ce443389c0599cf31d0e88af1ca0203c12cff90b2789c14af7a992d1c6b95caf7e78b9dadbf4d4a0f09
+  metadata.gz: 891d8c29ac63d25cdb34178024d7a9202675d77b121a903e24a51e9465e46a9b7a0a9b70a2d893d9b274724b5547d5bb90e133aa2c217052f3f523f952e1a0a3
+  data.tar.gz: eea1fb6ff2f179208932a3bb84ca96841b1b08ff588d914e88ace6ad9e31f71c567c21321e3376b019a265122e51a4352b3f0039dd6bea770dba2a383efe82e5

data/CHANGELOG.md

@@ -1,7 +1,17 @@
-### main [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.43.0...main)]
+### main [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.44.0...main)]
 
 - xxx
 
+### 0.44.0 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.43.1...0.44.0)]
+
+- Port Puppeteer v17.0-v17.1 features.
+  - `wait_for_selector` no longer accept `root` parameter.
+
+
+### 0.43.1 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.43.0...0.43.1)]
+
+- Port Puppeteer v16.1 features, including bugfix and XPath query handler.
+
 ### 0.43.0 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.42.0...0.43.0)]
 
 - Port Puppeteer v16.0 features. Increasing stability.

data/docs/api_coverage.md

@@ -1,6 +1,6 @@
 # API coverages
-- Puppeteer version: v16.2.0
-- puppeteer-ruby version: 0.43.0
+- Puppeteer version: v17.1.3
+- puppeteer-ruby version: 0.44.0
 
 ## Puppeteer
 
@@ -150,13 +150,6 @@
 * ~~removeAllListeners~~
 * ~~removeListener~~
 
-## ExecutionContext
-
-* evaluate
-* evaluateHandle => `#evaluate_handle`
-* frame
-* ~~queryObjects~~
-
 ## FileChooser
 
 * accept
@@ -172,12 +165,12 @@
 * $x => `#Sx`
 * addScriptTag => `#add_script_tag`
 * addStyleTag => `#add_style_tag`
+* addStyleTag => `#add_style_tag`
 * childFrames => `#child_frames`
 * click
 * content
 * evaluate
 * evaluateHandle => `#evaluate_handle`
-* executionContext => `#execution_context`
 * focus
 * goto
 * hover
@@ -251,7 +244,6 @@
 * dispose
 * evaluate
 * evaluateHandle => `#evaluate_handle`
-* executionContext => `#execution_context`
 * getProperties => `#properties`
 * getProperty => `#[]`
 * getProperty => `#[]`
@@ -289,6 +281,7 @@
 * $x => `#Sx`
 * addScriptTag => `#add_script_tag`
 * addStyleTag => `#add_style_tag`
+* addStyleTag => `#add_style_tag`
 * authenticate
 * bringToFront => `#bring_to_front`
 * browser
@@ -313,6 +306,7 @@
 * exposeFunction => `#expose_function`
 * focus
 * frames
+* ~~getDefaultTimeout~~
 * goBack => `#go_back`
 * goForward => `#go_forward`
 * goto
@@ -401,5 +395,4 @@
 
 * ~~evaluate~~
 * ~~evaluateHandle~~
-* ~~executionContext~~
 * ~~url~~

data/lib/puppeteer/aria_query_handler.rb

@@ -25,43 +25,83 @@ class Puppeteer::AriaQueryHandler
     query_options
   end
 
-  def query_one(element, selector)
-    context = element.execution_context
+  # @param element [Puppeteer::ElementHandle]
+  # @param selector [String]
+  private def query_one_id(element, selector)
     parse_result = parse_aria_selector(selector)
     res = element.query_ax_tree(accessible_name: parse_result[:name], role: parse_result[:role])
-    if res.empty?
+
+    if res.first.is_a?(Hash)
+      res.first['backendDOMNodeId']
+    else
       nil
+    end
+  end
+
+  def query_one(element, selector)
+    id = query_one_id(element, selector)
+
+    if id
+      element.frame.main_world.adopt_backend_node(id)
     else
-      context.adopt_backend_node_id(res.first['backendDOMNodeId'])
+      nil
     end
   end
 
-  def wait_for(dom_world, selector, visible: nil, hidden: nil, timeout: nil, root: nil)
+  def wait_for(element_or_frame, selector, visible: nil, hidden: nil, timeout: nil)
+    case element_or_frame
+    when Puppeteer::Frame
+      frame = element_or_frame
+      element = nil
+    when Puppeteer::ElementHandle
+      frame = element_or_frame.frame
+      element = frame.puppeteer_world.adopt_handle(element_or_frame)
+    else
+      raise ArgumentError.new("element_or_frame must be a Frame or ElementHandle. #{element_or_frame.inspect}")
+    end
+
     # addHandlerToWorld
-    binding_function = Puppeteer::DOMWorld::BindingFunction.new(
+    binding_function = Puppeteer::IsolaatedWorld::BindingFunction.new(
       name: 'ariaQuerySelector',
-      proc: -> (sel) { query_one(root || dom_world.send(:document), sel) },
+      proc: -> (sel) {
+        id = query_one_id(element || frame.puppeteer_world.document, sel)
+
+        if id
+          frame.puppeteer_world.adopt_backend_node(id)
+        else
+          nil
+        end
+      },
     )
-    dom_world.send(:wait_for_selector_in_page,
+    result = frame.puppeteer_world.send(:wait_for_selector_in_page,
       '(_, selector) => globalThis.ariaQuerySelector(selector)',
+      element,
       selector,
       visible: visible,
       hidden: hidden,
       timeout: timeout,
       binding_function: binding_function,
-      root: root,
     )
+
+    element&.dispose
+
+    if result.is_a?(Puppeteer::ElementHandle)
+      result.frame.main_world.transfer_handle(result)
+    else
+      result&.dispose
+      nil
+    end
   end
 
   def query_all(element, selector)
-    context = element.execution_context
+    world = element.frame.main_world
     parse_result = parse_aria_selector(selector)
     res = element.query_ax_tree(accessible_name: parse_result[:name], role: parse_result[:role])
     if res.empty?
       nil
     else
       promises = res.map do |ax_node|
-        context.send(:async_adopt_backend_node_id, ax_node['backendDOMNodeId'])
+        world.send(:async_adopt_backend_node, ax_node['backendDOMNodeId'])
       end
       await_all(*promises)
     end

data/lib/puppeteer/browser.rb

@@ -196,7 +196,7 @@ class Puppeteer::Browser
       session: session,
       browser_context: context,
       target_manager: @target_manager,
-      session_factory: -> { @connection.create_session(target_info) },
+      session_factory: -> (auto_attach_emulated) { @connection.create_session(target_info, auto_attach_emulated: auto_attach_emulated) },
       ignore_https_errors: @ignore_https_errors,
       default_viewport: @default_viewport,
       is_page_target_callback: @is_page_target_callback,

data/lib/puppeteer/chrome_target_manager.rb

@@ -1,4 +1,5 @@
 class Puppeteer::ChromeTargetManager
+  include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
 
   def initialize(connection:, target_factory:, target_filter_callback:)
@@ -33,20 +34,34 @@ class Puppeteer::ChromeTargetManager
     )
 
     setup_attachment_listeners(@connection)
-    @connection.async_send_message('Target.setDiscoverTargets', discover: true)
+    @connection.async_send_message('Target.setDiscoverTargets', {
+      discover: true,
+      filter: [
+        { type: 'tab', exclude: true },
+        {},
+      ],
+    }).then do
+      store_existing_targets_for_init
+    end.rescue do |err|
+      debug_puts(err)
+    end
   end
 
-  def init
+  private def store_existing_targets_for_init
     @discovered_targets_by_target_id.each do |target_id, target_info|
-      if @target_filter_callback.call(target_info)
+      if @target_filter_callback.call(target_info) && target_info.type != 'browser'
         @target_ids_for_init << target_id
       end
     end
+  end
+
+  def init
     @connection.send_message('Target.setAutoAttach', {
       waitForDebuggerOnStart: true,
       flatten: true,
       autoAttach: true,
     })
+    finish_initialization_if_ready
     @initialize_promise.value!
   end
 
@@ -114,7 +129,7 @@ class Puppeteer::ChromeTargetManager
       # Special case (https://crbug.com/1338156): currently, shared_workers
       # don't get auto-attached. This should be removed once the auto-attach
       # works.
-      @connection.create_session(target_info)
+      @connection.create_session(target_info, auto_attach_emulated: true)
     end
   end
 
@@ -170,6 +185,8 @@ class Puppeteer::ChromeTargetManager
       end
     }
 
+    return unless @connection.auto_attached?(target_info.target_id)
+
     # Special case for service workers: being attached to service workers will
     # prevent them from ever being destroyed. Therefore, we silently detach
     # from service workers unless the connection was manually created via
@@ -197,6 +214,8 @@ class Puppeteer::ChromeTargetManager
       return
     end
 
+    is_existing_target = @attached_targets_by_target_id.has_key?(target_info.target_id)
+
     target = @attached_targets_by_target_id[target_info.target_id] || @target_factory.call(target_info, session)
     setup_attachment_listeners(session)
 
@@ -218,11 +237,10 @@ class Puppeteer::ChromeTargetManager
     end
 
     @target_ids_for_init.delete(target.target_id)
-    future { emit_event(TargetManagerEmittedEvents::TargetAvailable, target) }
-
-    if @target_ids_for_init.empty?
-      @initialize_promise.fulfill(nil) unless @initialize_promise.resolved?
+    unless is_existing_target
+      future { emit_event(TargetManagerEmittedEvents::TargetAvailable, target) }
     end
+    finish_initialization_if_ready
 
     future do
       # TODO: the browser might be shutting down here. What do we do with the error?
@@ -239,8 +257,8 @@ class Puppeteer::ChromeTargetManager
     end
   end
 
-  private def finish_initialization_if_ready(target_id)
-    @target_ids_for_init.delete(target_id)
+  private def finish_initialization_if_ready(target_id = nil)
+    @target_ids_for_init.delete(target_id) if target_id
     if @target_ids_for_init.empty?
       @initialize_promise.fulfill(nil) unless @initialize_promise.resolved?
     end

data/lib/puppeteer/connection.rb

@@ -319,15 +319,18 @@ class Puppeteer::Connection
   end
 
   def auto_attached?(target_id)
-    @manually_attached.include?(target_id)
+    !@manually_attached.include?(target_id)
   end
 
   # @param {Protocol.Target.TargetInfo} targetInfo
   # @return [CDPSession]
-  def create_session(target_info)
-    @manually_attached << target_info.target_id
+  def create_session(target_info, auto_attach_emulated: false)
+    unless auto_attach_emulated
+      @manually_attached << target_info.target_id
+    end
     result = send_message('Target.attachToTarget', targetId: target_info.target_id, flatten: true)
     session_id = result['sessionId']
+    @manually_attached.delete(target_info.target_id)
     @sessions[session_id]
   end
 end

data/lib/puppeteer/coverage.rb

@@ -108,7 +108,7 @@ class Puppeteer::Coverage
 
       # Filter out empty ranges.
       results.select do |range|
-        range[:end] - range[:start] > 1
+        range[:end] - range[:start] > 0
       end
     end
   end

data/lib/puppeteer/custom_query_handler.rb

@@ -21,12 +21,39 @@ class Puppeteer::CustomQueryHandler
     nil
   end
 
-  def wait_for(dom_world, selector, visible: nil, hidden: nil, timeout: nil, root: nil)
+  def wait_for(element_or_frame, selector, visible: nil, hidden: nil, timeout: nil)
+    case element_or_frame
+    when Puppeteer::Frame
+      frame = element_or_frame
+      element = nil
+    when Puppeteer::ElementHandle
+      frame = element_or_frame.frame
+      element = frame.puppeteer_world.adopt_handle(element_or_frame)
+    else
+      raise ArgumentError.new("element_or_frame must be a Frame or ElementHandle. #{element_or_frame.inspect}")
+    end
+
     unless @query_one
       raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
     end
 
-    dom_world.send(:wait_for_selector_in_page, @query_one, selector, visible: visible, hidden: hidden, timeout: timeout, root: root)
+    result = frame.puppeteer_world.send(:wait_for_selector_in_page,
+      @query_one,
+      element,
+      selector,
+      visible: visible,
+      hidden: hidden,
+      timeout: timeout,
+    )
+
+    element&.dispose
+
+    if result.is_a?(Puppeteer::ElementHandle)
+      result.frame.main_world.transfer_handle(result)
+    else
+      result&.dispose
+      nil
+    end
   end
 
   def query_all(element, selector)

data/lib/puppeteer/element_handle.rb

@@ -12,16 +12,16 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # @param client [Puppeteer::CDPSession]
   # @param remote_object [Puppeteer::RemoteObject]
   # @param frame [Puppeteer::Frame]
-  # @param page [Puppeteer::Page]
-  # @param frame_manager [Puppeteer::FrameManager]
-  def initialize(context:, client:, remote_object:, frame:, page:, frame_manager:)
+  def initialize(context:, client:, remote_object:, frame:)
     super(context: context, client: client, remote_object: remote_object)
     @frame = frame
-    @page = page
-    @frame_manager = frame_manager
+    @page = frame.page
+    @frame_manager = frame.frame_manager
     @disposed = false
   end
 
+  attr_reader :page, :frame, :frame_manager
+
   def inspect
     values = %i[context remote_object page disposed].map do |sym|
       value = instance_variable_get(:"@#{sym}")
@@ -60,18 +60,7 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # (30 seconds). Pass `0` to disable timeout. The default value can be changed
   # by using the {@link Page.setDefaultTimeout} method.
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
-    frame = @context.frame
-
-    secondary_world = frame.secondary_world
-    adopted_root = secondary_world.execution_context.adopt_element_handle(self)
-    handle = secondary_world.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout, root: adopted_root)
-    adopted_root.dispose
-    return nil unless handle
-
-    main_world = frame.main_world
-    result = main_world.execution_context.adopt_element_handle(handle)
-    handle.dispose
-    result
+    query_handler_manager.detect_query_handler(selector).wait_for(self, visible: visible, hidden: hidden, timeout: timeout)
   end
 
   define_async_method :async_wait_for_selector
@@ -125,28 +114,14 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default
   # value can be changed by using the {@link Page.setDefaultTimeout} method.
   def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
-    frame = @context.frame
-
-    secondary_world = frame.secondary_world
-    adopted_root = secondary_world.execution_context.adopt_element_handle(self)
     param_xpath =
       if xpath.start_with?('//')
         ".#{xpath}"
       else
         xpath
       end
-    unless param_xpath.start_with?('.//')
-      adopted_root.dispose
-      raise ArgumentError.new("Unsupported xpath expression: #{xpath}")
-    end
-    handle = secondary_world.wait_for_xpath(param_xpath, visible: visible, hidden: hidden, timeout: timeout, root: adopted_root)
-    adopted_root.dispose
-    return nil unless handle
 
-    main_world = frame.main_world
-    result = main_world.execution_context.adopt_element_handle(handle)
-    handle.dispose
-    result
+    wait_for_selector("xpath/#{param_xpath}", visible: visible, hidden: hidden, timeout: timeout)
   end
 
   define_async_method :async_wait_for_xpath
@@ -623,21 +598,14 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # @param expression [String]
   # @return [Array<ElementHandle>]
   def Sx(expression)
-    fn = <<~JAVASCRIPT
-    (element, expression) => {
-      const document = element.ownerDocument || element;
-      const iterator = document.evaluate(expression, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE);
-      const array = [];
-      let item;
-      while ((item = iterator.iterateNext()))
-        array.push(item);
-      return array;
-    }
-    JAVASCRIPT
-    handles = evaluate_handle(fn, expression)
-    properties = handles.properties
-    handles.dispose
-    properties.values.map(&:as_element).compact
+    param_xpath =
+      if expression.start_with?('//')
+        ".#{expression}"
+      else
+        expression
+      end
+
+    query_selector_all("xpath/#{param_xpath}")
   end
 
   define_async_method :async_Sx
@@ -674,6 +642,6 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # used in AriaQueryHandler
   def query_ax_tree(accessible_name: nil, role: nil)
     @remote_object.query_ax_tree(@client,
-    accessible_name: accessible_name, role: role)
+      accessible_name: accessible_name, role: role)
   end
 end

data/lib/puppeteer/execution_context.rb

@@ -7,7 +7,7 @@ class Puppeteer::ExecutionContext
 
   # @param client [Puppeteer::CDPSession]
   # @param context_payload [Hash]
-  # @param world [Puppeteer::DOMWorld?]
+  # @param world [Puppeteer::IsolaatedWorld?]
   def initialize(client, context_payload, world)
     @client = client
     @world = world
@@ -17,23 +17,16 @@ class Puppeteer::ExecutionContext
 
   attr_reader :client, :world
 
-  # only used in DOMWorld
+  # only used in IsolaatedWorld
   private def _context_id
     @context_id
   end
 
-  # only used in DOMWorld::BindingFunction#add_binding_to_context
+  # only used in IsolaatedWorld::BindingFunction#add_binding_to_context
   private def _context_name
     @context_name
   end
 
-  # @return [Puppeteer::Frame]
-  def frame
-    if_present(@world) do |world|
-      world.frame
-    end
-  end
-
   # @param page_function [String]
   # @return [Object]
   def evaluate(page_function, *args)
@@ -208,54 +201,4 @@ class Puppeteer::ExecutionContext
       context_id: @context_id,
     )
   end
-
-  # /**
-  #  * @param {!JSHandle} prototypeHandle
-  #  * @return {!Promise<!JSHandle>}
-  #  */
-  # async queryObjects(prototypeHandle) {
-  #   assert(!prototypeHandle._disposed, 'Prototype JSHandle is disposed!');
-  #   assert(prototypeHandle._remoteObject.objectId, 'Prototype JSHandle must not be referencing primitive value');
-  #   const response = await this._client.send('Runtime.queryObjects', {
-  #     prototypeObjectId: prototypeHandle._remoteObject.objectId
-  #   });
-  #   return createJSHandle(this, response.objects);
-  # }
-
-  # @param backend_node_id [Integer]
-  # @return [Puppeteer::ElementHandle]
-  def adopt_backend_node_id(backend_node_id)
-    response = @client.send_message('DOM.resolveNode',
-      backendNodeId: backend_node_id,
-      executionContextId: @context_id,
-    )
-    Puppeteer::JSHandle.create(
-      context: self,
-      remote_object: Puppeteer::RemoteObject.new(response["object"]),
-    )
-  end
-  private define_async_method :async_adopt_backend_node_id
-
-  # @param element_handle [Puppeteer::ElementHandle]
-  # @return [Puppeteer::ElementHandle]
-  def adopt_element_handle(element_handle)
-    if element_handle.execution_context == self
-      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
-    end
-
-    unless @world
-      raise 'Cannot adopt handle without DOMWorld'
-    end
-
-    node_info = element_handle.remote_object.node_info(@client)
-    response = @client.send_message('DOM.resolveNode',
-      backendNodeId: node_info["node"]["backendNodeId"],
-      executionContextId: @context_id,
-    )
-
-    Puppeteer::JSHandle.create(
-      context: self,
-      remote_object: Puppeteer::RemoteObject.new(response["object"]),
-    )
-  end
 end

data/lib/puppeteer/frame.rb

@@ -37,8 +37,8 @@ class Puppeteer::Frame
   # @param client [Puppeteer::CDPSession]
   private def update_client(client)
     @client = client
-    @main_world = Puppeteer::DOMWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
-    @secondary_world = Puppeteer::DOMWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
+    @main_world = Puppeteer::IsolaatedWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
+    @puppeteer_world = Puppeteer::IsolaatedWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
   end
 
   def page
@@ -49,7 +49,7 @@ class Puppeteer::Frame
     @client != @frame_manager.client
   end
 
-  attr_accessor :frame_manager, :id, :loader_id, :lifecycle_events, :main_world, :secondary_world
+  attr_accessor :frame_manager, :id, :loader_id, :lifecycle_events, :main_world, :puppeteer_world
 
   def has_started_loading?
     @has_started_loading
@@ -106,7 +106,14 @@ class Puppeteer::Frame
   # @param {string} expression
   # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
   def Sx(expression)
-    @main_world.Sx(expression)
+    param_xpath =
+      if expression.start_with?('//')
+        ".#{expression}"
+      else
+        expression
+      end
+
+    query_selector_all("xpath/#{param_xpath}")
   end
 
   define_async_method :async_Sx
@@ -147,14 +154,14 @@ class Puppeteer::Frame
 
   # @return [String]
   def content
-    @secondary_world.content
+    @puppeteer_world.content
   end
 
   # @param html [String]
   # @param timeout [Integer]
   # @param wait_until [String|Array<String>]
   def set_content(html, timeout: nil, wait_until: nil)
-    @secondary_world.set_content(html, timeout: timeout, wait_until: wait_until)
+    @puppeteer_world.set_content(html, timeout: timeout, wait_until: wait_until)
   end
 
   # @return [String]
@@ -205,35 +212,35 @@ class Puppeteer::Frame
   # @param button [String] "left"|"right"|"middle"
   # @param click_count [Number]
   def click(selector, delay: nil, button: nil, click_count: nil)
-    @secondary_world.click(selector, delay: delay, button: button, click_count: click_count)
+    @puppeteer_world.click(selector, delay: delay, button: button, click_count: click_count)
   end
 
   define_async_method :async_click
 
   # @param {string} selector
   def focus(selector)
-    @secondary_world.focus(selector)
+    @puppeteer_world.focus(selector)
   end
 
   define_async_method :async_focus
 
   # @param {string} selector
   def hover(selector)
-    @secondary_world.hover(selector)
+    @puppeteer_world.hover(selector)
   end
 
   # @param {string} selector
   # @param {!Array<string>} values
   # @return {!Promise<!Array<string>>}
   def select(selector, *values)
-    @secondary_world.select(selector, *values)
+    @puppeteer_world.select(selector, *values)
   end
 
   define_async_method :async_select
 
   # @param {string} selector
   def tap(selector)
-    @secondary_world.tap(selector)
+    @puppeteer_world.tap(selector)
   end
 
   define_async_method :async_tap
@@ -252,14 +259,8 @@ class Puppeteer::Frame
   # @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)
-    handle = @secondary_world.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
-    if !handle
-      return nil
-    end
-    main_execution_context = @main_world.execution_context
-    result = main_execution_context.adopt_element_handle(handle)
-    handle.dispose
-    result
+    query_handler_manager = Puppeteer::QueryHandlerManager.instance
+    query_handler_manager.detect_query_handler(selector).wait_for(self, visible: visible, hidden: hidden, timeout: timeout)
   end
 
   define_async_method :async_wait_for_selector
@@ -274,14 +275,14 @@ class Puppeteer::Frame
   # @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)
-    handle = @secondary_world.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
-    if !handle
-      return nil
-    end
-    main_execution_context = @main_world.execution_context
-    result = main_execution_context.adopt_element_handle(handle)
-    handle.dispose
-    result
+    param_xpath =
+      if xpath.start_with?('//')
+        ".#{xpath}"
+      else
+        xpath
+      end
+
+    wait_for_selector("xpath/#{param_xpath}", visible: visible, hidden: hidden, timeout: timeout)
   end
 
   define_async_method :async_wait_for_xpath
@@ -299,7 +300,7 @@ class Puppeteer::Frame
 
   # @return [String]
   def title
-    @secondary_world.title
+    @puppeteer_world.title
   end
 
   # @param frame_payload [Hash]
@@ -337,7 +338,7 @@ class Puppeteer::Frame
   def detach
     @detached = true
     @main_world.detach
-    @secondary_world.detach
+    @puppeteer_world.detach
     if @parent_frame
       @parent_frame._child_frames.delete(self)
     end

data/lib/puppeteer/frame_manager.rb

@@ -144,13 +144,13 @@ class Puppeteer::FrameManager
           watcher.same_document_navigation_promise
         end,
       )
+
+      watcher.navigation_response
     rescue Puppeteer::TimeoutError => err
       raise NavigationError.new(err)
     ensure
       watcher.dispose
     end
-
-    watcher.navigation_response
   end
 
   # @param timeout [number|nil]
@@ -168,13 +168,13 @@ class Puppeteer::FrameManager
         watcher.same_document_navigation_promise,
         watcher.new_document_navigation_promise,
       )
+
+      watcher.navigation_response
     rescue Puppeteer::TimeoutError => err
       raise NavigationError.new(err)
     ensure
       watcher.dispose
     end
-
-    watcher.navigation_response
   end
 
   # @param event [Hash]
@@ -413,11 +413,11 @@ class Puppeteer::FrameManager
 
       if context_payload.dig('auxData', 'isDefault')
         world = frame.main_world
-      elsif context_payload['name'] == UTILITY_WORLD_NAME && !frame.secondary_world.has_context?
+      elsif context_payload['name'] == UTILITY_WORLD_NAME && !frame.puppeteer_world.has_context?
         # In case of multiple sessions to the same target, there's a race between
         # connections so we might end up creating multiple isolated worlds.
         # We can use either.
-        world = frame.secondary_world
+        world = frame.puppeteer_world
       end
     end
 

data/lib/puppeteer/{dom_world.rb → isolated_world.rb}

@@ -1,7 +1,7 @@
 require 'thread'
 
-# https://github.com/puppeteer/puppeteer/blob/master/src/DOMWorld.js
-class Puppeteer::DOMWorld
+# https://github.com/puppeteer/puppeteer/blob/master/src/IsolaatedWorld.js
+class Puppeteer::IsolaatedWorld
   using Puppeteer::DefineAsyncMethod
 
   class BindingFunction
@@ -152,7 +152,7 @@ class Puppeteer::DOMWorld
     raise 'Bug of puppeteer-ruby...'
   end
 
-  private def document
+  def document
     @document ||= evaluate_document.as_element
   end
 
@@ -416,16 +416,6 @@ class Puppeteer::DOMWorld
     handle.dispose
   end
 
-  # @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]
-  def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil, root: nil)
-    # 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, root: root)
-  end
-
   private def binding_identifier(name, context)
     "#{name}_#{context.send(:_context_id)}"
   end
@@ -497,7 +487,7 @@ class Puppeteer::DOMWorld
   # @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_in_page(query_one, selector, visible: nil, hidden: nil, timeout: nil, root: nil, binding_function: nil)
+  private def wait_for_selector_in_page(query_one, root, 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
@@ -531,55 +521,7 @@ class Puppeteer::DOMWorld
       root: option_root,
       binding_function: binding_function,
     )
-    handle = wait_task.await_promise
-    unless handle.as_element
-      handle.dispose
-      return nil
-    end
-    handle.as_element
-  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, root: nil)
-    option_wait_for_visible = visible || false
-    option_wait_for_hidden = hidden || false
-    option_timeout = timeout || @timeout_settings.timeout
-    option_root = root
-
-    polling =
-      if option_wait_for_visible || option_wait_for_hidden
-        'raf'
-      else
-        'mutation'
-      end
-    title = "XPath #{xpath}#{option_wait_for_hidden ? 'to be hidden' : ''}"
-
-    xpath_predicate = make_predicate_string(
-      predicate_arg_def: '(root, selector, waitForVisible, waitForHidden)',
-      predicate_body: <<~JAVASCRIPT
-        const node = document.evaluate(selector, root, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-        return checkWaitForOptions(node, waitForVisible, waitForHidden);
-      JAVASCRIPT
-    )
-
-    wait_task = Puppeteer::WaitTask.new(
-      dom_world: self,
-      predicate_body: xpath_predicate,
-      title: title,
-      polling: polling,
-      timeout: option_timeout,
-      args: [xpath, option_wait_for_visible, option_wait_for_hidden],
-      root: option_root,
-    )
-    handle = wait_task.await_promise
-    unless handle.as_element
-      handle.dispose
-      return nil
-    end
-    handle.as_element
+    wait_task.await_promise
   end
 
   # @param page_function [String]
@@ -644,4 +586,35 @@ class Puppeteer::DOMWorld
     }
     JAVASCRIPT
   end
+
+  # @param backend_node_id [Integer]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_backend_node(backend_node_id)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: backend_node_id,
+      executionContextId: execution_context.send(:_context_id),
+    )
+    Puppeteer::JSHandle.create(
+      context: execution_context,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
+  private define_async_method :async_adopt_backend_node
+
+  # @param element_handle [Puppeteer::ElementHandle]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_handle(element_handle)
+    if element_handle.execution_context == execution_context
+      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
+    end
+
+    node_info = element_handle.remote_object.node_info(@client)
+    adopt_backend_node(node_info["node"]["backendNodeId"])
+  end
+
+  def transfer_handle(element_handle)
+    result = adopt_handle(element_handle)
+    element_handle.dispose
+    result
+  end
 end

data/lib/puppeteer/js_handle.rb

@@ -5,16 +5,12 @@ class Puppeteer::JSHandle
   # @param context [Puppeteer::ExecutionContext]
   # @param remote_object [Puppeteer::RemoteObject]
   def self.create(context:, remote_object:)
-    frame = context.frame
-    if remote_object.sub_type == 'node' && frame
-      frame_manager = frame.frame_manager
+    if remote_object.sub_type == 'node' && context.world
       Puppeteer::ElementHandle.new(
         context: context,
         client: context.client,
         remote_object: remote_object,
-        frame: frame,
-        page: frame_manager.page,
-        frame_manager: frame_manager,
+        frame: context.world.frame,
       )
     else
       Puppeteer::JSHandle.new(

data/lib/puppeteer/lifecycle_watcher.rb

@@ -81,7 +81,10 @@ class Puppeteer::LifecycleWatcher
       @frame_manager.add_event_listener(FrameManagerEmittedEvents::FrameSwapped, &method(:handle_frame_swapped)),
       @frame_manager.add_event_listener(FrameManagerEmittedEvents::FrameDetached, &method(:handle_frame_detached)),
     ]
-    @listener_ids['network_manager'] = @frame_manager.network_manager.add_event_listener(NetworkManagerEmittedEvents::Request, &method(:handle_request))
+    @listener_ids['network_manager'] = [
+      @frame_manager.network_manager.add_event_listener(NetworkManagerEmittedEvents::Request, &method(:handle_request)),
+      @frame_manager.network_manager.add_event_listener(NetworkManagerEmittedEvents::Response, &method(:handle_response)),
+    ]
 
     @same_document_navigation_promise = resolvable_future
     @lifecycle_promise = resolvable_future
@@ -94,6 +97,21 @@ class Puppeteer::LifecycleWatcher
   def handle_request(request)
     return if request.frame != @frame || !request.navigation_request?
     @navigation_request = request
+    # Resolve previous navigation response in case there are multiple
+    # navigation requests reported by the backend. This generally should not
+    # happen by it looks like it's possible.
+    @navigation_response_received&.fulfill(nil)
+    @navigation_response_received = resolvable_future
+    if request.response && !@navigation_response_received.resolved?
+      @navigation_response_received.fulfill(nil)
+    end
+  end
+
+  # @param [Puppeteer::HTTPResponse] response
+  def handle_response(response)
+    return if @navigation_request&.internal&.request_id  != response.request.internal.request_id
+
+    @navigation_response_received.fulfill(nil) unless @navigation_response_received.resolved?
   end
 
   # @param frame [Puppeteer::Frame]
@@ -107,6 +125,8 @@ class Puppeteer::LifecycleWatcher
 
   # @return [Puppeteer::HTTPResponse]
   def navigation_response
+    # Continue with a possibly null response.
+    @navigation_response_received.value! rescue nil
     if_present(@navigation_request) do |request|
       request.response
     end
@@ -175,8 +195,8 @@ class Puppeteer::LifecycleWatcher
     if_present(@listener_ids['frame_manager']) do |ids|
       @frame_manager.remove_event_listener(*ids)
     end
-    if_present(@listener_ids['network_manager']) do |id|
-      @frame_manager.network_manager.remove_event_listener(id)
+    if_present(@listener_ids['network_manager']) do |ids|
+      @frame_manager.network_manager.remove_event_listener(*ids)
     end
   end
 end

data/lib/puppeteer/page.rb

@@ -191,8 +191,7 @@ class Puppeteer::Page
     return if @file_chooser_interceptors.empty?
 
     frame = @frame_manager.frame(event['frameId'])
-    context = frame.execution_context
-    element = context.adopt_backend_node_id(event['backendNodeId'])
+    element = frame.main_world.adopt_backend_node(event['backendNodeId'])
     interceptors = @file_chooser_interceptors.to_a
     @file_chooser_interceptors.clear
     file_chooser = Puppeteer::FileChooser.new(element, event)
@@ -1070,7 +1069,8 @@ class Puppeteer::Page
     clip = if_present(screenshot_options.clip) do |rect|
       x = rect[:x].round
       y = rect[:y].round
-      { x: x, y: y, width: rect[:width] + rect[:x] - x, height: rect[:height] + rect[:y] - y, scale: 1 }
+      scale = rect[:scale] || 1
+      { x: x, y: y, width: rect[:width] + rect[:x] - x, height: rect[:height] + rect[:y] - y, scale: scale }
     end
 
     if screenshot_options.full_page?

data/lib/puppeteer/query_handler_manager.rb

@@ -6,6 +6,7 @@ class Puppeteer::QueryHandlerManager
   def query_handlers
     @query_handlers ||= {
       aria: Puppeteer::AriaQueryHandler.new,
+      xpath: xpath_handler,
     }
   end
 
@@ -16,6 +17,40 @@ class Puppeteer::QueryHandlerManager
     )
   end
 
+  private def xpath_handler
+    @xpath_handler ||= Puppeteer::CustomQueryHandler.new(
+      query_one: <<~JAVASCRIPT,
+      (element, selector) => {
+        const doc = element.ownerDocument || document;
+        const result = doc.evaluate(
+          selector,
+          element,
+          null,
+          XPathResult.FIRST_ORDERED_NODE_TYPE
+        );
+        return result.singleNodeValue;
+      }
+      JAVASCRIPT
+      query_all: <<~JAVASCRIPT,
+      (element, selector) => {
+        const doc = element.ownerDocument || document;
+        const iterator = doc.evaluate(
+          selector,
+          element,
+          null,
+          XPathResult.ORDERED_NODE_ITERATOR_TYPE
+        );
+        const array = [];
+        let item;
+        while ((item = iterator.iterateNext())) {
+          array.push(item);
+        }
+        return array;
+      }
+      JAVASCRIPT
+    )
+  end
+
   class Result
     def initialize(query_handler:, selector:)
       @query_handler = query_handler
@@ -26,8 +61,8 @@ class Puppeteer::QueryHandlerManager
       @query_handler.query_one(element_handle, @selector)
     end
 
-    def wait_for(dom_world, visible:, hidden:, timeout:, root:)
-      @query_handler.wait_for(dom_world, @selector, visible: visible, hidden: hidden, timeout: timeout, root: root)
+    def wait_for(element_or_frame, visible:, hidden:, timeout:)
+      @query_handler.wait_for(element_or_frame, @selector, visible: visible, hidden: hidden, timeout: timeout)
     end
 
     def query_all(element_handle)

data/lib/puppeteer/remote_object.rb

@@ -105,8 +105,8 @@ class Puppeteer::RemoteObject
       role: role,
     }.compact)
 
-    result['nodes'].reject do |node|
-      node['role']['value'] == 'text'
+    result['nodes'].select do |node|
+      node['role'] && node['role']['value'] != 'StaticText'
     end
   end
 

data/lib/puppeteer/target.rb

@@ -93,7 +93,7 @@ class Puppeteer::Target
   end
 
   def create_cdp_session
-    @session_factory.call
+    @session_factory.call(false)
   end
 
   def target_manager
@@ -102,7 +102,7 @@ class Puppeteer::Target
 
   def page
     if @is_page_target_callback.call(@target_info) && @page.nil?
-      client = @session || @session_factory.call
+      client = @session || @session_factory.call(true)
       @page = Puppeteer::Page.create(client, self, @ignore_https_errors, @default_viewport)
     end
     @page

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 module Puppeteer
-  VERSION = '0.43.0'
+  VERSION = '0.44.0'
 end

data/lib/puppeteer.rb

@@ -32,7 +32,6 @@ require 'puppeteer/css_coverage'
 require 'puppeteer/custom_query_handler'
 require 'puppeteer/devices'
 require 'puppeteer/dialog'
-require 'puppeteer/dom_world'
 require 'puppeteer/emulation_manager'
 require 'puppeteer/exception_details'
 require 'puppeteer/executable_path_finder'
@@ -43,6 +42,7 @@ require 'puppeteer/frame'
 require 'puppeteer/frame_manager'
 require 'puppeteer/http_request'
 require 'puppeteer/http_response'
+require 'puppeteer/isolated_world'
 require 'puppeteer/js_coverage'
 require 'puppeteer/js_handle'
 require 'puppeteer/keyboard'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppeteer-ruby
 version: !ruby/object:Gem::Version
-  version: 0.43.0
+  version: 0.44.0
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-13 00:00:00.000000000 Z
+date: 2022-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -272,7 +272,6 @@ files:
 - lib/puppeteer/device.rb
 - lib/puppeteer/devices.rb
 - lib/puppeteer/dialog.rb
-- lib/puppeteer/dom_world.rb
 - lib/puppeteer/element_handle.rb
 - lib/puppeteer/element_handle/bounding_box.rb
 - lib/puppeteer/element_handle/box_model.rb
@@ -294,6 +293,7 @@ files:
 - lib/puppeteer/http_request.rb
 - lib/puppeteer/http_response.rb
 - lib/puppeteer/if_present.rb
+- lib/puppeteer/isolated_world.rb
 - lib/puppeteer/js_coverage.rb
 - lib/puppeteer/js_handle.rb
 - lib/puppeteer/keyboard.rb