playwright-ruby-client 1.28.1 → 1.29.0

data/lib/playwright_api/browser_context.rb

@@ -20,6 +20,7 @@ module Playwright
   # ```
   class BrowserContext < PlaywrightApi
 
+    #
     # API testing helper associated with this context. Requests made with this API will use context cookies.
     def request # property
       wrap_impl(@impl.request)
@@ -29,9 +30,12 @@ module Playwright
       wrap_impl(@impl.tracing)
     end
 
+    #
     # Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies can be
     # obtained via [`method: BrowserContext.cookies`].
     #
+    # **Usage**
+    #
     # ```python sync
     # browser_context.add_cookies([cookie_object1, cookie_object2])
     # ```
@@ -39,14 +43,16 @@ module Playwright
       wrap_impl(@impl.add_cookies(unwrap_impl(cookies)))
     end
 
+    #
     # Adds a script which would be evaluated in one of the following scenarios:
     # - Whenever a page is created in the browser context or is navigated.
-    # - Whenever a child frame is attached or navigated in any page in the browser context. In this case, the script is
-    #   evaluated in the context of the newly attached frame.
+    # - Whenever a child frame is attached or navigated in any page in the browser context. In this case, the script is evaluated in the context of the newly attached frame.
     #
     # The script is evaluated after the document was created but before any of its scripts were run. This is useful to amend
     # the JavaScript environment, e.g. to seed `Math.random`.
     #
+    # **Usage**
+    #
     # An example of overriding `Math.random` before the page loads:
     #
     # ```python sync
@@ -54,31 +60,37 @@ module Playwright
     # browser_context.add_init_script(path="preload.js")
     # ```
     #
-    # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
+    # **NOTE**: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
     def add_init_script(path: nil, script: nil)
       wrap_impl(@impl.add_init_script(path: unwrap_impl(path), script: unwrap_impl(script)))
     end
 
-    # > NOTE: Background pages are only supported on Chromium-based browsers.
+    #
+    # **NOTE**: Background pages are only supported on Chromium-based browsers.
     #
     # All existing background pages in the context.
     def background_pages
       wrap_impl(@impl.background_pages)
     end
 
+    #
     # Returns the browser instance of the context. If it was launched as a persistent context null gets returned.
     def browser
       wrap_impl(@impl.browser)
     end
 
+    #
     # Clears context cookies.
     def clear_cookies
       wrap_impl(@impl.clear_cookies)
     end
 
+    #
     # Clears all permission overrides for the browser context.
     #
+    # **Usage**
+    #
     # ```python sync
     # context = browser.new_context()
     # context.grant_permissions(["clipboard-read"])
@@ -89,28 +101,33 @@ module Playwright
       wrap_impl(@impl.clear_permissions)
     end
 
+    #
     # Closes the browser context. All the pages that belong to the browser context will be closed.
     #
-    # > NOTE: The default browser context cannot be closed.
+    # **NOTE**: The default browser context cannot be closed.
     def close
       wrap_impl(@impl.close)
     end
 
+    #
     # If no URLs are specified, this method returns all cookies. If URLs are specified, only cookies that affect those URLs
     # are returned.
     def cookies(urls: nil)
       wrap_impl(@impl.cookies(urls: unwrap_impl(urls)))
     end
 
-    # The method adds a function called `name` on the `window` object of every frame in every page in the context. When
-    # called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`. If
-    # the `callback` returns a [Promise], it will be awaited.
     #
-    # The first argument of the `callback` function contains information about the caller: `{ browserContext: BrowserContext,
-    # page: Page, frame: Frame }`.
+    # The method adds a function called `name` on the `window` object of every frame in every page in the context.
+    # When called, the function executes `callback` and returns a [Promise] which resolves to the return value of
+    # `callback`. If the `callback` returns a [Promise], it will be awaited.
+    #
+    # The first argument of the `callback` function contains information about the caller: `{ browserContext:
+    # BrowserContext, page: Page, frame: Frame }`.
     #
     # See [`method: Page.exposeBinding`] for page-only version.
     #
+    # **Usage**
+    #
     # An example of exposing page URL to all frames in all pages in the context:
     #
     # ```python sync
@@ -156,13 +173,17 @@ module Playwright
       wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback), handle: unwrap_impl(handle)))
     end
 
-    # The method adds a function called `name` on the `window` object of every frame in every page in the context. When
-    # called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+    #
+    # The method adds a function called `name` on the `window` object of every frame in every page in the context.
+    # When called, the function executes `callback` and returns a [Promise] which resolves to the return value of
+    # `callback`.
     #
     # If the `callback` returns a [Promise], it will be awaited.
     #
     # See [`method: Page.exposeFunction`] for page-only version.
     #
+    # **Usage**
+    #
     # An example of adding a `sha256` function to all pages in the context:
     #
     # ```python sync
@@ -199,35 +220,40 @@ module Playwright
       wrap_impl(@impl.expose_function(unwrap_impl(name), unwrap_impl(callback)))
     end
 
+    #
     # Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if
     # specified.
     def grant_permissions(permissions, origin: nil)
       wrap_impl(@impl.grant_permissions(unwrap_impl(permissions), origin: unwrap_impl(origin)))
     end
 
-    # > NOTE: CDP sessions are only supported on Chromium-based browsers.
+    #
+    # **NOTE**: CDP sessions are only supported on Chromium-based browsers.
     #
     # Returns the newly created session.
     def new_cdp_session(page)
       wrap_impl(@impl.new_cdp_session(unwrap_impl(page)))
     end
 
+    #
     # Creates a new page in the browser context.
     def new_page(&block)
       wrap_impl(@impl.new_page(&wrap_block_call(block)))
     end
 
+    #
     # Returns all open pages in the context.
     def pages
       wrap_impl(@impl.pages)
     end
 
+    #
     # Routing provides the capability to modify network requests that are made by any page in the browser context. Once route
     # is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.
     #
-    # > NOTE: [`method: BrowserContext.route`] will not intercept requests intercepted by Service Worker. See
-    # [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
-    # request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+    # **NOTE**: [`method: BrowserContext.route`] will not intercept requests intercepted by Service Worker. See [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+    #
+    # **Usage**
     #
     # An example of a naive handler that aborts all image requests:
     #
@@ -251,8 +277,7 @@ module Playwright
     # browser.close()
     # ```
     #
-    # It is possible to examine the request to decide the route action. For example, mocking all requests that contain some
-    # post data, and leaving all other requests as is:
+    # It is possible to examine the request to decide the route action. For example, mocking all requests that contain some post data, and leaving all other requests as is:
     #
     # ```python sync
     # def handle_route(route):
@@ -268,28 +293,28 @@ module Playwright
     #
     # To remove a route with its handler you can use [`method: BrowserContext.unroute`].
     #
-    # > NOTE: Enabling routing disables http cache.
+    # **NOTE**: Enabling routing disables http cache.
     def route(url, handler, times: nil)
       wrap_impl(@impl.route(unwrap_impl(url), unwrap_impl(handler), times: unwrap_impl(times)))
     end
 
-    # If specified the network requests that are made in the context will be served from the HAR file. Read more about
-    # [Replaying from HAR](../network.md#replaying-from-har).
     #
-    # Playwright will not serve requests intercepted by Service Worker from the HAR file. See
-    # [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
-    # request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+    # If specified the network requests that are made in the context will be served from the HAR file. Read more about [Replaying from HAR](../network.md#replaying-from-har).
+    #
+    # Playwright will not serve requests intercepted by Service Worker from the HAR file. See [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
     def route_from_har(har, notFound: nil, update: nil, url: nil)
       wrap_impl(@impl.route_from_har(unwrap_impl(har), notFound: unwrap_impl(notFound), update: unwrap_impl(update), url: unwrap_impl(url)))
     end
 
-    # > NOTE: Service workers are only supported on Chromium-based browsers.
+    #
+    # **NOTE**: Service workers are only supported on Chromium-based browsers.
     #
     # All existing service workers in the context.
     def service_workers
       wrap_impl(@impl.service_workers)
     end
 
+    #
     # This setting will change the default maximum navigation time for the following methods and related shortcuts:
     # - [`method: Page.goBack`]
     # - [`method: Page.goForward`]
@@ -298,40 +323,45 @@ module Playwright
     # - [`method: Page.setContent`]
     # - [`method: Page.waitForNavigation`]
     #
-    # > NOTE: [`method: Page.setDefaultNavigationTimeout`] and [`method: Page.setDefaultTimeout`] take priority over
+    # **NOTE**: [`method: Page.setDefaultNavigationTimeout`] and [`method: Page.setDefaultTimeout`] take priority over
     # [`method: BrowserContext.setDefaultNavigationTimeout`].
     def set_default_navigation_timeout(timeout)
       wrap_impl(@impl.set_default_navigation_timeout(unwrap_impl(timeout)))
     end
     alias_method :default_navigation_timeout=, :set_default_navigation_timeout
 
+    #
     # This setting will change the default maximum time for all the methods accepting `timeout` option.
     #
-    # > NOTE: [`method: Page.setDefaultNavigationTimeout`], [`method: Page.setDefaultTimeout`] and
+    # **NOTE**: [`method: Page.setDefaultNavigationTimeout`], [`method: Page.setDefaultTimeout`] and
     # [`method: BrowserContext.setDefaultNavigationTimeout`] take priority over [`method: BrowserContext.setDefaultTimeout`].
     def set_default_timeout(timeout)
       wrap_impl(@impl.set_default_timeout(unwrap_impl(timeout)))
     end
     alias_method :default_timeout=, :set_default_timeout
 
+    #
     # The extra HTTP headers will be sent with every request initiated by any page in the context. These headers are merged
     # with page-specific extra HTTP headers set with [`method: Page.setExtraHTTPHeaders`]. If page overrides a particular
     # header, page-specific header value will be used instead of the browser context header value.
     #
-    # > NOTE: [`method: BrowserContext.setExtraHTTPHeaders`] does not guarantee the order of headers in the outgoing requests.
+    # **NOTE**: [`method: BrowserContext.setExtraHTTPHeaders`] does not guarantee the order of headers in the outgoing requests.
     def set_extra_http_headers(headers)
       wrap_impl(@impl.set_extra_http_headers(unwrap_impl(headers)))
     end
     alias_method :extra_http_headers=, :set_extra_http_headers
 
+    #
     # Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.
     #
+    # **Usage**
+    #
     # ```python sync
     # browser_context.set_geolocation({"latitude": 59.95, "longitude": 30.31667})
     # ```
     #
-    # > NOTE: Consider using [`method: BrowserContext.grantPermissions`] to grant permissions for the browser context pages to
-    # read its geolocation.
+    # **NOTE**: Consider using [`method: BrowserContext.grantPermissions`] to grant permissions for the browser context pages to read
+    # its geolocation.
     def set_geolocation(geolocation)
       wrap_impl(@impl.set_geolocation(unwrap_impl(geolocation)))
     end
@@ -342,20 +372,25 @@ module Playwright
     end
     alias_method :offline=, :set_offline
 
+    #
     # Returns storage state for this browser context, contains current cookies and local storage snapshot.
     def storage_state(path: nil)
       wrap_impl(@impl.storage_state(path: unwrap_impl(path)))
     end
 
-    # Removes a route created with [`method: BrowserContext.route`]. When `handler` is not specified, removes all routes for
-    # the `url`.
+    #
+    # Removes a route created with [`method: BrowserContext.route`]. When `handler` is not specified, removes all
+    # routes for the `url`.
     def unroute(url, handler: nil)
       wrap_impl(@impl.unroute(unwrap_impl(url), handler: unwrap_impl(handler)))
     end
 
+    #
     # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
     # value. Will throw an error if the context closes before the event is fired. Returns the event data value.
     #
+    # **Usage**
+    #
     # ```python sync
     # with context.expect_event("page") as event_info:
     #     page.get_by_role("button").click()
@@ -365,18 +400,20 @@ module Playwright
       wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
-    # Performs action and waits for a new `Page` to be created in the context. If predicate is provided, it passes `Page`
-    # value into the `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error if
-    # the context closes before new `Page` is created.
+    #
+    # Performs action and waits for a new `Page` to be created in the context. If predicate is provided, it passes
+    # `Page` value into the `predicate` function and waits for `predicate(event)` to return a truthy value.
+    # Will throw an error if the context closes before new `Page` is created.
     def expect_page(predicate: nil, timeout: nil)
       wrap_impl(@impl.expect_page(predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout)))
     end
 
-    # > NOTE: In most cases, you should use [`method: BrowserContext.waitForEvent`].
     #
-    # Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and
-    # waits for `predicate(event)` to return a truthy value. Will throw an error if the browser context is closed before the
-    # `event` is fired.
+    # **NOTE**: In most cases, you should use [`method: BrowserContext.waitForEvent`].
+    #
+    # Waits for given `event` to fire. If predicate is provided, it passes
+    # event's value into the `predicate` function and waits for `predicate(event)` to return a truthy value.
+    # Will throw an error if the browser context is closed before the `event` is fired.
     def wait_for_event(event, predicate: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end

data/lib/playwright_api/browser_type.rb

@@ -1,4 +1,5 @@
 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:
   #
@@ -18,18 +19,20 @@ module Playwright
   # ```
   class BrowserType < PlaywrightApi
 
-    # This method attaches Playwright to an existing browser instance. When connecting to another browser launched via
-    # `BrowserType.launchServer` in Node.js, the major and minor version needs to match the client version (1.2.3 → is
-    # compatible with 1.2.x).
+    #
+    # This method attaches Playwright to an existing browser instance. When connecting to another browser launched via `BrowserType.launchServer` in Node.js, the major and minor version needs to match the client version (1.2.3 → is compatible with 1.2.x).
     def connect(wsEndpoint, headers: nil, slowMo: nil, timeout: nil)
       raise NotImplementedError.new('connect is not implemented yet.')
     end
 
+    #
     # This method attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.
     #
     # The default browser context is accessible via [`method: Browser.contexts`].
     #
-    # > NOTE: Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
+    # **NOTE**: Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
+    #
+    # **Usage**
     #
     # ```python sync
     # browser = playwright.chromium.connect_over_cdp("http://localhost:9222")
@@ -45,13 +48,17 @@ module Playwright
       wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), headers: unwrap_impl(headers), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
+    #
     # A path where Playwright expects to find a bundled browser executable.
     def executable_path
       wrap_impl(@impl.executable_path)
     end
 
+    #
     # Returns the browser instance.
     #
+    # **Usage**
+    #
     # You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
     #
     # ```python sync
@@ -60,18 +67,19 @@ module Playwright
     # )
     # ```
     #
-    # > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, 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.
+    # > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, 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.
+    #
     # >
-    # > Stock browsers like Google Chrome and Microsoft Edge are suitable for tests that require proprietary media codecs for
-    # video playback. See
-    # [this article](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for other
-    # differences between Chromium and Chrome.
+    #
+    # > Stock browsers like Google Chrome and Microsoft Edge are suitable for tests that require proprietary media codecs for video playback. See [this article](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for other 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(
@@ -96,10 +104,11 @@ module Playwright
       wrap_impl(@impl.launch(args: unwrap_impl(args), channel: unwrap_impl(channel), chromiumSandbox: unwrap_impl(chromiumSandbox), devtools: unwrap_impl(devtools), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), firefoxUserPrefs: unwrap_impl(firefoxUserPrefs), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), headless: unwrap_impl(headless), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), proxy: unwrap_impl(proxy), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), tracesDir: unwrap_impl(tracesDir), &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,
           acceptDownloads: nil,
@@ -153,6 +162,7 @@ module Playwright
       wrap_impl(@impl.launch_persistent_context(unwrap_impl(userDataDir), acceptDownloads: unwrap_impl(acceptDownloads), args: unwrap_impl(args), baseURL: unwrap_impl(baseURL), bypassCSP: unwrap_impl(bypassCSP), channel: unwrap_impl(channel), chromiumSandbox: unwrap_impl(chromiumSandbox), colorScheme: unwrap_impl(colorScheme), deviceScaleFactor: unwrap_impl(deviceScaleFactor), devtools: unwrap_impl(devtools), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), forcedColors: unwrap_impl(forcedColors), geolocation: unwrap_impl(geolocation), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), hasTouch: unwrap_impl(hasTouch), headless: unwrap_impl(headless), httpCredentials: unwrap_impl(httpCredentials), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), isMobile: unwrap_impl(isMobile), javaScriptEnabled: unwrap_impl(javaScriptEnabled), locale: unwrap_impl(locale), noViewport: unwrap_impl(noViewport), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), proxy: unwrap_impl(proxy), record_har_content: unwrap_impl(record_har_content), record_har_mode: unwrap_impl(record_har_mode), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_har_url_filter: unwrap_impl(record_har_url_filter), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), reducedMotion: unwrap_impl(reducedMotion), screen: unwrap_impl(screen), serviceWorkers: unwrap_impl(serviceWorkers), slowMo: unwrap_impl(slowMo), strictSelectors: unwrap_impl(strictSelectors), timeout: unwrap_impl(timeout), timezoneId: unwrap_impl(timezoneId), tracesDir: unwrap_impl(tracesDir), userAgent: unwrap_impl(userAgent), viewport: unwrap_impl(viewport), &wrap_block_call(block)))
     end
 
+    #
     # Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
     def name
       wrap_impl(@impl.name)

data/lib/playwright_api/cdp_session.rb

@@ -6,10 +6,8 @@ module Playwright
   # - protocol events can be subscribed to with `session.on` method.
   #
   # Useful links:
-  # - 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
+  # - 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
   #
   # ```python sync
   # client = page.context.new_cdp_session(page)
@@ -23,6 +21,7 @@ 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.
     def detach

data/lib/playwright_api/console_message.rb

@@ -1,6 +1,8 @@
 module Playwright
-  # `ConsoleMessage` objects are dispatched by page via the [`event: Page.console`] event. For each console messages logged
-  # in the page there will be corresponding event in the Playwright context.
+  #
+  # `ConsoleMessage` objects are dispatched by page via the [`event: Page.console`] event.
+  # For each console messages logged in the page there will be corresponding event in the Playwright
+  # context.
   #
   # ```python sync
   # # Listen for all console logs
@@ -21,6 +23,7 @@ module Playwright
   # ```
   class ConsoleMessage < PlaywrightApi
 
+    #
     # List of arguments passed to a `console` function call. See also [`event: Page.console`].
     def args
       wrap_impl(@impl.args)
@@ -30,11 +33,13 @@ module Playwright
       wrap_impl(@impl.location)
     end
 
+    #
     # The text of the console message.
     def text
       wrap_impl(@impl.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'`.

data/lib/playwright_api/dialog.rb

@@ -1,4 +1,5 @@
 module Playwright
+  #
   # `Dialog` objects are dispatched by page via the [`event: Page.dialog`] event.
   #
   # An example of using `Dialog` class:
@@ -22,32 +23,35 @@ module Playwright
   #     run(playwright)
   # ```
   #
-  # > NOTE: Dialogs are dismissed automatically, unless there is a [`event: Page.dialog`] listener. When listener is
-  # present, it **must** either [`method: Dialog.accept`] or [`method: Dialog.dismiss`] the dialog - otherwise the page will
-  # [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the dialog, and
-  # actions like click will never finish.
+  # **NOTE**: Dialogs are dismissed automatically, unless there is a [`event: Page.dialog`] listener.
+  # When listener is present, it **must** either [`method: Dialog.accept`] or [`method: Dialog.dismiss`] the dialog - otherwise the page will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the dialog, and actions like click will never finish.
   class Dialog < PlaywrightApi
 
+    #
     # Returns when the dialog has been accepted.
     def accept(promptText: nil)
       wrap_impl(@impl.accept(promptText: unwrap_impl(promptText)))
     end
 
+    #
     # If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
     def default_value
       wrap_impl(@impl.default_value)
     end
 
+    #
     # Returns when the dialog has been dismissed.
     def dismiss
       wrap_impl(@impl.dismiss)
     end
 
+    #
     # A message displayed in the dialog.
     def message
       wrap_impl(@impl.message)
     end
 
+    #
     # Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
     def type
       wrap_impl(@impl.type)

data/lib/playwright_api/download.rb

@@ -1,7 +1,9 @@
 module Playwright
+  #
   # `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 the downloaded files belonging to the browser context are deleted when the
+  # browser context is closed.
   #
   # Download event is emitted once the download starts. Download path becomes available once download completes:
   #
@@ -14,42 +16,49 @@ module Playwright
   # ```
   class Download < PlaywrightApi
 
-    # Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,
-    # `download.failure()` would resolve to `'canceled'`.
+    #
+    # Cancels a download. Will not fail if the download is already finished or canceled.
+    # Upon successful cancellations, `download.failure()` would resolve to `'canceled'`.
     def cancel
       wrap_impl(@impl.cancel)
     end
 
+    #
     # Deletes the downloaded file. Will wait for the download to finish if necessary.
     def delete
       wrap_impl(@impl.delete)
     end
 
+    #
     # Returns download error if any. Will wait for the download to finish if necessary.
     def failure
       wrap_impl(@impl.failure)
     end
 
+    #
     # Get the page that the download belongs to.
     def page
       wrap_impl(@impl.page)
     end
 
-    # Returns path to the downloaded file in case of successful download. The method will wait for the download to finish if
-    # necessary. The method throws when connected remotely.
     #
-    # Note that the download's file name is a random GUID, use [`method: Download.suggestedFilename`] to get suggested file
-    # name.
+    # Returns path to the downloaded file in case of successful download. The method will
+    # wait for the download to finish if necessary. The method throws when connected remotely.
+    #
+    # Note that the download's file name is a random GUID, use [`method: Download.suggestedFilename`]
+    # to get suggested file name.
     def path
       wrap_impl(@impl.path)
     end
 
-    # Copy the download to a user-specified path. It is safe to call this method while the download is still in progress. Will
-    # wait for the download to finish if necessary.
+    #
+    # Copy the download to a user-specified path. It is safe to call this method while the download
+    # is still in progress. Will wait for the download to finish if necessary.
     def save_as(path)
       wrap_impl(@impl.save_as(unwrap_impl(path)))
     end
 
+    #
     # 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
@@ -58,6 +67,7 @@ module Playwright
       wrap_impl(@impl.suggested_filename)
     end
 
+    #
     # Returns downloaded url.
     def url
       wrap_impl(@impl.url)