playwright-ruby-client 1.25.0 → 1.27.0

data/lib/playwright/locator_impl.rb

@@ -1,49 +1,25 @@
 require 'json'
+require_relative './locator_utils'
 
 module Playwright
-  class EscapeWithQuotes
-    def initialize(text, char = "'")
-      stringified = text.to_json
-      escaped_text = stringified[1...-1].gsub(/\\"/, '"')
-
-      case char
-      when '"'
-        text = escaped_text.gsub(/["]/, '\\"')
-        @text = "\"#{text}\""
-      when "'"
-        text = escaped_text.gsub(/[']/, '\\\'')
-        @text = "'#{text}'"
-      else
-        raise ArgumentError.new('Invalid escape char')
-      end
-    end
-
-    def to_s
-      @text
-    end
-  end
-
   define_api_implementation :LocatorImpl do
+    include LocatorUtils
+
     def initialize(frame:, timeout_settings:, selector:, hasText: nil, has: nil)
       @frame = frame
       @timeout_settings = timeout_settings
       selector_scopes = [selector]
 
-      case hasText
-      when Regexp
-        regex = JavaScript::Regex.new(hasText)
-        source = EscapeWithQuotes.new(regex.source, '"')
-        selector_scopes << "has=#{"text=/#{regex.source}/#{regex.flag}".to_json}"
-      when String
-        text = EscapeWithQuotes.new(hasText, '"')
-        selector_scopes << ":scope:has-text(#{text})"
+      if hasText
+        text_selector = "text=#{escape_for_text_selector(hasText, false)}"
+        selector_scopes << "internal:has=#{text_selector.to_json}"
       end
 
       if has
         unless same_frame?(has)
           raise DifferentFrameError.new
         end
-        selector_scopes << "has=#{has.send(:selector_json)}"
+        selector_scopes << "internal:has=#{has.send(:selector_json)}"
       end
 
       @selector = selector_scopes.join(' >> ')

data/lib/playwright/locator_utils.rb

@@ -0,0 +1,142 @@
+module Playwright
+  module LocatorUtils
+    def get_by_test_id(test_id)
+      locator(get_by_test_id_selector(test_id))
+    end
+
+    def get_by_alt_text(text, exact: false)
+      locator(get_by_alt_text_selector(text, exact: exact))
+    end
+
+    def get_by_label(text, exact: false)
+      locator(get_by_label_selector(text, exact: exact))
+    end
+
+    def get_by_placeholder(text, exact: false)
+      locator(get_by_placeholder_selector(text, exact: exact))
+    end
+
+    def get_by_text(text, exact: false)
+      locator(get_by_text_selector(text, exact: exact))
+    end
+
+    def get_by_title(text, exact: false)
+      locator(get_by_title_selector(text, exact: exact))
+    end
+
+    def get_by_role(role, **options)
+      locator(get_by_role_selector(role, **(options.compact)))
+    end
+
+    # set from Playwright::Selectors#test_id_attribute=
+    @test_id_attribute_name = 'data-testid'
+
+    private def get_by_attribute_text_selector(attr_name, text, exact: false)
+      "internal:attr=[#{attr_name}=#{escape_for_attribute_selector_or_regex(text, exact)}]"
+    end
+
+    private def get_by_test_id_selector(test_id)
+      get_by_attribute_text_selector(
+        ::Playwright::LocatorUtils.instance_variable_get(:@test_id_attribute_name),
+        test_id,
+        exact: true)
+    end
+
+    private def get_by_label_selector(text, exact:)
+      "internal:label=#{escape_for_text_selector(text, exact)}"
+    end
+
+    private def get_by_alt_text_selector(text, exact:)
+      get_by_attribute_text_selector('alt', text, exact: exact)
+    end
+
+    private def get_by_title_selector(text, exact:)
+      get_by_attribute_text_selector('title', text, exact: exact)
+    end
+
+    private def get_by_placeholder_selector(text, exact:)
+      get_by_attribute_text_selector('placeholder', text, exact: exact)
+    end
+
+    private def get_by_text_selector(text, exact:)
+      "text=#{escape_for_text_selector(text, exact)}"
+    end
+
+    private def get_by_role_selector(role, **options)
+      props = []
+
+      ex = {
+        includeHidden: -> (value) { ['include-hidden', value.to_s] },
+        name: -> (value) { ['name', escape_for_attribute_selector_or_regex(value, false)]},
+      }
+
+      %i[
+        checked
+        disabled
+        selected
+        expanded
+        includeHidden
+        level
+        name
+        pressed
+      ].each do |attr_name|
+        if options.key?(attr_name)
+          attr_value = options[attr_name]
+          props << ex[attr_name]&.call(attr_value) || [attr_name, attr_value.to_s]
+        end
+      end
+
+      opts = props.map { |k, v| "[#{k}=#{v}]"}.join('')
+      "role=#{role}#{opts}"
+    end
+
+    # @param text [String]
+    private def escape_for_regex(text)
+      text.gsub(/[.*+?^>${}()|\[\]\\]/) { "\\#{$&}" }
+    end
+
+    # @param text [Regexp|String]
+    private def escape_for_text_selector(text, exact)
+      if text.is_a?(Regexp)
+        regex = JavaScript::Regex.new(text)
+        return "/#{regex.source}/#{regex.flag}"
+      end
+
+      if exact
+        _text = text.gsub(/["]/, '\\"')
+        return "\"#{_text}\""
+      end
+
+      if text.include?('"') || text.include?('>>') || text.start_with?('/')
+        _text = escape_for_regex(text).gsub(/\s+/, '\\s+')
+        return "/#{_text}/i"
+      end
+
+      text
+    end
+
+    # @param text [Regexp|String]
+    private def escape_for_attribute_selector_or_regex(text, exact)
+      if text.is_a?(Regexp)
+        regex = JavaScript::Regex.new(text)
+        "/#{regex.source}/#{regex.flag}"
+      else
+        escape_for_attribute_selector(text, exact)
+      end
+    end
+
+    # @param text [String]
+    private def escape_for_attribute_selector(text, exact)
+      # TODO: this should actually be
+      # cssEscape(value).replace(/\\ /g, ' ')
+      # However, our attribute selectors do not conform to CSS parsing spec,
+      # so we escape them differently.
+      _text = text.gsub(/["]/, '\\"')
+      if exact
+        "\"#{_text}\""
+      else
+        "\"#{_text}\"i"
+      end
+    end
+  end
+end

data/lib/playwright/route_handler.rb

@@ -47,10 +47,10 @@ module Playwright
       @url_matcher.match?(url)
     end
 
-    def async_handle(route, request)
+    def async_handle(route)
       @counter.increment
 
-      Concurrent::Promises.future { @handler.call(route, request) }.rescue do |err|
+      Concurrent::Promises.future { @handler.call(route, route.request) }.rescue do |err|
         puts err, err.backtrace
       end
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.25.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.25.0'
+  VERSION = '1.27.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.27.0'
 end

data/lib/playwright_api/api_request_context.rb

@@ -75,10 +75,11 @@ module Playwright
           form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.delete(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.delete(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # All responses returned by [`method: APIRequestContext.get`] and similar methods are stored in the memory, so that you
@@ -90,6 +91,32 @@ module Playwright
 
     # Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and update
     # context cookies from the response. The method will automatically follow redirects.
+    #
+    # JSON objects can be passed directly to the request:
+    #
+    # ```python
+    # data = {
+    #     "title": "Book Title",
+    #     "body": "John Doe",
+    # }
+    # api_request_context.fetch("https://example.com/api/createBook", method="post", data=data)
+    # ```
+    #
+    # The common way to send file(s) in the body of a request is to encode it as form fields with `multipart/form-data`
+    # encoding. You can achieve that with Playwright API like this:
+    #
+    # ```python
+    # api_request_context.fetch(
+    #   "https://example.com/api/uploadScrip'",
+    #   method="post",
+    #   multipart={
+    #     "fileField": {
+    #       "name": "f.js",
+    #       "mimeType": "text/javascript",
+    #       "buffer": b"console.log(2022);",
+    #     },
+    #   })
+    # ```
     def fetch(
           urlOrRequest,
           data: nil,
@@ -97,24 +124,39 @@ module Playwright
           form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           method: nil,
           multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.fetch(unwrap_impl(urlOrRequest), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), method: unwrap_impl(method), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.fetch(unwrap_impl(urlOrRequest), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), method: unwrap_impl(method), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET) request and returns its response. The
     # method will populate request cookies from the context and update context cookies from the response. The method will
     # automatically follow redirects.
+    #
+    # Request parameters can be configured with `params` option, they will be serialized into the URL search parameters:
+    #
+    # ```python
+    # query_params = {
+    #   "isbn": "1234",
+    #   "page": "23"
+    # }
+    # api_request_context.get("https://example.com/api/getText", params=query_params)
+    # ```
     def get(
           url,
+          data: nil,
           failOnStatusCode: nil,
+          form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.get(unwrap_impl(url), failOnStatusCode: unwrap_impl(failOnStatusCode), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.get(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) request and returns its response.
@@ -122,12 +164,16 @@ module Playwright
     # automatically follow redirects.
     def head(
           url,
+          data: nil,
           failOnStatusCode: nil,
+          form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.head(unwrap_impl(url), failOnStatusCode: unwrap_impl(failOnStatusCode), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.head(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [PATCH](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) request and returns its response.
@@ -140,15 +186,52 @@ module Playwright
           form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.patch(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.patch(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) request and returns its response.
     # The method will populate request cookies from the context and update context cookies from the response. The method will
     # automatically follow redirects.
+    #
+    # JSON objects can be passed directly to the request:
+    #
+    # ```python
+    # data = {
+    #     "title": "Book Title",
+    #     "body": "John Doe",
+    # }
+    # api_request_context.post("https://example.com/api/createBook", data=data)
+    # ```
+    #
+    # To send form data to the server use `form` option. Its value will be encoded into the request body with
+    # `application/x-www-form-urlencoded` encoding (see below how to use `multipart/form-data` form encoding to send files):
+    #
+    # ```python
+    # formData = {
+    #     "title": "Book Title",
+    #     "body": "John Doe",
+    # }
+    # api_request_context.post("https://example.com/api/findBook", form=formData)
+    # ```
+    #
+    # The common way to send file(s) in the body of a request is to upload them as form fields with `multipart/form-data`
+    # encoding. You can achieve that with Playwright API like this:
+    #
+    # ```python
+    # api_request_context.post(
+    #   "https://example.com/api/uploadScrip'",
+    #   multipart={
+    #     "fileField": {
+    #       "name": "f.js",
+    #       "mimeType": "text/javascript",
+    #       "buffer": b"console.log(2022);",
+    #     },
+    #   })
+    # ```
     def post(
           url,
           data: nil,
@@ -156,10 +239,11 @@ module Playwright
           form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.post(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.post(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) request and returns its response. The
@@ -172,10 +256,11 @@ module Playwright
           form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           multipart: nil,
           params: nil,
           timeout: nil)
-      wrap_impl(@impl.put(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
+      wrap_impl(@impl.put(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Returns storage state for this request context, contains current cookies and local storage snapshot if it was passed to

data/lib/playwright_api/browser_context.rb

@@ -131,7 +131,7 @@ module Playwright
     #     <button onclick="onClick()">Click me</button>
     #     <div></div>
     #     """)
-    #     page.locator("button").click()
+    #     page.get_by_role("button").click()
     #
     # with sync_playwright() as playwright:
     #     run(playwright)
@@ -190,7 +190,7 @@ module Playwright
     #         <button onclick="onClick()">Click me</button>
     #         <div></div>
     #     """)
-    #     page.locator("button").click()
+    #     page.get_by_role("button").click()
     #
     # with sync_playwright() as playwright:
     #     run(playwright)
@@ -358,7 +358,7 @@ module Playwright
     #
     # ```python sync
     # with context.expect_event("page") as event_info:
-    #     page.locator("button").click()
+    #     page.get_by_role("button").click()
     # page = event_info.value
     # ```
     def expect_event(event, predicate: nil, timeout: nil, &block)

data/lib/playwright_api/browser_type.rb

@@ -30,6 +30,12 @@ module Playwright
     # The default browser context is accessible via [`method: Browser.contexts`].
     #
     # > NOTE: Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
+    #
+    # ```python sync
+    # browser = playwright.chromium.connect_over_cdp("http://localhost:9222")
+    # default_context = browser.contexts[0]
+    # page = default_context.pages[0]
+    # ```
     def connect_over_cdp(
           endpointURL,
           headers: nil,

data/lib/playwright_api/download.rb

@@ -7,7 +7,7 @@ module Playwright
   #
   # ```python sync
   # with page.expect_download() as download_info:
-  #     page.locator("a").click()
+  #     page.get_by_text("Download file").click()
   # download = download_info.value
   # # wait for download to complete
   # path = download.path()

data/lib/playwright_api/element_handle.rb

@@ -36,7 +36,7 @@ module Playwright
   # in the snippet below, underlying DOM element is going to be located twice.
   #
   # ```python sync
-  # locator = page.locator("text=Submit")
+  # locator = page.get_by_text("Submit")
   # locator.hover()
   # locator.click()
   # ```

data/lib/playwright_api/file_chooser.rb

@@ -3,7 +3,7 @@ module Playwright
   #
   # ```python sync
   # with page.expect_file_chooser() as fc_info:
-  #     page.locator("upload").click()
+  #     page.get_by_text("Upload").click()
   # file_chooser = fc_info.value
   # file_chooser.set_files("myfile.pdf")
   # ```

data/lib/playwright_api/frame.rb

@@ -335,7 +335,7 @@ module Playwright
     # id="my-frame">`:
     #
     # ```python sync
-    # locator = frame.frame_locator("#my-iframe").locator("text=Submit")
+    # locator = frame.frame_locator("#my-iframe").get_by_text("Submit")
     # locator.click()
     # ```
     def frame_locator(selector)
@@ -347,6 +347,78 @@ module Playwright
       wrap_impl(@impl.get_attribute(unwrap_impl(selector), unwrap_impl(name), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
     end
 
+    # Allows locating elements by their alt text. For example, this method will find the image by alt text "Castle":
+    #
+    # ```html
+    # <img alt='Castle'>
+    # ```
+    def get_by_alt_text(text, exact: nil)
+      wrap_impl(@impl.get_by_alt_text(unwrap_impl(text), exact: unwrap_impl(exact)))
+    end
+
+    # Allows locating input elements by the text of the associated label. For example, this method will find the input by
+    # label text Password in the following DOM:
+    #
+    # ```html
+    # <label for="password-input">Password:</label>
+    # <input id="password-input">
+    # ```
+    def get_by_label(text, exact: nil)
+      wrap_impl(@impl.get_by_label(unwrap_impl(text), exact: unwrap_impl(exact)))
+    end
+
+    # Allows locating input elements by the placeholder text. For example, this method will find the input by placeholder
+    # "Country":
+    #
+    # ```html
+    # <input placeholder="Country">
+    # ```
+    def get_by_placeholder(text, exact: nil)
+      wrap_impl(@impl.get_by_placeholder(unwrap_impl(text), exact: unwrap_impl(exact)))
+    end
+
+    # Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),
+    # [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and
+    # [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). Note that role selector **does not replace**
+    # accessibility audits and conformance tests, but rather gives early feedback about the ARIA guidelines.
+    #
+    # Note that many html elements have an implicitly
+    # [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings) that is recognized by the role selector. You
+    # can find all the [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not
+    # recommend** duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.
+    def get_by_role(
+          role,
+          checked: nil,
+          disabled: nil,
+          expanded: nil,
+          includeHidden: nil,
+          level: nil,
+          name: nil,
+          pressed: nil,
+          selected: nil)
+      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), disabled: unwrap_impl(disabled), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
+    end
+
+    # Locate element by the test id. By default, the `data-testid` attribute is used as a test id. Use
+    # [`method: Selectors.setTestIdAttribute`] to configure a different test id attribute if necessary.
+    def get_by_test_id(testId)
+      wrap_impl(@impl.get_by_test_id(unwrap_impl(testId)))
+    end
+
+    # Allows locating elements that contain given text.
+    def get_by_text(text, exact: nil)
+      wrap_impl(@impl.get_by_text(unwrap_impl(text), exact: unwrap_impl(exact)))
+    end
+
+    # Allows locating elements by their title. For example, this method will find the button by its title "Submit":
+    #
+    # ```html
+    # <button title='Place the order'>Order Now</button>
+    # ```
+    def get_by_title(text, exact: nil)
+      wrap_impl(@impl.get_by_title(unwrap_impl(text), exact: unwrap_impl(exact)))
+    end
+
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
     # last redirect.
     #
@@ -445,9 +517,11 @@ module Playwright
       wrap_impl(@impl.visible?(unwrap_impl(selector), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
     end
 
-    # The method returns an element locator that can be used to perform actions in the frame. Locator is resolved to the
-    # element immediately before performing an action, so a series of actions on the same locator can in fact be performed on
-    # different DOM elements. That would happen if the DOM structure between those actions has changed.
+    # The method returns an element locator that can be used to perform actions on this page / frame. Locator is resolved to
+    # the element immediately before performing an action, so a series of actions on the same locator can in fact be performed
+    # on different DOM elements. That would happen if the DOM structure between those actions has changed.
+    #
+    # [Learn more about locators](../locators.md).
     #
     # [Learn more about locators](../locators.md).
     def locator(selector, has: nil, hasText: nil)