playwright-ruby-client 0.6.1 → 0.6.6

data/documentation/docs/api/page.md

@@ -224,9 +224,9 @@ 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_9220b94fd2fa381ab91448dcb551e2eb9806ad331c83454a710f4d8a280990e8.py
+```ruby
+page.content = '<button id="submit">Send</button>'
 page.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
@@ -243,11 +243,12 @@ 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_9b4482b7243b7ce304d6ce8454395e23db30f3d1d83229242ab7bd2abd5b72e0.py
+```ruby
+page.content = '<div id="source">Drag</div>'
+
 # note you can only create data_transfer in chromium and firefox
 data_transfer = page.evaluate_handle("new DataTransfer()")
-page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
-
+page.dispatch_event("#source", "dragstart", eventInit: { dataTransfer: data_transfer })
 ```
 
 
@@ -255,40 +256,30 @@ page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
 ## emulate_media
 
 ```
-def emulate_media(colorScheme: nil, media: nil)
+def emulate_media(colorScheme: nil, media: nil, reducedMotion: nil)
 ```
 
 This method changes the `CSS media type` through the `media` argument, and/or the `'prefers-colors-scheme'` media
 feature, using the `colorScheme` argument.
 
-```python sync title=example_df304caf6c61f6f44b3e2b0006a7e05552362a47b17c9ba227df76e918d88a5c.py
-page.evaluate("matchMedia('screen').matches")
-# → True
-page.evaluate("matchMedia('print').matches")
-# → False
-
-page.emulate_media(media="print")
-page.evaluate("matchMedia('screen').matches")
-# → False
-page.evaluate("matchMedia('print').matches")
-# → True
+```ruby
+page.evaluate("matchMedia('screen').matches") # => true
+page.evaluate("matchMedia('print').matches") # => false
 
-page.emulate_media()
-page.evaluate("matchMedia('screen').matches")
-# → True
-page.evaluate("matchMedia('print').matches")
-# → False
+page.emulate_media(media: "print")
+page.evaluate("matchMedia('screen').matches") # => false
+page.evaluate("matchMedia('print').matches") # => true
 
+page.emulate_media
+page.evaluate("matchMedia('screen').matches") # => true
+page.evaluate("matchMedia('print').matches") # => false
 ```
 
-```python sync title=example_f0479a2ee8d8f51dab94f48b7e121cade07e5026d4f602521cc6ccc47feb5a98.py
-page.emulate_media(color_scheme="dark")
-page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches")
-# → True
-page.evaluate("matchMedia('(prefers-color-scheme: light)').matches")
-# → False
-page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
-
+```ruby
+page.emulate_media(colorScheme="dark")
+page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches") # => true
+page.evaluate("matchMedia('(prefers-color-scheme: light)').matches") # => false
+page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches") # => false
 ```
 
 
@@ -370,7 +361,7 @@ puts page.evaluate("1 + #{x}") # => "11"
 ```ruby
 body_handle = page.query_selector("body")
 html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", arg: [body_handle, "hello"])
-body_handle.dispose()
+body_handle.dispose
 ```
 
 Shortcut for main frame's [Frame#evaluate](./frame#evaluate).
@@ -389,17 +380,15 @@ The only difference between [Page#evaluate](./page#evaluate) and [Page#evaluate_
 If the function passed to the [Page#evaluate_handle](./page#evaluate_handle) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [Page#evaluate_handle](./page#evaluate_handle)
 would wait for the promise to resolve and return its value.
 
-```python sync title=example_6802829f93cc4da7e67f3886b9773c7b84054afa84251add50704f8ca6837138.py
+```ruby
 a_window_handle = page.evaluate_handle("Promise.resolve(window)")
 a_window_handle # handle for the window object.
-
 ```
 
 A string can also be passed in instead of a function:
 
-```python sync title=example_9daa37cfd3d747c9360d9544f64786bf49d291a6887b0efccc813215b62ae4c6.py
+```ruby
 a_handle = page.evaluate_handle("document") # handle for the "document"
-
 ```
 
 [JSHandle](./js_handle) instances can be passed as an argument to the [Page#evaluate_handle](./page#evaluate_handle):
@@ -407,8 +396,8 @@ a_handle = page.evaluate_handle("document") # handle for the "document"
 ```ruby
 body_handle = page.evaluate_handle("document.body")
 result_handle = page.evaluate_handle("body => body.innerHTML", arg: body_handle)
-puts result_handle.json_value()
-result_handle.dispose()
+puts result_handle.json_value
+result_handle.dispose
 ```
 
 
@@ -423,8 +412,7 @@ The method adds a function called `name` on the `window` object of every frame i
 executes `callback` and returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) which resolves to the return value of `callback`. If the `callback` returns
 a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), it will be awaited.
 
-The first argument of the `callback` function contains information about the caller: `{ browserContext: BrowserContext,
-page: Page, frame: Frame }`.
+The first argument of the `callback` function contains information about the caller: `{ browser_context: BrowserContext, page: Page, frame: Frame }`.
 
 See [BrowserContext#expose_binding](./browser_context#expose_binding) for the context-wide version.
 
@@ -432,46 +420,39 @@ See [BrowserContext#expose_binding](./browser_context#expose_binding) for the co
 
 An example of exposing page URL to all frames in a page:
 
-```python sync title=example_551f5963351bfd7141fa8c94f5f22c305ec1c01d617861953374e9290929a551.py
-from playwright.sync_api import sync_playwright
-
-def run(playwright):
-    webkit = playwright.webkit
-    browser = webkit.launch(headless=false)
-    context = browser.new_context()
-    page = context.new_page()
-    page.expose_binding("pageURL", lambda source: source["page"].url)
-    page.set_content("""
-    <script>
-      async function onClick() {
-        document.querySelector('div').textContent = await window.pageURL();
-      }
-    </script>
-    <button onclick="onClick()">Click me</button>
-    <div></div>
-    """)
-    page.click("button")
-
-with sync_playwright() as playwright:
-    run(playwright)
-
+```ruby
+page.expose_binding("pageURL", ->(source) { source[:page].url })
+page.content = <<~HTML
+<script>
+  async function onClick() {
+    document.querySelector('div').textContent = await window.pageURL();
+  }
+</script>
+<button onclick="onClick()">Click me</button>
+<div></div>
+HTML
+page.click("button")
 ```
 
 An example of passing an element handle:
 
-```python sync title=example_6534a792e99e05b5644cea6e5b77ca5d864675a3012f447f0f8318c4fa6a6a54.py
-def print(source, element):
-    print(element.text_content())
+```ruby
+def print_text(source, element)
+  element.text_content
+end
 
-page.expose_binding("clicked", print, handle=true)
-page.set_content("""
-  <script>
-    document.addEventListener('click', event => window.clicked(event.target));
-  </script>
-  <div>Click me</div>
-  <div>Or click me</div>
-""")
+page.expose_binding("clicked", method(:print_text), handle: true)
+page.content = <<~HTML
+<script>
+  document.addEventListener('click', async (event) => {
+    alert(await window.clicked(event.target));
+  })
+</script>
+<div>Click me</div>
+<div>Or click me</div>
+HTML
 
+page.click('div')
 ```
 
 
@@ -491,37 +472,26 @@ See [BrowserContext#expose_function](./browser_context#expose_function) for cont
 
 > NOTE: Functions installed via [Page#expose_function](./page#expose_function) survive navigations.
 
-An example of adding an `sha1` function to the page:
-
-```python sync title=example_496ab45e0c5f4c47869f66c2b738fbd9eef0ef4065fa923caf9c929e50e14c21.py
-import hashlib
-from playwright.sync_api import sync_playwright
+An example of adding a `sha256` function to the page:
 
-def sha1(text):
-    m = hashlib.sha1()
-    m.update(bytes(text, "utf8"))
-    return m.hexdigest()
-
-
-def run(playwright):
-    webkit = playwright.webkit
-    browser = webkit.launch(headless=False)
-    page = browser.new_page()
-    page.expose_function("sha1", sha1)
-    page.set_content("""
-        <script>
-          async function onClick() {
-            document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
-          }
-        </script>
-        <button onclick="onClick()">Click me</button>
-        <div></div>
-    """)
-    page.click("button")
+```ruby
+require 'digest'
 
-with sync_playwright() as playwright:
-    run(playwright)
+def sha1(text)
+  Digest::SHA256.hexdigest(text)
+end
 
+page.expose_function("sha256", method(:sha256))
+page.content = <<~HTML
+<script>
+  async function onClick() {
+    document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
+  }
+</script>
+<button onclick="onClick()">Click me</button>
+<div></div>
+HTML
+page.click("button")
 ```
 
 
@@ -564,14 +534,12 @@ def frame(name: nil, url: nil)
 
 Returns frame matching the specified criteria. Either `name` or `url` must be specified.
 
-```py title=example_034f224ec0f7b4d98fdf875cefbc7e6c8726a6d615cbba9b1cb8c49180fd7d69.py
-frame = page.frame(name="frame-name")
-
+```ruby
+frame = page.frame(name: "frame-name")
 ```
 
-```py title=example_a8a4717d8505a35662faafa9e6c2cfbbc0a44755c8e4d43252f882b7e4f1f04a.py
-frame = page.frame(url=r".*domain.*")
-
+```ruby
+frame = page.frame(url: /.*domain.*/)
 ```
 
 
@@ -786,11 +754,10 @@ Returns the PDF buffer.
 [`-webkit-print-color-adjust`](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-print-color-adjust) property to
 force rendering of exact colors.
 
-```python sync title=example_e079fbec8ee0607ee45cdca94df61dea36f7fd3840986d5f4ac24918569a5f5e.py
+```ruby
 # generates a pdf with "screen" media type.
-page.emulate_media(media="screen")
-page.pdf(path="page.pdf")
-
+page.emulate_media(media: "screen")
+page.pdf(path: "page.pdf")
 ```
 
 The `width`, `height`, and `margin` options accept values labeled with units. Unlabeled values are treated as pixels.
@@ -852,17 +819,14 @@ 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.
 
-```python sync title=example_aa4598bd7dbeb8d2f8f5c0aa3bdc84042eb396de37b49f8ff8c1ea39f080f709.py
-page = browser.new_page()
+```ruby
 page.goto("https://keycode.info")
 page.press("body", "A")
-page.screenshot(path="a.png")
+page.screenshot(path: "a.png")
 page.press("body", "ArrowLeft")
-page.screenshot(path="arrow_left.png")
+page.screenshot(path: "arrow_left.png")
 page.press("body", "Shift+O")
-page.screenshot(path="o.png")
-browser.close()
-
+page.screenshot(path: "o.png")
 ```
 
 
@@ -912,35 +876,31 @@ Once routing is enabled, every request matching the url pattern will stall unles
 
 An example of a naive handler that aborts all image requests:
 
-```python sync title=example_a3038a6fd55b06cb841251877bf6eb781b08018695514c6e0054848d4e93d345.py
-page = browser.new_page()
-page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
+```ruby
+page.route("**/*.{png,jpg,jpeg}", ->(route, request) { route.abort })
 page.goto("https://example.com")
-browser.close()
-
 ```
 
 or the same snippet using a regex pattern instead:
 
-```python sync title=example_7fda2a761bdd66b942415ab444c6b4bb89dd87ec0f0a4a03e6775feb694f7913.py
-page = browser.new_page()
-page.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
+```ruby
+page.route(/\.(png|jpg)$/, ->(route, request) { route.abort })
 page.goto("https://example.com")
-browser.close()
-
 ```
 
 It is possible to examine the request to decide the route action. For example, mocking all requests that contain some
 post data, and leaving all other requests as is:
 
-```python sync title=example_ff4fba1273c7e65f4d68b4fcdd9dc4b792bba435005f0b9e7066ca18ded750b5.py
-def handle_route(route):
-  if ("my-string" in route.request.post_data)
-    route.fulfill(body="mocked-data")
+```ruby
+def handle_route(route, request)
+  if request.post_data["my-string"]
+    mocked_data = request.post_data.merge({ "my-string" => 'mocked-data'})
+    route.fulfill(postData: mocked_data)
   else
-    route.continue_()
-page.route("/api/**", handle_route)
-
+    route.continue
+  end
+end
+page.route("/api/**", method(:handle_route))
 ```
 
 Page routes take precedence over browser context routes (set up with [BrowserContext#route](./browser_context#route)) when request
@@ -989,14 +949,13 @@ 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_4b17eb65721c55859c50eb12b4ee762e65408618cf3b7d07958b68d60ea6be6c.py
+```ruby
 # single selection matching the value
-page.select_option("select#colors", "blue")
+page.select_option("select#colors", value: "blue")
 # single selection matching both the label
-page.select_option("select#colors", label="blue")
+page.select_option("select#colors", label: "blue")
 # multiple selection
-page.select_option("select#colors", value=["red", "green", "blue"])
-
+page.select_option("select#colors", value: ["red", "green", "blue"])
 ```
 
 Shortcut for main frame's [Frame#select_option](./frame#select_option).
@@ -1076,11 +1035,9 @@ In the case of multiple pages in a single browser, each page can have its own vi
 `page.setViewportSize` will resize the page. A lot of websites don't expect phones to change size, so you should set the
 viewport size before navigating to the page.
 
-```python sync title=example_e3883d51c0785c34b62633fe311c4f1252dd9f29e6b4b6c7719f1eb74384e6e9.py
-page = browser.new_page()
-page.set_viewport_size({"width": 640, "height": 480})
+```ruby
+page.viewport_size = { width: 640, height: 480 }
 page.goto("https://example.com")
-
 ```
 
 
@@ -1145,10 +1102,9 @@ fine-grained keyboard events. To fill values in form fields, use [Page#fill](./p
 
 To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./keyboard#press).
 
-```python sync title=example_4c7291f6023d2fe4f957cb7727646b50fdee40275db330a6f4517e349ea7f916.py
+```ruby
 page.type("#mytextarea", "hello") # types instantly
-page.type("#mytextarea", "world", delay=100) # types slower, like a user
-
+page.type("#mytextarea", "world", delay: 100) # types slower, like a user
 ```
 
 Shortcut for main frame's [Frame#type](./frame#type).
@@ -1221,7 +1177,7 @@ def expect_console_message(predicate: nil, timeout: nil, &block)
 
 Performs action and waits for a [ConsoleMessage](./console_message) to be logged by in the page. If predicate is provided, it passes
 [ConsoleMessage](./console_message) value into the `predicate` function and waits for `predicate(message)` to return a truthy value. Will
-throw an error if the page is closed before the console event is fired.
+throw an error if the page is closed before the [`event: Page.console`] event is fired.
 
 ## expect_download
 
@@ -1242,15 +1198,13 @@ def expect_event(event, predicate: nil, timeout: nil, &block)
 Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
 value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
 
-```python sync title=example_1b007e0db5f2b594b586367be3b56f9eb9b928740efbceada2c60cb7794592d4.py
-with page.expect_event("framenavigated") as event_info:
-    page.click("button")
-frame = event_info.value
-
+```ruby
+frame = page.expect_event("framenavigated") do
+  page.click("button")
+end
 ```
 
 
-
 ## expect_file_chooser
 
 ```
@@ -1258,7 +1212,7 @@ def expect_file_chooser(predicate: nil, timeout: nil, &block)
 ```
 
 Performs action and waits for a new [FileChooser](./file_chooser) to be created. If predicate is provided, it passes [FileChooser](./file_chooser) value
-into the `predicate` function and waits for `predicate(fileChooser)` to return a truthy value. Will throw an error if
+into the `predicate` function and waits for `predicate.call(fileChooser)` to return a truthy value. Will throw an error if
 the page is closed before the file chooser is opened.
 
 ## wait_for_function
@@ -1271,28 +1225,16 @@ Returns when the `expression` returns a truthy value. It resolves to a JSHandle
 
 The [Page#wait_for_function](./page#wait_for_function) can be used to observe viewport size change:
 
-```python sync title=example_e50869c913bec2f0a89a22ff1c438128c3c8f2e3710acb10665445cf52e3ec73.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.wait_for_function("() => window.x > 0")
-    browser.close()
-
-with sync_playwright() as playwright:
-    run(playwright)
-
+```ruby
+page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
+page.wait_for_function("() => window.x > 0")
 ```
 
 To pass an argument to the predicate of [Page#wait_for_function](./page#wait_for_function) function:
 
-```python sync title=example_04c93558dde8de62944515a8ed91fda6e0d01feca4d3bb2e58c6fda10a8c6ade.py
+```ruby
 selector = ".foo"
-page.wait_for_function("selector => !!document.querySelector(selector)", selector)
-
+page.wait_for_function("selector => !!document.querySelector(selector)", arg: selector)
 ```
 
 Shortcut for main frame's [Frame#wait_for_function](./frame#wait_for_function).
@@ -1308,20 +1250,19 @@ Returns when the required load state has been reached.
 This resolves when the page 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_cd35fb085612055231ddf97f68bc5331b4620914e0686b889f2cd4061836cff8.py
+```ruby
 page.click("button") # click triggers navigation.
-page.wait_for_load_state() # the promise resolves after "load" event.
-
+page.wait_for_load_state # the promise resolves after "load" event.
 ```
 
-```python sync title=example_51ba8a745d5093516e9a50482d8bf3ce29afe507ca5cfe89f4a0e35963f52a36.py
-with page.expect_popup() as page_info:
-    page.click("button") # click triggers a popup.
-popup = page_info.value
- # Following resolves after "domcontentloaded" event.
-popup.wait_for_load_state("domcontentloaded")
-print(popup.title()) # popup is ready to use.
+```ruby
+popup = page.expect_popup do
+  page.click("button") # click triggers a popup.
+end
 
+# Following resolves after "domcontentloaded" event.
+popup.wait_for_load_state("domcontentloaded")
+puts popup.title # popup is ready to use.
 ```
 
 Shortcut for main frame's [Frame#wait_for_load_state](./frame#wait_for_load_state).
@@ -1340,17 +1281,16 @@ This resolves when the page navigates to a new URL or reloads. It is useful for
 cause the page to navigate. e.g. The click target has an `onclick` handler that triggers navigation from a `setTimeout`.
 Consider this example:
 
-```python sync title=example_bc5a01f756c1275b9942c4b3e50a9f1748c04da8d5f8f697567b9d04806ec0dc.py
-with page.expect_navigation():
-    page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
-# Resolves after navigation has finished
-
+```ruby
+page.expect_navigation do
+  page.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
 considered a navigation.
 
-Shortcut for main frame's [`method: Frame.waitForNavigation`].
+Shortcut for main frame's [Frame#expect_navigation](./frame#expect_navigation).
 
 ## expect_popup
 
@@ -1358,29 +1298,32 @@ Shortcut for main frame's [`method: Frame.waitForNavigation`].
 def expect_popup(predicate: nil, timeout: nil, &block)
 ```
 
-Performs action and waits for a popup [Page](./page). If predicate is provided, it passes [Popup] value into the `predicate`
-function and waits for `predicate(page)` to return a truthy value. Will throw an error if the page is closed before the
-popup event is fired.
+Performs action and waits for a popup [Page](./page). If predicate is provided, it passes popup [Page](./page) value into the predicate function and waits for `predicate.call(page)` to return a truthy value. Will throw an error if the page is closed before the popup event is fired.
 
 ## expect_request
 
 ```
-def expect_request(urlOrPredicate, timeout: nil)
+def expect_request(urlOrPredicate, timeout: nil, &block)
 ```
 
 Waits for the matching request and returns it.  See [waiting for event](https://playwright.dev/python/docs/events) for more details
 about events.
 
-```python sync title=example_9246912bc386c2f9310662279b12200ae131f724a1ec1ca99e511568767cb9c8.py
-with page.expect_request("http://example.com/resource") as first:
-    page.click('button')
-first_request = first.value
+```ruby
+page.content = '<form action="https://example.com/resource"><input type="submit" /></form>'
+request = page.expect_request(/example.com\/resource/) do
+  page.click("input")
+end
+puts request.headers
 
-# or with a lambda
-with page.expect_request(lambda request: request.url == "http://example.com" and request.method == "get") as second:
-    page.click('img')
-second_request = second.value
+page.wait_for_load_state # wait for request finished.
 
+# or with a predicate
+page.content = '<form action="https://example.com/resource"><input type="submit" /></form>'
+request = page.expect_request(->(req) { req.url.start_with? 'https://example.com/resource' }) do
+  page.click("input")
+end
+puts request.headers
 ```
 
 
@@ -1388,23 +1331,24 @@ second_request = second.value
 ## expect_response
 
 ```
-def expect_response(urlOrPredicate, timeout: nil)
+def expect_response(urlOrPredicate, timeout: nil, &block)
 ```
 
 Returns the matched response. See [waiting for event](https://playwright.dev/python/docs/events) for more details about events.
 
-```python sync title=example_d2a76790c0bb59bf5ae2f41d1a29b50954412136de3699ec79dc33cdfd56004b.py
-with page.expect_response("https://example.com/resource") as response_info:
-    page.click("input")
-response = response_info.value
-return response.ok
-
-# or with a lambda
-with page.expect_response(lambda response: response.url == "https://example.com" and response.status === 200) as response_info:
-    page.click("input")
-response = response_info.value
-return response.ok
+```ruby
+page.content = '<form action="https://example.com/resource"><input type="submit" /></form>'
+response = page.expect_response(/example.com\/resource/) do
+  page.click("input")
+end
+puts response.body
 
+# or with a predicate
+page.content = '<form action="https://example.com/resource"><input type="submit" /></form>'
+response = page.expect_response(->(res) { res.url.start_with? 'https://example.com/resource' }) do
+  page.click("input")
+end
+puts response.body
 ```
 
 
@@ -1424,22 +1368,12 @@ selector doesn't satisfy the condition for the `timeout` milliseconds, the funct
 
 This method works across navigations:
 
-```python sync title=example_0a62ff34b0d31a64dd1597b9dff456e4139b36207d26efdec7109e278dc315a3.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.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")
+  element = page.wait_for_selector("img")
+  puts "Loaded image: #{element["src"]}"
+end
 ```
 
 
@@ -1452,10 +1386,9 @@ def wait_for_url(url, timeout: nil, waitUntil: nil)
 
 Waits for the main frame to navigate to the given URL.
 
-```python sync title=example_a49b1deed2b93fe358b57bca9c4032f44b3d24436a78720421ba040aad4d661c.py
+```ruby
 page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
 page.wait_for_url("**/target.html")
-
 ```
 
 Shortcut for main frame's [Frame#wait_for_url](./frame#wait_for_url).