playwright-ruby-client 1.14.beta2 → 1.15.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e8cf4acb773b928d276eac118c170bb0eb2f0c8235f7c19bf0ebf2a4883a3e7
-  data.tar.gz: 7a70fbaad653abe274b8fac05b953ec413ca213bfc9d0e6396c3bf2c6c0f5b2d
+  metadata.gz: 2247f39a5fa4881e45ad884606295d7003b3e42ca9db5436b223d921649e5553
+  data.tar.gz: f7f57d5044c66e300912578faa1d8114ee98f2eb1de736eac3da698e7851b9d6
 SHA512:
-  metadata.gz: 981c3cab4a5060634f858b934b01ef51e0f1e887d2bf5e4bbb62dca636d1ab3b9459542e436965c49cf0240f8431732a5fa50f9b7dc6d324c7c21fc36b8b01b8
-  data.tar.gz: '08e490a08488fac3f0633ade8fc4f2299dc6e69fcc6cd86c5587197a9a7bfdca78e836de8fff6b0a578c64387b59c0cba2f245a93280ba7e7b0e6488875ae819'
+  metadata.gz: 86b2003368d06755bfef64cebe40c716ef9d0156d6bd21f18fddc79cef07ffee5a48f562294c32b956dd664b5480326587736ee56334c76e80e8a8e2b89dfb72
+  data.tar.gz: 20697ed55fb7ce54856d04dc0f9568316d5941b0b103ce5c0138e680a28aeda1b7876a3cf4d358f006a2b5d7115a267ed8e7c689064bf54f65e6797848d69a2f

data/README.md

@@ -6,19 +6,13 @@
 
 ## Getting Started
 
-At this point, playwright-ruby-client doesn't include the downloader of playwright driver, so **we have to install [playwright](https://github.com/microsoft/playwright) in advance**.
-
-```sh
-npx playwright install
+```
+gem 'playwright-ruby-client'
 ```
 
-and then, set `playwright_cli_executable_path: "npx playwright"` at `Playwright.create`.
-
-**Prefer npm install instead of npx?**
-
-Actually `npx playwright` is a bit slow. We can also use `npm install` to setup.
+and then 'bundle install'.
 
-Instead of `npx playwright install`:
+Since playwright-ruby-client doesn't include the playwright driver, **we have to install [playwright](https://github.com/microsoft/playwright) in advance**.
 
 ```
 npm install playwright
@@ -29,14 +23,14 @@ And set `playwright_cli_executable_path: './node_modules/.bin/playwright'`
 
 **Prefer playwrighting without Node.js?**
 
-Instead of npm, you can also directly download playwright driver from playwright.azureedge.net/builds/. The URL can be easily detected from [here](https://github.com/microsoft/playwright-python/blob/79f6ce0a6a69c480573372706df84af5ef99c4a4/setup.py#L56-L61)
+Instead of npm, you can also directly download playwright driver from playwright.azureedge.net/builds/. The URL can be easily detected from [here](https://github.com/microsoft/playwright-python/blob/cb5409934629adaabc0cff1891080de2052fa778/setup.py#L73-L77)
 
 ### Capture a site
 
 ```ruby
 require 'playwright'
 
-Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
+Playwright.create(playwright_cli_executable_path: './node_modules/.bin/playwright') do |playwright|
   playwright.chromium.launch(headless: false) do |browser|
     page = browser.new_page
     page.goto('https://github.com/YusukeIwaki')
@@ -52,7 +46,7 @@ end
 ```ruby
 require 'playwright'
 
-Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
+Playwright.create(playwright_cli_executable_path: './node_modules/.bin/playwright') do |playwright|
   playwright.chromium.launch(headless: false) do |browser|
     page = browser.new_page
     page.goto('https://github.com/')
@@ -94,7 +88,7 @@ $ bundle exec ruby main.rb
 ```ruby
 require 'playwright'
 
-Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
+Playwright.create(playwright_cli_executable_path: './node_modules/.bin/playwright') do |playwright|
   devices = playwright.android.devices
   unless devices.empty?
     device = devices.last
@@ -185,6 +179,8 @@ end
 
 When `Playwright.connect_to_playwright_server` is used, playwright_cli_executable_path is not required.
 
+For more detailed instraction, refer this article: https://playwright-ruby-client.vercel.app/docs/article/guides/playwright_on_alpine_linux
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/documentation/docs/api/accessibility.md

@@ -32,27 +32,26 @@ Playwright will discard them as well for an easier to process tree, unless `inte
 
 An example of dumping the entire accessibility tree:
 
-```python sync title=example_2e5019929403491cde0c78bed1e0e18e0c86ab423d7ac8715876c4de4814f483.py
-snapshot = page.accessibility.snapshot()
-print(snapshot)
-
+```ruby
+snapshot = page.accessibility.snapshot
+puts snapshot
 ```
 
 An example of logging the focused node's name:
 
-```python sync title=example_df2acadf9e261a7624d83399f0d8b0910293a6a7081c812474715f22f8af7a4a.py
-def find_focused_node(node):
-    if (node.get("focused"))
-        return node
-    for child in (node.get("children") or []):
-        found_node = find_focused_node(child)
-        return found_node
-    return None
-
-snapshot = page.accessibility.snapshot()
+```ruby
+def find_focused_node(node)
+  if node['focused']
+    node
+  else
+    node['children']&.find do |child|
+      find_focused_node(child)
+    end
+  end
+end
+
+snapshot = page.accessibility.snapshot
 node = find_focused_node(snapshot)
-if node:
-    print(node["name"])
-
+puts node['name']
 ```
 

data/documentation/docs/api/browser.md

@@ -81,6 +81,7 @@ def new_context(
       colorScheme: nil,
       deviceScaleFactor: nil,
       extraHTTPHeaders: nil,
+      forcedColors: nil,
       geolocation: nil,
       hasTouch: nil,
       httpCredentials: nil,
@@ -99,6 +100,7 @@ def new_context(
       reducedMotion: nil,
       screen: nil,
       storageState: nil,
+      strictSelectors: nil,
       timezoneId: nil,
       userAgent: nil,
       viewport: nil,
@@ -130,6 +132,7 @@ def new_page(
       colorScheme: nil,
       deviceScaleFactor: nil,
       extraHTTPHeaders: nil,
+      forcedColors: nil,
       geolocation: nil,
       hasTouch: nil,
       httpCredentials: nil,
@@ -148,6 +151,7 @@ def new_page(
       reducedMotion: nil,
       screen: nil,
       storageState: nil,
+      strictSelectors: nil,
       timezoneId: nil,
       userAgent: nil,
       viewport: nil,

data/documentation/docs/api/browser_context.md

@@ -265,12 +265,16 @@ Returns all open pages in the context.
 ## route
 
 ```
-def route(url, handler)
+def route(url, handler, times: nil)
 ```
 
 Routing provides the capability to modify network requests that are made by any page in the browser context. Once route
 is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.
 
+> NOTE: [Page#route](./page#route) will not intercept requests intercepted by Service Worker. See
+[this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
+request interception. Via `await context.addInitScript(() => delete window.navigator.serviceWorker);`
+
 An example of a naive handler that aborts all image requests:
 
 ```ruby

data/documentation/docs/api/browser_type.md

@@ -114,6 +114,7 @@ def launch_persistent_context(
       env: nil,
       executablePath: nil,
       extraHTTPHeaders: nil,
+      forcedColors: nil,
       geolocation: nil,
       handleSIGHUP: nil,
       handleSIGINT: nil,
@@ -137,6 +138,7 @@ def launch_persistent_context(
       reducedMotion: nil,
       screen: nil,
       slowMo: nil,
+      strictSelectors: nil,
       timeout: nil,
       timezoneId: nil,
       tracesDir: nil,

data/documentation/docs/api/element_handle.md

@@ -510,6 +510,32 @@ def select_text(force: nil, timeout: nil)
 This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, then focuses the element and selects all its text
 content.
 
+## set_checked
+
+```
+def set_checked(
+      checked,
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+alias: `checked=`
+
+This method checks or unchecks an element by performing the following steps:
+1. Ensure that element is a checkbox or a radio input. If not, this method throws.
+1. If the element already has the right checked state, this method returns immediately.
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `force` option is set. If the
+   element is detached during the checks, the whole action is retried.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to click in the center of the element.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+1. Ensure that the element is now checked or unchecked. If not, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
+
 ## set_input_files
 
 ```
@@ -630,7 +656,7 @@ If the element does not satisfy the condition for the `timeout` milliseconds, th
 ## wait_for_selector
 
 ```
-def wait_for_selector(selector, state: nil, timeout: nil)
+def wait_for_selector(selector, state: nil, strict: nil, timeout: nil)
 ```
 
 Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
@@ -641,12 +667,11 @@ become visible/hidden). If at the moment of calling the method `selector` alread
 will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will
 throw.
 
-```python sync title=example_3b0f6c6573db513b7b707a39d6c5bbf5ce5896b4785466d80f525968cfbd0be7.py
-page.set_content("<div><span></span></div>")
+```ruby
+page.content = "<div><span></span></div>"
 div = page.query_selector("div")
 # waiting for the "span" selector relative to the div.
-span = div.wait_for_selector("span", state="attached")
-
+span = div.wait_for_selector("span", state: "attached")
 ```
 
 > NOTE: This method does not work across navigations, use [Page#wait_for_selector](./page#wait_for_selector) instead.

data/documentation/docs/api/experimental/android.md

@@ -4,8 +4,21 @@ sidebar_position: 10
 
 # Android
 
-Playwright has **experimental** support for Android automation. See [here](https://playwright.dev/python/docs/mobile) for more information. You can
-access android namespace via:
+Playwright has **experimental** support for Android automation. This includes Chrome for Android and Android WebView.
+
+*Requirements*
+- Android device or AVD Emulator.
+- [ADB daemon](https://developer.android.com/studio/command-line/adb) running and authenticated with your device.
+  Typically running `adb devices` is all you need to do.
+- [`Chrome 87`](https://play.google.com/store/apps/details?id=com.android.chrome) or newer installed on the device
+- "Enable command line on non-rooted devices" enabled in `chrome://flags`.
+
+*Known limitations*
+- Raw USB operation is not yet supported, so you need ADB.
+- Device needs to be awake to produce screenshots. Enabling "Stay awake" developer mode will help.
+- We didn't run all the tests against the device, so not everything works.
+
+*How to run*
 
 An example of the Android automation script would be:
 

data/documentation/docs/api/experimental/android_device.md

@@ -34,6 +34,7 @@ def launch_browser(
       command: nil,
       deviceScaleFactor: nil,
       extraHTTPHeaders: nil,
+      forcedColors: nil,
       geolocation: nil,
       hasTouch: nil,
       httpCredentials: nil,
@@ -50,6 +51,7 @@ def launch_browser(
       record_video_size: nil,
       reducedMotion: nil,
       screen: nil,
+      strictSelectors: nil,
       timezoneId: nil,
       userAgent: nil,
       viewport: nil,

data/documentation/docs/api/frame.md

@@ -16,25 +16,16 @@ At every point of time, page exposes its current frame tree via the [Page#main_f
 
 An example of dumping frame tree:
 
-```python sync title=example_a4a9e01d1e0879958d591c4bc9061574f5c035e821a94214e650d15564d77bf4.py
-from playwright.sync_api import sync_playwright
-
-def run(playwright):
-    firefox = playwright.firefox
-    browser = firefox.launch()
-    page = browser.new_page()
-    page.goto("https://www.theverge.com")
-    dump_frame_tree(page.main_frame, "")
-    browser.close()
-
-def dump_frame_tree(frame, indent):
-    print(indent + frame.name + '@' + frame.url)
-    for child in frame.child_frames:
-        dump_frame_tree(child, indent + "    ")
-
-with sync_playwright() as playwright:
-    run(playwright)
+```ruby
+def dump_frame_tree(frame, indent = 0)
+  puts "#{' ' * indent}#{frame.name}@#{frame.url}"
+  frame.child_frames.each do |child|
+    dump_frame_tree(child, indent + 2)
+  end
+end
 
+page.goto("https://www.theverge.com")
+dump_frame_tree(page.main_frame)
 ```
 
 
@@ -176,9 +167,8 @@ The snippet below dispatches the `click` event on the element. Regardless of the
 `click` is dispatched. This is equivalent to calling
 [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).
 
-```python sync title=example_de439a4f4839a9b1bc72dbe0890d6b989c437620ba1b88a2150faa79f98184fc.py
+```ruby
 frame.dispatch_event("button#submit", "click")
-
 ```
 
 Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
@@ -195,11 +185,10 @@ Since `eventInit` is event-specific, please refer to the events documentation fo
 
 You can also specify [JSHandle](./js_handle) as the property value if you want live objects to be passed into the event:
 
-```python sync title=example_5410f49339561b3cc9d91c7548c8195a570c8be704bb62f45d90c68f869d450d.py
+```ruby
 # note you can only create data_transfer in chromium and firefox
 data_transfer = frame.evaluate_handle("new DataTransfer()")
-frame.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
-
+frame.dispatch_event("#source", "dragstart", eventInit: { dataTransfer: data_transfer })
 ```
 
 
@@ -238,11 +227,10 @@ return its value.
 
 Examples:
 
-```python sync title=example_6814d0e91763f4d27a0d6a380c36d62b551e4c3e902d1157012dde0a49122abe.py
+```ruby
 search_value = frame.eval_on_selector("#search", "el => el.value")
 preload_href = frame.eval_on_selector("link[rel=preload]", "el => el.href")
-html = frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
-
+html = frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", arg: "hello")
 ```
 
 
@@ -263,9 +251,8 @@ return its value.
 
 Examples:
 
-```python sync title=example_618e7f8f681d1c4a1c0c9b8d23892e37cbbef013bf3d8906fd4311c51d9819d7.py
-divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
-
+```ruby
+divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", arg: 10)
 ```
 
 
@@ -285,28 +272,25 @@ If the function passed to the [Frame#evaluate](./frame#evaluate) returns a non-[
 [Frame#evaluate](./frame#evaluate) returns `undefined`. Playwright also supports transferring some additional values that are
 not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
 
-```python sync title=example_15a235841cd1bc56fad6e3c8aaea2a30e352fedd8238017f22f97fc70e058d2b.py
-result = frame.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
-print(result) # prints "56"
-
+```ruby
+result = frame.evaluate("([x, y]) => Promise.resolve(x * y)", arg: [7, 8])
+puts result # => "56"
 ```
 
 A string can also be passed in instead of a function.
 
-```python sync title=example_9c73167b900498bca191abc2ce2627e063f84b0abc8ce3a117416cb734602760.py
-print(frame.evaluate("1 + 2")) # prints "3"
+```ruby
+puts frame.evaluate("1 + 2") # => 3
 x = 10
-print(frame.evaluate(f"1 + {x}")) # prints "11"
-
+puts frame.evaluate("1 + #{x}") # => "11"
 ```
 
 [ElementHandle](./element_handle) instances can be passed as an argument to the [Frame#evaluate](./frame#evaluate):
 
-```python sync title=example_05568c81173717fa6841099571d8a66e14fc0853e01684630d1622baedc25f67.py
+```ruby
 body_handle = frame.query_selector("body")
-html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
-body_handle.dispose()
-
+html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", arg: [body_handle, "hello"])
+body_handle.dispose
 ```
 
 
@@ -325,10 +309,9 @@ The only difference between [Frame#evaluate](./frame#evaluate) and [Frame#evalua
 If the function, passed to the [Frame#evaluate_handle](./frame#evaluate_handle), returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then
 [Frame#evaluate_handle](./frame#evaluate_handle) would wait for the promise to resolve and return its value.
 
-```python sync title=example_a1c8e837e826079359d01d6f7eecc64092a45d8c74280d23ee9039c379132c51.py
+```ruby
 a_window_handle = frame.evaluate_handle("Promise.resolve(window)")
 a_window_handle # handle for the window object.
-
 ```
 
 A string can also be passed in instead of a function.
@@ -393,11 +376,10 @@ frame.
 
 This method throws an error if the frame has been detached before `frameElement()` returns.
 
-```python sync title=example_e6b4fdef29a401d84b17acfa319bee08f39e1f28e07c435463622220c6a24747.py
-frame_element = frame.frame_element()
-content_frame = frame_element.content_frame()
-assert frame == content_frame
-
+```ruby
+frame_element = frame.frame_element
+content_frame = frame_element.content_frame
+puts frame == content_frame # => true
 ```
 
 
@@ -419,18 +401,18 @@ def goto(url, referer: nil, timeout: nil, waitUntil: nil)
 Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
 last redirect.
 
-`frame.goto` will throw an error if:
+The method will throw an error if:
 - there's an SSL error (e.g. in case of self-signed certificates).
 - target URL is invalid.
 - the `timeout` is exceeded during navigation.
 - the remote server does not respond or is unreachable.
 - the main resource failed to load.
 
-`frame.goto` will not throw an error when any valid HTTP status code is returned by the remote server, including 404
-"Not Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling
+The method will not throw an error when any valid HTTP status code is returned by the remote server, including 404 "Not
+Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling
 [Response#status](./response#status).
 
-> NOTE: `frame.goto` either throws an error or returns a main resource response. The only exceptions are navigation to
+> NOTE: The method either throws an error or returns a main resource response. The only exceptions are navigation to
 `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.
 > NOTE: Headless mode doesn't support navigation to a PDF document. See the
 [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).
@@ -551,8 +533,6 @@ The method returns an element locator that can be used to perform actions in the
 element immediately before performing an action, so a series of actions on the same locator can in fact be performed on
 different DOM elements. That would happen if the DOM structure between those actions has changed.
 
-Note that locator always implies visibility, so it will always be locating visible elements.
-
 ## name
 
 ```
@@ -658,17 +638,44 @@ Returns the array of option values that have been successfully selected.
 
 Triggers a `change` and `input` event once all the provided options have been selected.
 
-```python sync title=example_230c12044664b222bf35d6163b1e415c011d87d9911a4d39648c7f601b344a31.py
+```ruby
 # single selection matching the value
-frame.select_option("select#colors", "blue")
+frame.select_option("select#colors", value: "blue")
 # single selection matching both the label
-frame.select_option("select#colors", label="blue")
+frame.select_option("select#colors", label: "blue")
 # multiple selection
-frame.select_option("select#colors", value=["red", "green", "blue"])
+frame.select_option("select#colors", value: ["red", "green", "blue"])
+```
+
+
+
+## set_checked
 
 ```
+def set_checked(
+      selector,
+      checked,
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      strict: nil,
+      timeout: nil,
+      trial: nil)
+```
 
+This method checks or unchecks an element matching `selector` by performing the following steps:
+1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+1. Ensure that matched element is a checkbox or a radio input. If not, this method throws.
+1. If the element already has the right checked state, this method returns immediately.
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `force` option is set. If the
+   element is detached during the checks, the whole action is retried.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to click in the center of the element.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
 
 ## set_content
 
@@ -756,10 +763,9 @@ send fine-grained keyboard events. To fill values in form fields, use [Frame#fil
 
 To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./keyboard#press).
 
-```python sync title=example_beae7f0d11663c3c98b9d3a8e6ab76b762578cf2856e3b04ad8e42bfb23bb1e1.py
+```ruby
 frame.type("#mytextarea", "hello") # types instantly
-frame.type("#mytextarea", "world", delay=100) # types slower, like a user
-
+frame.type("#mytextarea", "world", delay: 100) # types slower, like a user
 ```
 
 
@@ -809,28 +815,16 @@ Returns when the `expression` returns a truthy value, returns that value.
 
 The [Frame#wait_for_function](./frame#wait_for_function) can be used to observe viewport size change:
 
-```python sync title=example_2f82dcf15fa9338be87a4faf7fe7de3c542040924db1e1ad1c98468ec0f425ce.py
-from playwright.sync_api import sync_playwright
-
-def run(playwright):
-    webkit = playwright.webkit
-    browser = webkit.launch()
-    page = browser.new_page()
-    page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
-    page.main_frame.wait_for_function("() => window.x > 0")
-    browser.close()
-
-with sync_playwright() as playwright:
-    run(playwright)
-
+```ruby
+frame.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
+frame.wait_for_function("() => window.x > 0")
 ```
 
 To pass an argument to the predicate of `frame.waitForFunction` function:
 
-```python sync title=example_8b95be0fb4d149890f7817d9473428a50dc631d3a75baf89846648ca6a157562.py
+```ruby
 selector = ".foo"
-frame.wait_for_function("selector => !!document.querySelector(selector)", selector)
-
+frame.wait_for_function("selector => !!document.querySelector(selector)", arg: selector)
 ```
 
 
@@ -846,10 +840,9 @@ Waits for the required load state to be reached.
 This returns when the frame reaches a required load state, `load` by default. The navigation must have been committed
 when this method is called. If current document has already reached the required state, resolves immediately.
 
-```python sync title=example_fe41b79b58d046cda4673ededd4d216cb97a63204fcba69375ce8a84ea3f6894.py
+```ruby
 frame.click("button") # click triggers navigation.
-frame.wait_for_load_state() # the promise resolves after "load" event.
-
+frame.wait_for_load_state # the promise resolves after "load" event.
 ```
 
 
@@ -867,11 +860,10 @@ History API usage, the navigation will resolve with `null`.
 This method waits for the frame to navigate to a new URL. It is useful for when you run code which will indirectly cause
 the frame to navigate. Consider this example:
 
-```python sync title=example_03f0ac17eb6c1ce8780cfa83c4ae15a9ddbfde3f96c96f36fdf3fbf9aac721f7.py
-with frame.expect_navigation():
-    frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
-# Resolves after navigation has finished
-
+```ruby
+frame.expect_navigation do
+  frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+end # Resolves after navigation has finished
 ```
 
 > NOTE: Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL is
@@ -892,22 +884,13 @@ selector doesn't satisfy the condition for the `timeout` milliseconds, the funct
 
 This method works across navigations:
 
-```python sync title=example_a5b9dd4745d45ac630e5953be1c1815ae8e8ab03399fb35f45ea77c434f17eea.py
-from playwright.sync_api import sync_playwright
-
-def run(playwright):
-    chromium = playwright.chromium
-    browser = chromium.launch()
-    page = browser.new_page()
-    for current_url in ["https://google.com", "https://bbc.com"]:
-        page.goto(current_url, wait_until="domcontentloaded")
-        element = page.main_frame.wait_for_selector("img")
-        print("Loaded image: " + str(element.get_attribute("src")))
-    browser.close()
-
-with sync_playwright() as playwright:
-    run(playwright)
-
+```ruby
+%w[https://google.com https://bbc.com].each do |current_url|
+  page.goto(current_url, waitUntil: "domcontentloaded")
+  frame = page.main_frame
+  element = frame.wait_for_selector("img")
+  puts "Loaded image: #{element["src"]}"
+end
 ```
 
 
@@ -931,10 +914,9 @@ def wait_for_url(url, timeout: nil, waitUntil: nil)
 
 Waits for the frame to navigate to the given URL.
 
-```python sync title=example_86a9a19ec4c41e1a5ac302fbca9a3d3d6dca3fe3314e065b8062ddf5f75abfbd.py
+```ruby
 frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
 frame.wait_for_url("**/target.html")
-
 ```