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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e8cf4acb773b928d276eac118c170bb0eb2f0c8235f7c19bf0ebf2a4883a3e7
-  data.tar.gz: 7a70fbaad653abe274b8fac05b953ec413ca213bfc9d0e6396c3bf2c6c0f5b2d
+  metadata.gz: 88c8fbe4451b00ed8eba172f656e0171fb2580d555eefb4d2aa0cc1a13f86fc4
+  data.tar.gz: 3d307147cc4a23356d561f9528ef95343984bf4623ad77ebb6e479ce4f4f9462
 SHA512:
-  metadata.gz: 981c3cab4a5060634f858b934b01ef51e0f1e887d2bf5e4bbb62dca636d1ab3b9459542e436965c49cf0240f8431732a5fa50f9b7dc6d324c7c21fc36b8b01b8
-  data.tar.gz: '08e490a08488fac3f0633ade8fc4f2299dc6e69fcc6cd86c5587197a9a7bfdca78e836de8fff6b0a578c64387b59c0cba2f245a93280ba7e7b0e6488875ae819'
+  metadata.gz: 647702705f820c268e5b858a1cd587b0e8f32f16415df2fd7b91505a221cadc20400fc9f2db188964fe4759f4734c8b30bc15c265434d2ac2b78e0683228c192
+  data.tar.gz: b4af0552e547d28be8c9390441bb7131d61fcea36fb5d3d293fd6985d6b47d3925e1c3bf27aa5f4e59243fc03ad751355acc20cb4e63b6e7489c47abb55b1864

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/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)
 ```
 
 
@@ -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
 ```
 
 
@@ -658,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"])
 ```
 
 
@@ -756,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
 ```
 
 
@@ -809,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)
 ```
 
 
@@ -846,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.
 ```
 
 
@@ -867,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
@@ -892,22 +858,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 +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")
-
 ```
 
 

data/documentation/docs/api/locator.md

@@ -253,8 +253,8 @@ def evaluate_all(expression, arg: nil)
 The method finds all elements matching the specified locator and passes an array of matched elements as a first argument
 to `expression`. Returns the result of `expression` invocation.
 
-If `expression` returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [`Locator.evaluateAll`] would wait for the promise to resolve and return its
-value.
+If `expression` returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [Locator#evaluate_all](./locator#evaluate_all) would wait for the promise to resolve and
+return its value.
 
 Examples:
 

data/documentation/docs/api/mouse.md

@@ -8,16 +8,15 @@ The Mouse class operates in main-frame CSS pixels relative to the top-left corne
 
 Every `page` object has its own Mouse, accessible with [Page#mouse](./page#mouse).
 
-```python sync title=example_ba01da1f358cafb4c22b792488ff2f3de4dbd82d4ee1cc4050e3f0c24a2bd7dd.py
+```ruby
 # using ‘page.mouse’ to trace a 100x100 square.
 page.mouse.move(0, 0)
-page.mouse.down()
+page.mouse.down
 page.mouse.move(0, 100)
 page.mouse.move(100, 100)
 page.mouse.move(100, 0)
 page.mouse.move(0, 0)
-page.mouse.up()
-
+page.mouse.up
 ```
 
 

data/documentation/docs/api/request.md

@@ -28,9 +28,8 @@ The method returns `null` unless this request has failed, as reported by `reques
 
 Example of logging of all the failed requests:
 
-```py title=example_5f3f4534ab17f584cfd41ca38448ce7de9490b6588e29e73116ede3cb15a25a5.py
-page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
-
+```ruby
+page.on("requestfailed", ->(request) { puts "#{request.url} #{request.failure}" })
 ```
 
 
@@ -108,18 +107,17 @@ construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
 
 For example, if the website `http://example.com` redirects to `https://example.com`:
 
-```python sync title=example_89568fc86bf623eef37b68c6659b1a8524647c8365bb32a7a8af63bd86111075.py
-response = page.goto("http://example.com")
-print(response.request.redirected_from.url) # "http://example.com"
-
+```ruby
+response = page.goto("http://github.com")
+puts response.url # => "https://github.com"
+puts response.request.redirected_from&.url # => "http://github.com"
 ```
 
 If the website `https://google.com` has no redirects:
 
-```python sync title=example_6d7b3fbf8d69dbe639b71fedc5a8977777fca29dfb16d38012bb07c496342472.py
+```ruby
 response = page.goto("https://google.com")
-print(response.request.redirected_from) # None
-
+puts response.request.redirected_from&.url # => nil
 ```
 
 
@@ -134,9 +132,8 @@ New request issued by the browser if the server responded with redirect.
 
 This method is the opposite of [Request#redirected_from](./request#redirected_from):
 
-```py title=example_922623f4033e7ec2158787e54a8554655f7e1e20a024e4bf4f69337f781ab88a.py
-assert request.redirected_from.redirected_to == request
-
+```ruby
+request.redirected_from.redirected_to # equals to request
 ```
 
 
@@ -169,12 +166,11 @@ Returns resource timing information for given request. Most of the timing values
 `responseEnd` becomes available when request finishes. Find more information at
 [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).
 
-```python sync title=example_e2a297fe95fd0699b6a856c3be2f28106daa2615c0f4d6084f5012682a619d20.py
-with page.expect_event("requestfinished") as request_info:
-    page.goto("http://example.com")
-request = request_info.value
-print(request.timing)
-
+```ruby
+request = page.expect_event("requestfinished") do
+  page.goto("https://example.com")
+end
+puts request.timing
 ```
 
 

data/documentation/docs/api/tracing.md

@@ -9,13 +9,14 @@ Playwright script runs.
 
 Start with specifying the folder traces will be stored in:
 
-```python sync title=example_a767dfb400d98aef50f2767b94171d23474ea1ac1cf9b4d75d412936208e652d.py
-browser = chromium.launch()
-context = browser.new_context()
-context.tracing.start(screenshots=True, snapshots=True)
-page.goto("https://playwright.dev")
-context.tracing.stop(path = "trace.zip")
-
+```ruby
+browser.new_page do |page|
+  context = page.context
+
+  context.tracing.start(screenshots: true, snapshots: true)
+  page.goto('https://playwright.dev')
+  context.tracing.stop(path: 'trace.zip')
+end
 ```
 
 
@@ -28,12 +29,12 @@ def start(name: nil, screenshots: nil, snapshots: nil)
 
 Start tracing.
 
-```python sync title=example_e611abc8b1066118d0c87eae1bbbb08df655f36d50a94402fc56b8713150997b.py
-context.tracing.start(name="trace", screenshots=True, snapshots=True)
-page.goto("https://playwright.dev")
-context.tracing.stop()
-context.tracing.stop(path = "trace.zip")
+```ruby
+context = page.context
 
+context.tracing.start(name: 'trace', screenshots: true, snapshots: true)
+page.goto('https://playwright.dev')
+context.tracing.stop(path: 'trace.zip')
 ```
 
 

data/lib/playwright/channel_owners/request.rb

@@ -100,14 +100,14 @@ module Playwright
                   request_start:,
                   response_start:)
 
-      @timing["startTime"] = start_time
-      @timing["domainLookupStart"] = domain_lookup_start
-      @timing["domainLookupEnd"] = domain_lookup_end
-      @timing["connectStart"] = connect_start
-      @timing["secureConnectionStart"] = secure_connection_start
-      @timing["connectEnd"] = connect_end
-      @timing["requestStart"] = request_start
-      @timing["responseStart"] = response_start
+      @timing[:startTime] = start_time
+      @timing[:domainLookupStart] = domain_lookup_start
+      @timing[:domainLookupEnd] = domain_lookup_end
+      @timing[:connectStart] = connect_start
+      @timing[:secureConnectionStart] = secure_connection_start
+      @timing[:connectEnd] = connect_end
+      @timing[:requestStart] = request_start
+      @timing[:responseStart] = response_start
     end
 
     private def update_headers(headers)

data/lib/playwright/locator_impl.rb

@@ -142,7 +142,7 @@ module Playwright
       LocatorImpl.new(
         frame: @frame,
         timeout_settings: @timeout_settings,
-        selector: "#{@selector} >> _nth=first",
+        selector: "#{@selector} >> nth=0",
       )
     end
 
@@ -150,7 +150,7 @@ module Playwright
       LocatorImpl.new(
         frame: @frame,
         timeout_settings: @timeout_settings,
-        selector: "#{@selector} >> _nth=last",
+        selector: "#{@selector} >> nth=-1",
       )
     end
 
@@ -158,7 +158,7 @@ module Playwright
       LocatorImpl.new(
         frame: @frame,
         timeout_settings: @timeout_settings,
-        selector: "#{@selector} >> _nth=#{index}",
+        selector: "#{@selector} >> nth=#{index}",
       )
     end
 

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.14.beta2'
+  VERSION = '1.14.beta3'
   COMPATIBLE_PLAYWRIGHT_VERSION = '1.14.0'
 end

data/lib/playwright_api/android.rb

@@ -1,6 +1,19 @@
 module Playwright
-  # Playwright has **experimental** support for Android automation. See [here](./mobile.md) 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/lib/playwright_api/locator.rb

@@ -197,8 +197,8 @@ module Playwright
     # The method finds all elements matching the specified locator and passes an array of matched elements as a first argument
     # to `expression`. Returns the result of `expression` invocation.
     #
-    # If `expression` returns a [Promise], then [`Locator.evaluateAll`] would wait for the promise to resolve and return its
-    # value.
+    # If `expression` returns a [Promise], then [`method: Locator.evaluateAll`] would wait for the promise to resolve and
+    # return its value.
     #
     # Examples:
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: playwright-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.14.beta2
+  version: 1.14.beta3
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-06 00:00:00.000000000 Z
+date: 2021-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby