playwright-ruby-client 0.5.10 → 0.6.4

data/lib/playwright/channel_owners/binding_call.rb

@@ -3,5 +3,38 @@ module Playwright
     def name
       @initializer['name']
     end
+
+    def call_async(callback)
+      Thread.new(callback) { call(callback) }
+    end
+
+    # @param callback [Proc]
+    def call(callback)
+      frame = ChannelOwners::Frame.from(@initializer['frame'])
+      # It is not desired to use PlaywrightApi.wrap directly.
+      # However it is a little difficult to define wrapper for `source` parameter in generate_api.
+      # Just a workaround...
+      source = {
+        context: PlaywrightApi.wrap(frame.page.context),
+        page: PlaywrightApi.wrap(frame.page),
+        frame: PlaywrightApi.wrap(frame),
+      }
+      args =
+        if @initializer['handle']
+          handle = ChannelOwners::ElementHandle.from(@initializer['handle'])
+          [handle]
+        else
+          @initializer['args'].map do |arg|
+            JavaScript::ValueParser.new(arg).parse
+          end
+        end
+
+      begin
+        result = PlaywrightApi.unwrap(callback.call(source, *args))
+        @channel.send_message_to_server('resolve', result: JavaScript::ValueSerializer.new(result).serialize)
+      rescue => err
+        @channel.send_message_to_server('reject', error: { error: { message: err.message, name: 'Error' }})
+      end
+    end
   end
 end

data/lib/playwright/channel_owners/browser.rb

@@ -5,6 +5,10 @@ module Playwright
     include Utils::PrepareBrowserContextOptions
 
     private def after_initialize
+      @connected = true
+      @closed_or_closing = false
+      @remote = false
+
       @contexts = Set.new
       @channel.on('close', method(:on_close))
     end
@@ -26,24 +30,28 @@ module Playwright
       @contexts << context
       context.browser = self
       context.options = params
+      return context unless block
 
-      if block
-        begin
-          block.call(context)
-        ensure
-          context.close
-        end
-      else
-        context
+      begin
+        block.call(context)
+      ensure
+        context.close
       end
     end
 
-    def new_page(**options)
+    def new_page(**options, &block)
       context = new_context(**options)
       page = context.new_page
       page.owned_context = context
       context.owner_page = page
-      page
+
+      return page unless block
+
+      begin
+        block.call(page)
+      ensure
+        page.close
+      end
     end
 
     def close
@@ -77,8 +85,8 @@ module Playwright
 
     private def on_close(_ = {})
       @connected = false
-      emit(Events::Browser::Disconnected)
-      @closed_or_closing = false
+      emit(Events::Browser::Disconnected, self)
+      @closed_or_closing = true
     end
 
     # called from BrowserType#connectOverCDP
@@ -86,6 +94,11 @@ module Playwright
       @contexts << context
     end
 
+    # called from BrowserType#connectOverCDP
+    private def update_as_remote
+      @remote = true
+    end
+
     # called from BrowserContext#on_close with send(:remove_context), so keep private.
     private def remove_context(context)
       @contexts.delete(context)

data/lib/playwright/channel_owners/browser_context.rb

@@ -4,6 +4,7 @@ module Playwright
     include Utils::Errors::SafeCloseError
     attr_accessor :browser
     attr_writer :owner_page, :options
+    attr_reader :tracing
 
     private def after_initialize
       @pages = Set.new
@@ -11,16 +12,45 @@ module Playwright
       @bindings = {}
       @timeout_settings = TimeoutSettings.new
 
+      @tracing = TracingImpl.new(@channel, self)
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
       @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
       @channel.on('route', ->(params) {
         on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
       })
+      @channel.on('request', ->(params) {
+        on_request(
+          ChannelOwners::Request.from(params['request']),
+          ChannelOwners::Request.from_nullable(params['page']),
+        )
+      })
+      @channel.on('requestFailed', ->(params) {
+        on_request_failed(
+          ChannelOwners::Request.from(params['request']),
+          params['responseEndTiming'],
+          params['failureText'],
+          ChannelOwners::Request.from_nullable(params['page']),
+        )
+      })
+      @channel.on('requestFinished', ->(params) {
+        on_request_finished(
+          ChannelOwners::Request.from(params['request']),
+          params['responseEndTiming'],
+          ChannelOwners::Request.from_nullable(params['page']),
+        )
+      })
+      @channel.on('response', ->(params) {
+        on_response(
+          ChannelOwners::Response.from(params['response']),
+          ChannelOwners::Request.from_nullable(params['page']),
+        )
+      })
+
+      @closed_promise = Concurrent::Promises.resolvable_future
     end
 
     private def on_page(page)
-      page.send(:update_browser_context, self)
       @pages << page
       emit(Events::BrowserContext::Page, page)
       page.send(:emit_popup_event_from_browser_context)
@@ -39,12 +69,35 @@ module Playwright
     end
 
     private def on_binding(binding_call)
-      func = @binding[binding_call.name]
+      func = @bindings[binding_call.name]
       if func
-        binding_call.call(func)
+        binding_call.call_async(func)
       end
     end
 
+    private def on_request_failed(request, response_end_timing, failure_text, page)
+      request.send(:update_failure_text, failure_text)
+      request.send(:update_response_end_timing, response_end_timing)
+      emit(Events::BrowserContext::RequestFailed, request)
+      page&.emit(Events::Page::RequestFailed, request)
+    end
+
+    private def on_request_finished(request, response_end_timing, page)
+      request.send(:update_response_end_timing, response_end_timing)
+      emit(Events::BrowserContext::RequestFinished, request)
+      page&.emit(Events::Page::RequestFinished, request)
+    end
+
+    private def on_request(request, page)
+      emit(Events::BrowserContext::Request, request)
+      page&.emit(Events::Page::Request, request)
+    end
+
+    private def on_response(response, page)
+      emit(Events::BrowserContext::Response, response)
+      page&.emit(Events::Page::Response, response)
+    end
+
     def set_default_navigation_timeout(timeout)
       @timeout_settings.default_navigation_timeout = timeout
       @channel.send_message_to_server('setDefaultNavigationTimeoutNoReply', timeout: timeout)
@@ -60,10 +113,17 @@ module Playwright
     end
 
     # @returns [Playwright::Page]
-    def new_page
+    def new_page(&block)
       raise 'Please use browser.new_context' if @owner_page
       resp = @channel.send_message_to_server('newPage')
-      ChannelOwners::Page.from(resp)
+      page = ChannelOwners::Page.from(resp)
+      return page unless block
+
+      begin
+        block.call(page)
+      ensure
+        page.close
+      end
     end
 
     def cookies(urls: nil)
@@ -172,15 +232,14 @@ module Playwright
     end
 
     private def on_close
-      @closed_or_closing = true
       @browser&.send(:remove_context, self)
       emit(Events::BrowserContext::Close)
+      @closed_promise.fulfill(true)
     end
 
     def close
-      return if @closed_or_closing
-      @closed_or_closing = true
       @channel.send_message_to_server('close')
+      @closed_promise.value!
       nil
     rescue => err
       raise unless safe_close_error?(err)

data/lib/playwright/channel_owners/browser_type.rb

@@ -11,29 +11,33 @@ module Playwright
     def launch(options, &block)
       resp = @channel.send_message_to_server('launch', options.compact)
       browser = ChannelOwners::Browser.from(resp)
+      return browser unless block
 
-      if block
-        begin
-          block.call(browser)
-        ensure
-          browser.close
-        end
-      else
-        browser
+      begin
+        block.call(browser)
+      ensure
+        browser.close
       end
     end
 
-    def connect_over_cdp(endpointURL, slowMo: nil, timeout: nil, &block)
+    def connect_over_cdp(endpointURL, headers: nil, slowMo: nil, timeout: nil, &block)
       raise 'Connecting over CDP is only supported in Chromium.' unless name == 'chromium'
 
       params = {
         sdkLanguage: 'ruby',
         endpointURL: endpointURL,
+        headers: headers,
         slowMo: slowMo,
         timeout: timeout,
       }.compact
+
+      if headers
+        params[:headers] = HttpHeaders.new(headers).as_serialized
+      end
+
       result = @channel.send_message_to_server_result('connectOverCDP', params)
       browser = ChannelOwners::Browser.from(result['browser'])
+      browser.send(:update_as_remote)
 
       if result['defaultContext']
         context = ChannelOwners::BrowserContext.from(result['defaultContext'])

data/lib/playwright/channel_owners/element_handle.rb

@@ -76,12 +76,13 @@ module Playwright
         nil
       end
 
-      def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
+      def hover(force: nil, modifiers: nil, position: nil, timeout: nil, trial: nil)
         params = {
           force: force,
           modifiers: modifiers,
           position: position,
           timeout: timeout,
+          trial: trial,
         }.compact
         @channel.send_message_to_server('hover', params)
 
@@ -96,7 +97,8 @@ module Playwright
             modifiers: nil,
             noWaitAfter: nil,
             position: nil,
-            timeout: nil)
+            timeout: nil,
+            trial: nil)
 
         params = {
           button: button,
@@ -107,6 +109,7 @@ module Playwright
           noWaitAfter: noWaitAfter,
           position: position,
           timeout: timeout,
+          trial: trial,
         }.compact
         @channel.send_message_to_server('click', params)
 
@@ -120,7 +123,8 @@ module Playwright
             modifiers: nil,
             noWaitAfter: nil,
             position: nil,
-            timeout: nil)
+            timeout: nil,
+            trial: nil)
 
         params = {
           button: button,
@@ -130,6 +134,7 @@ module Playwright
           noWaitAfter: noWaitAfter,
           position: position,
           timeout: timeout,
+          trial: trial,
         }.compact
         @channel.send_message_to_server('dblclick', params)
 
@@ -158,7 +163,8 @@ module Playwright
             modifiers: nil,
             noWaitAfter: nil,
             position: nil,
-            timeout: nil)
+            timeout: nil,
+            trial: nil)
 
         params = {
           force: force,
@@ -166,6 +172,7 @@ module Playwright
           noWaitAfter: noWaitAfter,
           position: position,
           timeout: timeout,
+          trial: trial,
         }.compact
         @channel.send_message_to_server('tap', params)
 
@@ -228,24 +235,26 @@ module Playwright
         nil
       end
 
-      def check(force: nil, noWaitAfter: nil, position: nil, timeout: nil)
+      def check(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil)
         params = {
           force: force,
           noWaitAfter:  noWaitAfter,
           position: position,
           timeout: timeout,
+          trial: trial,
         }.compact
         @channel.send_message_to_server('check', params)
 
         nil
       end
 
-      def uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil)
+      def uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil)
         params = {
           force: force,
           noWaitAfter:  noWaitAfter,
           position: position,
           timeout: timeout,
+          trial: trial,
         }.compact
         @channel.send_message_to_server('uncheck', params)
 
@@ -292,19 +301,11 @@ module Playwright
       end
 
       def eval_on_selector(selector, pageFunction, arg: nil)
-        if JavaScript.function?(pageFunction)
-          JavaScript::Function.new(pageFunction, arg).eval_on_selector(@channel, selector)
-        else
-          JavaScript::Expression.new(pageFunction).eval_on_selector(@channel, selector)
-        end
+        JavaScript::Expression.new(pageFunction, arg).eval_on_selector(@channel, selector)
       end
 
       def eval_on_selector_all(selector, pageFunction, arg: nil)
-        if JavaScript.function?(pageFunction)
-          JavaScript::Function.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
-        else
-          JavaScript::Expression.new(pageFunction).eval_on_selector_all(@channel, selector)
-        end
+        JavaScript::Expression.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
       end
 
       def wait_for_element_state(state, timeout: nil)

data/lib/playwright/channel_owners/frame.rb

@@ -132,19 +132,11 @@ module Playwright
     end
 
     def evaluate(pageFunction, arg: nil)
-      if JavaScript.function?(pageFunction)
-        JavaScript::Function.new(pageFunction, arg).evaluate(@channel)
-      else
-        JavaScript::Expression.new(pageFunction).evaluate(@channel)
-      end
+      JavaScript::Expression.new(pageFunction, arg).evaluate(@channel)
     end
 
     def evaluate_handle(pageFunction, arg: nil)
-      if JavaScript.function?(pageFunction)
-        JavaScript::Function.new(pageFunction, arg).evaluate_handle(@channel)
-      else
-        JavaScript::Expression.new(pageFunction).evaluate_handle(@channel)
-      end
+      JavaScript::Expression.new(pageFunction, arg).evaluate_handle(@channel)
     end
 
     def query_selector(selector)
@@ -208,19 +200,11 @@ module Playwright
     end
 
     def eval_on_selector(selector, pageFunction, arg: nil)
-      if JavaScript.function?(pageFunction)
-        JavaScript::Function.new(pageFunction, arg).eval_on_selector(@channel, selector)
-      else
-        JavaScript::Expression.new(pageFunction).eval_on_selector(@channel, selector)
-      end
+      JavaScript::Expression.new(pageFunction, arg).eval_on_selector(@channel, selector)
     end
 
     def eval_on_selector_all(selector, pageFunction, arg: nil)
-      if JavaScript.function?(pageFunction)
-        JavaScript::Function.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
-      else
-        JavaScript::Expression.new(pageFunction).eval_on_selector_all(@channel, selector)
-      end
+      JavaScript::Expression.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
     end
 
     def content
@@ -289,7 +273,8 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
+          timeout: nil,
+          trial: nil)
 
       params = {
         selector: selector,
@@ -301,6 +286,7 @@ module Playwright
         noWaitAfter: noWaitAfter,
         position: position,
         timeout: timeout,
+        trial: trial,
       }.compact
       @channel.send_message_to_server('click', params)
 
@@ -315,7 +301,8 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
+          timeout: nil,
+          trial: nil)
 
       params = {
         selector: selector,
@@ -326,6 +313,7 @@ module Playwright
         noWaitAfter: noWaitAfter,
         position: position,
         timeout: timeout,
+        trial: trial,
       }.compact
       @channel.send_message_to_server('dblclick', params)
 
@@ -338,7 +326,8 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
+          timeout: nil,
+          trial: nil)
       params = {
         selector: selector,
         force: force,
@@ -346,6 +335,7 @@ module Playwright
         noWaitAfter: noWaitAfter,
         position: position,
         timeout: timeout,
+        trial: trial,
       }.compact
       @channel.send_message_to_server('tap', params)
 
@@ -399,13 +389,15 @@ module Playwright
           force: nil,
           modifiers: nil,
           position: nil,
-          timeout: nil)
+          timeout: nil,
+          trial: nil)
       params = {
         selector: selector,
         force: force,
         modifiers: modifiers,
         position: position,
         timeout: timeout,
+        trial: trial,
       }.compact
       @channel.send_message_to_server('hover', params)
 
@@ -481,7 +473,8 @@ module Playwright
       force: nil,
       noWaitAfter: nil,
       position: nil,
-      timeout: nil)
+      timeout: nil,
+      trial: nil)
 
       params = {
         selector: selector,
@@ -489,6 +482,7 @@ module Playwright
         noWaitAfter:  noWaitAfter,
         position: position,
         timeout: timeout,
+        trial: trial,
       }.compact
       @channel.send_message_to_server('check', params)
 
@@ -500,7 +494,8 @@ module Playwright
       force: nil,
       noWaitAfter: nil,
       position: nil,
-      timeout: nil)
+      timeout: nil,
+      trial: nil)
 
       params = {
         selector: selector,
@@ -508,6 +503,7 @@ module Playwright
         noWaitAfter:  noWaitAfter,
         position: position,
         timeout: timeout,
+        trial: trial,
       }.compact
       @channel.send_message_to_server('uncheck', params)
 
@@ -519,14 +515,8 @@ module Playwright
         raise ArgumentError.new("Unknown polling option: #{polling}")
       end
 
-      function_or_expression =
-        if JavaScript.function?(pageFunction)
-          JavaScript::Function.new(pageFunction, arg)
-        else
-          JavaScript::Expression.new(pageFunction)
-        end
-
-      function_or_expression.wait_for_function(@channel, polling: polling, timeout: timeout)
+      expression = JavaScript::Expression.new(pageFunction, arg)
+      expression.wait_for_function(@channel, polling: polling, timeout: timeout)
     end
 
     def title