playwright-ruby-client 0.0.3 → 0.0.4

data/lib/playwright_api/browser_type.rb

@@ -1,5 +1,7 @@
 module Playwright
-  # BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is a typical example of using Playwright to drive automation:
+  # BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is a
+  # typical example of using Playwright to drive automation:
+  # 
   #
   # ```js
   # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
@@ -25,7 +27,9 @@ module Playwright
     end
 
     # Returns the browser instance.
+    # 
     # You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+    # 
     #
     # ```js
     # const browser = await chromium.launch({  // Or 'firefox' or 'webkit'.
@@ -33,76 +37,91 @@ module Playwright
     # });
     # ```
     # 
-    # **Chromium-only** Playwright can also be used to control the Chrome browser, but it works best with the version of Chromium it is bundled with. There is no guarantee it will work with any other version. Use `executablePath` option with extreme caution.
-    # If Google Chrome (rather than Chromium) is preferred, a Chrome Canary or Dev Channel build is suggested.
-    # In `browserType.launch([options])` above, any mention of Chromium also applies to Chrome.
-    # See `this article` for a description of the differences between Chromium and Chrome. `This article` describes some differences for Linux users.
+    # > **Chromium-only** Playwright can also be used to control the Chrome browser, but it works best with the version of
+    # Chromium it is bundled with. There is no guarantee it will work with any other version. Use `executablePath` option with
+    # extreme caution.
+    # >
+    # > If Google Chrome (rather than Chromium) is preferred, a
+    # [Chrome Canary](https://www.google.com/chrome/browser/canary.html) or
+    # [Dev Channel](https://www.chromium.org/getting-involved/dev-channel) build is suggested.
+    # >
+    # > In [`method: BrowserType.launch`] above, any mention of Chromium also applies to Chrome.
+    # >
+    # > See [`this article`](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for
+    # a description of the differences between Chromium and Chrome.
+    # [`This article`](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)
+    # describes some differences for Linux users.
     def launch(
-          headless: nil,
-          executablePath: nil,
           args: nil,
-          ignoreDefaultArgs: nil,
-          proxy: nil,
-          downloadsPath: nil,
           chromiumSandbox: nil,
+          devtools: nil,
+          downloadsPath: nil,
+          env: nil,
+          executablePath: nil,
           firefoxUserPrefs: nil,
+          handleSIGHUP: nil,
           handleSIGINT: nil,
           handleSIGTERM: nil,
-          handleSIGHUP: nil,
+          headless: nil,
+          ignoreDefaultArgs: nil,
           logger: nil,
-          timeout: nil,
-          env: nil,
-          devtools: nil,
+          proxy: nil,
           slowMo: nil,
+          timeout: nil,
           &block)
-      wrap_channel_owner(@channel_owner.launch(headless: headless, executablePath: executablePath, args: args, ignoreDefaultArgs: ignoreDefaultArgs, proxy: proxy, downloadsPath: downloadsPath, chromiumSandbox: chromiumSandbox, firefoxUserPrefs: firefoxUserPrefs, handleSIGINT: handleSIGINT, handleSIGTERM: handleSIGTERM, handleSIGHUP: handleSIGHUP, logger: logger, timeout: timeout, env: env, devtools: devtools, slowMo: slowMo, &wrap_block_call(block)))
+      wrap_channel_owner(@channel_owner.launch(args: args, chromiumSandbox: chromiumSandbox, devtools: devtools, downloadsPath: downloadsPath, env: env, executablePath: executablePath, firefoxUserPrefs: firefoxUserPrefs, handleSIGHUP: handleSIGHUP, handleSIGINT: handleSIGINT, handleSIGTERM: handleSIGTERM, headless: headless, ignoreDefaultArgs: ignoreDefaultArgs, logger: logger, proxy: proxy, slowMo: slowMo, timeout: timeout, &wrap_block_call(block)))
     end
 
     # Returns the persistent browser context instance.
-    # Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this context will automatically close the browser.
+    # 
+    # Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
+    # context will automatically close the browser.
     def launch_persistent_context(
           userDataDir,
-          headless: nil,
-          executablePath: nil,
+          acceptDownloads: nil,
           args: nil,
-          ignoreDefaultArgs: nil,
-          proxy: nil,
-          downloadsPath: nil,
+          bypassCSP: nil,
           chromiumSandbox: nil,
+          colorScheme: nil,
+          deviceScaleFactor: nil,
+          devtools: nil,
+          downloadsPath: nil,
+          env: nil,
+          executablePath: nil,
+          extraHTTPHeaders: nil,
+          geolocation: nil,
+          handleSIGHUP: nil,
           handleSIGINT: nil,
           handleSIGTERM: nil,
-          handleSIGHUP: nil,
-          timeout: nil,
-          env: nil,
-          devtools: nil,
-          slowMo: nil,
-          acceptDownloads: nil,
+          hasTouch: nil,
+          headless: nil,
+          httpCredentials: nil,
+          ignoreDefaultArgs: nil,
           ignoreHTTPSErrors: nil,
-          bypassCSP: nil,
-          viewport: nil,
-          userAgent: nil,
-          deviceScaleFactor: nil,
           isMobile: nil,
-          hasTouch: nil,
           javaScriptEnabled: nil,
-          timezoneId: nil,
-          geolocation: nil,
           locale: nil,
-          permissions: nil,
-          extraHTTPHeaders: nil,
-          offline: nil,
-          httpCredentials: nil,
-          colorScheme: nil,
           logger: nil,
-          videosPath: nil,
-          videoSize: nil,
+          offline: nil,
+          permissions: nil,
+          proxy: nil,
           recordHar: nil,
-          recordVideo: nil)
+          recordVideo: nil,
+          slowMo: nil,
+          timeout: nil,
+          timezoneId: nil,
+          userAgent: nil,
+          videoSize: nil,
+          videosPath: nil,
+          viewport: nil)
       raise NotImplementedError.new('launch_persistent_context is not implemented yet.')
     end
 
     # Returns the browser app instance.
-    # Launches browser server that client can connect to. An example of launching a browser executable and connecting to it later:
+    # 
+    # Launches browser server that client can connect to. An example of launching a browser executable and connecting to it
+    # later:
+    # 
     #
     # ```js
     # const { chromium } = require('playwright');  // Or 'webkit' or 'firefox'.
@@ -117,22 +136,22 @@ module Playwright
     # })();
     # ```
     def launch_server(
-          headless: nil,
-          port: nil,
-          executablePath: nil,
           args: nil,
-          ignoreDefaultArgs: nil,
-          proxy: nil,
-          downloadsPath: nil,
           chromiumSandbox: nil,
+          devtools: nil,
+          downloadsPath: nil,
+          env: nil,
+          executablePath: nil,
           firefoxUserPrefs: nil,
+          handleSIGHUP: nil,
           handleSIGINT: nil,
           handleSIGTERM: nil,
-          handleSIGHUP: nil,
+          headless: nil,
+          ignoreDefaultArgs: nil,
           logger: nil,
-          timeout: nil,
-          env: nil,
-          devtools: nil)
+          port: nil,
+          proxy: nil,
+          timeout: nil)
       raise NotImplementedError.new('launch_server is not implemented yet.')
     end
 

data/lib/playwright_api/cdp_session.rb

@@ -1,13 +1,15 @@
 module Playwright
-  # The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:
+  # - extends: [EventEmitter](https://nodejs.org/api/events.html#events_class_eventemitter)
   # 
-  # protocol methods can be called with `session.send` method.
-  # protocol events can be subscribed to with `session.on` method.
+  # The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:
+  # - protocol methods can be called with `session.send` method.
+  # - protocol events can be subscribed to with `session.on` method.
   # 
   # Useful links:
-  # 
-  # Documentation on DevTools Protocol can be found here: DevTools Protocol Viewer.
-  # Getting Started with DevTools Protocol: https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
+  # - Documentation on DevTools Protocol can be found here:
+  #   [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).
+  # - Getting Started with DevTools Protocol:
+  #   https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
   # 
   #
   # ```js
@@ -22,7 +24,8 @@ module Playwright
   # ```
   class CDPSession < PlaywrightApi
 
-    # Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to send messages.
+    # Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
+    # send messages.
     def detach
       raise NotImplementedError.new('detach is not implemented yet.')
     end

data/lib/playwright_api/chromium_browser_context.rb

@@ -1,7 +1,10 @@
 require_relative './browser_context.rb'
 
 module Playwright
+  # - extends: `BrowserContext`
+  # 
   # Chromium-specific features including background pages, service worker support, etc.
+  # 
   #
   # ```js
   # const backgroundPage = await context.waitForEvent('backgroundpage');

data/lib/playwright_api/console_message.rb

@@ -1,22 +1,29 @@
 module Playwright
-  # ConsoleMessage objects are dispatched by page via the page.on('console') event.
+  # `ConsoleMessage` objects are dispatched by page via the [`event: Page.console`] event.
   class ConsoleMessage < PlaywrightApi
 
     def args
-      raise NotImplementedError.new('args is not implemented yet.')
+      wrap_channel_owner(@channel_owner.args)
     end
 
     def location
-      raise NotImplementedError.new('location is not implemented yet.')
+      wrap_channel_owner(@channel_owner.location)
     end
 
     def text
-      raise NotImplementedError.new('text is not implemented yet.')
+      wrap_channel_owner(@channel_owner.text)
     end
 
-    # One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`, `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`, `'count'`, `'timeEnd'`.
+    # One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
+    # `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`,
+    # `'count'`, `'timeEnd'`.
     def type_text
       raise NotImplementedError.new('type_text is not implemented yet.')
     end
+
+    # @nodoc
+    def type
+      wrap_channel_owner(@channel_owner.type)
+    end
   end
 end

data/lib/playwright_api/dialog.rb

@@ -1,6 +1,8 @@
 module Playwright
-  # Dialog objects are dispatched by page via the page.on('dialog') event.
+  # `Dialog` objects are dispatched by page via the [`event: Page.dialog`] event.
+  # 
   # An example of using `Dialog` class:
+  # 
   #
   # ```js
   # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.

data/lib/playwright_api/download.rb

@@ -1,7 +1,11 @@
 module Playwright
-  # Download objects are dispatched by page via the page.on('download') event.
-  # All the downloaded files belonging to the browser context are deleted when the browser context is closed. All downloaded files are deleted when the browser closes.
+  # `Download` objects are dispatched by page via the [`event: Page.download`] event.
+  # 
+  # All the downloaded files belonging to the browser context are deleted when the browser context is closed. All downloaded
+  # files are deleted when the browser closes.
+  # 
   # Download event is emitted once the download starts. Download path becomes available once download completes:
+  # 
   #
   # ```js
   # const [ download ] = await Promise.all([
@@ -13,7 +17,9 @@ module Playwright
   # ...
   # ```
   # 
-  # **NOTE** Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the downloaded content. If `acceptDownloads` is not set or set to `false`, download events are emitted, but the actual download is not performed and user has no access to the downloaded files.
+  # > **NOTE** Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
+  # downloaded content. If `acceptDownloads` is not set or set to `false`, download events are emitted, but the actual
+  # download is not performed and user has no access to the downloaded files.
   class Download < PlaywrightApi
 
     # Returns readable stream for current download or `null` if download failed.
@@ -41,7 +47,10 @@ module Playwright
       raise NotImplementedError.new('save_as is not implemented yet.')
     end
 
-    # Returns suggested filename for this download. It is typically computed by the browser from the `Content-Disposition` response header or the `download` attribute. See the spec on whatwg. Different browsers can use different logic for computing it.
+    # Returns suggested filename for this download. It is typically computed by the browser from the
+    # [`Content-Disposition`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) response header
+    # or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources). Different
+    # browsers can use different logic for computing it.
     def suggested_filename
       raise NotImplementedError.new('suggested_filename is not implemented yet.')
     end

data/lib/playwright_api/element_handle.rb

@@ -1,7 +1,10 @@
 require_relative './js_handle.rb'
 
 module Playwright
-  # ElementHandle represents an in-page DOM element. ElementHandles can be created with the `page.$(selector)` method.
+  # - extends: `JSHandle`
+  # 
+  # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.$`] method.
+  # 
   #
   # ```js
   # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
@@ -15,57 +18,86 @@ module Playwright
   #   // ...
   # })();
   # ```
-  # ElementHandle prevents DOM element from garbage collection unless the handle is disposed with `jsHandle.dispose()`. ElementHandles are auto-disposed when their origin frame gets navigated.
-  # ElementHandle instances can be used as an argument in `page.$eval(selector, pageFunction[, arg])` and `page.evaluate(pageFunction[, arg])` methods.
+  # 
+  # ElementHandle prevents DOM element from garbage collection unless the handle is disposed with
+  # [`method: JSHandle.dispose`]. ElementHandles are auto-disposed when their origin frame gets navigated.
+  # 
+  # ElementHandle instances can be used as an argument in [`method: Page.$eval`] and [`method: Page.evaluate`] methods.
   class ElementHandle < JSHandle
 
-    # The method finds an element matching the specified selector in the `ElementHandle`'s subtree. See Working with selectors for more details. If no elements match the selector, returns `null`.
-    def S(selector)
-      raise NotImplementedError.new('S is not implemented yet.')
+    # The method finds an element matching the specified selector in the `ElementHandle`'s subtree. See
+    # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
+    # returns `null`.
+    def query_selector(selector)
+      raise NotImplementedError.new('query_selector is not implemented yet.')
     end
 
-    # The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See Working with selectors for more details. If no elements match the selector, returns empty array.
-    def SS(selector)
-      raise NotImplementedError.new('SS is not implemented yet.')
+    # The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See
+    # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
+    # returns empty array.
+    def query_selector_all(selector)
+      raise NotImplementedError.new('query_selector_all is not implemented yet.')
     end
 
     # Returns the return value of `pageFunction`
-    # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first argument to `pageFunction`. See Working with selectors for more details. If no elements match the selector, the method throws an error.
-    # If `pageFunction` returns a Promise, then `frame.$eval` would wait for the promise to resolve and return its value.
+    # 
+    # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
+    # argument to `pageFunction`. See [Working with selectors](./selectors.md#working-with-selectors) for more details. If no
+    # elements match the selector, the method throws an error.
+    # 
+    # If `pageFunction` returns a [Promise], then `frame.$eval` would wait for the promise to resolve and return its value.
+    # 
     # Examples:
+    # 
     #
     # ```js
     # const tweetHandle = await page.$('.tweet');
     # expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');
     # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
     # ```
-    def Seval(selector, pageFunction, arg: nil)
-      raise NotImplementedError.new('Seval is not implemented yet.')
+    def eval_on_selector(selector, pageFunction, arg: nil)
+      raise NotImplementedError.new('eval_on_selector is not implemented yet.')
     end
 
     # Returns the return value of `pageFunction`
-    # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of matched elements as a first argument to `pageFunction`. See Working with selectors for more details.
-    # If `pageFunction` returns a Promise, then `frame.$$eval` would wait for the promise to resolve and return its value.
+    # 
+    # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of
+    # matched elements as a first argument to `pageFunction`. See
+    # [Working with selectors](./selectors.md#working-with-selectors) for more details.
+    # 
+    # If `pageFunction` returns a [Promise], then `frame.$$eval` would wait for the promise to resolve and return its value.
+    # 
     # Examples:
+    # 
     # ```html
     # <div class="feed">
     #   <div class="tweet">Hello!</div>
     #   <div class="tweet">Hi!</div>
     # </div>
     # ```
+    # 
     #
     # ```js
     # const feedHandle = await page.$('.feed');
     # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
     # ```
-    def SSeval(selector, pageFunction, arg: nil)
-      raise NotImplementedError.new('SSeval is not implemented yet.')
+    def eval_on_selector_all(selector, pageFunction, arg: nil)
+      raise NotImplementedError.new('eval_on_selector_all is not implemented yet.')
     end
 
-    # 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 bonding box, similarly to 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.
-    # 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.
+    # 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 bonding box, similarly to
+    # [Element.getBoundingClientRect](https://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](https://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.
+    # 
     #
     # ```js
     # const box = await elementHandle.boundingBox();
@@ -76,37 +108,40 @@ module Playwright
     end
 
     # This method checks the element by performing the following steps:
-    # 
-    # Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-    # Wait for actionability checks on the element, unless `force` option is set.
-    # Scroll the element into view if needed.
-    # Use page.mouse to click in the center of the element.
-    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # Ensure that the element is now checked. If not, this method rejects.
+    # 1. Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    #    checked, this method returns immediately.
+    # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
+    # 1. Scroll the element into view if needed.
+    # 1. Use [`property: Page.mouse`] to click in the center of the element.
+    # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # 1. Ensure that the element is now checked. If not, this method rejects.
     # 
     # If the element is detached from the DOM at any moment during the action, this method rejects.
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
+    # 
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
+    # Passing zero timeout disables this.
     def check(force: nil, noWaitAfter: nil, timeout: nil)
       raise NotImplementedError.new('check is not implemented yet.')
     end
 
     # This method clicks the element by performing the following steps:
-    # 
-    # Wait for actionability checks on the element, unless `force` option is set.
-    # Scroll the element into view if needed.
-    # Use page.mouse to click in the center of the element, or the specified `position`.
-    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
+    # 1. Scroll the element into view if needed.
+    # 1. Use [`property: Page.mouse`] to click in the center of the element, or the specified `position`.
+    # 1. 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 rejects.
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
+    # 
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
+    # Passing zero timeout disables this.
     def click(
           button: nil,
           clickCount: nil,
           delay: nil,
-          position: nil,
-          modifiers: nil,
           force: nil,
+          modifiers: nil,
           noWaitAfter: nil,
+          position: nil,
           timeout: nil)
       raise NotImplementedError.new('click is not implemented yet.')
     end
@@ -117,44 +152,52 @@ module Playwright
     end
 
     # This method double clicks the element by performing the following steps:
-    # 
-    # Wait for actionability checks on the element, unless `force` option is set.
-    # Scroll the element into view if needed.
-    # Use page.mouse to double click in the center of the element, or the specified `position`.
-    # 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 reject.
+    # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
+    # 1. Scroll the element into view if needed.
+    # 1. Use [`property: Page.mouse`] to double click in the center of the element, or the specified `position`.
+    # 1. 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 reject.
     # 
     # If the element is detached from the DOM at any moment during the action, this method rejects.
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
     # 
-    # **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
+    # Passing zero timeout disables this.
+    # 
+    # > **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
           button: nil,
           delay: nil,
-          position: nil,
-          modifiers: nil,
           force: nil,
+          modifiers: nil,
           noWaitAfter: nil,
+          position: nil,
           timeout: nil)
       raise NotImplementedError.new('dblclick is not implemented yet.')
     end
 
-    # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click` is dispatched. This is equivalend to calling element.click().
+    # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
+    # is dispatched. This is equivalend to calling
+    # [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).
+    # 
     #
     # ```js
     # await elementHandle.dispatchEvent('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:
     # 
-    # DragEvent
-    # FocusEvent
-    # KeyboardEvent
-    # MouseEvent
-    # PointerEvent
-    # TouchEvent
-    # Event
+    # 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:
+    # - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)
+    # - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)
+    # - [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)
+    # - [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)
+    # - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)
+    # - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)
+    # - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
     # 
     # You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
+    # 
     #
     # ```js
     # // Note you can only create DataTransfer in Chromium and Firefox
@@ -165,12 +208,14 @@ module Playwright
       raise NotImplementedError.new('dispatch_event is not implemented yet.')
     end
 
-    # This method waits for actionability checks, focuses the element, fills it and triggers an `input` event after filling. If the element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to clear the input field.
+    # This method waits for [actionability](./actionability.md) checks, focuses the element, fills it and triggers an `input`
+    # event after filling. If the element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws
+    # an error. Note that you can pass an empty string to clear the input field.
     def fill(value, noWaitAfter: nil, timeout: nil)
       raise NotImplementedError.new('fill is not implemented yet.')
     end
 
-    # Calls focus on the element.
+    # Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.
     def focus
       raise NotImplementedError.new('focus is not implemented yet.')
     end
@@ -181,15 +226,16 @@ module Playwright
     end
 
     # This method hovers over the element by performing the following steps:
-    # 
-    # Wait for actionability checks on the element, unless `force` option is set.
-    # Scroll the element into view if needed.
-    # Use page.mouse to hover over the center of the element, or the specified `position`.
-    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
+    # 1. Scroll the element into view if needed.
+    # 1. Use [`property: Page.mouse`] to hover over the center of the element, or the specified `position`.
+    # 1. 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 rejects.
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
-    def hover(position: nil, modifiers: nil, force: nil, timeout: nil)
+    # 
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
+    # Passing zero timeout disables this.
+    def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
       raise NotImplementedError.new('hover is not implemented yet.')
     end
 
@@ -203,41 +249,91 @@ module Playwright
       raise NotImplementedError.new('inner_text is not implemented yet.')
     end
 
+    # Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
+    def checked?
+      raise NotImplementedError.new('checked? is not implemented yet.')
+    end
+
+    # Returns whether the element is disabled, the opposite of [enabled](./actionability.md#enabled).
+    def disabled?
+      raise NotImplementedError.new('disabled? is not implemented yet.')
+    end
+
+    # Returns whether the element is [editable](./actionability.md#editable).
+    def editable?
+      raise NotImplementedError.new('editable? is not implemented yet.')
+    end
+
+    # Returns whether the element is [enabled](./actionability.md#enabled).
+    def enabled?
+      raise NotImplementedError.new('enabled? is not implemented yet.')
+    end
+
+    # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).
+    def hidden?
+      raise NotImplementedError.new('hidden? is not implemented yet.')
+    end
+
+    # Returns whether the element is [visible](./actionability.md#visible).
+    def visible?
+      raise NotImplementedError.new('visible? is not implemented yet.')
+    end
+
     # Returns the frame containing the given element.
     def owner_frame
       raise NotImplementedError.new('owner_frame is not implemented yet.')
     end
 
-    # Focuses the element, and then uses `keyboard.down(key)` and `keyboard.up(key)`.
-    # `key` can specify the intended keyboardEvent.key value or a single character to generate the text for. A superset of the `key` values can be found here. 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+    # Focuses the element, and then uses [`method: Keyboard.down`] and [`method: Keyboard.up`].
+    # 
+    # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
+    # value or a single character to generate the text for. A superset of the `key` values can be found
+    # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
+    # 
+    # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
+    # `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 speficied with the modifier, modifier is pressed and being held while the subsequent key is being pressed.
+    # 
+    # 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 speficied with the
+    # modifier, modifier is pressed and being held while the subsequent key is being pressed.
     def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
       raise NotImplementedError.new('press is not implemented yet.')
     end
 
     # Returns the buffer with the captured screenshot.
-    # This method waits for the actionability checks, then scrolls element into view before taking a screenshot. If the element is detached from DOM, the method throws an error.
+    # 
+    # 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.
     def screenshot(
+          omitBackground: nil,
           path: nil,
-          type: nil,
           quality: nil,
-          omitBackground: nil,
-          timeout: nil)
+          timeout: nil,
+          type: nil)
       raise NotImplementedError.new('screenshot is not implemented yet.')
     end
 
-    # This method waits for actionability checks, then tries to scroll element into view, unless it is completely visible as defined by IntersectionObserver's `ratio`.
-    # Throws when `elementHandle` does not point to an element connected to a Document or a ShadowRoot.
+    # This method waits for [actionability](./actionability.md) checks, then tries to scroll element into view, unless it is
+    # completely visible as defined by
+    # [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s ```ratio```.
+    # 
+    # Throws when `elementHandle` does not point to an element
+    # [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
     def scroll_into_view_if_needed(timeout: nil)
       raise NotImplementedError.new('scroll_into_view_if_needed is not implemented yet.')
     end
 
     # 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. If element is not a `<select>` element, the method throws an error.
+    # 
+    # Triggers a `change` and `input` event once all the provided options have been selected. If element is not a `<select>`
+    # element, the method throws an error.
+    # 
     #
     # ```js
     # // single selection matching the value
@@ -256,33 +352,38 @@ module Playwright
       raise NotImplementedError.new('select_option is not implemented yet.')
     end
 
-    # This method waits for actionability checks, then focuses the element and selects all its text content.
+    # This method waits for [actionability](./actionability.md) checks, then focuses the element and selects all its text
+    # content.
     def select_text(timeout: nil)
       raise NotImplementedError.new('select_text is not implemented yet.')
     end
 
-    # This method expects `elementHandle` to point to an input element.
-    # 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 the current working directory. For empty array, clears the selected files.
+    # This method expects `elementHandle` to point to an
+    # [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
+    # 
+    # 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 the current working directory. For empty array, clears the selected files.
     def set_input_files(files, noWaitAfter: nil, timeout: nil)
       raise NotImplementedError.new('set_input_files is not implemented yet.')
     end
 
     # This method taps the element by performing the following steps:
-    # 
-    # Wait for actionability checks on the element, unless `force` option is set.
-    # Scroll the element into view if needed.
-    # Use page.touchscreen to tap in the center of the element, or the specified `position`.
-    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
+    # 1. Scroll the element into view if needed.
+    # 1. Use [`property: Page.touchscreen`] to tap the center of the element, or the specified `position`.
+    # 1. 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 rejects.
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
     # 
-    # **NOTE** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
+    # Passing zero timeout disables this.
+    # 
+    # > **NOTE** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
-          position: nil,
-          modifiers: nil,
           force: nil,
+          modifiers: nil,
           noWaitAfter: nil,
+          position: nil,
           timeout: nil)
       raise NotImplementedError.new('tap_point is not implemented yet.')
     end
@@ -292,18 +393,18 @@ module Playwright
       raise NotImplementedError.new('text_content is not implemented yet.')
     end
 
-    def to_string
-      raise NotImplementedError.new('to_string is not implemented yet.')
-    end
-
     # 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 `elementHandle.press(key[, options])`.
+    # 
+    # To press a special key, like `Control` or `ArrowDown`, use [`method: ElementHandle.press`].
+    # 
     #
     # ```js
     # await elementHandle.type('Hello'); // Types instantly
     # await elementHandle.type('World', {delay: 100}); // Types slower, like a user
     # ```
+    # 
     # An example of typing into a text field and then submitting the form:
+    # 
     #
     # ```js
     # const elementHandle = await page.$('input');
@@ -315,36 +416,48 @@ module Playwright
     end
 
     # This method checks the element by performing the following steps:
-    # 
-    # Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-    # Wait for actionability checks on the element, unless `force` option is set.
-    # Scroll the element into view if needed.
-    # Use page.mouse to click in the center of the element.
-    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # Ensure that the element is now unchecked. If not, this method rejects.
+    # 1. Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    #    unchecked, this method returns immediately.
+    # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
+    # 1. Scroll the element into view if needed.
+    # 1. Use [`property: Page.mouse`] to click in the center of the element.
+    # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # 1. Ensure that the element is now unchecked. If not, this method rejects.
     # 
     # If the element is detached from the DOM at any moment during the action, this method rejects.
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
+    # 
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
+    # Passing zero timeout disables this.
     def uncheck(force: nil, noWaitAfter: nil, timeout: nil)
       raise NotImplementedError.new('uncheck is not implemented yet.')
     end
 
-    # Returns the element satisfies the `state`.
-    # Depending on the `state` parameter, this method waits for one of the actionability checks to pass. This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
+    # Returns when the element satisfies the `state`.
     # 
-    # `"visible"` Wait until the element is visible.
-    # `"hidden"` Wait until the element is not visible or not attached. Note that waiting for hidden does not throw when the element detaches.
-    # `"stable"` Wait until the element is both visible and stable.
-    # `"enabled"` Wait until the element is enabled.
-    # `"disabled"` Wait until the element is not enabled.
+    # Depending on the `state` parameter, this method waits for one of the [actionability](./actionability.md) checks to pass.
+    # This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
+    # - `"visible"` Wait until the element is [visible](./actionability.md#visible).
+    # - `"hidden"` Wait until the element is [not visible](./actionability.md#visible) or
+    #   [not attached](./actionability.md#attached). Note that waiting for hidden does not throw when the element detaches.
+    # - `"stable"` Wait until the element is both [visible](./actionability.md#visible) and
+    #   [stable](./actionability.md#stable).
+    # - `"enabled"` Wait until the element is [enabled](./actionability.md#enabled).
+    # - `"disabled"` Wait until the element is [not enabled](./actionability.md#enabled).
+    # - `"editable"` Wait until the element is [editable](./actionability.md#editable).
     # 
     # If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
     def wait_for_element_state(state, timeout: nil)
       raise NotImplementedError.new('wait_for_element_state is not implemented yet.')
     end
 
-    # Returns element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or `detached`.
-    # Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+    # Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
+    # `detached`.
+    # 
+    # Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or
+    # become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method
+    # will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will
+    # throw.
+    # 
     #
     # ```js
     # await page.setContent(`<div><span></span></div>`);
@@ -353,7 +466,7 @@ module Playwright
     # const span = await div.waitForSelector('span', { state: 'attached' });
     # ```
     # 
-    # **NOTE** This method does not work across navigations, use `page.waitForSelector(selector[, options])` instead.
+    # > **NOTE** This method does not work across navigations, use [`method: Page.waitForSelector`] instead.
     def wait_for_selector(selector, state: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_selector is not implemented yet.')
     end