playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/channel_owners/browser_type.rb

@@ -1,5 +1,15 @@
 module Playwright
   define_channel_owner :BrowserType do
+    include Utils::PrepareBrowserContextOptions
+
+    private def after_initialize
+      @timeout_settings = TimeoutSettings.new
+    end
+
+    private def update_playwright(playwright)
+      @playwright = playwright
+    end
+
     def name
       @initializer['name']
     end
@@ -9,8 +19,65 @@ module Playwright
     end
 
     def launch(options, &block)
-      resp = @channel.send_message_to_server('launch', options.compact)
+      params = options.dup
+      params[:timeout] ||= @timeout_settings.launch_timeout
+      resp = @channel.send_message_to_server('launch', params.compact)
       browser = ChannelOwners::Browser.from(resp)
+      browser.send(:connect_to_browser_type, self, params[:tracesDir])
+      return browser unless block
+
+      begin
+        block.call(browser)
+      ensure
+        browser.close
+      end
+    end
+
+    def launch_persistent_context(userDataDir, **options, &block)
+      params = options.dup
+      prepare_browser_context_options(params)
+      params['userDataDir'] = userDataDir
+      params[:timeout] ||= @timeout_settings.launch_timeout
+
+      result = @channel.send_message_to_server_result('launchPersistentContext', params.compact)
+      browser = ChannelOwners::Browser.from(result['browser'])
+      browser.send(:connect_to_browser_type, self, params[:tracesDir])
+      context = ChannelOwners::BrowserContext.from(result['context'])
+      context.send(:initialize_har_from_options,
+        record_har_content: params[:record_har_content],
+        record_har_mode: params[:record_har_mode],
+        record_har_omit_content: params[:record_har_omit_content],
+        record_har_path: params[:record_har_path],
+        record_har_url_filter: params[:record_har_url_filter],
+      )
+
+      return context unless block
+
+      begin
+        block.call(context)
+      ensure
+        context.close
+      end
+    end
+
+    def connect_over_cdp(endpointURL, headers: nil, isLocal: nil, slowMo: nil, timeout: nil, &block)
+      raise 'Connecting over CDP is only supported in Chromium.' unless name == 'chromium'
+
+      params = {
+        endpointURL: endpointURL,
+        headers: headers,
+        isLocal: isLocal,
+        slowMo: slowMo,
+        timeout: @timeout_settings.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(:connect_to_browser_type, self, nil)
 
       if block
         begin
@@ -22,5 +89,27 @@ module Playwright
         browser
       end
     end
+
+    private def did_create_context(context, context_options = {}, browser_options = {})
+      context.send(:update_options, context_options: context_options, browser_options: browser_options)
+    end
+
+    private def update_with_playwright_selectors_options(options)
+      selectors = @playwright&.selectors
+      if selectors
+        selectors.send(:update_with_selector_options, options)
+      else
+        options
+      end
+    end
+
+    private def playwright_selectors_browser_contexts
+      selectors = @playwright&.selectors
+      if selectors
+        selectors.send(:contexts_for_selectors)
+      else
+        []
+      end
+    end
   end
 end

data/lib/playwright/channel_owners/cdp_session.rb

@@ -0,0 +1,19 @@
+module Playwright
+  define_channel_owner :CDPSession do
+    private def after_initialize
+      @channel.on('event', method(:on_event))
+    end
+
+    private def on_event(params)
+      emit(params['method'], params['params'])
+    end
+
+    def send_message(method, params: {})
+      @channel.send_message_to_server('send', method: method, params: params)
+    end
+
+    def detach
+      @channel.send_message_to_server('detach')
+    end
+  end
+end

data/lib/playwright/channel_owners/dialog.rb

@@ -0,0 +1,32 @@
+module Playwright
+  define_channel_owner :Dialog do
+    def page
+      @page ||= ChannelOwners::Page.from_nullable(@initializer['page'])
+    end
+
+    def type
+      @initializer['type']
+    end
+
+    def message
+      @initializer['message']
+    end
+
+    def default_value
+      @initializer['defaultValue']
+    end
+
+    def accept(promptText: nil)
+      accept_async(promptText: promptText).value!
+    end
+
+    def accept_async(promptText: nil)
+      params = { promptText: promptText }.compact
+      @channel.async_send_message_to_server('accept', params)
+    end
+
+    def dismiss
+      @channel.async_send_message_to_server('dismiss')
+    end
+  end
+end

data/lib/playwright/channel_owners/element_handle.rb

@@ -3,6 +3,11 @@ require_relative './js_handle'
 module Playwright
   module ChannelOwners
     class ElementHandle < JSHandle
+      private def _timeout(timeout)
+        # @parent is Frame
+        @parent.send(:_timeout, timeout)
+      end
+
       def as_element
         self
       end
@@ -69,20 +74,28 @@ module Playwright
 
       def scroll_into_view_if_needed(timeout: nil)
         params = {
-          timeout: timeout,
+          timeout: _timeout(timeout),
         }.compact
         @channel.send_message_to_server('scrollIntoViewIfNeeded', params)
 
         nil
       end
 
-      def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
+      def hover(
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil,
+            trial: nil)
         params = {
           force: force,
           modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
           position: position,
-          timeout: timeout,
-        }
+          timeout: _timeout(timeout),
+          trial: trial,
+        }.compact
         @channel.send_message_to_server('hover', params)
 
         nil
@@ -96,7 +109,9 @@ module Playwright
             modifiers: nil,
             noWaitAfter: nil,
             position: nil,
-            timeout: nil)
+            timeout: nil,
+            trial: nil,
+            steps: nil)
 
         params = {
           button: button,
@@ -106,7 +121,9 @@ module Playwright
           modifiers: modifiers,
           noWaitAfter: noWaitAfter,
           position: position,
-          timeout: timeout,
+          timeout: _timeout(timeout),
+          trial: trial,
+          steps: steps,
         }.compact
         @channel.send_message_to_server('click', params)
 
@@ -120,7 +137,9 @@ module Playwright
             modifiers: nil,
             noWaitAfter: nil,
             position: nil,
-            timeout: nil)
+            timeout: nil,
+            trial: nil,
+            steps: nil)
 
         params = {
           button: button,
@@ -129,19 +148,31 @@ module Playwright
           modifiers: modifiers,
           noWaitAfter: noWaitAfter,
           position: position,
-          timeout: timeout,
+          timeout: _timeout(timeout),
+          trial: trial,
+          steps: steps,
         }.compact
         @channel.send_message_to_server('dblclick', params)
 
         nil
       end
 
-      def select_option(values, noWaitAfter: nil, timeout: nil)
-        base_params = SelectOptionValues.new(values).as_params
-        params = base_params + { noWaitAfter: noWaitAfter, timeout: timeout }.compact
+      def select_option(
+            element: nil,
+            index: nil,
+            value: nil,
+            label: nil,
+            force: nil,
+            noWaitAfter: nil,
+            timeout: nil)
+        base_params = SelectOptionValues.new(
+          element: element,
+          index: index,
+          value: value,
+          label: label,
+        ).as_params
+        params = base_params.merge({ force: force, noWaitAfter: noWaitAfter, timeout: _timeout(timeout) }.compact)
         @channel.send_message_to_server('selectOption', params)
-
-        nil
       end
 
       def tap_point(
@@ -149,42 +180,55 @@ module Playwright
             modifiers: nil,
             noWaitAfter: nil,
             position: nil,
-            timeout: nil)
+            timeout: nil,
+            trial: nil)
 
         params = {
           force: force,
           modifiers: modifiers,
           noWaitAfter: noWaitAfter,
           position: position,
-          timeout: timeout,
+          timeout: _timeout(timeout),
+          trial: trial,
         }.compact
         @channel.send_message_to_server('tap', params)
 
         nil
       end
 
-      def fill(value, noWaitAfter: nil, timeout: nil)
+      def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
         params = {
           value: value,
+          force: force,
           noWaitAfter: noWaitAfter,
-          timeout: timeout,
-        }
+          timeout: _timeout(timeout),
+        }.compact
         @channel.send_message_to_server('fill', params)
 
         nil
       end
 
-      def select_text(timeout: nil)
-        params = { timeout: timeout }.compact
+      def select_text(force: nil, timeout: nil)
+        params = { force: force, timeout: _timeout(timeout) }.compact
         @channel.send_message_to_server('selectText', params)
 
         nil
       end
 
+      def input_value(timeout: nil)
+        params = { timeout: _timeout(timeout) }.compact
+        @channel.send_message_to_server('inputValue', params)
+      end
+
       def set_input_files(files, noWaitAfter: nil, timeout: nil)
-        base_params = InputFiles.new(values).as_params
-        params = base_params + { noWaitAfter: noWaitAfter, timeout: timeout }.compact
-        @channel.send_message_to_server('setInputFiles', params)
+        frame = owner_frame
+        unless frame
+          raise 'Cannot set input files to detached element'
+        end
+
+        method_name, params = InputFiles.new(frame.page.context, files).as_method_and_params
+        params.merge!({ noWaitAfter: noWaitAfter, timeout: _timeout(timeout) }.compact)
+        @channel.send_message_to_server(method_name, params)
 
         nil
       end
@@ -200,7 +244,7 @@ module Playwright
           text: text,
           delay: delay,
           noWaitAfter: noWaitAfter,
-          timeout: timeout,
+          timeout: _timeout(timeout),
         }.compact
         @channel.send_message_to_server('type', params)
 
@@ -212,53 +256,81 @@ module Playwright
           key: key,
           delay: delay,
           noWaitAfter: noWaitAfter,
-          timeout: timeout,
+          timeout: _timeout(timeout),
         }.compact
         @channel.send_message_to_server('press', params)
 
         nil
       end
 
-      def check(force: nil, noWaitAfter: nil, timeout: nil)
+      def check(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil)
         params = {
           force: force,
           noWaitAfter:  noWaitAfter,
-          timeout: timeout,
+          position: position,
+          timeout: _timeout(timeout),
+          trial: trial,
         }.compact
         @channel.send_message_to_server('check', params)
 
         nil
       end
 
-      def uncheck(force: nil, noWaitAfter: nil, timeout: nil)
+      def uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil)
         params = {
           force: force,
           noWaitAfter:  noWaitAfter,
-          timeout: timeout,
+          position: position,
+          timeout: _timeout(timeout),
+          trial: trial,
         }.compact
         @channel.send_message_to_server('uncheck', params)
 
         nil
       end
 
+      def set_checked(checked, **options)
+        if checked
+          check(**options)
+        else
+          uncheck(**options)
+        end
+      end
+
       def bounding_box
         @channel.send_message_to_server('boundingBox')
       end
 
       def screenshot(
+        animations: nil,
+        caret: nil,
+        mask: nil,
+        maskColor: nil,
         omitBackground: nil,
         path: nil,
         quality: nil,
+        scale: nil,
+        style: nil,
         timeout: nil,
         type: nil)
 
         params = {
+          animations: animations,
+          caret: caret,
+          maskColor: maskColor,
           omitBackground: omitBackground,
           path: path,
           quality: quality,
-          timeout: timeout,
+          scale: scale,
+          style: style,
+          timeout: _timeout(timeout),
           type: type,
         }.compact
+        if mask.is_a?(Enumerable)
+          params[:mask] = mask.map do |locator|
+            locator.send(:to_protocol)
+          end
+        end
         encoded_binary = @channel.send_message_to_server('screenshot', params)
         decoded_binary = Base64.strict_decode64(encoded_binary)
         if path
@@ -281,30 +353,22 @@ 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)
-        params = { state: state, timeout: timeout }.compact
+        params = { state: state, timeout: _timeout(timeout) }.compact
         @channel.send_message_to_server('waitForElementState', params)
 
         nil
       end
 
-      def wait_for_selector(selector, state: nil, timeout: nil)
-        params = { selector: selector, state: state, timeout: timeout }.compact
+      def wait_for_selector(selector, state: nil, strict: nil, timeout: nil)
+        params = { selector: selector, state: state, strict: strict, timeout: _timeout(timeout) }.compact
         resp = @channel.send_message_to_server('waitForSelector', params)
 
         ChannelOwners::ElementHandle.from_nullable(resp)

data/lib/playwright/channel_owners/fetch_request.rb

@@ -0,0 +1,8 @@
+require_relative './api_request_context'
+
+module Playwright
+  module ChannelOwners
+    class FetchRequest < APIRequestContext
+    end
+  end
+end