Playwright Ruby Client

https://github.com/yusukeiwaki/playwright-ruby-client
Admin
Playwright Ruby Client is a Ruby binding for Playwright that enables browser automation for testing,...
Tokens:138,925
Snippets:1,619
Trust Score:9.2
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Ruby dependencies

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/development/README.md

Run the setup script to install necessary Ruby dependencies.

```sh
bin/setup
```

--------------------------------

### Install Dependencies

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/README.md

Run this command to install the necessary project dependencies.

```console
yarn install
```

--------------------------------

### Start Local Development Server

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/README.md

Starts a local development server with live reloading enabled.

```console
yarn start
```

--------------------------------

### PDF dimension configuration examples

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Examples showing how to specify width using pixels or other units.

```ruby
page.pdf({width: 100})
page.pdf({width: '100px'})
page.pdf({width: '10cm'})
```

--------------------------------

### Set input files usage examples

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Examples demonstrating how to select single files, multiple files, directories, or clear existing selections.

```ruby
# Select one file
page.get_by_label("Upload file").set_input_files('myfile.pdf')

# Select multiple files
page.get_by_label("Upload files").set_input_files(['file1.txt', 'file2.txt'])

# Select a directory
page.get_by_label("Upload directory").set_input_files('mydir')

# Remove all the selected files
page.get_by_label("Upload file").set_input_files([])
```

--------------------------------

### Basic Fetch GET Requests

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/network-tab/network.html

Examples of performing simple GET requests and requests with query parameters.

```javascript
fetch('/api/endpoint')
fetch('/call-with-query-params?param1=value1&param1=value2&param2=value2')
```

--------------------------------

### Tracing#start

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Starts recording a trace for the browser context.

```APIDOC
## Tracing#start

### Description
Starts tracing for the current browser context. It is recommended to use Playwright Test configuration instead of this method for complete test coverage.

### Method
Ruby Method

### Signature
`start(live: nil, name: nil, screenshots: nil, snapshots: nil, sources: nil, title: nil)`

### Parameters
- **live** (boolean) - Optional - Whether to enable live tracing.
- **name** (string) - Optional - Name of the trace.
- **screenshots** (boolean) - Optional - Whether to capture screenshots.
- **snapshots** (boolean) - Optional - Whether to capture DOM snapshots.
- **sources** (boolean) - Optional - Whether to include source code.
- **title** (string) - Optional - Title for the trace.
```

--------------------------------

### install

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/credentials.md

Installs the virtual WebAuthn authenticator into the context, overriding navigator.credentials.create() and navigator.credentials.get() in all current and future pages.

```APIDOC
## install

### Description
Installs the virtual WebAuthn authenticator into the context. This must be called before the page interacts with navigator.credentials to ensure interception is active.

### Signature
`def install`
```

--------------------------------

### GET request with query parameters

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/api_request_context.md

Example of configuring URL search parameters using the params option.

```ruby
query_params = {
  isbn: "1234",
  page: "23"
}
api_request_context.get("https://example.com/api/get_text", params: query_params)
```

--------------------------------

### Launch Playwright Server

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/README.md

Command to install browsers and start the Playwright server on a specific port and path.

```bash
npx playwright install && npx playwright run-server --port 8080 --path /ws
```

--------------------------------

### install(time: nil)

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/clock.md

Installs fake implementations for time-related functions like setTimeout, setInterval, and Date.

```APIDOC
## install(time: nil)

### Description
Install fake implementations for time-related functions to manually control the flow of time in tests.

### Parameters
- **time** (Time|nil) - Optional - The initial time to set when installing the clock.
```

--------------------------------

### Tracing start method signature

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Method signature for starting a trace session.

```ruby
def start(
      live: nil,
      name: nil,
      screenshots: nil,
      snapshots: nil,
      sources: nil,
      title: nil)
```

--------------------------------

### Evaluate Handle Usage Examples

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Examples demonstrating how to use evaluate_handle with promises, strings, and JSHandle arguments.

```ruby
a_window_handle = page.evaluate_handle("Promise.resolve(window)")
a_window_handle # handle for the window object.
```

```ruby
a_handle = page.evaluate_handle("document") # handle for the "document"
```

```ruby
body_handle = page.evaluate_handle("document.body")
result_handle = page.evaluate_handle("body => body.innerHTML", arg: body_handle)
puts result_handle.json_value
result_handle.dispose
```

--------------------------------

### Install virtual authenticator

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/credentials.md

Method signature for installing the virtual WebAuthn authenticator into the browser context.

```ruby
def install
```

--------------------------------

### Install Playwright Driver

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/getting_started.md

Execute this command to install the required Playwright driver.

```shell
$ npx playwright install
```

--------------------------------

### Android Native Automation Setup

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/README.md

Download the required Android driver APKs.

```bash
wget https://github.com/microsoft/playwright/raw/master/bin/android-driver-target.apk -O /path/to/playwright-driver/package/bin/android-driver-target.apk
wget https://github.com/microsoft/playwright/raw/master/bin/android-driver.apk -O /path/to/playwright-driver/package/bin/android-driver.apk
```

--------------------------------

### start_tracing

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser.md

Starts the Chromium tracing tool to record performance data.

```APIDOC
## start_tracing

### Description
Starts the Chromium tracing tool. This is a low-level debugging tool for Chromium.

### Signature
`def start_tracing(page: nil, categories: nil, path: nil, screenshots: nil)`

### Parameters
- **page** (Page) - Optional - The page to trace.
- **categories** (Array) - Optional - The categories to trace.
- **path** (String) - Optional - The file path to save the trace.
- **screenshots** (Boolean) - Optional - Whether to capture screenshots.
```

--------------------------------

### Run tests

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/development/README.md

Install browser binaries and execute the RSpec test suite.

```sh
$PLAYWRIGHT_CLI_EXECUTABLE_PATH install
bundle exec rspec
```

--------------------------------

### Install Playwright Driver

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/README.md

Install the required Playwright driver via npm.

```bash
npm install playwright
./node_modules/.bin/playwright install
```

--------------------------------

### Expose Binding Usage Example

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Example of exposing a Ruby function to the browser window object.

```ruby
page.expose_binding("pageURL", ->(source) { source[:page].url })
page.content = <<~HTML
<script>
  async function onClick() {
    document.querySelector('div').textContent = await window.pageURL();
  }
</script>
<button onclick="onClick()">Click me</button>
<div></div>
HTML
page.click("button")
```

--------------------------------

### Tracing start usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Basic usage for initiating a trace session.

```ruby
context.tracing.start(screenshots: true, snapshots: true)
page = context.new_page
page.goto('https://playwright.dev')
context.tracing.stop(path: 'trace.zip')
```

--------------------------------

### Pick Locator Usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Example of initiating the pick locator mode and outputting the resulting locator.

```ruby
locator = page.pick_locator
puts locator
```

--------------------------------

### Launch a browser instance

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Use the launch method to start a browser instance and execute actions within a block.

```ruby
chromium = playwright.chromium
chromium.launch do |browser|
  page = browser.new_page
  page.goto('https://example.com/')

  # other actions

end
```

--------------------------------

### Install Playwright Ruby Client

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/README.md

Add the gem to your Gemfile.

```ruby
gem 'playwright-ruby-client'
```

--------------------------------

### Download driver directly

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/download_playwright_driver.md

Useful for Docker integration where Node.js installation is not desired.

```shell
$ export PLAYWRIGHT_CLI_VERSION=$(bundle exec ruby -e 'puts Playwright::COMPATIBLE_PLAYWRIGHT_VERSION.strip')
$ wget https://playwright.azureedge.net/builds/driver/playwright-$PLAYWRIGHT_CLI_VERSION-linux.zip
```

--------------------------------

### select_option usage examples

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/element_handle.md

Demonstrates selecting options by value or label, including support for multiple selections.

```ruby
# single selection matching the value
element_handle.select_option(value: "blue")
# single selection matching both the label
element_handle.select_option(label: "blue")
# multiple selection
element_handle.select_option(value: ["red", "green", "blue"])
```

--------------------------------

### Example DOM structure for get_by_role

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Sample HTML structure used to demonstrate role-based element selection.

```html
<h3>Sign up</h3>
<label>
  <input type="checkbox" /> Subscribe
</label>
<br/>
<button>Submit</button>
```

--------------------------------

### Iterate over elements with Locator#all

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example of using all to retrieve a list of locators and perform actions on each.

```ruby
page.get_by_role('listitem').all.each do |li|
  li.click
end
```

--------------------------------

### Wait for locator usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example demonstrating how to wait for a specific element to appear on the page.

```ruby
order_sent = page.locator("#order-sent")
order_sent.wait_for
```

--------------------------------

### Tracing#start_har

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Starts recording a HAR file of network activity.

```APIDOC
## Tracing#start_har

### Description
Starts recording a HAR (HTTP Archive) of network activity. Only one HAR recording can be active at a time per context.

### Method
Ruby Method

### Signature
`start_har(path, content: nil, mode: nil, urlFilter: nil)`

### Parameters
- **path** (string) - Required - File path to save the HAR.
- **content** (string) - Optional - Whether to include content.
- **mode** (string) - Optional - Recording mode.
- **urlFilter** (string) - Optional - Filter for URLs to record.
```

--------------------------------

### Start Chromium Tracing

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser.md

Defines the method signature for initiating Chromium tracing.

```ruby
def start_tracing(page: nil, categories: nil, path: nil, screenshots: nil)
```

--------------------------------

### Wait for Function Usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Examples demonstrating how to observe state changes and pass arguments to the predicate function.

```ruby
page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
page.wait_for_function("() => window.x > 0")
```

```ruby
selector = ".foo"
page.wait_for_function("selector => !!document.querySelector(selector)", arg: selector)
```

--------------------------------

### Tracing start_chunk method signature

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Method signature for starting a new trace chunk.

```ruby
def start_chunk(name: nil, title: nil)
```

--------------------------------

### Get Download Page

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/download.md

Returns the page instance associated with the download.

```ruby
def page
```

--------------------------------

### Usage of Browser Tracing

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser.md

Demonstrates how to wrap page navigation with start and stop tracing calls to generate a trace file.

```ruby
browser.start_tracing(page: page, path: "trace.json")
begin
  page.goto("https://www.google.com")
ensure
  browser.stop_tracing
end
```

--------------------------------

### Generate PDF with screen media

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Example of setting the media type to screen before generating a PDF file.

```ruby
# generates a pdf with "screen" media type.
page.emulate_media(media: "screen")
page.pdf(path: "page.pdf")
```

--------------------------------

### Advanced screenshot configuration

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example of disabling animations and saving to a specific path.

```ruby
page.get_by_role("link").screenshot(animations="disabled", path="link.png")
```

--------------------------------

### Get bounding box

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Defines the bounding_box method signature and provides an example of using it to click the center of an element.

```ruby
def bounding_box(timeout: nil)
```

```ruby
element = page.get_by_role("button")
box = element.bounding_box
page.mouse.click(
  box["x"] + box["width"] / 2,
  box["y"] + box["height"] / 2,
)
```

--------------------------------

### Tracing start_har method signature

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Method signature for starting a HAR network recording.

```ruby
def start_har(path, content: nil, mode: nil, urlFilter: nil)
```

--------------------------------

### Record a full trace in Ruby

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Start recording a trace before performing actions and save it to a file upon completion.

```ruby
browser.new_context do |context|
  context.tracing.start(screenshots: true, snapshots: true)
  page = context.new_page
  page.goto('https://playwright.dev')
  context.tracing.stop(path: 'trace.zip')
end
```

--------------------------------

### Wait for Load State Usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Examples showing how to wait for default load events or specific states like DOMContentLoaded.

```ruby
page.get_by_role("button").click # click triggers navigation.
page.wait_for_load_state # the promise resolves after "load" event.
```

```ruby
popup = page.expect_popup do
  page.get_by_role("button").click # click triggers a popup.
end

# Wait for the "DOMContentLoaded" event.
popup.wait_for_load_state("domcontentloaded")
puts popup.title # popup is ready to use.
```

--------------------------------

### Tracing#start_chunk

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Starts a new trace chunk to allow recording multiple traces within the same browser context.

```APIDOC
## Tracing#start_chunk

### Description
Starts a new trace chunk. Use this to record multiple distinct traces on the same browser context.

### Method
Ruby Method

### Signature
`start_chunk(name: nil, title: nil)`

### Parameters
- **name** (string) - Optional - Name of the chunk.
- **title** (string) - Optional - Title for the chunk.
```

--------------------------------

### launch

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Launches a browser instance with the specified configuration options.

```APIDOC
## launch

### Description
Returns a new browser instance. This method supports various configuration options such as headless mode, proxy settings, and environment variables.

### Signature
`def launch(args: nil, artifactsDir: nil, channel: nil, chromiumSandbox: nil, downloadsPath: nil, env: nil, executablePath: nil, firefoxUserPrefs: nil, handleSIGHUP: nil, handleSIGINT: nil, handleSIGTERM: nil, headless: nil, ignoreDefaultArgs: nil, proxy: nil, slowMo: nil, timeout: nil, tracesDir: nil, &block)`

### Usage Example
```ruby
browser = playwright.chromium.launch(
  ignoreDefaultArgs: ["--mute-audio"]
)
browser.close
```
```

--------------------------------

### Launch browser instance

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/launch_browser.md

Demonstrates launching a browser with a block for automatic closure, or manually using begin/ensure blocks.

```ruby
# scoped browser block
playwright.chromium.launch do |browser|
  # Play with `browser`
end
```

```ruby
# separated start/end
browser = playwright.chromium.launch

begin
  # Play with `@browser`
ensure
  browser.close
end
```

--------------------------------

### Locate inputs by placeholder

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame_locator.md

Signature and usage example for finding input elements using their placeholder text.

```ruby
def get_by_placeholder(text, exact: nil)
```

```html
<input type="email" placeholder="name@example.com" />
```

```ruby
page.get_by_placeholder("name@example.com").fill("playwright@microsoft.com")
```

--------------------------------

### Initialize React rendering helpers

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/mui.html

Sets up global functions for creating elements and rendering them into the .react-root container.

```javascript
window.e = React.createElement; window.reactRoot = document.querySelector('.react-root'); window.renderComponent = c => ReactDOM.render(c, window.reactRoot);
```

--------------------------------

### Manage WebStorage items in Ruby

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/web_storage.md

Demonstrates basic operations including setting, retrieving, listing, and clearing storage items.

```ruby
page.goto("https://example.com")
page.local_storage.set_item("token", "abc")
token = page.local_storage.get_item("token")
all = page.local_storage.items
page.local_storage.remove_item("token")
page.local_storage.clear
```

--------------------------------

### Emulate Media Usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Examples of changing CSS media types and color schemes, verified via evaluate calls.

```ruby
page.evaluate("matchMedia('screen').matches") # => true
page.evaluate("matchMedia('print').matches") # => false

page.emulate_media(media: "print")
page.evaluate("matchMedia('screen').matches") # => false
page.evaluate("matchMedia('print').matches") # => true

page.emulate_media
page.evaluate("matchMedia('screen').matches") # => true
page.evaluate("matchMedia('print').matches") # => false
```

```ruby
page.emulate_media(colorScheme: "dark")
page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches") # => true
page.evaluate("matchMedia('(prefers-color-scheme: light)').matches") # => false
```

--------------------------------

### GET request method definition

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/api_request_context.md

Signature for the GET request method in the API request context.

```ruby
def get(
      url,
      data: nil,
      failOnStatusCode: nil,
      form: nil,
      headers: nil,
      ignoreHTTPSErrors: nil,
      maxRedirects: nil,
      maxRetries: nil,
      multipart: nil,
      params: nil,
      timeout: nil)
```

--------------------------------

### Launch browser instance

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Launches a browser instance with various configuration options.

```ruby
def launch(
      args: nil,
      artifactsDir: nil,
      channel: nil,
      chromiumSandbox: nil,
      downloadsPath: nil,
      env: nil,
      executablePath: nil,
      firefoxUserPrefs: nil,
      handleSIGHUP: nil,
      handleSIGINT: nil,
      handleSIGTERM: nil,
      headless: nil,
      ignoreDefaultArgs: nil,
      proxy: nil,
      slowMo: nil,
      timeout: nil,
      tracesDir: nil,
      &block)
```

--------------------------------

### Perform Page Assertions

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page_assertions.md

Example of setting page content and asserting the URL after an interaction.

```ruby
page.content = <<~HTML
<a href="https://example.com/user/login">Sign in</a>
HTML

page.get_by_text("Sign in").click
expect(page).to have_url(/.*\/login/)
```

--------------------------------

### Setup Touch Event Listeners

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/input/touches.html

Configures a button to log touch event identifiers to a result array for testing purposes.

```javascript
window.result = []; const button = document.querySelector('button'); button.style.height = '200px'; button.style.width = '200px'; button.focus(); button.addEventListener('touchstart', event => { log('Touchstart:', ...Array.from(event.changedTouches).map(touch => touch.identifier)); }); button.addEventListener('touchend', event => { log('Touchend:', ...Array.from(event.changedTouches).map(touch => touch.identifier)); }); button.addEventListener('touchmove', event => { log('Touchmove:', ...Array.from(event.changedTouches).map(touch => touch.identifier)); }); function log(...args) { console.log.apply(console, args); result.push(args.join(' ')); } function getResult() { let temp = result; result = []; return temp; }
```

--------------------------------

### Submit form using press_sequentially

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example of typing into a field and submitting via Enter key.

```ruby
element = page.get_by_label("Password")
element.press_sequentially("my password")
element.press("Enter")
```

--------------------------------

### goto

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Navigates to a specified URL and returns the main resource response.

```APIDOC
## goto(url, referer: nil, timeout: nil, waitUntil: nil)

### Description
Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect.

### Parameters
- **url** (string) - Required - The URL to navigate to.
- **referer** (string) - Optional - Referer header value.
- **timeout** (number) - Optional - Maximum navigation time in milliseconds.
- **waitUntil** (string) - Optional - When to consider navigation succeeded.
```

--------------------------------

### Example DOM structure for title lookup

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Sample HTML structure used to demonstrate title-based element selection.

```html
<span title='Issues count'>25 issues</span>
```

--------------------------------

### Create a Page with Browser

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser.md

Demonstrates launching a Firefox browser instance and creating a new page within it.

```ruby
firefox = playwright.firefox
browser = firefox.launch
begin
  page = browser.new_page
  page.goto("https://example.com")
ensure
  browser.close
end
```

--------------------------------

### Install Playwright driver

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/development/README.md

Install the specific Node.js Playwright driver version compatible with the Ruby client.

```sh
VERSION=$(ruby -r "./lib/playwright/version" -e "puts Playwright::COMPATIBLE_PLAYWRIGHT_VERSION")
npm install "playwright@$VERSION"
```

--------------------------------

### Retrieve text contents with Locator#all_text_contents

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example of retrieving text content values from all matching nodes.

```ruby
texts = page.get_by_role("link").all_text_contents
```

--------------------------------

### get(url, ...)

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/api_request_context.md

Sends an HTTP(S) GET request and returns the response, automatically handling cookies and redirects.

```APIDOC
## get(url, ...)

### Description
Sends an HTTP(S) GET request and returns its response. The method populates request cookies from the context and updates context cookies from the response, while automatically following redirects.

### Parameters
- **url** (string) - Required - The URL to send the request to.
- **data** (any) - Optional - Request body data.
- **failOnStatusCode** (boolean) - Optional - Whether to fail on non-success status codes.
- **form** (hash) - Optional - Form data to send.
- **headers** (hash) - Optional - HTTP headers to include.
- **ignoreHTTPSErrors** (boolean) - Optional - Whether to ignore HTTPS errors.
- **maxRedirects** (integer) - Optional - Maximum number of redirects to follow.
- **maxRetries** (integer) - Optional - Maximum number of retries.
- **multipart** (hash) - Optional - Multipart form data.
- **params** (hash) - Optional - URL search parameters.
- **timeout** (integer) - Optional - Request timeout in milliseconds.
```

--------------------------------

### Connect over CDP usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Example of attaching to an existing browser via CDP and accessing the default context.

```ruby
browser = playwright.chromium.connect_over_cdp("http://localhost:9222")
default_context = browser.contexts.first
page = default_context.pages.first
```

--------------------------------

### Name test case 747 setup

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wpt/accname/manual/name_test_case_747-manual.html

Initializes the accessibility test case with specific property expectations for various accessibility APIs.

```javascript
setup({explicit_timeout: true, explicit_done: true }); var theTest = new ATTAcomm( { "steps" : [ { "element" : "test", "test" : { "ATK" : [ [ "property", "name", "is", "crazy 4" ] ], "AXAPI" : [ [ "property", "AXDescription", "is", "crazy 4" ] ], "IAccessible2" : [ [ "property", "accName", "is", "crazy 4" ] ], "UIA" : [ [ "property", "Name", "is", "crazy 4" ] ] }, "title" : "step 1", "type" : "test" } ], "title" : "Name test case 747" } ) ;
```

--------------------------------

### browser

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_context.md

Gets the browser instance that owns the context.

```APIDOC
## browser

### Description
Gets the browser instance that owns the context. Returns null if the context is created outside of normal browser, e.g. Android or Electron.
```

--------------------------------

### Get page title

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Returns the title of the current page.

```ruby
def title
```

--------------------------------

### goto

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Navigates to a specified URL.

```APIDOC
## goto(url, referer: nil, timeout: nil, waitUntil: nil)

### Description
Navigates to the specified URL. Returns the main resource response.

### Parameters
- **url** (string) - Required - The URL to navigate to.
- **referer** (string) - Optional - Referer header value.
- **timeout** (number) - Optional - Maximum navigation time in milliseconds.
- **waitUntil** (string) - Optional - When to consider navigation succeeded.
```

--------------------------------

### Get request method

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/request.md

Returns the HTTP method of the request.

```ruby
def method
```

--------------------------------

### Connect method signature

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Signature for connecting to an existing browser instance created via launchServer.

```ruby
def connect(
      endpoint,
      exposeNetwork: nil,
      headers: nil,
      slowMo: nil,
      timeout: nil,
      &block)
```

--------------------------------

### Get security details

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns SSL and other security-related information.

```ruby
def security_details
```

--------------------------------

### Usage of press_sequentially

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Examples of typing text with and without delay.

```ruby
element.press_sequentially("hello") # types instantly
element.press_sequentially("world", delay: 100) # types slower, like a user
```

--------------------------------

### Configure and use select_option method

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Defines the signature for selecting options in a select element and provides examples for single and multiple selection.

```ruby
def select_option(
      selector,
      element: nil,
      index: nil,
      value: nil,
      label: nil,
      force: nil,
      noWaitAfter: nil,
      strict: nil,
      timeout: nil)
```

```ruby
# single selection matching the value
page.select_option("select#colors", value: "blue")
# single selection matching both the label
page.select_option("select#colors", label: "blue")
# multiple selection
page.select_option("select#colors", value: ["red", "green", "blue"])
```

--------------------------------

### Connect with Launch Options

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/playwright_on_alpine_linux.md

Pass browser launch options as a JSON-encoded query string in the WebSocket endpoint URL.

```ruby
require 'json'

launch_params = { headless: false }
Playwright.connect_to_browser_server("wss://example.com:8888/ws?launch-options=#{launch_params.to_json}") do |browser|
  page = browser.new_page
  page.goto('https://github.com/microsoft/playwright')
  page.screenshot(path: 'github-microsoft-playwright_headful.png')
end

Playwright.connect_to_browser_server('wss://example.com:8888/ws') do |browser|
  page = browser.new_page
  page.goto('https://github.com/microsoft/playwright')
  page.screenshot(path: 'github-microsoft-playwright_headless.png')
end
```

--------------------------------

### Download driver using npm

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/download_playwright_driver.md

Recommended for most use cases where a Node.js environment is available.

```shell
$ export PLAYWRIGHT_CLI_VERSION=$(bundle exec ruby -e 'puts Playwright::COMPATIBLE_PLAYWRIGHT_VERSION.strip')
$ npm install playwright@$PLAYWRIGHT_CLI_VERSION || npm install playwright@next
$ ./node_modules/.bin/playwright install
```

--------------------------------

### Get viewport size

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Retrieves the current viewport size of the page.

```ruby
def viewport_size
```

--------------------------------

### Create a new page

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_context.md

Initializes a new page within the current browser context.

```ruby
def new_page(&block)
```

--------------------------------

### Initialize Description Test Case 666

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wpt/accname/manual/description_test_case_666-manual.html

Sets up the test environment and defines the expected accessibility property values for the 'test' element.

```javascript
setup({explicit_timeout: true, explicit_done: true }); var theTest = new ATTAcomm( { "steps" : [ { "element" : "test", "test" : { "ATK" : [ [ "property", "description", "is", "foo" ] ], "AXAPI" : [ [ "property", "AXHelp", "is", "foo" ] ], "IAccessible2" : [ [ "property", "accDescription", "is", "foo" ] ], "UIA" : [ [ "property", "Description", "is", "foo" ] ] }, "title" : "step 1", "type" : "test" } ], "title" : "Description test case 666" } ) ;
```

--------------------------------

### Get Browser Context

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Retrieves the browser context associated with the page.

```ruby
def context
```

--------------------------------

### Create and manage a BrowserContext

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_context.md

Demonstrates initializing a new incognito context, creating a page, and disposing of the context.

```ruby
# create a new incognito browser context
context = browser.new_context

# create a new page inside context.
page = context.new_page
page.goto("https://example.com")

# dispose context once it is no longer needed.
context.close
```

--------------------------------

### Get element attribute

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/element_handle.md

Retrieves the value of a specific attribute from the element.

```ruby
def get_attribute(name)
```

--------------------------------

### Get request post data

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/request.md

Retrieves the request body if present.

```ruby
def post_data
```

--------------------------------

### Load and execute WebAssembly table functions

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wasm/table2.html

Initializes a WebAssembly table with 'anyfunc' elements and invokes functions stored at specific indices after instantiation.

```javascript
async function loadTable() { const tbl = new WebAssembly.Table({ initial: 2, element: 'anyfunc' }); const response = await fetch('table2.wasm'); const body = await response.arrayBuffer(); await WebAssembly.instantiate(body, { js: { tbl: tbl } }); return `${tbl.get(0)()}, ${tbl.get(1)()}`; }
```

--------------------------------

### Get status text

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the status text associated with the response.

```ruby
def status_text
```

--------------------------------

### Get status code

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the HTTP status code of the response.

```ruby
def status
```

--------------------------------

### Launch persistent browser context in Ruby

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Initializes a browser instance with persistent storage at the specified directory. Closing the returned context automatically terminates the browser process.

```ruby
def launch_persistent_context(
      userDataDir,
      acceptDownloads: nil,
      args: nil,
      artifactsDir: nil,
      baseURL: nil,
      bypassCSP: nil,
      channel: nil,
      chromiumSandbox: nil,
      clientCertificates: nil,
      colorScheme: nil,
      contrast: nil,
      deviceScaleFactor: nil,
      downloadsPath: nil,
      env: nil,
      executablePath: nil,
      extraHTTPHeaders: nil,
      firefoxUserPrefs: nil,
      forcedColors: nil,
      geolocation: nil,
      handleSIGHUP: nil,
      handleSIGINT: nil,
      handleSIGTERM: nil,
      hasTouch: nil,
      headless: nil,
      httpCredentials: nil,
      ignoreDefaultArgs: nil,
      ignoreHTTPSErrors: nil,
      isMobile: nil,
      javaScriptEnabled: nil,
      locale: nil,
      noViewport: nil,
      offline: nil,
      permissions: nil,
      proxy: nil,
      record_har_content: nil,
      record_har_mode: nil,
      record_har_omit_content: nil,
      record_har_path: nil,
      record_har_url_filter: nil,
      record_video_dir: nil,
      record_video_size: nil,
      reducedMotion: nil,
      screen: nil,
      serviceWorkers: nil,
      slowMo: nil,
      strictSelectors: nil,
      timeout: nil,
      timezoneId: nil,
      tracesDir: nil,
      userAgent: nil,
      viewport: nil,
      &block)
```

--------------------------------

### Get server address

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the IP address and port of the server.

```ruby
def server_addr
```

--------------------------------

### Get matching request

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the Request object associated with this response.

```ruby
def request
```

--------------------------------

### Get HTTP version

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the HTTP version used by the response.

```ruby
def http_version
```

--------------------------------

### Get initiating frame

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the Frame object that initiated the response.

```ruby
def frame
```

--------------------------------

### Initialize Description Test Case 557

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wpt/accname/manual/description_test_case_557-manual.html

Sets up the test environment and defines the expected accessibility property values for the 'test' element.

```javascript
setup({explicit_timeout: true, explicit_done: true }); var theTest = new ATTAcomm( { "steps" : [ { "element" : "test", "test" : { "ATK" : [ [ "property", "description", "is", "t" ] ], "AXAPI" : [ [ "property", "AXHelp", "is", "t" ] ], "IAccessible2" : [ [ "property", "accDescription", "is", "t" ] ], "UIA" : [ [ "property", "Description", "is", "t" ] ] }, "title" : "step 1", "type" : "test" } ], "title" : "Description test case 557" } ) ;
```

--------------------------------

### Get Download URL

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/download.md

Returns the source URL of the downloaded file.

```ruby
def url
```

--------------------------------

### Usage of hover

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example of triggering a hover action on a link element.

```ruby
page.get_by_role("link").hover
```

--------------------------------

### Basic ElementHandle usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/element_handle.md

Demonstrates querying an anchor element and performing a click action.

```ruby
href_element = page.query_selector("a")
href_element.click
```

--------------------------------

### launch_persistent_context

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Launches a browser that uses persistent storage located at the specified directory and returns the browser context instance. Closing this context will automatically close the browser.

```APIDOC
## launch_persistent_context

### Description
Launches a browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this context will automatically close the browser.

### Method
Ruby Method

### Parameters
- **userDataDir** (String) - Required - Path to the user data directory.
- **acceptDownloads** (Boolean) - Optional - Whether to automatically download all attachments.
- **args** (Array) - Optional - Additional arguments to pass to the browser instance.
- **baseURL** (String) - Optional - Base URL to be used with all navigation methods.
- **headless** (Boolean) - Optional - Whether to run browser in headless mode.
- **viewport** (Hash) - Optional - Sets a consistent viewport for each page.
- **userAgent** (String) - Optional - Specific user agent to use in this context.
- **locale** (String) - Optional - Specify user locale, for example en-GB, de-DE.
- **timezoneId** (String) - Optional - Changes the timezone of the context.
- **permissions** (Array) - Optional - A list of permissions to grant.
- **timeout** (Integer) - Optional - Maximum time in milliseconds to wait for the browser to launch.
```

--------------------------------

### Get text content

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Returns the text content of the element matching the selector.

```ruby
def text_content(selector, strict: nil, timeout: nil)
```

--------------------------------

### Get Browser Type

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser.md

Retrieves the browser type associated with the current instance.

```ruby
def browser_type
```

--------------------------------

### Navigate and Screenshot with Page

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Creates a new page, navigates to a specified URL, and captures a screenshot.

```ruby
playwright.webkit.launch do |browser|
  page = browser.new_page
  page.goto('https://example.com/')
  page.screenshot(path: 'screenshot.png')
end
```

--------------------------------

### Get response body as text

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns the text representation of the response body.

```ruby
def text
```

--------------------------------

### Deploy to GitHub Pages

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/README.md

Builds the site and pushes the static content to the gh-pages branch.

```console
GIT_USER=<Your GitHub username> USE_SSH=true yarn deploy
```

--------------------------------

### get

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/credentials.md

Retrieves credentials held by the authenticator, optionally filtered by ID or rpId.

```APIDOC
## get

### Description
Returns every credential currently held by the authenticator, optionally filtered by rpId or id.

### Signature
`def get(id: nil, rpId: nil)`

### Parameters
- **id** (String) - Optional - Filter by credential ID.
- **rpId** (String) - Optional - Filter by Relying Party ID.
```

--------------------------------

### Usage of wait_for_selector

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Example of waiting for a selector across multiple page navigations.

```ruby
%w[https://playwright.dev/ https://playwright-ruby-client.vercel.app/].each do |current_url|
  page.goto(current_url, waitUntil: "domcontentloaded")
  element = page.wait_for_selector("img")
  puts "Loaded image: #{element["src"]}"
end
```

--------------------------------

### Locator usage comparison

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/element_handle.md

Illustrates the preferred approach using Locators, which re-locate the element before each action.

```ruby
locator = page.get_by_text("Submit")
locator.hover
locator.click
```

--------------------------------

### Usage of expect_response

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Examples of waiting for a response using a regex or a lambda predicate.

```ruby
page.content = '<form action="https://example.com/resource"><input type="submit" value="trigger response" /></form>'
response = page.expect_response(/example.com\/resource/) do
  page.get_by_text("trigger response").click
end
puts response.body
puts response.ok?

page.wait_for_load_state # wait for request finished.

# or with a predicate
page.content = '<form action="https://example.com/resource"><input type="submit" value="trigger response" /></form>'
response = page.expect_response(->(res) { res.url.start_with? 'https://example.com/resource' }) do
  page.get_by_text("trigger response").click
end
puts response.body
puts response.ok?
```

--------------------------------

### Tracing start_chunk usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/tracing.md

Record multiple trace files on the same browser context using chunks.

```ruby
context.tracing.start(screenshots: true, snapshots: true)
page = context.new_page
page.goto("https://playwright.dev")

context.tracing.start_chunk
page.get_by_text("Get Started").click
# Everything between start_chunk and stop_chunk will be recorded in the trace.
context.tracing.stop_chunk(path: "trace1.zip")

context.tracing.start_chunk
page.goto("http://example.com")
# Save a second trace file with different actions.
context.tracing.stop_chunk(path: "trace2.zip")
```

--------------------------------

### Usage of eval_on_selector_all

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Example of evaluating a JavaScript expression on all elements matching a selector.

```ruby
divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", arg: 10)
```

--------------------------------

### Record browser video with Playwright

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/recording_video.md

Demonstrates how to configure a browser context to record video to a temporary directory and retrieve the path while the context is active.

```ruby
require 'tmpdir'

playwright.chromium.launch do |browser|
  Dir.mktmpdir do |tmp|
    video_path = nil

    browser.new_context(record_video_dir: tmp) do |context|
      page = context.new_page
      # play with page

      # NOTE: Page#video is available **only when browser context is alive.**
      video_path = page.video.path
    end

    # NOTE: video is completely saved **only after browser context is closed.**
    handle_video_as_you_like(video_path)
  end
```

--------------------------------

### Open new window and tab

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/launch_browser.md

Use browser contexts to manage isolated windows and pages.

```ruby
Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
  playwright.chromium.launch(headless: false) do |browser| # Chromium task icon appears.
    context = browser.new_context # Prepare new window.
    page = context.new_page # Open new window and new tab here. (about:blank)
    page.goto('https://example.com') # Navigate to a site.

    page2 = context.new_page # Open another tab here.
    page2.goto('https://example.com') # Navigate to a site.

    another_context = browser.new_context # Prepare another window here.
    another_page = another_context.new_page # Open a new window and new tab.
    another_page.goto('https://example.com/') # Navigate to a site.
  end
end
```

--------------------------------

### Handle Worker Events in Ruby

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/worker.md

Demonstrates how to listen for worker creation and closure events on a page.

```ruby
def handle_worker(worker)
  puts "worker created: #{worker.url}"
  worker.once("close", -> (w) { puts "worker destroyed: #{w.url}" })
end

page.on('worker', method(:handle_worker))

puts "current workers:"
page.workers.each do |worker|
  puts "    #{worker.url}"
end
```

--------------------------------

### Install capybara-playwright-driver gem

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/article/guides/rails_integration.md

Add this line to your Gemfile to include the Playwright driver for Capybara.

```rb
gem 'capybara-playwright-driver'
```

--------------------------------

### Launch with ignored default arguments

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_type.md

Demonstrates filtering out specific default arguments like --mute-audio during browser launch.

```ruby
browser = playwright.chromium.launch( # or "firefox" or "webkit".
  ignoreDefaultArgs: ["--mute-audio"]
)

browser.close
```

--------------------------------

### Get page opener

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Returns the opener for popup pages, or null if not applicable or closed.

```ruby
def opener
```

--------------------------------

### Register and use a custom selector engine

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/selectors.md

Demonstrates registering a tag-based selector engine and using it within a browser context.

```ruby
tag_selector = <<~JAVASCRIPT
{
    // Returns the first element matching given selector in the root's subtree.
    query(root, selector) {
        return root.querySelector(selector);
    },
    // Returns all elements matching given selector in the root's subtree.
    queryAll(root, selector) {
        return Array.from(root.querySelectorAll(selector));
    }
}
JAVASCRIPT

# Register the engine. Selectors will be prefixed with "tag=".
playwright.selectors.register("tag", script: tag_selector)
playwright.chromium.launch do |browser|
  page = browser.new_page
  page.content = '<div><button>Click me</button></div>'

  # Use the selector prefixed with its name.
  button = page.locator('tag=button')
  # Combine it with other selector engines.
  page.locator('tag=div').get_by_text('Click me').click

  # Can use it in any methods supporting selectors.
  button_count = page.locator('tag=button').count
  button_count # => 1
end
```

--------------------------------

### Get main frame

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/page.md

Returns the page's main frame, which persists during navigations.

```ruby
def main_frame
```

--------------------------------

### Launch a browser instance with Playwright

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/playwright.md

Initializes a Playwright session and launches a Chromium browser instance to navigate to a URL.

```ruby
require 'playwright'

Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
  chromium = playwright.chromium # or "firefox" or "webkit".
  chromium.launch do |browser|
    page = browser.new_page
    page.goto('https://example.com/')

    # other actions

  end
end
```

--------------------------------

### Get storage state

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser_context.md

Retrieves the current cookies, local storage, and IndexedDB snapshot.

```ruby
def storage_state(indexedDB: nil, path: nil)
```

--------------------------------

### Get Browser Version

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/browser.md

Defines the method signature for retrieving the browser version string.

```ruby
def version
```

--------------------------------

### Initialize Description Test Case 664

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wpt/accname/manual/description_test_case_664-manual.html

Configures the test environment and defines the expected accessibility property values for the 'foo' description.

```javascript
setup({explicit_timeout: true, explicit_done: true }); var theTest = new ATTAcomm( { "steps" : [ { "element" : "test", "test" : { "ATK" : [ [ "property", "description", "is", "foo" ] ], "AXAPI" : [ [ "property", "AXHelp", "is", "foo" ] ], "IAccessible2" : [ [ "property", "accDescription", "is", "foo" ] ], "UIA" : [ [ "property", "Description", "is", "foo" ] ] }, "title" : "step 1", "type" : "test" } ], "title" : "Description test case 664" } ) ;
```

--------------------------------

### Initialize Description Test Case 838

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wpt/accname/manual/description_test_case_838-manual.html

Sets up the test environment and defines the expected accessibility property values for the description attribute.

```javascript
setup({explicit_timeout: true, explicit_done: true }); var theTest = new ATTAcomm( { "steps" : [ { "element" : "test", "test" : { "ATK" : [ [ "property", "description", "is", "foo" ] ], "AXAPI" : [ [ "property", "AXHelp", "is", "foo" ] ], "IAccessible2" : [ [ "property", "accDescription", "is", "foo" ] ], "UIA" : [ [ "property", "Description", "is", "foo" ] ] }, "title" : "step 1", "type" : "test" } ], "title" : "Description test case 838" } ) ;
```

--------------------------------

### Get all values for a header

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/response.md

Returns all values for a specific header name as a list, case-insensitive.

```ruby
def header_values(name)
```

--------------------------------

### Get credentials

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/credentials.md

Method signature for retrieving credentials held by the authenticator, with optional filtering.

```ruby
def get(id: nil, rpId: nil)
```

--------------------------------

### Initialize Shadow DOM Slots for Name Computation

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/spec/assets/wpt/accname/name/shadowdom/slot.html

Sets up various shadow DOM configurations with slots to test name computation behavior.

```javascript
document.getElementById('host1').attachShadow({ mode: 'open' }).innerHTML = 'foo <slot></slot> bar'; document.getElementById('host2').attachShadow({ mode: 'open' }).innerHTML = 'foo <slot>default</slot> bar'; document.getElementById('host3').attachShadow({ mode: 'open' }).innerHTML = 'foo <slot aria-label="label"></slot> bar'; document.getElementById('host4').attachShadow({ mode: 'open' }).innerHTML = 'foo <slot aria-label="label">default</slot> bar'; AriaUtils.verifyLabelsBySelector('.labelled');
```

--------------------------------

### Fill Input Field Usage

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/locator.md

Example of filling a textbox element with a specific value.

```ruby
page.get_by_role("textbox").fill("example value")
```

--------------------------------

### Trigger select-all keyboard shortcut

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/keyboard.md

Demonstrates cross-platform keyboard shortcuts for selecting all text.

```ruby
# RECOMMENDED
page.keyboard.press("ControlOrMeta+A")

# or just on windows and linux
page.keyboard.press("Control+A")
# or just on macOS
page.keyboard.press("Meta+A")
```

--------------------------------

### Example DOM structure for get_by_test_id

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Sample HTML structure containing a data-testid attribute.

```html
<button data-testid="directions">Itinéraire</button>
```

--------------------------------

### Browser Launchers (chromium, firefox, webkit)

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/playwright.md

Methods to launch or connect to specific browser engines, returning a Browser instance.

```APIDOC
## playwright.chromium / playwright.firefox / playwright.webkit

### Description
These objects provide methods to launch or connect to their respective browser engines (Chromium, Firefox, or WebKit).

### Return Value
- **Browser** - Returns an instance of the Browser class.
```

--------------------------------

### Usage of eval_on_selector

Source: https://github.com/yusukeiwaki/playwright-ruby-client/blob/main/documentation/docs/api/frame.md

Examples of evaluating JavaScript expressions on a single element found by a selector.

```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", arg: "hello")
```
Tokens:
Raw