playwright-ruby-client 1.28.1 → 1.29.0

data/documentation/docs/api/frame_locator.md

@@ -4,9 +4,8 @@ sidebar_position: 10
 
 # FrameLocator
 
-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 [Page#frame_locator](./page#frame_locator) or
-[Locator#frame_locator](./locator#frame_locator) 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 [Page#frame_locator](./page#frame_locator) or [Locator#frame_locator](./locator#frame_locator) method.
 
 ```ruby
 locator = page.frame_locator("my-frame").get_by_text("Submit")
@@ -15,8 +14,7 @@ locator.click
 
 **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.
 
 ```ruby
 # Throws if there are several frames in DOM:
@@ -28,21 +26,19 @@ page.frame_locator('.result-frame').first.get_by_role('button').click
 
 **Converting Locator to FrameLocator**
 
-If you have a [Locator](./locator) object pointing to an `iframe` it can be converted to [FrameLocator](./frame_locator) using
-[`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) CSS selector:
+If you have a [Locator](./locator) object pointing to an `iframe` it can be converted to [FrameLocator](./frame_locator) using [`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) CSS selector:
 
 ```ruby
 frame_locator = locator.frame_locator(':scope')
 ```
 
-
-
 ## first
 
 ```
 def first
 ```
 
+
 Returns locator to the first matching frame.
 
 ## frame_locator
@@ -51,8 +47,9 @@ Returns locator to the first matching frame.
 def frame_locator(selector)
 ```
 
-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.
 
 ## get_by_alt_text
 
@@ -60,42 +57,40 @@ that iframe.
 def get_by_alt_text(text, exact: nil)
 ```
 
+
 Allows locating elements by their alt text. For example, this method will find the image by alt text "Castle":
 
 ```html
 <img alt='Castle'>
 ```
 
-
 ## get_by_label
 
 ```
 def get_by_label(text, exact: nil)
 ```
 
-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>
 <input id="password-input">
 ```
 
-
 ## get_by_placeholder
 
 ```
 def get_by_placeholder(text, exact: nil)
 ```
 
-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">
 ```
 
-
 ## get_by_role
 
 ```
@@ -112,15 +107,10 @@ def get_by_role(
       selected: nil)
 ```
 
-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.
 
 ## get_by_test_id
 
@@ -128,10 +118,8 @@ recommend** duplicating implicit roles and attributes by setting `role` and/or `
 def get_by_test_id(testId)
 ```
 
-Locate element by the test id. By default, the `data-testid` attribute is used as a test id. Use
-[Selectors#set_test_id_attribute](./selectors#set_test_id_attribute) 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 [Selectors#set_test_id_attribute](./selectors#set_test_id_attribute) to configure a different test id attribute if necessary.
 
 ## get_by_text
 
@@ -139,6 +127,7 @@ Locate element by the test id. By default, the `data-testid` attribute is used a
 def get_by_text(text, exact: nil)
 ```
 
+
 Allows locating elements that contain given text. Consider the following DOM structure:
 
 ```html
@@ -177,13 +166,11 @@ locator = page.get_by_text(/^hello$/i)
 expect(locator.evaluate('e => e.outerHTML')).to eq('<div>Hello</div>')
 ```
 
-See also [Locator#filter](./locator#filter) that allows to match by another criteria, like an accessible role, and then filter
-by the text content.
+See also [Locator#filter](./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: 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**: 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">`.
 
 ## get_by_title
 
@@ -191,19 +178,20 @@ example, locating by text `"Log in"` matches `<input type=button value="Log in">
 def get_by_title(text, exact: nil)
 ```
 
+
 Allows locating elements by their title. For example, this method will find the button by its title "Place the order":
 
 ```html
 <button title='Place the order'>Order Now</button>
 ```
 
-
 ## last
 
 ```
 def last
 ```
 
+
 Returns locator to the last matching frame.
 
 ## locator
@@ -212,8 +200,8 @@ Returns locator to the last matching frame.
 def locator(selector, has: nil, hasText: nil)
 ```
 
-The method finds an element matching the specified selector in the locator's subtree. It also accepts filter options,
-similar to [Locator#filter](./locator#filter) method.
+
+The method finds an element matching the specified selector in the locator's subtree. It also accepts filter options, similar to [Locator#filter](./locator#filter) method.
 
 [Learn more about locators](https://playwright.dev/python/docs/locators).
 
@@ -223,4 +211,5 @@ similar to [Locator#filter](./locator#filter) method.
 def nth(index)
 ```
 
+
 Returns locator to the n-th matching frame. It's zero based, `nth(0)` selects the first frame.

data/documentation/docs/api/js_handle.md

@@ -4,6 +4,7 @@ sidebar_position: 10
 
 # JSHandle
 
+
 JSHandle represents an in-page JavaScript object. JSHandles can be created with the [Page#evaluate_handle](./page#evaluate_handle)
 method.
 
@@ -25,6 +26,7 @@ JSHandle instances can be used as an argument in [Page#eval_on_selector](./page#
 def as_element
 ```
 
+
 Returns either `null` or the object handle itself, if the object handle is an instance of [ElementHandle](./element_handle).
 
 ## dispose
@@ -33,6 +35,7 @@ Returns either `null` or the object handle itself, if the object handle is an in
 def dispose
 ```
 
+
 The `jsHandle.dispose` method stops referencing the element handle.
 
 ## evaluate
@@ -41,33 +44,33 @@ The `jsHandle.dispose` method stops referencing the element handle.
 def evaluate(expression, arg: nil)
 ```
 
+
 Returns the return value of `expression`.
 
 This method passes this handle as the first argument to `expression`.
 
-If `expression` returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then `handle.evaluate` 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 `handle.evaluate` would wait for the promise to resolve and return
+its value.
 
-Examples:
+**Usage**
 
 ```ruby
 tweet_handle = page.query_selector(".tweet .retweets")
 tweet_handle.evaluate("node => node.innerText") # => "10 retweets"
 ```
 
-
-
 ## evaluate_handle
 
 ```
 def evaluate_handle(expression, arg: nil)
 ```
 
+
 Returns the return value of `expression` as a [JSHandle](./js_handle).
 
 This method passes this handle as the first argument to `expression`.
 
-The only difference between [JSHandle#evaluate](./js_handle#evaluate) and [JSHandle#evaluate_handle](./js_handle#evaluate_handle) is that [JSHandle#evaluate_handle](./js_handle#evaluate_handle) returns
-[JSHandle](./js_handle).
+The only difference between [JSHandle#evaluate](./js_handle#evaluate) and [JSHandle#evaluate_handle](./js_handle#evaluate_handle) is that [JSHandle#evaluate_handle](./js_handle#evaluate_handle) returns [JSHandle](./js_handle).
 
 If the function passed to the [JSHandle#evaluate_handle](./js_handle#evaluate_handle) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [JSHandle#evaluate_handle](./js_handle#evaluate_handle) would wait
 for the promise to resolve and return its value.
@@ -81,8 +84,11 @@ def get_properties
 ```
 alias: `properties`
 
+
 The method returns a map with **own property names** as keys and JSHandle instances for the property values.
 
+**Usage**
+
 ```ruby
 page.goto('https://example.com/')
 handle = page.evaluate_handle("({window, document})")
@@ -93,14 +99,13 @@ document_handle = properties["document"]
 handle.dispose
 ```
 
-
-
 ## get_property
 
 ```
 def get_property(propertyName)
 ```
 
+
 Fetches a single property from the referenced object.
 
 ## json_value
@@ -109,7 +114,8 @@ Fetches a single property from the referenced object.
 def json_value
 ```
 
+
 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.

data/documentation/docs/api/keyboard.md

@@ -4,6 +4,7 @@ sidebar_position: 10
 
 # Keyboard
 
+
 Keyboard provides an api for managing a virtual keyboard. The high level api is [Keyboard#type](./keyboard#type), which takes
 raw characters and generates proper `keydown`, `keypress`/`input`, and `keyup` events on your page.
 
@@ -39,18 +40,18 @@ page.keyboard.press("Control+A")
 page.keyboard.press("Meta+A")
 ```
 
-
-
 ## down
 
 ```
 def down(key)
 ```
 
+
 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`,
@@ -60,17 +61,17 @@ Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`,
 
 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 [Keyboard#up](./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 [Keyboard#up](./keyboard#up).
 
 After the key is pressed once, subsequent calls to [Keyboard#down](./keyboard#down) will have
 [repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) set to true. To release the key, use
 [Keyboard#up](./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.
 
 ## insert_text
 
@@ -78,13 +79,16 @@ After the key is pressed once, subsequent calls to [Keyboard#down](./keyboard#do
 def insert_text(text)
 ```
 
+
 Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
 
+**Usage**
+
 ```ruby
 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.
 
 ## press
 
@@ -92,8 +96,10 @@ page.keyboard.insert_text("嗨")
 def press(key, delay: nil)
 ```
 
-`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`,
@@ -103,12 +109,14 @@ Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`,
 
 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**
+
 ```ruby
 page.goto("https://keycode.info")
 page.keyboard.press("a")
@@ -127,17 +135,21 @@ Shortcut for [Keyboard#down](./keyboard#down) and [Keyboard#up](./keyboard#up).
 def type(text, delay: nil)
 ```
 
+
 Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
 
 To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./keyboard#press).
 
+**Usage**
+
 ```ruby
 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.
 
 ## up
 
@@ -145,4 +157,5 @@ page.keyboard.type("World", delay: 100) # types slower, like a user
 def up(key)
 ```
 
+
 Dispatches a `keyup` event.