Class: Playwright::Locator

Inherits:
PlaywrightApi show all
Defined in:
lib/playwright_api/locator.rb

Overview

Locators are the central piece of Playwright’s auto-waiting and retry-ability. In a nutshell, locators represent a way to find element(s) on the page at any moment. Locator can be created with the [‘method: Page.locator`] method.

[Learn more about locators](../locators.md).

Instance Method Summary collapse

Methods inherited from PlaywrightApi

#initialize, unwrap, wrap

Constructor Details

This class inherits a constructor from Playwright::PlaywrightApi

Instance Method Details

#all ⇒ Object

When locator points to a list of elements, returns array of locators, pointing to respective elements.

Usage

“‘python sync for li in page.get_by_role(’listitem’).all():

li.click();

“‘



19
20
21
 
# File 'lib/playwright_api/locator.rb', line 19

def all
  wrap_impl(@impl.all)
end

#all_inner_texts ⇒ Object

Returns an array of node.innerText values for all matching nodes.



25
26
27
 
# File 'lib/playwright_api/locator.rb', line 25

def all_inner_texts
  wrap_impl(@impl.all_inner_texts)
end

#all_text_contents ⇒ Object

Returns an array of node.textContent values for all matching nodes.



31
32
33
 
# File 'lib/playwright_api/locator.rb', line 31

def all_text_contents
  wrap_impl(@impl.all_text_contents)
end

#blur(timeout: nil) ⇒ Object

Calls [blur](developer.mozilla.org/en-US/docs/Web/API/HTMLElement/blur) on the element.



37
38
39
 
# File 'lib/playwright_api/locator.rb', line 37

def blur(timeout: nil)
  wrap_impl(@impl.blur(timeout: unwrap_impl(timeout)))
end

#bounding_box(timeout: nil) ⇒ Object

This method returns the bounding box of the element, or null if the element is not visible. The bounding box is calculated relative to the main frame viewport - which is usually the same as the browser window.

Scrolling affects the returned bounding box, similarly to [Element.getBoundingClientRect](developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect). That means x and/or y may be negative.

Elements from child frames return the bounding box relative to the main frame, unlike the [Element.getBoundingClientRect](developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).

Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the following snippet should click the center of the element.

Usage

“‘python sync box = element.bounding_box() page.mouse.click(box + box / 2, box + box / 2) “`



61
62
63
 
# File 'lib/playwright_api/locator.rb', line 61

def bounding_box(timeout: nil)
  wrap_impl(@impl.bounding_box(timeout: unwrap_impl(timeout)))
end

#check(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object

This method checks the element by performing the following steps:

  1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already checked, this method returns immediately.

  2. Wait for [actionability](../actionability.md) checks on the element, unless force option is set.

  3. Scroll the element into view if needed.

  4. Use [‘property: Page.mouse`] to click in the center of the element.

  5. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set.

  6. Ensure that the element is now checked. If not, this method throws.

If the element is detached from the DOM at any moment during the action, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.



78
79
80
81
82
83
84
85
 
# File 'lib/playwright_api/locator.rb', line 78

def check(
      force: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.check(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#checked?(timeout: nil) ⇒ Boolean

Returns whether the element is checked. Throws if the element is not a checkbox or radio input.

Returns:

  • (Boolean) 


493
494
495
 
# File 'lib/playwright_api/locator.rb', line 493

def checked?(timeout: nil)
  wrap_impl(@impl.checked?(timeout: unwrap_impl(timeout)))
end

#clear(force: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

This method waits for [actionability](../actionability.md) checks, focuses the element, clears it and triggers an input event after clearing.

If the target element is not an ‘<input>`, `<textarea>` or [contenteditable] element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be cleared instead.



91
92
93
 
# File 'lib/playwright_api/locator.rb', line 91

def clear(force: nil, noWaitAfter: nil, timeout: nil)
  wrap_impl(@impl.clear(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
end

#click(button: nil, clickCount: nil, delay: nil, force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object

Click an element.

Details

This method clicks the element by performing the following steps:

  1. Wait for [actionability](../actionability.md) checks on the element, unless force option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.mouse`] to click in the center of the element, or the specified position.

  4. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set.

If the element is detached from the DOM at any moment during the action, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.



110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/playwright_api/locator.rb', line 110

def click(
      button: nil,
      clickCount: nil,
      delay: nil,
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.click(button: unwrap_impl(button), clickCount: unwrap_impl(clickCount), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#count ⇒ Object

Returns the number of elements matching given selector.



125
126
127
 
# File 'lib/playwright_api/locator.rb', line 125

def count
  wrap_impl(@impl.count)
end

#dblclick(button: nil, delay: nil, force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object

This method double clicks the element by performing the following steps:

  1. Wait for [actionability](../actionability.md) checks on the element, unless force option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.mouse`] to double click in the center of the element, or the specified position.

  4. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set. Note that if the first click of the ‘dblclick()` triggers a navigation event, this method will throw.

If the element is detached from the DOM at any moment during the action, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.

NOTE: ‘element.dblclick()` dispatches two click events and a single dblclick event.



142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/playwright_api/locator.rb', line 142

def dblclick(
      button: nil,
      delay: nil,
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.dblclick(button: unwrap_impl(button), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#disabled?(timeout: nil) ⇒ Boolean

Returns whether the element is disabled, the opposite of [enabled](../actionability.md#enabled).

Returns:

  • (Boolean) 


499
500
501
 
# File 'lib/playwright_api/locator.rb', line 499

def disabled?(timeout: nil)
  wrap_impl(@impl.disabled?(timeout: unwrap_impl(timeout)))
end

#dispatch_event(type, eventInit: nil, timeout: nil) ⇒ Object

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()](developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).

Usage

“‘python sync element.dispatch_event(“click”) “`

Under the hood, it creates an instance of an event based on the given type, initializes it with eventInit properties and dispatches it on the element. Events are composed, cancelable and bubble by default.

Since eventInit is event-specific, please refer to the events documentation for the lists of initial properties:

You can also specify JSHandle as the property value if you want live objects to be passed into the event:

“‘python sync # note you can only create data_transfer in chromium and firefox data_transfer = page.evaluate_handle(“new DataTransfer()”) element.dispatch_event(“#source”, “dragstart”, data_transfer) “`



186
187
188
 
# File 'lib/playwright_api/locator.rb', line 186

def dispatch_event(type, eventInit: nil, timeout: nil)
  wrap_impl(@impl.dispatch_event(unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
end

#drag_to(target, force: nil, noWaitAfter: nil, sourcePosition: nil, targetPosition: nil, timeout: nil, trial: nil) ⇒ Object

This method drags the locator to another target locator or target position. It will first move to the source element, perform a mousedown, then move to the target element or position and perform a mouseup.

Usage

“‘python sync source = page.locator(“#source”) target = page.locator(“#target”)

source.drag_to(target) # or specify exact positions relative to the top-left corners of the elements: source.drag_to(

target,
source_position={"x": 34, "y": 7},
target_position={"x": 10, "y": 20}

) “‘



209
210
211
212
213
214
215
216
217
218
 
# File 'lib/playwright_api/locator.rb', line 209

def drag_to(
      target,
      force: nil,
      noWaitAfter: nil,
      sourcePosition: nil,
      targetPosition: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.drag_to(unwrap_impl(target), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), sourcePosition: unwrap_impl(sourcePosition), targetPosition: unwrap_impl(targetPosition), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#editable?(timeout: nil) ⇒ Boolean

Returns whether the element is [editable](../actionability.md#editable).

Returns:

  • (Boolean) 


505
506
507
 
# File 'lib/playwright_api/locator.rb', line 505

def editable?(timeout: nil)
  wrap_impl(@impl.editable?(timeout: unwrap_impl(timeout)))
end

#element_handle(timeout: nil) ⇒ Object

Resolves given locator to the first matching DOM element. If no elements matching the query are visible, waits for them up to a given timeout. If multiple elements match the selector, throws.



222
223
224
 
# File 'lib/playwright_api/locator.rb', line 222

def element_handle(timeout: nil)
  wrap_impl(@impl.element_handle(timeout: unwrap_impl(timeout)))
end

#element_handles ⇒ Object

Resolves given locator to all matching DOM elements.



228
229
230
 
# File 'lib/playwright_api/locator.rb', line 228

def element_handles
  wrap_impl(@impl.element_handles)
end

#enabled?(timeout: nil) ⇒ Boolean

Returns whether the element is [enabled](../actionability.md#enabled).

Returns:

  • (Boolean) 


511
512
513
 
# File 'lib/playwright_api/locator.rb', line 511

def enabled?(timeout: nil)
  wrap_impl(@impl.enabled?(timeout: unwrap_impl(timeout)))
end

#evaluate(expression, arg: nil, timeout: nil) ⇒ Object

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.

Usage

“‘python sync tweets = page.locator(“.tweet .retweets”) assert tweets.evaluate(“node => node.innerText”) == “10 retweets” “`



246
247
248
 
# File 'lib/playwright_api/locator.rb', line 246

def evaluate(expression, arg: nil, timeout: nil)
  wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg), timeout: unwrap_impl(timeout)))
end

#evaluate_all(expression, arg: nil) ⇒ Object

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 [‘method: Locator.evaluateAll`] would wait for the promise to resolve and return its value.

Usage

“‘python sync elements = page.locator(“div”) div_counts = elements.evaluate_all(“(divs, min) => divs.length >= min”, 10) “`



263
264
265
 
# File 'lib/playwright_api/locator.rb', line 263

def evaluate_all(expression, arg: nil)
  wrap_impl(@impl.evaluate_all(unwrap_impl(expression), arg: unwrap_impl(arg)))
end

#evaluate_handle(expression, arg: nil, timeout: nil) ⇒ Object

Returns the return value of expression as a JSHandle.

This method passes this handle as the first argument to expression.

The only difference between [‘method: Locator.evaluate`] and [`method: Locator.evaluateHandle`] is that [`method: Locator.evaluateHandle`] returns JSHandle.

If the function passed to the [‘method: Locator.evaluateHandle`] returns a [Promise], then [`method: Locator.evaluateHandle`] would wait for the promise to resolve and return its value.

See [‘method: Page.evaluateHandle`] for more details.



278
279
280
 
# File 'lib/playwright_api/locator.rb', line 278

def evaluate_handle(expression, arg: nil, timeout: nil)
  wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg), timeout: unwrap_impl(timeout)))
end

#fill(value, force: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

This method waits for [actionability](../actionability.md) checks, focuses the element, fills it and triggers an input event after filling. Note that you can pass an empty string to clear the input field.

If the target element is not an ‘<input>`, `<textarea>` or [contenteditable] element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.

To send fine-grained keyboard events, use [‘method: Locator.type`].



288
289
290
 
# File 'lib/playwright_api/locator.rb', line 288

def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
  wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
end

#filter(has: nil, hasText: nil) ⇒ Object

This method narrows existing locator according to the options, for example filters by text. It can be chained to filter multiple times.

Usage

“‘python sync row_locator = page.locator(“tr”) # … row_locator

.filter(has_text="text in column 1")
.filter(has=page.get_by_role("button", name="column 2 button"))
.screenshot()

“‘



306
307
308
 
# File 'lib/playwright_api/locator.rb', line 306

def filter(has: nil, hasText: nil)
  wrap_impl(@impl.filter(has: unwrap_impl(has), hasText: unwrap_impl(hasText)))
end

#first ⇒ Object

Returns locator to the first matching element.



312
313
314
 
# File 'lib/playwright_api/locator.rb', line 312

def first
  wrap_impl(@impl.first)
end

#focus(timeout: nil) ⇒ Object

Calls [focus](developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.



318
319
320
 
# File 'lib/playwright_api/locator.rb', line 318

def focus(timeout: nil)
  wrap_impl(@impl.focus(timeout: unwrap_impl(timeout)))
end

#frame_locator(selector) ⇒ Object

Usage

When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in that iframe:

“‘python sync locator = page.frame_locator(“iframe”).get_by_text(“Submit”) locator.click() “`



332
333
334
 
# File 'lib/playwright_api/locator.rb', line 332

def frame_locator(selector)
  wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
end

#get_attribute(name, timeout: nil) ⇒ Object Also known as: []

Returns element attribute value.



338
339
340
 
# File 'lib/playwright_api/locator.rb', line 338

def get_attribute(name, timeout: nil)
  wrap_impl(@impl.get_attribute(unwrap_impl(name), timeout: unwrap_impl(timeout)))
end

#get_by_alt_text(text, exact: nil) ⇒ Object

Allows locating elements by their alt text. For example, this method will find the image by alt text “Castle”:

“‘html <img alt=’Castle’> “‘



349
350
351
 
# File 'lib/playwright_api/locator.rb', line 349

def get_by_alt_text(text, exact: nil)
  wrap_impl(@impl.get_by_alt_text(unwrap_impl(text), exact: unwrap_impl(exact)))
end

#get_by_label(text, exact: nil) ⇒ Object

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”> “`



360
361
362
 
# File 'lib/playwright_api/locator.rb', line 360

def get_by_label(text, exact: nil)
  wrap_impl(@impl.get_by_label(unwrap_impl(text), exact: unwrap_impl(exact)))
end

#get_by_placeholder(text, exact: nil) ⇒ Object

Allows locating input elements by the placeholder text. For example, this method will find the input by placeholder “Country”:

“‘html <input placeholder=“Country”> “`



370
371
372
 
# File 'lib/playwright_api/locator.rb', line 370

def get_by_placeholder(text, exact: nil)
  wrap_impl(@impl.get_by_placeholder(unwrap_impl(text), exact: unwrap_impl(exact)))
end

#get_by_role(role, checked: nil, disabled: nil, exact: nil, expanded: nil, includeHidden: nil, level: nil, name: nil, pressed: nil, selected: nil) ⇒ Object

Allows locating elements by their [ARIA role](www.w3.org/TR/wai-aria-1.2/#roles), [ARIA attributes](www.w3.org/TR/wai-aria-1.2/#aria-attributes) and [accessible name](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](w3c.github.io/html-aam/#html-element-role-mappings) that is recognized by the role selector. You can find all the [supported roles here](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.



378
379
380
381
382
383
384
385
386
387
388
389
390
 
# File 'lib/playwright_api/locator.rb', line 378

def get_by_role(
      role,
      checked: nil,
      disabled: nil,
      exact: nil,
      expanded: nil,
      includeHidden: nil,
      level: nil,
      name: nil,
      pressed: nil,
      selected: nil)
  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

#get_by_test_id(testId) ⇒ Object

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.



394
395
396
 
# File 'lib/playwright_api/locator.rb', line 394

def get_by_test_id(testId)
  wrap_impl(@impl.get_by_test_id(unwrap_impl(testId)))
end

#get_by_text(text, exact: nil) ⇒ Object

Allows locating elements that contain given text. Consider the following DOM structure:

“‘html <div>Hello <span>world</span></div> <div>Hello</div> “`

You can locate by text substring, exact string, or a regular expression:

“‘python sync # Matches <span> page.get_by_text(“world”)

# Matches first <div> page.get_by_text(“Hello world”)

# Matches second <div> page.get_by_text(“Hello”, exact=True)

# Matches both <div>s page.get_by_text(re.compile(“Hello”))

# Matches second <div> 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.

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”>`.



430
431
432
 
# File 'lib/playwright_api/locator.rb', line 430

def get_by_text(text, exact: nil)
  wrap_impl(@impl.get_by_text(unwrap_impl(text), exact: unwrap_impl(exact)))
end

#get_by_title(text, exact: nil) ⇒ Object

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> “‘



440
441
442
 
# File 'lib/playwright_api/locator.rb', line 440

def get_by_title(text, exact: nil)
  wrap_impl(@impl.get_by_title(unwrap_impl(text), exact: unwrap_impl(exact)))
end

#hidden?(timeout: nil) ⇒ Boolean

Returns whether the element is hidden, the opposite of [visible](../actionability.md#visible).

Returns:

  • (Boolean) 


517
518
519
 
# File 'lib/playwright_api/locator.rb', line 517

def hidden?(timeout: nil)
  wrap_impl(@impl.hidden?(timeout: unwrap_impl(timeout)))
end

#highlight ⇒ Object

Highlight the corresponding element(s) on the screen. Useful for debugging, don’t commit the code that uses [‘method: Locator.highlight`].



446
447
448
 
# File 'lib/playwright_api/locator.rb', line 446

def highlight
  wrap_impl(@impl.highlight)
end

#hover(force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object

This method hovers over the element by performing the following steps:

  1. Wait for [actionability](../actionability.md) checks on the element, unless force option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.mouse`] to hover over the center of the element, or the specified position.

  4. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set.

If the element is detached from the DOM at any moment during the action, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.



461
462
463
464
465
466
467
468
469
 
# File 'lib/playwright_api/locator.rb', line 461

def hover(
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.hover(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#inner_html(timeout: nil) ⇒ Object

Returns the element.innerHTML.



473
474
475
 
# File 'lib/playwright_api/locator.rb', line 473

def inner_html(timeout: nil)
  wrap_impl(@impl.inner_html(timeout: unwrap_impl(timeout)))
end

#inner_text(timeout: nil) ⇒ Object

Returns the element.innerText.



479
480
481
 
# File 'lib/playwright_api/locator.rb', line 479

def inner_text(timeout: nil)
  wrap_impl(@impl.inner_text(timeout: unwrap_impl(timeout)))
end

#input_value(timeout: nil) ⇒ Object

Returns input.value for the selected ‘<input>` or `<textarea>` or `<select>` element.

Throws for non-input elements. However, if the element is inside the ‘<label>` element that has an associated [control](developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), returns the value of the control.



487
488
489
 
# File 'lib/playwright_api/locator.rb', line 487

def input_value(timeout: nil)
  wrap_impl(@impl.input_value(timeout: unwrap_impl(timeout)))
end

#last ⇒ Object

Returns locator to the last matching element.



529
530
531
 
# File 'lib/playwright_api/locator.rb', line 529

def last
  wrap_impl(@impl.last)
end

#locator(selector, has: nil, hasText: nil) ⇒ Object

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).



537
538
539
 
# File 'lib/playwright_api/locator.rb', line 537

def locator(selector, has: nil, hasText: nil)
  wrap_impl(@impl.locator(unwrap_impl(selector), has: unwrap_impl(has), hasText: unwrap_impl(hasText)))
end

#nth(index) ⇒ Object

Returns locator to the n-th matching element. It’s zero based, ‘nth(0)` selects the first element.



543
544
545
 
# File 'lib/playwright_api/locator.rb', line 543

def nth(index)
  wrap_impl(@impl.nth(unwrap_impl(index)))
end

#page ⇒ Object

A page this locator belongs to.



549
550
551
 
# File 'lib/playwright_api/locator.rb', line 549

def page
  wrap_impl(@impl.page)
end

#press(key, delay: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

Focuses the element, and then uses [‘method: Keyboard.down`] and [`method: Keyboard.up`].

key can specify the intended [keyboardEvent.key](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](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, Delete, Escape, ArrowDown, End, Enter, Home, Insert, PageDown, PageUp, ArrowRight, ArrowUp, etc.

Following modification shortcuts are also supported: Shift, Control, Alt, Meta, ShiftLeft.

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.

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.



573
574
575
 
# File 'lib/playwright_api/locator.rb', line 573

def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
  wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
end

#screenshot(animations: nil, caret: nil, mask: nil, omitBackground: nil, path: nil, quality: nil, scale: nil, timeout: nil, type: nil) ⇒ Object

This method captures a screenshot of the page, clipped to the size and position of a particular element matching the locator. If the element is covered by other elements, it will not be actually visible on the screenshot. If the element is a scrollable container, only the currently scrolled content will be visible on the screenshot.

This method waits for the [actionability](../actionability.md) checks, then scrolls element into view before taking a screenshot. If the element is detached from DOM, the method throws an error.

Returns the buffer with the captured screenshot.



584
585
586
587
588
589
590
591
592
593
594
595
 
# File 'lib/playwright_api/locator.rb', line 584

def screenshot(
      animations: nil,
      caret: nil,
      mask: nil,
      omitBackground: nil,
      path: nil,
      quality: nil,
      scale: nil,
      timeout: nil,
      type: nil)
  wrap_impl(@impl.screenshot(animations: unwrap_impl(animations), caret: unwrap_impl(caret), mask: unwrap_impl(mask), omitBackground: unwrap_impl(omitBackground), path: unwrap_impl(path), quality: unwrap_impl(quality), scale: unwrap_impl(scale), timeout: unwrap_impl(timeout), type: unwrap_impl(type)))
end

#scroll_into_view_if_needed(timeout: nil) ⇒ Object

This method waits for [actionability](../actionability.md) checks, then tries to scroll element into view, unless it is completely visible as defined by [IntersectionObserver](developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)‘s ratio.



601
602
603
 
# File 'lib/playwright_api/locator.rb', line 601

def scroll_into_view_if_needed(timeout: nil)
  wrap_impl(@impl.scroll_into_view_if_needed(timeout: unwrap_impl(timeout)))
end

#select_option(element: nil, index: nil, value: nil, label: nil, force: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

Selects option or options in ‘<select>`.

Details

This method waits for [actionability](../actionability.md) checks, waits until all specified options are present in the ‘<select>` element and selects these options.

If the target element is not a ‘<select>` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used instead.

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.

Usage

“‘html <select multiple>

<option value="red">Red</div>
<option value="green">Green</div>
<option value="blue">Blue</div>

</select> “‘

“‘python sync # single selection matching the value or label element.select_option(“blue”) # single selection matching the label element.select_option(label=“blue”) # multiple selection for blue, red and second option element.select_option(value=[“red”, “green”, “blue”]) “`



636
637
638
639
640
641
642
643
644
645
 
# File 'lib/playwright_api/locator.rb', line 636

def select_option(
      element: nil,
      index: nil,
      value: nil,
      label: nil,
      force: nil,
      noWaitAfter: nil,
      timeout: nil)
  wrap_impl(@impl.select_option(element: unwrap_impl(element), index: unwrap_impl(index), value: unwrap_impl(value), label: unwrap_impl(label), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
end

#select_text(force: nil, timeout: nil) ⇒ Object

This method waits for [actionability](../actionability.md) checks, then focuses the element and selects all its text content.

If the element is inside the ‘<label>` element that has an associated [control](developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), focuses and selects text in the control instead.



652
653
654
 
# File 'lib/playwright_api/locator.rb', line 652

def select_text(force: nil, timeout: nil)
  wrap_impl(@impl.select_text(force: unwrap_impl(force), timeout: unwrap_impl(timeout)))
end

#set_checked(checked, force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object Also known as: checked=

This method checks or unchecks an element by performing the following steps:

  1. Ensure that matched element is a checkbox or a radio input. If not, this method throws.

  2. If the element already has the right checked state, this method returns immediately.

  3. Wait for [actionability](../actionability.md) checks on the matched element, unless force option is set. If the element is detached during the checks, the whole action is retried.

  4. Scroll the element into view if needed.

  5. Use [‘property: Page.mouse`] to click in the center of the element.

  6. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set.

  7. Ensure that the element is now checked or unchecked. If not, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.



668
669
670
671
672
673
674
675
676
 
# File 'lib/playwright_api/locator.rb', line 668

def set_checked(
      checked,
      force: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.set_checked(unwrap_impl(checked), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#set_input_files(files, noWaitAfter: nil, timeout: nil) ⇒ Object Also known as: input_files=

Sets the value of the file input to these file paths or files. If some of the filePaths are relative paths, then they are resolved relative to the current working directory. For empty array, clears the selected files.

This method expects Locator to point to an [input element](developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside the ‘<label>` element that has an associated [control](developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), targets the control instead.



685
686
687
 
# File 'lib/playwright_api/locator.rb', line 685

def set_input_files(files, noWaitAfter: nil, timeout: nil)
  wrap_impl(@impl.set_input_files(unwrap_impl(files), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
end

#tap_point(force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object

This method taps the element by performing the following steps:

  1. Wait for [actionability](../actionability.md) checks on the element, unless force option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.touchscreen`] to tap the center of the element, or the specified position.

  4. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set.

If the element is detached from the DOM at any moment during the action, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.

NOTE: ‘element.tap()` requires that the hasTouch option of the browser context be set to true.



703
704
705
706
707
708
709
710
711
 
# File 'lib/playwright_api/locator.rb', line 703

def tap_point(
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.tap_point(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#text_content(timeout: nil) ⇒ Object

Returns the node.textContent.



715
716
717
 
# File 'lib/playwright_api/locator.rb', line 715

def text_content(timeout: nil)
  wrap_impl(@impl.text_content(timeout: unwrap_impl(timeout)))
end

#to_s ⇒ Object 



781
782
783
 
# File 'lib/playwright_api/locator.rb', line 781

def to_s
  wrap_impl(@impl.to_s)
end

#type(text, delay: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

Focuses the element, and then 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: Locator.press`].

Usage

“‘python sync element.type(“hello”) # types instantly element.type(“world”, delay=100) # types slower, like a user “`

An example of typing into a text field and then submitting the form:

“‘python sync element = page.get_by_label(“Password”) element.type(“my password”) element.press(“Enter”) “`



738
739
740
 
# File 'lib/playwright_api/locator.rb', line 738

def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
  wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
end

#uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil) ⇒ Object

This method checks the element by performing the following steps:

  1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already unchecked, this method returns immediately.

  2. Wait for [actionability](../actionability.md) checks on the element, unless force option is set.

  3. Scroll the element into view if needed.

  4. Use [‘property: Page.mouse`] to click in the center of the element.

  5. Wait for initiated navigations to either succeed or fail, unless noWaitAfter option is set.

  6. Ensure that the element is now unchecked. If not, this method throws.

If the element is detached from the DOM at any moment during the action, this method throws.

When all steps combined have not finished during the specified timeout, this method throws a TimeoutError. Passing zero timeout disables this.



755
756
757
758
759
760
761
762
 
# File 'lib/playwright_api/locator.rb', line 755

def uncheck(
      force: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  wrap_impl(@impl.uncheck(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
end

#visible?(timeout: nil) ⇒ Boolean

Returns whether the element is [visible](../actionability.md#visible).

Returns:

  • (Boolean) 


523
524
525
 
# File 'lib/playwright_api/locator.rb', line 523

def visible?(timeout: nil)
  wrap_impl(@impl.visible?(timeout: unwrap_impl(timeout)))
end

#wait_for(state: nil, timeout: nil) ⇒ Object

Returns when element specified by locator satisfies the state option.

If target element already satisfies the condition, the method returns immediately. Otherwise, waits for up to timeout milliseconds until the condition is met.

Usage

“‘python sync order_sent = page.locator(“#order-sent”) order_sent.wait_for() “`



776
777
778
 
# File 'lib/playwright_api/locator.rb', line 776

def wait_for(state: nil, timeout: nil)
  wrap_impl(@impl.wait_for(state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
end