playwright-ruby-client 0.8.1 → 1.14.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e631604c0af31dc184fd1bfe6953be910d4f19be8613e8a2a11c83a3d5e9049
-  data.tar.gz: b320853082ae065cc09195f09e35f9a5bf18edc3105c729c9bd4a4daeb804948
+  metadata.gz: 88c8fbe4451b00ed8eba172f656e0171fb2580d555eefb4d2aa0cc1a13f86fc4
+  data.tar.gz: 3d307147cc4a23356d561f9528ef95343984bf4623ad77ebb6e479ce4f4f9462
 SHA512:
-  metadata.gz: 1ea608b469db2082b899c3b4c10cbfea703f222a79fb255a0d07d03eb46eacbd0274cb98c1c32a9241f120f5059bdb20fbc82a65a072c05e616bdbd4b76586aa
-  data.tar.gz: 50ea41552e79e96add337084c9a38961bae124dfcaf04c9fe3ab61ceb2cd5e8738f0ae6fffdb6e04157416593f351bc7177e03e0da75cf51a80e929e1bce3f42
+  metadata.gz: 647702705f820c268e5b858a1cd587b0e8f32f16415df2fd7b91505a221cadc20400fc9f2db188964fe4759f4734c8b30bc15c265434d2ac2b78e0683228c192
+  data.tar.gz: b4af0552e547d28be8c9390441bb7131d61fcea36fb5d3d293fd6985d6b47d3925e1c3bf27aa5f4e59243fc03ad751355acc20cb4e63b6e7489c47abb55b1864

data/documentation/docs/api/accessibility.md

@@ -4,4 +4,54 @@ sidebar_position: 10
 
 # Accessibility
 
-Not Implemented
+The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by
+assistive technology such as [screen readers](https://en.wikipedia.org/wiki/Screen_reader) or
+[switches](https://en.wikipedia.org/wiki/Switch_access).
+
+Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that might
+have wildly different output.
+
+Rendering engines of Chromium, Firefox and WebKit have a concept of "accessibility tree", which is then translated into
+different platform-specific APIs. Accessibility namespace gives access to this Accessibility Tree.
+
+Most of the accessibility tree gets filtered out when converting from internal browser AX Tree to Platform-specific
+AX-Tree or by assistive technologies themselves. By default, Playwright tries to approximate this filtering, exposing
+only the "interesting" nodes of the tree.
+
+## snapshot
+
+```
+def snapshot(interestingOnly: nil, root: nil)
+```
+
+Captures the current state of the accessibility tree. The returned object represents the root accessible node of the
+page.
+
+> NOTE: The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers.
+Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to `false`.
+
+An example of dumping the entire accessibility tree:
+
+```ruby
+snapshot = page.accessibility.snapshot
+puts snapshot
+```
+
+An example of logging the focused node's name:
+
+```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)
+puts node['name']
+```
+

data/documentation/docs/api/browser_context.md

@@ -67,6 +67,16 @@ browser_context.add_init_script(path: "preload.js")
 > NOTE: The order of evaluation of multiple scripts installed via [BrowserContext#add_init_script](./browser_context#add_init_script) and
 [Page#add_init_script](./page#add_init_script) is not defined.
 
+## background_pages
+
+```
+def background_pages
+```
+
+> NOTE: Background pages are only supported on Chromium-based browsers.
+
+All existing background pages in the context.
+
 ## browser
 
 ```
@@ -301,6 +311,16 @@ To remove a route with its handler you can use [BrowserContext#unroute](./browse
 
 > NOTE: Enabling routing disables http cache.
 
+## service_workers
+
+```
+def service_workers
+```
+
+> NOTE: Service workers are only supported on Chromium-based browsers.
+
+All existing service workers in the context.
+
 ## set_default_navigation_timeout
 
 ```
@@ -369,6 +389,14 @@ alias: `offline=`
 
 
 
+## storage_state
+
+```
+def storage_state(path: nil)
+```
+
+Returns storage state for this browser context, contains current cookies and local storage snapshot.
+
 ## unroute
 
 ```

data/documentation/docs/api/download.md

@@ -0,0 +1,97 @@
+---
+sidebar_position: 10
+---
+
+# Download
+
+[Download](./download) objects are dispatched by page via the [`event: Page.download`] event.
+
+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:
+
+```ruby
+download = page.expect_download do
+  page.click('a')
+end
+
+# wait for download to complete
+path = download.path
+```
+
+> NOTE: Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
+downloaded content. If `acceptDownloads` is not set, download events are emitted, but the actual download is not
+performed and user has no access to the downloaded files.
+
+## cancel
+
+```
+def cancel
+```
+
+Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,
+`download.failure()` would resolve to `'canceled'`.
+
+## delete
+
+```
+def delete
+```
+
+Deletes the downloaded file. Will wait for the download to finish if necessary.
+
+## failure
+
+```
+def failure
+```
+
+Returns download error if any. Will wait for the download to finish if necessary.
+
+## page
+
+```
+def page
+```
+
+Get the page that the download belongs to.
+
+## path
+
+```
+def path
+```
+
+Returns path to the downloaded file in case of successful download. The method will wait for the download to finish if
+necessary. The method throws when connected remotely.
+
+Note that the download's file name is a random GUID, use [Download#suggested_filename](./download#suggested_filename) to get suggested file
+name.
+
+## save_as
+
+```
+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.
+
+## suggested_filename
+
+```
+def suggested_filename
+```
+
+Returns suggested filename for this download. It is typically computed by the browser from the
+[`Content-Disposition`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) response header
+or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources). Different
+browsers can use different logic for computing it.
+
+## url
+
+```
+def url
+```
+
+Returns downloaded url.

data/documentation/docs/api/element_handle.md

@@ -10,10 +10,8 @@ ElementHandle represents an in-page DOM element. ElementHandles can be created w
 method.
 
 ```ruby
-page.goto("https://example.com")
 href_element = page.query_selector("a")
 href_element.click
-# ...
 ```
 
 ElementHandle prevents DOM element from garbage collection unless the handle is disposed with
@@ -22,6 +20,33 @@ ElementHandle prevents DOM element from garbage collection unless the handle is
 ElementHandle instances can be used as an argument in [Page#eval_on_selector](./page#eval_on_selector) and [Page#evaluate](./page#evaluate)
 methods.
 
+> NOTE: In most cases, you would want to use the [Locator](./locator) object instead. You should only use [ElementHandle](./element_handle) if you
+want to retain a handle to a particular DOM Node that you intend to pass into [Page#evaluate](./page#evaluate) as an argument.
+
+The difference between the [Locator](./locator) and ElementHandle is that the ElementHandle points to a particular element, while
+[Locator](./locator) captures the logic of how to retrieve an element.
+
+In the example below, handle points to a particular DOM element on page. If that element changes text or is used by
+React to render an entirely different component, handle is still pointing to that very DOM element. This can lead to
+unexpected behaviors.
+
+```ruby
+handle = page.query_selector("text=Submit")
+handle.hover
+handle.click
+```
+
+With the locator, every time the `element` is used, up-to-date DOM element is located in the page using the selector. So
+in the snippet below, underlying DOM element is going to be located twice.
+
+```ruby
+locator = page.locator("text=Submit")
+locator.hover
+locator.click
+```
+
+
+
 ## bounding_box
 
 ```
@@ -306,7 +331,7 @@ Returns the `element.innerText`.
 def input_value(timeout: nil)
 ```
 
-Returns `input.value` for `<input>` or `<textarea>` element. Throws for non-input elements.
+Returns `input.value` for `<input>` or `<textarea>` or `<select>` element. Throws for non-input elements.
 
 ## checked?
 

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/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)
 ```
 
 
@@ -68,6 +59,7 @@ def check(
       force: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -106,6 +98,7 @@ def click(
       modifiers: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -140,6 +133,7 @@ def dblclick(
       modifiers: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -161,16 +155,20 @@ zero timeout disables this.
 ## dispatch_event
 
 ```
-def dispatch_event(selector, type, eventInit: nil, timeout: nil)
+def dispatch_event(
+      selector,
+      type,
+      eventInit: nil,
+      strict: nil,
+      timeout: nil)
 ```
 
 The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,
 `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
@@ -187,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 })
 ```
 
 
@@ -204,6 +201,9 @@ def drag_and_drop(
       target,
       force: nil,
       noWaitAfter: nil,
+      sourcePosition: nil,
+      strict: nil,
+      targetPosition: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -213,7 +213,7 @@ def drag_and_drop(
 ## eval_on_selector
 
 ```
-def eval_on_selector(selector, expression, arg: nil)
+def eval_on_selector(selector, expression, arg: nil, strict: nil)
 ```
 
 Returns the return value of `expression`.
@@ -227,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")
 ```
 
 
@@ -252,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)
 ```
 
 
@@ -274,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
 ```
 
 
@@ -314,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.
@@ -345,6 +339,7 @@ def fill(
       value,
       force: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -362,7 +357,7 @@ To send fine-grained keyboard events, use [Frame#type](./frame#type).
 ## focus
 
 ```
-def focus(selector, timeout: nil)
+def focus(selector, strict: nil, timeout: nil)
 ```
 
 This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
@@ -381,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
 ```
 
 
@@ -393,7 +387,7 @@ assert frame == content_frame
 ## get_attribute
 
 ```
-def get_attribute(selector, name, timeout: nil)
+def get_attribute(selector, name, strict: nil, timeout: nil)
 ```
 
 Returns element attribute value.
@@ -431,6 +425,7 @@ def hover(
       force: nil,
       modifiers: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -449,7 +444,7 @@ zero timeout disables this.
 ## inner_html
 
 ```
-def inner_html(selector, timeout: nil)
+def inner_html(selector, strict: nil, timeout: nil)
 ```
 
 Returns `element.innerHTML`.
@@ -457,7 +452,7 @@ Returns `element.innerHTML`.
 ## inner_text
 
 ```
-def inner_text(selector, timeout: nil)
+def inner_text(selector, strict: nil, timeout: nil)
 ```
 
 Returns `element.innerText`.
@@ -465,15 +460,15 @@ Returns `element.innerText`.
 ## input_value
 
 ```
-def input_value(selector, timeout: nil)
+def input_value(selector, strict: nil, timeout: nil)
 ```
 
-Returns `input.value` for the selected `<input>` or `<textarea>` element. Throws for non-input elements.
+Returns `input.value` for the selected `<input>` or `<textarea>` or `<select>` element. Throws for non-input elements.
 
 ## checked?
 
 ```
-def checked?(selector, timeout: nil)
+def checked?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
@@ -489,7 +484,7 @@ Returns `true` if the frame has been detached, or `false` otherwise.
 ## disabled?
 
 ```
-def disabled?(selector, timeout: nil)
+def disabled?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability).
@@ -497,7 +492,7 @@ Returns whether the element is disabled, the opposite of [enabled](https://playw
 ## editable?
 
 ```
-def editable?(selector, timeout: nil)
+def editable?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is [editable](https://playwright.dev/python/docs/actionability).
@@ -505,7 +500,7 @@ Returns whether the element is [editable](https://playwright.dev/python/docs/act
 ## enabled?
 
 ```
-def enabled?(selector, timeout: nil)
+def enabled?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability).
@@ -513,7 +508,7 @@ Returns whether the element is [enabled](https://playwright.dev/python/docs/acti
 ## hidden?
 
 ```
-def hidden?(selector, timeout: nil)
+def hidden?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability).  `selector` that does not
@@ -522,12 +517,24 @@ match any elements is considered hidden.
 ## visible?
 
 ```
-def visible?(selector, timeout: nil)
+def visible?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is [visible](https://playwright.dev/python/docs/actionability). `selector` that does not match any elements is
 considered not visible.
 
+## locator
+
+```
+def locator(selector)
+```
+
+The method returns an element locator that can be used to perform actions in the frame. Locator is resolved to 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
 
 ```
@@ -564,6 +571,7 @@ def press(
       key,
       delay: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -587,7 +595,7 @@ modifier, modifier is pressed and being held while the subsequent key is being p
 ## query_selector
 
 ```
-def query_selector(selector)
+def query_selector(selector, strict: nil)
 ```
 
 Returns the ElementHandle pointing to the frame element.
@@ -617,6 +625,7 @@ def select_option(
       label: nil,
       force: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -631,14 +640,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_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"])
 ```
 
 
@@ -655,7 +663,12 @@ alias: `content=`
 ## set_input_files
 
 ```
-def set_input_files(selector, files, noWaitAfter: nil, timeout: nil)
+def set_input_files(
+      selector,
+      files,
+      noWaitAfter: nil,
+      strict: nil,
+      timeout: nil)
 ```
 
 This method expects `selector` to point to an
@@ -673,6 +686,7 @@ def tap_point(
       modifiers: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -693,7 +707,7 @@ zero timeout disables this.
 ## text_content
 
 ```
-def text_content(selector, timeout: nil)
+def text_content(selector, strict: nil, timeout: nil)
 ```
 
 Returns `element.textContent`.
@@ -714,6 +728,7 @@ def type(
       text,
       delay: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -722,10 +737,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
 ```
 
 
@@ -738,6 +752,7 @@ def uncheck(
       force: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -774,28 +789,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)
 ```
 
 
@@ -811,10 +814,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.
 ```
 
 
@@ -832,11 +834,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
@@ -845,7 +846,7 @@ considered a navigation.
 ## wait_for_selector
 
 ```
-def wait_for_selector(selector, state: nil, timeout: nil)
+def wait_for_selector(selector, state: nil, strict: nil, timeout: nil)
 ```
 
 Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
@@ -857,25 +858,27 @@ 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
+```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
+```
+
 
-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)
+## wait_for_timeout
 
+```
+def wait_for_timeout(timeout)
 ```
 
+Waits for the given `timeout` in milliseconds.
 
+Note that `frame.waitForTimeout()` should only be used for debugging. Tests using the timer in production are going to
+be flaky. Use signals such as network events, selectors becoming visible and others instead.
 
 ## wait_for_url
 
@@ -885,10 +888,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")
-
 ```