playwright-ruby-client 1.28.1 → 1.29.0

data/lib/playwright_api/frame_locator.rb

@@ -1,7 +1,6 @@
 module Playwright
-  # FrameLocator represents a view to the `iframe` on the page. It captures the logic sufficient to retrieve the `iframe`
-  # and locate elements in that iframe. FrameLocator can be created with either [`method: Page.frameLocator`] or
-  # [`method: Locator.frameLocator`] method.
+  #
+  # FrameLocator represents a view to the `iframe` on the page. It captures the logic sufficient to retrieve the `iframe` and locate elements in that iframe. FrameLocator can be created with either [`method: Page.frameLocator`] or [`method: Locator.frameLocator`] method.
   #
   # ```python sync
   # locator = page.frame_locator("my-frame").get_by_text("Submit")
@@ -10,8 +9,7 @@ module Playwright
   #
   # **Strictness**
   #
-  # Frame locators are strict. This means that all operations on frame locators will throw if more than one element matches
-  # a given selector.
+  # Frame locators are strict. This means that all operations on frame locators will throw if more than one element matches a given selector.
   #
   # ```python sync
   # # Throws if there are several frames in DOM:
@@ -23,25 +21,27 @@ module Playwright
   #
   # **Converting Locator to FrameLocator**
   #
-  # If you have a `Locator` object pointing to an `iframe` it can be converted to `FrameLocator` using
-  # [`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) CSS selector:
+  # If you have a `Locator` object pointing to an `iframe` it can be converted to `FrameLocator` using [`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) CSS selector:
   #
   # ```python sync
   # frameLocator = locator.frame_locator(":scope")
   # ```
   class FrameLocator < PlaywrightApi
 
+    #
     # Returns locator to the first matching frame.
     def first
       wrap_impl(@impl.first)
     end
 
-    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
-    # that iframe.
+    #
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements
+    # in that iframe.
     def frame_locator(selector)
       wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
     end
 
+    #
     # Allows locating elements by their alt text. For example, this method will find the image by alt text "Castle":
     #
     # ```html
@@ -51,8 +51,8 @@ module Playwright
       wrap_impl(@impl.get_by_alt_text(unwrap_impl(text), exact: unwrap_impl(exact)))
     end
 
-    # Allows locating input elements by the text of the associated label. For example, this method will find the input by
-    # label text "Password" in the following DOM:
+    #
+    # Allows locating input elements by the text of the associated label. For example, this method will find the input by label text "Password" in the following DOM:
     #
     # ```html
     # <label for="password-input">Password:</label>
@@ -62,8 +62,8 @@ module Playwright
       wrap_impl(@impl.get_by_label(unwrap_impl(text), exact: unwrap_impl(exact)))
     end
 
-    # Allows locating input elements by the placeholder text. For example, this method will find the input by placeholder
-    # "Country":
+    #
+    # Allows locating input elements by the placeholder text. For example, this method will find the input by placeholder "Country":
     #
     # ```html
     # <input placeholder="Country">
@@ -72,15 +72,10 @@ module Playwright
       wrap_impl(@impl.get_by_placeholder(unwrap_impl(text), exact: unwrap_impl(exact)))
     end
 
-    # Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),
-    # [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and
-    # [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). Note that role selector **does not replace**
-    # accessibility audits and conformance tests, but rather gives early feedback about the ARIA guidelines.
-    #
-    # Note that many html elements have an implicitly
-    # [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings) that is recognized by the role selector. You
-    # can find all the [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not
-    # recommend** duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.
+    #
+    # Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles), [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). Note that role selector **does not replace** accessibility audits and conformance tests, but rather gives early feedback about the ARIA guidelines.
+    #
+    # Note that many html elements have an implicitly [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings) that is recognized by the role selector. You can find all the [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not recommend** duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.
     def get_by_role(
           role,
           checked: nil,
@@ -95,12 +90,13 @@ module Playwright
       wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
     end
 
-    # Locate element by the test id. By default, the `data-testid` attribute is used as a test id. Use
-    # [`method: Selectors.setTestIdAttribute`] to configure a different test id attribute if necessary.
+    #
+    # Locate element by the test id. By default, the `data-testid` attribute is used as a test id. Use [`method: Selectors.setTestIdAttribute`] to configure a different test id attribute if necessary.
     def get_by_test_id(testId)
       wrap_impl(@impl.get_by_test_id(unwrap_impl(testId)))
     end
 
+    #
     # Allows locating elements that contain given text. Consider the following DOM structure:
     #
     # ```html
@@ -127,17 +123,16 @@ module Playwright
     # page.get_by_text(re.compile("^hello$", re.IGNORECASE))
     # ```
     #
-    # See also [`method: Locator.filter`] that allows to match by another criteria, like an accessible role, and then filter
-    # by the text content.
+    # See also [`method: Locator.filter`] that allows to match by another criteria, like an accessible role, and then filter by the text content.
     #
-    # > NOTE: Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into
-    # one, turns line breaks into spaces and ignores leading and trailing whitespace.
-    # > NOTE: Input elements of the type `button` and `submit` are matched by their `value` instead of the text content. For
-    # example, locating by text `"Log in"` matches `<input type=button value="Log in">`.
+    # **NOTE**: Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into one, turns line breaks into spaces and ignores leading and trailing whitespace.
+    #
+    # **NOTE**: Input elements of the type `button` and `submit` are matched by their `value` instead of the text content. For example, locating by text `"Log in"` matches `<input type=button value="Log in">`.
     def get_by_text(text, exact: nil)
       wrap_impl(@impl.get_by_text(unwrap_impl(text), exact: unwrap_impl(exact)))
     end
 
+    #
     # Allows locating elements by their title. For example, this method will find the button by its title "Place the order":
     #
     # ```html
@@ -147,19 +142,21 @@ module Playwright
       wrap_impl(@impl.get_by_title(unwrap_impl(text), exact: unwrap_impl(exact)))
     end
 
+    #
     # Returns locator to the last matching frame.
     def last
       wrap_impl(@impl.last)
     end
 
-    # The method finds an element matching the specified selector in the locator's subtree. It also accepts filter options,
-    # similar to [`method: Locator.filter`] method.
+    #
+    # The method finds an element matching the specified selector in the locator's subtree. It also accepts filter options, similar to [`method: Locator.filter`] method.
     #
     # [Learn more about locators](../locators.md).
     def locator(selector, has: nil, hasText: nil)
       wrap_impl(@impl.locator(unwrap_impl(selector), has: unwrap_impl(has), hasText: unwrap_impl(hasText)))
     end
 
+    #
     # Returns locator to the n-th matching frame. It's zero based, `nth(0)` selects the first frame.
     def nth(index)
       wrap_impl(@impl.nth(unwrap_impl(index)))

data/lib/playwright_api/js_handle.rb

@@ -1,4 +1,5 @@
 module Playwright
+  #
   # JSHandle represents an in-page JavaScript object. JSHandles can be created with the [`method: Page.evaluateHandle`]
   # method.
   #
@@ -15,23 +16,27 @@ module Playwright
   # [`method: Page.evaluateHandle`] methods.
   class JSHandle < PlaywrightApi
 
+    #
     # Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
     def as_element
       wrap_impl(@impl.as_element)
     end
 
+    #
     # The `jsHandle.dispose` method stops referencing the element handle.
     def dispose
       wrap_impl(@impl.dispose)
     end
 
+    #
     # Returns the return value of `expression`.
     #
     # This method passes this handle as the first argument to `expression`.
     #
-    # If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.
+    # If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return
+    # its value.
     #
-    # Examples:
+    # **Usage**
     #
     # ```python sync
     # tweet_handle = page.query_selector(".tweet .retweets")
@@ -41,12 +46,12 @@ module Playwright
       wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
+    #
     # Returns the return value of `expression` as a `JSHandle`.
     #
     # This method passes this handle as the first argument to `expression`.
     #
-    # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
-    # `JSHandle`.
+    # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns `JSHandle`.
     #
     # If the function passed to the `jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would wait
     # for the promise to resolve and return its value.
@@ -56,8 +61,11 @@ module Playwright
       wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
+    #
     # The method returns a map with **own property names** as keys and JSHandle instances for the property values.
     #
+    # **Usage**
+    #
     # ```python sync
     # handle = page.evaluate_handle("({window, document})")
     # properties = handle.get_properties()
@@ -70,15 +78,17 @@ module Playwright
     end
     alias_method :properties, :get_properties
 
+    #
     # Fetches a single property from the referenced object.
     def get_property(propertyName)
       wrap_impl(@impl.get_property(unwrap_impl(propertyName)))
     end
 
+    #
     # Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.
     #
-    # > NOTE: The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an
-    # error if the object has circular references.
+    # **NOTE**: The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an error if the
+    # object has circular references.
     def json_value
       wrap_impl(@impl.json_value)
     end

data/lib/playwright_api/keyboard.rb

@@ -1,4 +1,5 @@
 module Playwright
+  #
   # Keyboard provides an api for managing a virtual keyboard. The high level api is [`method: Keyboard.type`], which takes
   # raw characters and generates proper `keydown`, `keypress`/`input`, and `keyup` events on your page.
   #
@@ -36,10 +37,12 @@ module Playwright
   # ```
   class Keyboard < PlaywrightApi
 
+    #
     # Dispatches a `keydown` event.
     #
-    # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
-    # value or a single character to generate the text for. A superset of the `key` values can be found
+    # `key` can specify the intended
+    # [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to
+    # generate the text for. A superset of the `key` values can be found
     # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
     #
     # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
@@ -49,34 +52,39 @@ module Playwright
     #
     # Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
     #
-    # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
-    # texts.
+    # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different
+    # respective texts.
     #
-    # If `key` is a modifier key, `Shift`, `Meta`, `Control`, or `Alt`, subsequent key presses will be sent with that modifier
-    # active. To release the modifier key, use [`method: Keyboard.up`].
+    # If `key` is a modifier key, `Shift`, `Meta`, `Control`, or `Alt`, subsequent key presses will be sent with that
+    # modifier active. To release the modifier key, use [`method: Keyboard.up`].
     #
     # After the key is pressed once, subsequent calls to [`method: Keyboard.down`] will have
     # [repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) set to true. To release the key, use
     # [`method: Keyboard.up`].
     #
-    # > NOTE: Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
+    # **NOTE**: Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
     def down(key)
       wrap_impl(@impl.down(unwrap_impl(key)))
     end
 
+    #
     # Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
     #
+    # **Usage**
+    #
     # ```python sync
     # page.keyboard.insert_text("嗨")
     # ```
     #
-    # > NOTE: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
+    # **NOTE**: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
     def insert_text(text)
       wrap_impl(@impl.insert_text(unwrap_impl(text)))
     end
 
-    # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
-    # value or a single character to generate the text for. A superset of the `key` values can be found
+    #
+    # `key` can specify the intended
+    # [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to
+    # generate the text for. A superset of the `key` values can be found
     # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
     #
     # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
@@ -86,12 +94,14 @@ module Playwright
     #
     # Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
     #
-    # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
-    # texts.
+    # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different
+    # respective texts.
     #
     # Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified with the
     # modifier, modifier is pressed and being held while the subsequent key is being pressed.
     #
+    # **Usage**
+    #
     # ```python sync
     # page = browser.new_page()
     # page.goto("https://keycode.info")
@@ -109,21 +119,26 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
     end
 
+    #
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
     #
+    # **Usage**
+    #
     # ```python sync
     # page.keyboard.type("Hello") # types instantly
     # page.keyboard.type("World", delay=100) # types slower, like a user
     # ```
     #
-    # > NOTE: Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
-    # > NOTE: For characters that are not on a US keyboard, only an `input` event will be sent.
+    # **NOTE**: Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
+    #
+    # **NOTE**: For characters that are not on a US keyboard, only an `input` event will be sent.
     def type(text, delay: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay)))
     end
 
+    #
     # Dispatches a `keyup` event.
     def up(key)
       wrap_impl(@impl.up(unwrap_impl(key)))