playwright-ruby-client 1.37.1 → 1.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00d50bbadac84d3bfa4881ee450991e7e0999c9ca5daab2343bceb885d90522b
-  data.tar.gz: 16bfdd05cc45587c02a89a9e9098c32a518c3e6b81e254524393e71b47483391
+  metadata.gz: 421d718c0a7b5e649fe2632e9f193ef66722149f63a52ba0c1baa63252a0b99d
+  data.tar.gz: 0fb410e0d38bff1cd589afa3499ac3938c1897220be2a7c9ebcf7bddfa4c157c
 SHA512:
-  metadata.gz: 4e936a99c032fb86e7865cc8880c6679a23b2d621624a98b31d528a7c9d9886851b02b6cb9bab43937bf85b85a2d27ee2cbb0d15d25a11f2962066991531eac0
-  data.tar.gz: 5e3c6c5bf4af0df7129d6c5ed1ebd6b29928ed68b10b698eb3385ac414c3a04a7ec4a96b964feffa6a65e2f96a7821c3dea8e5b841d186312a66ec1ad53ad825
+  metadata.gz: da207f741063627b79efb045adff0af67c935926f30cc5086da9fcf2ccf80555c2f449dc57b2cd953d939c0117ed4f6050c93c8ad35a3d9e654b0141d75e1c53
+  data.tar.gz: eac5d5f995949b5e6e925016e2f0ab3ad4dd6c92766e8204023fa84f1a2b50d157659f9bdbb1fcac6500fae64752632b3ed3dfcd6fb042c07706f3ce30c00b48

data/README.md

@@ -51,18 +51,24 @@ Playwright.create(playwright_cli_executable_path: './node_modules/.bin/playwrigh
     page = browser.new_page
     page.goto('https://github.com/')
 
-    form = page.query_selector("form.js-site-search-form")
-    search_input = form.query_selector("input.header-search-input")
-    search_input.click
+    page.get_by_placeholder("Search or jump to...").click
+    page.locator('input[name="query-builder-test"]').click
+
+    expect(page.keyboard).to be_a(::Playwright::Keyboard)
+
     page.keyboard.type("playwright")
     page.expect_navigation {
       page.keyboard.press("Enter")
     }
 
-    list = page.query_selector("ul.repo-list")
-    items = list.query_selector_all("div.f4")
-    items.each do |item|
-      title = item.eval_on_selector("a", "a => a.innerText")
+    list = page.get_by_test_id('results-list').locator('.search-title')
+
+    # wait for item to appear
+    list.first.wait_for
+
+    # list them
+    list.locator('.search-title').all.each do |item|
+      title = item.text_content
       puts("==> #{title}")
     end
   end

data/documentation/docs/api/download.md

@@ -10,15 +10,18 @@ sidebar_position: 10
 All the downloaded files belonging to the browser context are deleted when the
 browser context is closed.
 
-Download event is emitted once the download starts. Download path becomes available once download completes:
+Download event is emitted once the download starts. Download path becomes available once download completes.
 
-```ruby
-download = page.expect_download do
-  page.get_by_text("Download file").click
-end
+```python sync title=example_c247767083cf193df26a39a61a3a8bc19d63ed5c24db91b88c50b7d37975005d.py
+# Start waiting for the download
+with page.expect_download() as download_info:
+    # Perform the action that initiates download
+    page.get_by_text("Download file").click()
+download = download_info.value
+
+# Wait for the download process to complete and save the downloaded file somewhere
+download.save_as("/path/to/save/at/" + download.suggested_filename)
 
-# wait for download to complete
-path = download.path
 ```
 
 ## cancel
@@ -81,6 +84,13 @@ def save_as(path)
 Copy the download to a user-specified path. It is safe to call this method while the download
 is still in progress. Will wait for the download to finish if necessary.
 
+**Usage**
+
+```python sync title=example_66ffd4ef7286957e4294d84b8f660ff852c87af27a56b3e4dd9f84562b5ece02.py
+download.save_as("/path/to/save/at/" + download.suggested_filename)
+
+```
+
 ## suggested_filename
 
 ```

data/documentation/docs/api/element_handle.md

@@ -259,7 +259,7 @@ This method waits for [actionability](https://playwright.dev/python/docs/actiona
 
 If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
 
-To send fine-grained keyboard events, use [ElementHandle#type](./element_handle#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## focus
 
@@ -614,19 +614,6 @@ To press a special key, like `Control` or `ArrowDown`, use [ElementHandle#press]
 
 **Usage**
 
-```ruby
-element_handle.type("hello") # types instantly
-element_handle.type("world", delay: 100) # types slower, like a user
-```
-
-An example of typing into a text field and then submitting the form:
-
-```ruby
-element_handle = page.query_selector("input")
-element_handle.type("some text")
-element_handle.press("Enter")
-```
-
 ## uncheck
 
 ```

data/documentation/docs/api/frame.md

@@ -349,7 +349,7 @@ This method waits for an element matching `selector`, waits for [actionability](
 
 If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
 
-To send fine-grained keyboard events, use [Frame#type](./frame#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## focus
 
@@ -1041,11 +1041,6 @@ To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./ke
 
 **Usage**
 
-```ruby
-frame.type("#mytextarea", "hello") # types instantly
-frame.type("#mytextarea", "world", delay: 100) # types slower, like a user
-```
-
 ## uncheck
 
 ```

data/documentation/docs/api/keyboard.md

@@ -97,6 +97,8 @@ def press(key, delay: nil)
 ```
 
 
+**NOTE**: In most cases, you should use [Locator#press](./locator#press) instead.
+
 `key` can specify the intended
 [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to
 generate the text for. A superset of the `key` values can be found
@@ -136,6 +138,8 @@ def type(text, delay: nil)
 ```
 
 
+**NOTE**: In most cases, you should use [Locator#fill](./locator#fill) instead. You only need to press keys one by one if there is special keyboard handling on the page - in this case use [Locator#press_sequentially](./locator#press_sequentially).
+
 Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
 
 To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./keyboard#press).

data/documentation/docs/api/locator.md

@@ -458,7 +458,7 @@ This method waits for [actionability](https://playwright.dev/python/docs/actiona
 
 If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
 
-To send fine-grained keyboard events, use [Locator#type](./locator#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## filter
 
@@ -1032,6 +1032,36 @@ respective texts.
 Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified with the
 modifier, modifier is pressed and being held while the subsequent key is being pressed.
 
+## press_sequentially
+
+```
+def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+```
+
+
+**NOTE**: In most cases, you should use [Locator#fill](./locator#fill) instead. You only need to press keys one by one if there is special keyboard handling on the page.
+
+Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+
+To press a special key, like `Control` or `ArrowDown`, use [Locator#press](./locator#press).
+
+**Usage**
+
+```python sync title=example_1b7781d5527574a18d4b9812e3461203d2acc9ba7e09cbfd0ffbc4154e3f5971.py
+locator.press_sequentially("hello") # types instantly
+locator.press_sequentially("world", delay=100) # types slower, like a user
+
+```
+
+An example of typing into a text field and then submitting the form:
+
+```python sync title=example_cc0a6b9aa95b97e5c17c4b114da10a29c7f6f793e99aee1ea2703636af6e24f9.py
+locator = page.get_by_label("Password")
+locator.press_sequentially("my password")
+locator.press("Enter")
+
+```
+
 ## screenshot
 
 ```
@@ -1254,27 +1284,12 @@ def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
 ```
 
 
-**NOTE**: In most cases, you should use [Locator#fill](./locator#fill) instead. You only need to type characters if there is special keyboard handling on the page.
-
 Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
 
 To press a special key, like `Control` or `ArrowDown`, use [Locator#press](./locator#press).
 
 **Usage**
 
-```ruby
-element.type("hello") # types instantly
-element.type("world", delay: 100) # types slower, like a user
-```
-
-An example of typing into a text field and then submitting the form:
-
-```ruby
-element = page.get_by_label("Password")
-element.type("my password")
-element.press("Enter")
-```
-
 ## uncheck
 
 ```

data/documentation/docs/api/page.md

@@ -554,7 +554,7 @@ This method waits for an element matching `selector`, waits for [actionability](
 
 If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
 
-To send fine-grained keyboard events, use [Page#type](./page#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## focus
 
@@ -1519,11 +1519,6 @@ To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./ke
 
 **Usage**
 
-```ruby
-page.type("#mytextarea", "hello") # types instantly
-page.type("#mytextarea", "world", delay: 100) # types slower, like a user
-```
-
 ## uncheck
 
 ```

data/documentation/docs/api/request.md

@@ -54,6 +54,20 @@ def frame
 
 Returns the [Frame](./frame) that initiated this request.
 
+**Usage**
+
+```ruby
+frame_url = request.frame.url
+```
+
+**Details**
+
+Note that in some cases the frame is not available, and this method will throw.
+- When request originates in the Service Worker. You can use `request.serviceWorker()` to check that.
+- When navigation request is issued before the corresponding frame is created. You can use [Request#navigation_request?](./request#navigation_request?) to check that.
+
+Here is an example that handles all the cases:
+
 ## headers
 
 ```
@@ -93,6 +107,9 @@ def navigation_request?
 
 Whether this request is driving frame's navigation.
 
+Some navigation requests are issued before the corresponding frame is created, and therefore
+do not have [Request#frame](./request#frame) available.
+
 ## method
 
 ```

data/documentation/docs/include/api_coverage.md

@@ -470,6 +470,7 @@
 * or
 * page
 * press
+* press_sequentially
 * screenshot
 * scroll_into_view_if_needed
 * select_option

data/lib/playwright/channel_owners/browser_context.rb

@@ -38,6 +38,12 @@ module Playwright
       @channel.on('console', ->(params) {
         on_console_message(ChannelOwners::ConsoleMessage.from(params['message']))
       })
+      @channel.on('pageError', ->(params) {
+        on_page_error(
+          Error.parse(params['error']['error']),
+          ChannelOwners::Page.from_nullable(params['page']),
+        )
+      })
       @channel.on('dialog', ->(params) {
         on_dialog(ChannelOwners::Dialog.from(params['dialog']))
       })
@@ -97,6 +103,8 @@ module Playwright
     end
 
     private def on_route(route)
+      route.send(:update_context, self)
+
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
       # Just a workaround...
@@ -177,6 +185,13 @@ module Playwright
       end
     end
 
+    private def on_page_error(error, page)
+      emit(Events::BrowserContext::WebError, WebError.new(error, page))
+      if page
+        page.emit(Events::Page::PageError, error)
+      end
+    end
+
     private def on_request(request, page)
       emit(Events::BrowserContext::Request, request)
       page&.emit(Events::Page::Request, request)

data/lib/playwright/channel_owners/page.rb

@@ -96,6 +96,8 @@ module Playwright
     end
 
     private def on_route(route)
+      route.send(:update_context, self)
+
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
       # Just a workaround...

data/lib/playwright/channel_owners/request.rb

@@ -86,8 +86,24 @@ module Playwright
       ChannelOwners::Response.from_nullable(resp)
     end
 
+    class FramePageNotReadyError < StandardError
+      MESSAGE = [
+        'Frame for this navigation request is not available, because the request',
+        'was issued before the frame is created. You can check whether the request',
+        'is a navigation request by calling isNavigationRequest() method.',
+      ].join('\n').freeze
+
+      def initialize
+        super(MESSAGE)
+      end
+    end
+
     def frame
-      ChannelOwners::Frame.from(@initializer['frame'])
+      ChannelOwners::Frame.from(@initializer['frame']).tap do |result|
+        unless result.page
+          raise FramePageNotReadyError.new
+        end
+      end
     end
 
     def navigation_request?

data/lib/playwright/channel_owners/route.rb

@@ -111,7 +111,7 @@ module Playwright
     end
 
     def fetch(headers: nil, method: nil, postData: nil, url: nil, maxRedirects: nil, timeout: nil)
-      api_request_context = request.frame.page.context.request
+      api_request_context = @context.request
       api_request_context.send(:_inner_fetch,
         request,
         url,
@@ -172,5 +172,9 @@ module Playwright
       mime_types = MIME::Types.type_for(filepath)
       mime_types.first.to_s || 'application/octet-stream'
     end
+
+    private def update_context(context)
+      @context = context
+    end
   end
 end

data/lib/playwright/errors.rb

@@ -5,13 +5,13 @@ module Playwright
       if error_payload['name'] == 'TimeoutError'
         TimeoutError.new(
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       else
         new(
           name: error_payload['name'],
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       end
     end
@@ -25,6 +25,8 @@ module Playwright
       @message = message
       @stack = stack
     end
+
+    attr_reader :name, :message, :stack
   end
 
   class DriverCrashedError < StandardError
@@ -38,4 +40,13 @@ module Playwright
       super(name: 'TimeoutError', message: message, stack: stack)
     end
   end
+
+  class WebError
+    def initialize(error, page)
+      @error = error
+      @page = PlaywrightApi.wrap(page)
+    end
+
+    attr_reader :error, :page
+  end
 end

data/lib/playwright/events.rb

@@ -29,6 +29,7 @@ end
     Console: 'console',
     Dialog: 'dialog',
     Page: 'page',
+    WebError: 'weberror',
     ServiceWorker: 'serviceworker',
     Request: 'request',
     Response: 'response',

data/lib/playwright/javascript/value_parser.rb

@@ -56,6 +56,14 @@ module Playwright
           return hash['bi'].to_i
         end
 
+        if hash.key?('m')
+          return parse_hash(hash['m']).to_h
+        end
+
+        if hash.key?('se')
+          return Set.new(parse_hash(hash['se']))
+        end
+
         if hash.key?('r')
           # @see https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/RegExp
           # @see https://docs.ruby-lang.org/ja/latest/class/Regexp.html

data/lib/playwright/javascript/value_serializer.rb

@@ -56,11 +56,17 @@ module Playwright
           result = []
           value.each { |v| result << serialize_value(v) }
           { a: result, id: id }
+        when Set
+          { se: serialize_value(value.to_a) }
         when Hash
-          id = @visited.log(value)
-          result = []
-          value.each { |key, v| result << { k: key, v: serialize_value(v) } }
-          { o: result, id: id }
+          if value.any? { |k, v| !k.is_a?(String) && !k.is_a?(Symbol) } # Map
+            { m: serialize_value(value.to_a) }
+          else
+            id = @visited.log(value)
+            result = []
+            value.each { |key, v| result << { k: key, v: serialize_value(v) } }
+            { o: result, id: id }
+          end
         else
           raise ArgumentError.new("Unexpected value: #{value}")
         end

data/lib/playwright/locator_impl.rb

@@ -446,6 +446,10 @@ module Playwright
       @frame.type(@selector, text, strict: true, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
+    def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      type(text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
     def uncheck(
           force: nil,
           noWaitAfter: nil,

data/lib/playwright/utils.rb

@@ -61,6 +61,10 @@ module Playwright
           end
         end
 
+        if params[:acceptDownloads] || params[:acceptDownloads] == false
+          params[:acceptDownloads] = params[:acceptDownloads] ? 'accept' : 'deny'
+        end
+
         params
       end
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.37.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.37.0'
+  VERSION = '1.38.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.38.0'
 end

data/lib/playwright_api/download.rb

@@ -5,14 +5,17 @@ module Playwright
   # All the downloaded files belonging to the browser context are deleted when the
   # browser context is closed.
   #
-  # Download event is emitted once the download starts. Download path becomes available once download completes:
+  # Download event is emitted once the download starts. Download path becomes available once download completes.
   #
   # ```python sync
+  # # Start waiting for the download
   # with page.expect_download() as download_info:
+  #     # Perform the action that initiates download
   #     page.get_by_text("Download file").click()
   # download = download_info.value
-  # # wait for download to complete
-  # path = download.path()
+  #
+  # # Wait for the download process to complete and save the downloaded file somewhere
+  # download.save_as("/path/to/save/at/" + download.suggested_filename)
   # ```
   class Download < PlaywrightApi
 
@@ -54,6 +57,12 @@ module Playwright
     #
     # Copy the download to a user-specified path. It is safe to call this method while the download
     # is still in progress. Will wait for the download to finish if necessary.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # download.save_as("/path/to/save/at/" + download.suggested_filename)
+    # ```
     def save_as(path)
       wrap_impl(@impl.save_as(unwrap_impl(path)))
     end

data/lib/playwright_api/element_handle.rb

@@ -224,7 +224,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: ElementHandle.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -503,19 +503,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: ElementHandle.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # element_handle.type("hello") # types instantly
-    # element_handle.type("world", delay=100) # types slower, like a user
-    # ```
-    #
-    # An example of typing into a text field and then submitting the form:
-    #
-    # ```python sync
-    # element_handle = page.query_selector("input")
-    # element_handle.type("some text")
-    # element_handle.press("Enter")
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end

data/lib/playwright_api/frame.rb

@@ -300,7 +300,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Frame.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(
           selector,
           value,
@@ -867,11 +867,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # frame.type("#mytextarea", "hello") # types instantly
-    # frame.type("#mytextarea", "world", delay=100) # types slower, like a user
-    # ```
     def type(
           selector,
           text,

data/lib/playwright_api/keyboard.rb

@@ -81,6 +81,8 @@ module Playwright
       wrap_impl(@impl.insert_text(unwrap_impl(text)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.press`] instead.
     #
     # `key` can specify the intended
     # [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to
@@ -119,6 +121,8 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to press keys one by one if there is special keyboard handling on the page - in this case use [`method: Locator.pressSequentially`].
     #
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #

data/lib/playwright_api/locator.rb

@@ -391,7 +391,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Locator.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -869,6 +869,31 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to press keys one by one if there is special keyboard handling on the page.
+    #
+    # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+    #
+    # To press a special key, like `Control` or `ArrowDown`, use [`method: Locator.press`].
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # locator.press_sequentially("hello") # types instantly
+    # locator.press_sequentially("world", delay=100) # types slower, like a user
+    # ```
+    #
+    # An example of typing into a text field and then submitting the form:
+    #
+    # ```python sync
+    # locator = page.get_by_label("Password")
+    # locator.press_sequentially("my password")
+    # locator.press("Enter")
+    # ```
+    def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      wrap_impl(@impl.press_sequentially(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    end
+
     #
     # Take a screenshot of the element matching the locator.
     #
@@ -1066,27 +1091,12 @@ module Playwright
       wrap_impl(@impl.text_content(timeout: unwrap_impl(timeout)))
     end
 
-    #
-    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to type characters if there is special keyboard handling on the page.
     #
     # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Locator.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # element.type("hello") # types instantly
-    # element.type("world", delay=100) # types slower, like a user
-    # ```
-    #
-    # An example of typing into a text field and then submitting the form:
-    #
-    # ```python sync
-    # element = page.get_by_label("Password")
-    # element.type("my password")
-    # element.press("Enter")
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end

data/lib/playwright_api/page.rb

@@ -532,7 +532,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Page.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(
           selector,
           value,
@@ -1340,11 +1340,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # page.type("#mytextarea", "hello") # types instantly
-    # page.type("#mytextarea", "world", delay=100) # types slower, like a user
-    # ```
     def type(
           selector,
           text,

data/lib/playwright_api/request.rb

@@ -37,6 +37,20 @@ module Playwright
 
     #
     # Returns the `Frame` that initiated this request.
+    #
+    # **Usage**
+    #
+    # ```py
+    # frame_url = request.frame.url
+    # ```
+    #
+    # **Details**
+    #
+    # Note that in some cases the frame is not available, and this method will throw.
+    # - When request originates in the Service Worker. You can use `request.serviceWorker()` to check that.
+    # - When navigation request is issued before the corresponding frame is created. You can use [`method: Request.isNavigationRequest`] to check that.
+    #
+    # Here is an example that handles all the cases:
     def frame
       wrap_impl(@impl.frame)
     end
@@ -64,6 +78,9 @@ module Playwright
 
     #
     # Whether this request is driving frame's navigation.
+    #
+    # Some navigation requests are issued before the corresponding frame is created, and therefore
+    # do not have [`method: Request.frame`] available.
     def navigation_request?
       wrap_impl(@impl.navigation_request?)
     end

data/lib/playwright_api/worker.rb

@@ -47,13 +47,13 @@ module Playwright
     end
 
     # @nodoc
-    def page=(req)
-      wrap_impl(@impl.page=(unwrap_impl(req)))
+    def context=(req)
+      wrap_impl(@impl.context=(unwrap_impl(req)))
     end
 
     # @nodoc
-    def context=(req)
-      wrap_impl(@impl.context=(unwrap_impl(req)))
+    def page=(req)
+      wrap_impl(@impl.page=(unwrap_impl(req)))
     end
 
     # -- inherited from EventEmitter --

data/sig/playwright.rbs

@@ -483,6 +483,7 @@ module Playwright
     def or: (Locator locator) -> Locator
     def page: -> Page
     def press: (String key, ?delay: Float, ?noWaitAfter: bool, ?timeout: Float) -> void
+    def press_sequentially: (String text, ?delay: Float, ?noWaitAfter: bool, ?timeout: Float) -> void
     def screenshot: (?animations: ("disabled" | "allow"), ?caret: ("hide" | "initial"), ?mask: Array[untyped], ?maskColor: String, ?omitBackground: bool, ?path: (String | File), ?quality: Integer, ?scale: ("css" | "device"), ?timeout: Float, ?type: ("png" | "jpeg")) -> String
     def scroll_into_view_if_needed: (?timeout: Float) -> void
     def select_option: (?element: (ElementHandle | Array[untyped]), ?index: (Integer | Array[untyped]), ?value: (String | Array[untyped]), ?label: (String | Array[untyped]), ?force: bool, ?noWaitAfter: bool, ?timeout: Float) -> Array[untyped]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: playwright-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.37.1
+  version: 1.38.0
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2023-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -401,5 +401,5 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
-summary: The Ruby binding of playwright driver 1.37.0
+summary: The Ruby binding of playwright driver 1.38.0
 test_files: []