playwright-ruby-client 0.0.6 → 0.2.0

data/lib/playwright_api/js_handle.rb

@@ -22,13 +22,13 @@ module Playwright
   # [`method: JSHandle.dispose`]. JSHandles are auto-disposed when their origin frame gets navigated or the parent context
   # gets destroyed.
   # 
-  # JSHandle instances can be used as an argument in [`method: Page.$eval`], [`method: Page.evaluate`] and
+  # JSHandle instances can be used as an argument in [`method: Page.evalOnSelector`], [`method: Page.evaluate`] and
   # [`method: Page.evaluateHandle`] methods.
   class JSHandle < PlaywrightApi
 
     # Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
     def as_element
-      raise NotImplementedError.new('as_element is not implemented yet.')
+      wrap_impl(@impl.as_element)
     end
 
     # The `jsHandle.dispose` method stops referencing the element handle.
@@ -36,12 +36,11 @@ module Playwright
       wrap_impl(@impl.dispose)
     end
 
-    # Returns the return value of `pageFunction`
+    # Returns the return value of `expression`.
     # 
-    # This method passes this handle as the first argument to `pageFunction`.
+    # This method passes this handle as the first argument to `expression`.
     # 
-    # If `pageFunction` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its
-    # value.
+    # If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.
     # 
     # Examples:
     # 
@@ -60,23 +59,23 @@ module Playwright
     # tweet_handle = page.query_selector(".tweet .retweets")
     # assert tweet_handle.evaluate("node => node.innerText") == "10 retweets"
     # ```
-    def evaluate(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate is not implemented yet.')
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
-    # Returns the return value of `pageFunction` as in-page object (JSHandle).
+    # Returns the return value of `expression` as a `JSHandle`.
     # 
-    # This method passes this handle as the first argument to `pageFunction`.
+    # This method passes this handle as the first argument to `expression`.
     # 
     # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
-    # in-page object (JSHandle).
+    # `JSHandle`.
     # 
     # If the function passed to the `jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would wait
     # for the promise to resolve and return its value.
     # 
     # See [`method: Page.evaluateHandle`] for more details.
-    def evaluate_handle(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate_handle is not implemented yet.')
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # The method returns a map with **own property names** as keys and JSHandle instances for the property values.
@@ -106,12 +105,13 @@ module Playwright
     # handle.dispose()
     # ```
     def get_properties
-      raise NotImplementedError.new('get_properties is not implemented yet.')
+      wrap_impl(@impl.get_properties)
     end
+    alias_method :properties, :get_properties
 
     # Fetches a single property from the referenced object.
     def get_property(propertyName)
-      raise NotImplementedError.new('get_property is not implemented yet.')
+      wrap_impl(@impl.get_property(unwrap_impl(propertyName)))
     end
 
     # Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.
@@ -119,25 +119,29 @@ module Playwright
     # > NOTE: The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an
     # error if the object has circular references.
     def json_value
-      raise NotImplementedError.new('json_value is not implemented yet.')
+      wrap_impl(@impl.json_value)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(event, callback))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(event, callback))
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(event, callback))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/keyboard.rb

@@ -114,7 +114,7 @@ module Playwright
     # 
     # > NOTE: Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
     def down(key)
-      @impl.down(key)
+      wrap_impl(@impl.down(unwrap_impl(key)))
     end
 
     # Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
@@ -134,7 +134,7 @@ module Playwright
     # 
     # > NOTE: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
     def insert_text(text)
-      @impl.insert_text(text)
+      wrap_impl(@impl.insert_text(unwrap_impl(text)))
     end
 
     # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
@@ -193,7 +193,7 @@ module Playwright
     # 
     # Shortcut for [`method: Keyboard.down`] and [`method: Keyboard.up`].
     def press(key, delay: nil)
-      @impl.press(key, delay: delay)
+      wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
     end
 
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
@@ -217,13 +217,13 @@ module Playwright
     # ```
     # 
     # > NOTE: Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
-    def type_text(text, delay: nil)
-      @impl.type_text(text, delay: delay)
+    def type(text, delay: nil)
+      wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay)))
     end
 
     # Dispatches a `keyup` event.
     def up(key)
-      @impl.up(key)
+      wrap_impl(@impl.up(unwrap_impl(key)))
     end
   end
 end

data/lib/playwright_api/page.rb

@@ -2,8 +2,8 @@ module Playwright
   # - extends: [EventEmitter]
   # 
   # Page provides methods to interact with a single tab in a `Browser`, or an
-  # [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One [Browser]
-  # instance might have multiple [Page] instances.
+  # [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One `Browser`
+  # instance might have multiple `Page` instances.
   # 
   # This example creates a page, navigates it to a URL, and then saves a screenshot:
   # 
@@ -96,12 +96,6 @@ module Playwright
       wrap_impl(@impl.accessibility)
     end
 
-    # Browser-specific Coverage implementation, only available for Chromium atm. See
-    # `ChromiumCoverage`(#class-chromiumcoverage) for more details.
-    def coverage # property
-      raise NotImplementedError.new('coverage is not implemented yet.')
-    end
-
     def keyboard # property
       wrap_impl(@impl.keyboard)
     end
@@ -114,78 +108,6 @@ module Playwright
       wrap_impl(@impl.touchscreen)
     end
 
-    # The method finds an element matching the specified selector within the page. If no elements match the selector, the
-    # return value resolves to `null`.
-    # 
-    # Shortcut for main frame's [`method: Frame.$`].
-    def query_selector(selector)
-      wrap_impl(@impl.query_selector(selector))
-    end
-
-    # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
-    # return value resolves to `[]`.
-    # 
-    # Shortcut for main frame's [`method: Frame.$$`].
-    def query_selector_all(selector)
-      wrap_impl(@impl.query_selector_all(selector))
-    end
-
-    # The method finds an element matching the specified selector within the page and passes it as a first argument to
-    # `pageFunction`. If no elements match the selector, the method throws an error. Returns the value of `pageFunction`.
-    # 
-    # If `pageFunction` returns a [Promise], then [`method: Page.$eval`] would wait for the promise to resolve and return its
-    # value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const searchValue = await page.$eval('#search', el => el.value);
-    # const preloadHref = await page.$eval('link[rel=preload]', el => el.href);
-    # const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
-    # ```
-    # 
-    # ```python async
-    # search_value = await page.eval_on_selector("#search", "el => el.value")
-    # preload_href = await page.eval_on_selector("link[rel=preload]", "el => el.href")
-    # html = await page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
-    # ```
-    # 
-    # ```python sync
-    # search_value = page.eval_on_selector("#search", "el => el.value")
-    # preload_href = page.eval_on_selector("link[rel=preload]", "el => el.href")
-    # html = page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
-    # ```
-    # 
-    # Shortcut for main frame's [`method: Frame.$eval`].
-    def eval_on_selector(selector, pageFunction, arg: nil)
-      wrap_impl(@impl.eval_on_selector(selector, pageFunction, arg: arg))
-    end
-
-    # The method finds all elements matching the specified selector within the page and passes an array of matched elements as
-    # a first argument to `pageFunction`. Returns the result of `pageFunction` invocation.
-    # 
-    # If `pageFunction` returns a [Promise], then [`method: Page.$$eval`] would wait for the promise to resolve and return its
-    # value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
-    # ```
-    # 
-    # ```python async
-    # div_counts = await page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
-    # ```
-    # 
-    # ```python sync
-    # div_counts = page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
-    # ```
-    def eval_on_selector_all(selector, pageFunction, arg: nil)
-      wrap_impl(@impl.eval_on_selector_all(selector, pageFunction, arg: arg))
-    end
-
     # Adds a script which would be evaluated in one of the following scenarios:
     # - Whenever the page is navigated.
     # - Whenever the child frame is attached or navigated. In this case, the script is evaluated in the context of the newly
@@ -220,8 +142,8 @@ module Playwright
     # 
     # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
-    def add_init_script(script, arg: nil)
-      raise NotImplementedError.new('add_init_script is not implemented yet.')
+    def add_init_script(path: nil, script: nil)
+      wrap_impl(@impl.add_init_script(path: unwrap_impl(path), script: unwrap_impl(script)))
     end
 
     # Adds a `<script>` tag into the page with the desired url or content. Returns the added tag when the script's onload
@@ -229,7 +151,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.addScriptTag`].
     def add_script_tag(content: nil, path: nil, type: nil, url: nil)
-      raise NotImplementedError.new('add_script_tag is not implemented yet.')
+      wrap_impl(@impl.add_script_tag(content: unwrap_impl(content), path: unwrap_impl(path), type: unwrap_impl(type), url: unwrap_impl(url)))
     end
 
     # Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the
@@ -237,12 +159,12 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.addStyleTag`].
     def add_style_tag(content: nil, path: nil, url: nil)
-      raise NotImplementedError.new('add_style_tag is not implemented yet.')
+      wrap_impl(@impl.add_style_tag(content: unwrap_impl(content), path: unwrap_impl(path), url: unwrap_impl(url)))
     end
 
     # Brings page to front (activates tab).
     def bring_to_front
-      raise NotImplementedError.new('bring_to_front is not implemented yet.')
+      wrap_impl(@impl.bring_to_front)
     end
 
     # This method checks an element matching `selector` by performing the following steps:
@@ -261,7 +183,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.check`].
     def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('check is not implemented yet.')
+      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method clicks an element matching `selector` by performing the following steps:
@@ -286,7 +208,7 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      wrap_impl(@impl.click(selector, button: button, clickCount: clickCount, delay: delay, force: force, modifiers: modifiers, noWaitAfter: noWaitAfter, position: position, timeout: timeout))
+      wrap_impl(@impl.click(unwrap_impl(selector), button: unwrap_impl(button), clickCount: unwrap_impl(clickCount), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # If `runBeforeUnload` is `false`, does not run any unload handlers and waits for the page to be closed. If
@@ -297,7 +219,7 @@ module Playwright
     # > NOTE: if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned and should be handled manually
     # via [`event: Page.dialog`] event.
     def close(runBeforeUnload: nil)
-      wrap_impl(@impl.close(runBeforeUnload: runBeforeUnload))
+      wrap_impl(@impl.close(runBeforeUnload: unwrap_impl(runBeforeUnload)))
     end
 
     # Gets the full HTML contents of the page, including the doctype.
@@ -334,7 +256,7 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('dblclick is not implemented yet.')
+      wrap_impl(@impl.dblclick(unwrap_impl(selector), button: unwrap_impl(button), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
@@ -387,7 +309,7 @@ module Playwright
     # page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
     # ```
     def dispatch_event(selector, type, eventInit: nil, timeout: nil)
-      raise NotImplementedError.new('dispatch_event is not implemented yet.')
+      wrap_impl(@impl.dispatch_event(unwrap_impl(selector), unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
 
     # 
@@ -478,20 +400,76 @@ module Playwright
     # # → False
     # page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
     # ```
-    def emulate_media(params)
-      raise NotImplementedError.new('emulate_media is not implemented yet.')
+    def emulate_media(colorScheme: nil, media: nil)
+      wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), media: unwrap_impl(media)))
     end
 
-    # Returns the value of the `pageFunction` invocation.
+    # The method finds an element matching the specified selector within the page and passes it as a first argument to
+    # `expression`. If no elements match the selector, the method throws an error. Returns the value of `expression`.
+    # 
+    # If `expression` returns a [Promise], then [`method: Page.evalOnSelector`] would wait for the promise to resolve and
+    # return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const searchValue = await page.$eval('#search', el => el.value);
+    # const preloadHref = await page.$eval('link[rel=preload]', el => el.href);
+    # const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
+    # ```
+    # 
+    # ```python async
+    # search_value = await page.eval_on_selector("#search", "el => el.value")
+    # preload_href = await page.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = await page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
+    # ```
+    # 
+    # ```python sync
+    # search_value = page.eval_on_selector("#search", "el => el.value")
+    # preload_href = page.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
+    # ```
+    # 
+    # Shortcut for main frame's [`method: Frame.evalOnSelector`].
+    def eval_on_selector(selector, expression, arg: nil)
+      wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
+    end
+
+    # The method finds all elements matching the specified selector within the page and passes an array of matched elements as
+    # a first argument to `expression`. Returns the result of `expression` invocation.
+    # 
+    # If `expression` returns a [Promise], then [`method: Page.evalOnSelectorAll`] would wait for the promise to resolve and
+    # return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
+    # ```
+    # 
+    # ```python async
+    # div_counts = await page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    # 
+    # ```python sync
+    # div_counts = page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    def eval_on_selector_all(selector, expression, arg: nil)
+      wrap_impl(@impl.eval_on_selector_all(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
+    end
+
+    # Returns the value of the `expression` invocation.
     # 
     # If the function passed to the [`method: Page.evaluate`] returns a [Promise], then [`method: Page.evaluate`] would wait
     # for the promise to resolve and return its value.
     # 
-    # If the function passed to the [`method: Page.evaluate`] returns a non-[Serializable] value,
-    # then[ method: `Page.evaluate`] resolves to `undefined`. DevTools Protocol also supports transferring some additional
-    # values that are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+    # If the function passed to the [`method: Page.evaluate`] returns a non-[Serializable] value, then
+    # [`method: Page.evaluate`] resolves to `undefined`. Playwright also supports transferring some additional values that are
+    # not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
     # 
-    # Passing argument to `pageFunction`:
+    # Passing argument to `expression`:
     # 
     #
     # ```js
@@ -554,14 +532,14 @@ module Playwright
     # ```
     # 
     # Shortcut for main frame's [`method: Frame.evaluate`].
-    def evaluate(pageFunction, arg: nil)
-      wrap_impl(@impl.evaluate(pageFunction, arg: arg))
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
-    # Returns the value of the `pageFunction` invocation as in-page object (JSHandle).
+    # Returns the value of the `expression` invocation as a `JSHandle`.
     # 
     # The only difference between [`method: Page.evaluate`] and [`method: Page.evaluateHandle`] is that
-    # [`method: Page.evaluateHandle`] returns in-page object (JSHandle).
+    # [`method: Page.evaluateHandle`] returns `JSHandle`.
     # 
     # If the function passed to the [`method: Page.evaluateHandle`] returns a [Promise], then [`method: Page.evaluateHandle`]
     # would wait for the promise to resolve and return its value.
@@ -573,7 +551,6 @@ module Playwright
     # ```
     # 
     # ```python async
-    # # FIXME
     # a_window_handle = await page.evaluate_handle("Promise.resolve(window)")
     # a_window_handle # handle for the window object.
     # ```
@@ -621,8 +598,8 @@ module Playwright
     # print(result_handle.json_value())
     # result_handle.dispose()
     # ```
-    def evaluate_handle(pageFunction, arg: nil)
-      wrap_impl(@impl.evaluate_handle(pageFunction, arg: arg))
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # The method adds a function called `name` on the `window` object of every frame in this page. When called, the function
@@ -755,7 +732,7 @@ module Playwright
     # """)
     # ```
     def expose_binding(name, callback, handle: nil)
-      raise NotImplementedError.new('expose_binding is not implemented yet.')
+      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 the page. When called, the function
@@ -854,19 +831,20 @@ module Playwright
     #     run(playwright)
     # ```
     def expose_function(name, callback)
-      raise NotImplementedError.new('expose_function is not implemented yet.')
+      wrap_impl(@impl.expose_function(unwrap_impl(name), unwrap_impl(callback)))
     end
 
     # This method waits for an element matching `selector`, waits for [actionability](./actionability.md) checks, focuses the
-    # element, fills it and triggers an `input` event after filling. If the element matching `selector` 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.
+    # element, fills it and triggers an `input` event after filling. If the element is inside the `<label>` element that has
+    # associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), that control will be
+    # filled instead. If the element to be filled 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.
     # 
     # To send fine-grained keyboard events, use [`method: Page.type`].
     # 
     # Shortcut for main frame's [`method: Frame.fill`]
     def fill(selector, value, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('fill is not implemented yet.')
+      wrap_impl(@impl.fill(unwrap_impl(selector), unwrap_impl(value), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
@@ -874,7 +852,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.focus`].
     def focus(selector, timeout: nil)
-      wrap_impl(@impl.focus(selector, timeout: timeout))
+      wrap_impl(@impl.focus(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns frame matching the specified criteria. Either `name` or `url` must be specified.
@@ -896,8 +874,8 @@ module Playwright
     # ```py
     # frame = page.frame(url=r".*domain.*")
     # ```
-    def frame(frameSelector)
-      wrap_impl(@impl.frame(frameSelector))
+    def frame(name: nil, url: nil)
+      wrap_impl(@impl.frame(name: unwrap_impl(name), url: unwrap_impl(url)))
     end
 
     # An array of all frames attached to the page.
@@ -907,7 +885,7 @@ module Playwright
 
     # Returns element attribute value.
     def get_attribute(selector, name, timeout: nil)
-      raise NotImplementedError.new('get_attribute is not implemented yet.')
+      wrap_impl(@impl.get_attribute(unwrap_impl(selector), unwrap_impl(name), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
@@ -915,7 +893,7 @@ module Playwright
     # 
     # Navigate to the previous page in history.
     def go_back(timeout: nil, waitUntil: nil)
-      raise NotImplementedError.new('go_back is not implemented yet.')
+      wrap_impl(@impl.go_back(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
@@ -923,7 +901,7 @@ module Playwright
     # 
     # Navigate to the next page in history.
     def go_forward(timeout: nil, waitUntil: nil)
-      raise NotImplementedError.new('go_forward is not implemented yet.')
+      wrap_impl(@impl.go_forward(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
@@ -947,7 +925,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.goto`]
     def goto(url, referer: nil, timeout: nil, waitUntil: nil)
-      wrap_impl(@impl.goto(url, referer: referer, timeout: timeout, waitUntil: waitUntil))
+      wrap_impl(@impl.goto(unwrap_impl(url), referer: unwrap_impl(referer), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # This method hovers over an element matching `selector` by performing the following steps:
@@ -968,22 +946,22 @@ module Playwright
           modifiers: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('hover is not implemented yet.')
+      wrap_impl(@impl.hover(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns `element.innerHTML`.
     def inner_html(selector, timeout: nil)
-      raise NotImplementedError.new('inner_html is not implemented yet.')
+      wrap_impl(@impl.inner_html(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns `element.innerText`.
     def inner_text(selector, timeout: nil)
-      raise NotImplementedError.new('inner_text is not implemented yet.')
+      wrap_impl(@impl.inner_text(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
     def checked?(selector, timeout: nil)
-      raise NotImplementedError.new('checked? is not implemented yet.')
+      wrap_impl(@impl.checked?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Indicates that the page has been closed.
@@ -993,27 +971,27 @@ module Playwright
 
     # Returns whether the element is disabled, the opposite of [enabled](./actionability.md#enabled).
     def disabled?(selector, timeout: nil)
-      raise NotImplementedError.new('disabled? is not implemented yet.')
+      wrap_impl(@impl.disabled?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is [editable](./actionability.md#editable).
     def editable?(selector, timeout: nil)
-      raise NotImplementedError.new('editable? is not implemented yet.')
+      wrap_impl(@impl.editable?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is [enabled](./actionability.md#enabled).
     def enabled?(selector, timeout: nil)
-      raise NotImplementedError.new('enabled? is not implemented yet.')
+      wrap_impl(@impl.enabled?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).
     def hidden?(selector, timeout: nil)
-      raise NotImplementedError.new('hidden? is not implemented yet.')
+      wrap_impl(@impl.hidden?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is [visible](./actionability.md#visible).
     def visible?(selector, timeout: nil)
-      raise NotImplementedError.new('visible? is not implemented yet.')
+      wrap_impl(@impl.visible?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
@@ -1026,6 +1004,18 @@ module Playwright
       wrap_impl(@impl.opener)
     end
 
+    # Pauses script execution. Playwright will stop executing the script and wait for the user to either press 'Resume' button
+    # in the page overlay or to call `playwright.resume()` in the DevTools console.
+    # 
+    # User can inspect selectors or perform manual steps while paused. Resume will continue running the original script from
+    # the place it was paused.
+    # 
+    # > NOTE: This method requires Playwright to be started in a headed mode, with a falsy [`options: headless`] value in the
+    # [`method: BrowserType.launch`].
+    def pause
+      raise NotImplementedError.new('pause is not implemented yet.')
+    end
+
     # Returns the PDF buffer.
     # 
     # > NOTE: Generating a pdf is currently only supported in Chromium headless.
@@ -1098,7 +1088,7 @@ module Playwright
           printBackground: nil,
           scale: nil,
           width: nil)
-      raise NotImplementedError.new('pdf is not implemented yet.')
+      wrap_impl(@impl.pdf(displayHeaderFooter: unwrap_impl(displayHeaderFooter), footerTemplate: unwrap_impl(footerTemplate), format: unwrap_impl(format), headerTemplate: unwrap_impl(headerTemplate), height: unwrap_impl(height), landscape: unwrap_impl(landscape), margin: unwrap_impl(margin), pageRanges: unwrap_impl(pageRanges), path: unwrap_impl(path), preferCSSPageSize: unwrap_impl(preferCSSPageSize), printBackground: unwrap_impl(printBackground), scale: unwrap_impl(scale), width: unwrap_impl(width)))
     end
 
     # Focuses the element, and then uses [`method: Keyboard.down`] and [`method: Keyboard.up`].
@@ -1162,13 +1152,29 @@ module Playwright
           delay: nil,
           noWaitAfter: nil,
           timeout: nil)
-      wrap_impl(@impl.press(selector, key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.press(unwrap_impl(selector), unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    end
+
+    # The method finds an element matching the specified selector within the page. If no elements match the selector, the
+    # return value resolves to `null`.
+    # 
+    # Shortcut for main frame's [`method: Frame.querySelector`].
+    def query_selector(selector)
+      wrap_impl(@impl.query_selector(unwrap_impl(selector)))
+    end
+
+    # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
+    # return value resolves to `[]`.
+    # 
+    # Shortcut for main frame's [`method: Frame.querySelectorAll`].
+    def query_selector_all(selector)
+      wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
     # last redirect.
     def reload(timeout: nil, waitUntil: nil)
-      raise NotImplementedError.new('reload is not implemented yet.')
+      wrap_impl(@impl.reload(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # Routing provides the capability to modify network requests that are made by a page.
@@ -1245,7 +1251,7 @@ module Playwright
           quality: nil,
           timeout: nil,
           type: nil)
-      wrap_impl(@impl.screenshot(clip: clip, fullPage: fullPage, omitBackground: omitBackground, path: path, quality: quality, timeout: timeout, type: type))
+      wrap_impl(@impl.screenshot(clip: unwrap_impl(clip), fullPage: unwrap_impl(fullPage), omitBackground: unwrap_impl(omitBackground), path: unwrap_impl(path), quality: unwrap_impl(quality), timeout: unwrap_impl(timeout), type: unwrap_impl(type)))
     end
 
     # Returns the array of option values that have been successfully selected.
@@ -1287,12 +1293,19 @@ module Playwright
     # ```
     # 
     # Shortcut for main frame's [`method: Frame.selectOption`]
-    def select_option(selector, values, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('select_option is not implemented yet.')
+    def select_option(
+          selector,
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      wrap_impl(@impl.select_option(unwrap_impl(selector), element: unwrap_impl(element), index: unwrap_impl(index), value: unwrap_impl(value), label: unwrap_impl(label), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     def set_content(html, timeout: nil, waitUntil: nil)
-      wrap_impl(@impl.set_content(html, timeout: timeout, waitUntil: waitUntil))
+      wrap_impl(@impl.set_content(unwrap_impl(html), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
     alias_method :content=, :set_content
 
@@ -1307,7 +1320,7 @@ module Playwright
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`],
     # [`method: BrowserContext.setDefaultTimeout`] and [`method: BrowserContext.setDefaultNavigationTimeout`].
     def set_default_navigation_timeout(timeout)
-      raise NotImplementedError.new('set_default_navigation_timeout is not implemented yet.')
+      wrap_impl(@impl.set_default_navigation_timeout(unwrap_impl(timeout)))
     end
     alias_method :default_navigation_timeout=, :set_default_navigation_timeout
 
@@ -1315,7 +1328,7 @@ module Playwright
     # 
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`].
     def set_default_timeout(timeout)
-      raise NotImplementedError.new('set_default_timeout is not implemented yet.')
+      wrap_impl(@impl.set_default_timeout(unwrap_impl(timeout)))
     end
     alias_method :default_timeout=, :set_default_timeout
 
@@ -1323,7 +1336,7 @@ module Playwright
     # 
     # > NOTE: [`method: Page.setExtraHTTPHeaders`] does not guarantee the order of headers in the outgoing requests.
     def set_extra_http_headers(headers)
-      raise NotImplementedError.new('set_extra_http_headers is not implemented yet.')
+      wrap_impl(@impl.set_extra_http_headers(unwrap_impl(headers)))
     end
     alias_method :extra_http_headers=, :set_extra_http_headers
 
@@ -1333,7 +1346,7 @@ module Playwright
     # 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(selector, files, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('set_input_files is not implemented yet.')
+      wrap_impl(@impl.set_input_files(unwrap_impl(selector), unwrap_impl(files), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # In the case of multiple pages in a single browser, each page can have its own viewport size. However,
@@ -1364,7 +1377,7 @@ module Playwright
     # page.goto("https://example.com")
     # ```
     def set_viewport_size(viewportSize)
-      wrap_impl(@impl.set_viewport_size(viewportSize))
+      wrap_impl(@impl.set_viewport_size(unwrap_impl(viewportSize)))
     end
     alias_method :viewport_size=, :set_viewport_size
 
@@ -1389,12 +1402,12 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('tap_point is not implemented yet.')
+      wrap_impl(@impl.tap_point(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns `element.textContent`.
     def text_content(selector, timeout: nil)
-      raise NotImplementedError.new('text_content is not implemented yet.')
+      wrap_impl(@impl.text_content(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the page's title. Shortcut for main frame's [`method: Frame.title`].
@@ -1424,13 +1437,13 @@ module Playwright
     # ```
     # 
     # Shortcut for main frame's [`method: Frame.type`].
-    def type_text(
+    def type(
           selector,
           text,
           delay: nil,
           noWaitAfter: nil,
           timeout: nil)
-      wrap_impl(@impl.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.type(unwrap_impl(selector), unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method unchecks an element matching `selector` by performing the following steps:
@@ -1449,7 +1462,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.uncheck`].
     def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('uncheck is not implemented yet.')
+      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # Removes a route created with [`method: Page.route`]. When `handler` is not specified, removes all routes for the `url`.
@@ -1493,13 +1506,13 @@ module Playwright
     #     page.click("button")
     # frame = event_info.value
     # ```
-    def expect_event(event, optionsOrPredicate: nil)
-      raise NotImplementedError.new('expect_event is not implemented yet.')
+    def expect_event(event, predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
-    # Returns when the `pageFunction` returns a truthy value. It resolves to a JSHandle of the truthy value.
+    # Returns when the `expression` returns a truthy value. It resolves to a JSHandle of the truthy value.
     # 
-    # The `waitForFunction` can be used to observe viewport size change:
+    # The [`method: Page.waitForFunction`] can be used to observe viewport size change:
     # 
     #
     # ```js
@@ -1523,7 +1536,7 @@ module Playwright
     #     webkit = playwright.webkit
     #     browser = await webkit.launch()
     #     page = await browser.new_page()
-    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);", force_expr=True)
+    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
     #     await page.wait_for_function("() => window.x > 0")
     #     await browser.close()
     # 
@@ -1540,7 +1553,7 @@ module Playwright
     #     webkit = playwright.webkit
     #     browser = webkit.launch()
     #     page = browser.new_page()
-    #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);", force_expr=True)
+    #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
     #     page.wait_for_function("() => window.x > 0")
     #     browser.close()
     # 
@@ -1567,8 +1580,8 @@ module Playwright
     # ```
     # 
     # Shortcut for main frame's [`method: Frame.waitForFunction`].
-    def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_function is not implemented yet.')
+    def wait_for_function(expression, arg: nil, polling: nil, timeout: nil)
+      wrap_impl(@impl.wait_for_function(unwrap_impl(expression), arg: unwrap_impl(arg), polling: unwrap_impl(polling), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when the required load state has been reached.
@@ -1622,7 +1635,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.waitForLoadState`].
     def wait_for_load_state(state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_load_state is not implemented yet.')
+      wrap_impl(@impl.wait_for_load_state(state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
     # Waits for the main frame navigation and returns the main resource response. In case of multiple redirects, the
@@ -1657,8 +1670,8 @@ module Playwright
     # considered a navigation.
     # 
     # Shortcut for main frame's [`method: Frame.waitForNavigation`].
-    def expect_navigation(timeout: nil, url: nil, waitUntil: nil)
-      raise NotImplementedError.new('expect_navigation is not implemented yet.')
+    def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
+      wrap_impl(@impl.expect_navigation(timeout: unwrap_impl(timeout), url: unwrap_impl(url), waitUntil: unwrap_impl(waitUntil), &wrap_block_call(block)))
     end
 
     # Waits for the matching request and returns it.
@@ -1695,7 +1708,7 @@ module Playwright
     # await page.waitForRequest(request => request.url().searchParams.get('foo') === 'bar' && request.url().searchParams.get('foo2') === 'bar2');
     # ```
     def expect_request(urlOrPredicate, timeout: nil)
-      raise NotImplementedError.new('expect_request is not implemented yet.')
+      wrap_impl(@impl.expect_request(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the matched response.
@@ -1719,7 +1732,7 @@ module Playwright
     # return final_response.ok
     # ```
     def expect_response(urlOrPredicate, timeout: nil)
-      raise NotImplementedError.new('expect_response is not implemented yet.')
+      wrap_impl(@impl.expect_response(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
@@ -1784,7 +1797,7 @@ module Playwright
     #     run(playwright)
     # ```
     def wait_for_selector(selector, state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_selector is not implemented yet.')
+      wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
     # Waits for the given `timeout` in milliseconds.
@@ -1821,52 +1834,75 @@ module Playwright
       raise NotImplementedError.new('workers is not implemented yet.')
     end
 
-    # @nodoc
-    def owned_context=(req)
-      wrap_impl(@impl.owned_context=(req))
+    # Performs action and waits for `download` event to fire. If predicate is provided, it passes `Download` value into the
+    # `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is
+    # closed before the download event is fired.
+    def expect_download(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_download is not implemented yet.')
     end
 
-    # @nodoc
-    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
-      wrap_impl(@impl.wait_for_navigation(timeout: timeout, url: url, waitUntil: waitUntil, &wrap_block_call(block)))
+    # Performs action and waits for `popup` event to fire. If predicate is provided, it passes [Popup] value into the
+    # `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is
+    # closed before the popup event is fired.
+    def expect_popup(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_popup is not implemented yet.')
     end
 
-    # @nodoc
-    def wait_for_request(urlOrPredicate, timeout: nil)
-      wrap_impl(@impl.wait_for_request(urlOrPredicate, timeout: timeout))
+    # Performs action and waits for `worker` event to fire. If predicate is provided, it passes `Worker` value into the
+    # `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is
+    # closed before the worker event is fired.
+    def expect_worker(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_worker is not implemented yet.')
     end
 
-    # @nodoc
-    def wait_for_event(event, optionsOrPredicate: nil, &block)
-      wrap_impl(@impl.wait_for_event(event, optionsOrPredicate: optionsOrPredicate, &wrap_block_call(block)))
+    # Performs action and waits for `console` event to fire. If predicate is provided, it passes `ConsoleMessage` value into
+    # the `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is
+    # closed before the worker event is fired.
+    def expect_console_message(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_console_message is not implemented yet.')
+    end
+
+    # Performs action and waits for `filechooser` event to fire. If predicate is provided, it passes `FileChooser` value into
+    # the `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is
+    # closed before the worker event is fired.
+    def expect_file_chooser(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_file_chooser is not implemented yet.')
+    end
+
+    # > NOTE: In most cases, you should use [`method: Page.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 socket 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
 
     # @nodoc
-    def wait_for_response(urlOrPredicate, timeout: nil)
-      wrap_impl(@impl.wait_for_response(urlOrPredicate, timeout: timeout))
+    def owned_context=(req)
+      wrap_impl(@impl.owned_context=(unwrap_impl(req)))
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
-      wrap_impl(@impl.on(event, callback))
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
-      wrap_impl(@impl.off(event, callback))
+      event_emitter_proxy.off(event, callback)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(event, callback))
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end