playwright-ruby-client 0.0.6 → 0.2.0

data/lib/playwright_api/browser_type.rb

@@ -49,11 +49,6 @@ module Playwright
   # ```
   class BrowserType < PlaywrightApi
 
-    # This methods attaches Playwright to an existing browser instance.
-    def connect(params)
-      raise NotImplementedError.new('connect is not implemented yet.')
-    end
-
     # A path where Playwright expects to find a bundled browser executable.
     def executable_path
       wrap_impl(@impl.executable_path)
@@ -109,12 +104,11 @@ module Playwright
           handleSIGTERM: nil,
           headless: nil,
           ignoreDefaultArgs: nil,
-          logger: nil,
           proxy: nil,
           slowMo: nil,
           timeout: nil,
           &block)
-      wrap_impl(@impl.launch(args: args, chromiumSandbox: chromiumSandbox, devtools: devtools, downloadsPath: downloadsPath, env: env, executablePath: executablePath, firefoxUserPrefs: firefoxUserPrefs, handleSIGHUP: handleSIGHUP, handleSIGINT: handleSIGINT, handleSIGTERM: handleSIGTERM, headless: headless, ignoreDefaultArgs: ignoreDefaultArgs, logger: logger, proxy: proxy, slowMo: slowMo, timeout: timeout, &wrap_block_call(block)))
+      wrap_impl(@impl.launch(args: unwrap_impl(args), 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), &wrap_block_call(block)))
     end
 
     # Returns the persistent browser context instance.
@@ -146,60 +140,22 @@ module Playwright
           isMobile: nil,
           javaScriptEnabled: nil,
           locale: nil,
-          logger: nil,
+          noViewport: nil,
           offline: nil,
           permissions: nil,
           proxy: nil,
-          recordHar: nil,
-          recordVideo: nil,
+          record_har_omit_content: nil,
+          record_har_path: nil,
+          record_video_dir: nil,
+          record_video_size: nil,
           slowMo: nil,
           timeout: nil,
           timezoneId: nil,
           userAgent: nil,
-          videoSize: nil,
-          videosPath: nil,
           viewport: nil)
       raise NotImplementedError.new('launch_persistent_context is not implemented yet.')
     end
 
-    # Returns the browser app instance.
-    # 
-    # Launches browser server that client can connect to. An example of launching a browser executable and connecting to it
-    # later:
-    # 
-    #
-    # ```js
-    # const { chromium } = require('playwright');  // Or 'webkit' or 'firefox'.
-    # 
-    # (async () => {
-    #   const browserServer = await chromium.launchServer();
-    #   const wsEndpoint = browserServer.wsEndpoint();
-    #   // Use web socket endpoint later to establish a connection.
-    #   const browser = await chromium.connect({ wsEndpoint });
-    #   // Close browser instance.
-    #   await browserServer.close();
-    # })();
-    # ```
-    def launch_server(
-          args: nil,
-          chromiumSandbox: nil,
-          devtools: nil,
-          downloadsPath: nil,
-          env: nil,
-          executablePath: nil,
-          firefoxUserPrefs: nil,
-          handleSIGHUP: nil,
-          handleSIGINT: nil,
-          handleSIGTERM: nil,
-          headless: nil,
-          ignoreDefaultArgs: nil,
-          logger: nil,
-          port: nil,
-          proxy: nil,
-          timeout: nil)
-      raise NotImplementedError.new('launch_server is not implemented yet.')
-    end
-
     # Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
     def name
       wrap_impl(@impl.name)
@@ -207,20 +163,24 @@ module Playwright
 
     # -- 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/chromium_browser_context.rb

@@ -11,12 +11,10 @@ module Playwright
   # ```
   # 
   # ```python async
-  # # FIXME
   # background_page = await context.wait_for_event("backgroundpage")
   # ```
   # 
   # ```python sync
-  # # FIXME
   # background_page = context.wait_for_event("backgroundpage")
   # ```
   class ChromiumBrowserContext < BrowserContext
@@ -38,20 +36,24 @@ module Playwright
 
     # -- 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/console_message.rb

@@ -17,31 +17,30 @@ module Playwright
     # One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
     # `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`,
     # `'count'`, `'timeEnd'`.
-    def type_text
-      raise NotImplementedError.new('type_text is not implemented yet.')
+    def type
+      wrap_impl(@impl.type)
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def type
-      wrap_impl(@impl.type)
+    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

data/lib/playwright_api/dialog.rb

@@ -42,7 +42,6 @@ module Playwright
   # ```
   # 
   # ```python sync
-  # # FIXME
   # from playwright.sync_api import sync_playwright
   # 
   # def handle_dialog(dialog):
@@ -60,6 +59,11 @@ module Playwright
   # with sync_playwright() as 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.
   class Dialog < PlaywrightApi
 
     # Returns when the dialog has been accepted.
@@ -83,8 +87,8 @@ module Playwright
     end
 
     # Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
-    def type_text
-      raise NotImplementedError.new('type_text is not implemented yet.')
+    def type
+      raise NotImplementedError.new('type is not implemented yet.')
     end
   end
 end

data/lib/playwright_api/download.rb

@@ -37,29 +37,24 @@ module Playwright
   # performed and user has no access to the downloaded files.
   class Download < PlaywrightApi
 
-    # Returns readable stream for current download or `null` if download failed.
-    def create_read_stream
-      raise NotImplementedError.new('create_read_stream is not implemented yet.')
-    end
-
     # Deletes the downloaded file.
     def delete
-      raise NotImplementedError.new('delete is not implemented yet.')
+      wrap_impl(@impl.delete)
     end
 
     # Returns download error if any.
     def failure
-      raise NotImplementedError.new('failure is not implemented yet.')
+      wrap_impl(@impl.failure)
     end
 
     # Returns path to the downloaded file in case of successful download.
     def path
-      raise NotImplementedError.new('path is not implemented yet.')
+      wrap_impl(@impl.path)
     end
 
     # Saves the download to a user-specified path.
     def save_as(path)
-      raise NotImplementedError.new('save_as is not implemented yet.')
+      wrap_impl(@impl.save_as(unwrap_impl(path)))
     end
 
     # Returns suggested filename for this download. It is typically computed by the browser from the
@@ -67,12 +62,34 @@ module Playwright
     # or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources). Different
     # browsers can use different logic for computing it.
     def suggested_filename
-      raise NotImplementedError.new('suggested_filename is not implemented yet.')
+      wrap_impl(@impl.suggested_filename)
     end
 
     # Returns downloaded url.
     def url
-      raise NotImplementedError.new('url is not implemented yet.')
+      wrap_impl(@impl.url)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    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/element_handle.rb

@@ -3,7 +3,8 @@ require_relative './js_handle.rb'
 module Playwright
   # - extends: `JSHandle`
   # 
-  # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.$`] method.
+  # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.querySelector`]
+  # method.
   # 
   #
   # ```js
@@ -57,92 +58,10 @@ module Playwright
   # ElementHandle prevents DOM element from garbage collection unless the handle is disposed with
   # [`method: JSHandle.dispose`]. ElementHandles are auto-disposed when their origin frame gets navigated.
   # 
-  # ElementHandle instances can be used as an argument in [`method: Page.$eval`] and [`method: Page.evaluate`] methods.
+  # ElementHandle instances can be used as an argument in [`method: Page.evalOnSelector`] and [`method: Page.evaluate`]
+  # methods.
   class ElementHandle < JSHandle
 
-    # The method finds an element matching the specified selector in the `ElementHandle`'s subtree. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
-    # returns `null`.
-    def query_selector(selector)
-      wrap_impl(@impl.query_selector(selector))
-    end
-
-    # The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
-    # returns empty array.
-    def query_selector_all(selector)
-      wrap_impl(@impl.query_selector_all(selector))
-    end
-
-    # Returns the return value of `pageFunction`
-    # 
-    # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
-    # argument to `pageFunction`. See [Working with selectors](./selectors.md#working-with-selectors) for more details. If no
-    # elements match the selector, the method throws an error.
-    # 
-    # If `pageFunction` returns a [Promise], then `frame.$eval` would wait for the promise to resolve and return its value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const tweetHandle = await page.$('.tweet');
-    # expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');
-    # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
-    # ```
-    # 
-    # ```python async
-    # tweet_handle = await page.query_selector(".tweet")
-    # assert await tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
-    # assert await tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
-    # ```
-    # 
-    # ```python sync
-    # tweet_handle = page.query_selector(".tweet")
-    # assert tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
-    # assert tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
-    # ```
-    def eval_on_selector(selector, pageFunction, arg: nil)
-      wrap_impl(@impl.eval_on_selector(selector, pageFunction, arg: arg))
-    end
-
-    # Returns the return value of `pageFunction`
-    # 
-    # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of
-    # matched elements as a first argument to `pageFunction`. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more details.
-    # 
-    # If `pageFunction` returns a [Promise], then `frame.$$eval` would wait for the promise to resolve and return its value.
-    # 
-    # Examples:
-    # 
-    # ```html
-    # <div class="feed">
-    #   <div class="tweet">Hello!</div>
-    #   <div class="tweet">Hi!</div>
-    # </div>
-    # ```
-    # 
-    #
-    # ```js
-    # const feedHandle = await page.$('.feed');
-    # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
-    # ```
-    # 
-    # ```python async
-    # # FIXME
-    # feed_handle = await page.query_selector(".feed")
-    # assert await feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
-    # ```
-    # 
-    # ```python sync
-    # feed_handle = page.query_selector(".feed")
-    # assert feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
-    # ```
-    def eval_on_selector_all(selector, pageFunction, arg: nil)
-      wrap_impl(@impl.eval_on_selector_all(selector, pageFunction, arg: arg))
-    end
-
     # This method returns the bounding box of the element, or `null` if the element is not visible. The bounding box is
     # calculated relative to the main frame viewport - which is usually the same as the browser window.
     # 
@@ -172,7 +91,7 @@ module Playwright
     # page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
     # ```
     def bounding_box
-      raise NotImplementedError.new('bounding_box is not implemented yet.')
+      wrap_impl(@impl.bounding_box)
     end
 
     # This method checks the element by performing the following steps:
@@ -189,7 +108,7 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     def check(force: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('check is not implemented yet.')
+      wrap_impl(@impl.check(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method clicks the element by performing the following steps:
@@ -211,12 +130,12 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      wrap_impl(@impl.click(button: button, clickCount: clickCount, delay: delay, force: force, modifiers: modifiers, noWaitAfter: noWaitAfter, position: position, timeout: timeout))
+      wrap_impl(@impl.click(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
 
     # Returns the content frame for element handles referencing iframe nodes, or `null` otherwise
     def content_frame
-      raise NotImplementedError.new('content_frame is not implemented yet.')
+      wrap_impl(@impl.content_frame)
     end
 
     # This method double clicks the element by performing the following steps:
@@ -240,7 +159,7 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('dblclick is not implemented yet.')
+      wrap_impl(@impl.dblclick(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`
@@ -293,25 +212,97 @@ module Playwright
     # element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
     # ```
     def dispatch_event(type, eventInit: nil)
-      raise NotImplementedError.new('dispatch_event is not implemented yet.')
+      wrap_impl(@impl.dispatch_event(unwrap_impl(type), eventInit: unwrap_impl(eventInit)))
+    end
+
+    # Returns the return value of `expression`.
+    # 
+    # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
+    # argument to `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the
+    # selector, the method throws an error.
+    # 
+    # If `expression` returns a [Promise], then [`method: ElementHandle.evalOnSelector`] would wait for the promise to resolve
+    # and return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const tweetHandle = await page.$('.tweet');
+    # expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');
+    # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
+    # ```
+    # 
+    # ```python async
+    # tweet_handle = await page.query_selector(".tweet")
+    # assert await tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
+    # assert await tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
+    # ```
+    # 
+    # ```python sync
+    # tweet_handle = page.query_selector(".tweet")
+    # assert tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
+    # assert tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
+    # ```
+    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
+
+    # Returns the return value of `expression`.
+    # 
+    # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of
+    # matched elements as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
+    # 
+    # If `expression` returns a [Promise], then [`method: ElementHandle.evalOnSelectorAll`] would wait for the promise to
+    # resolve and return its value.
+    # 
+    # Examples:
+    # 
+    # ```html
+    # <div class="feed">
+    #   <div class="tweet">Hello!</div>
+    #   <div class="tweet">Hi!</div>
+    # </div>
+    # ```
+    # 
+    #
+    # ```js
+    # const feedHandle = await page.$('.feed');
+    # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
+    # ```
+    # 
+    # ```python async
+    # feed_handle = await page.query_selector(".feed")
+    # assert await feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
+    # ```
+    # 
+    # ```python sync
+    # feed_handle = page.query_selector(".feed")
+    # assert feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
+    # ```
+    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
 
     # This method waits for [actionability](./actionability.md) checks, focuses the element, fills it and triggers an `input`
-    # event after filling. If the element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws
-    # an error. Note that you can pass an empty string to clear the input field.
+    # 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.
     def fill(value, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('fill is not implemented yet.')
+      wrap_impl(@impl.fill(unwrap_impl(value), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.
     def focus
-      raise NotImplementedError.new('focus is not implemented yet.')
+      wrap_impl(@impl.focus)
     end
 
     # Returns element attribute value.
     def get_attribute(name)
-      raise NotImplementedError.new('get_attribute is not implemented yet.')
+      wrap_impl(@impl.get_attribute(unwrap_impl(name)))
     end
+    alias_method :[], :get_attribute
 
     # This method hovers over the element by performing the following steps:
     # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
@@ -324,52 +315,52 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
-      raise NotImplementedError.new('hover is not implemented yet.')
+      wrap_impl(@impl.hover(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the `element.innerHTML`.
     def inner_html
-      raise NotImplementedError.new('inner_html is not implemented yet.')
+      wrap_impl(@impl.inner_html)
     end
 
     # Returns the `element.innerText`.
     def inner_text
-      raise NotImplementedError.new('inner_text is not implemented yet.')
+      wrap_impl(@impl.inner_text)
     end
 
     # Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
     def checked?
-      raise NotImplementedError.new('checked? is not implemented yet.')
+      wrap_impl(@impl.checked?)
     end
 
     # Returns whether the element is disabled, the opposite of [enabled](./actionability.md#enabled).
     def disabled?
-      raise NotImplementedError.new('disabled? is not implemented yet.')
+      wrap_impl(@impl.disabled?)
     end
 
     # Returns whether the element is [editable](./actionability.md#editable).
     def editable?
-      raise NotImplementedError.new('editable? is not implemented yet.')
+      wrap_impl(@impl.editable?)
     end
 
     # Returns whether the element is [enabled](./actionability.md#enabled).
     def enabled?
-      raise NotImplementedError.new('enabled? is not implemented yet.')
+      wrap_impl(@impl.enabled?)
     end
 
     # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).
     def hidden?
-      raise NotImplementedError.new('hidden? is not implemented yet.')
+      wrap_impl(@impl.hidden?)
     end
 
     # Returns whether the element is [visible](./actionability.md#visible).
     def visible?
-      raise NotImplementedError.new('visible? is not implemented yet.')
+      wrap_impl(@impl.visible?)
     end
 
     # Returns the frame containing the given element.
     def owner_frame
-      raise NotImplementedError.new('owner_frame is not implemented yet.')
+      wrap_impl(@impl.owner_frame)
     end
 
     # Focuses the element, and then uses [`method: Keyboard.down`] and [`method: Keyboard.up`].
@@ -391,7 +382,19 @@ module Playwright
     # Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
     # modifier, modifier is pressed and being held while the subsequent key is being pressed.
     def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.press(key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.press(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 in the `ElementHandle`'s subtree. See
+    # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns `null`.
+    def query_selector(selector)
+      wrap_impl(@impl.query_selector(unwrap_impl(selector)))
+    end
+
+    # The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See
+    # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns empty array.
+    def query_selector_all(selector)
+      wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
     end
 
     # Returns the buffer with the captured screenshot.
@@ -404,7 +407,7 @@ module Playwright
           quality: nil,
           timeout: nil,
           type: nil)
-      raise NotImplementedError.new('screenshot is not implemented yet.')
+      wrap_impl(@impl.screenshot(omitBackground: unwrap_impl(omitBackground), path: unwrap_impl(path), quality: unwrap_impl(quality), timeout: unwrap_impl(timeout), type: unwrap_impl(type)))
     end
 
     # This method waits for [actionability](./actionability.md) checks, then tries to scroll element into view, unless it is
@@ -414,7 +417,7 @@ module Playwright
     # Throws when `elementHandle` does not point to an element
     # [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
     def scroll_into_view_if_needed(timeout: nil)
-      raise NotImplementedError.new('scroll_into_view_if_needed is not implemented yet.')
+      wrap_impl(@impl.scroll_into_view_if_needed(timeout: unwrap_impl(timeout)))
     end
 
     # Returns the array of option values that have been successfully selected.
@@ -455,7 +458,6 @@ module Playwright
     # ```
     # 
     # ```python sync
-    # # FIXME
     # # single selection matching the value
     # handle.select_option("blue")
     # # single selection matching both the value and the label
@@ -465,14 +467,20 @@ module Playwright
     # # multiple selection for blue, red and second option
     # handle.select_option(value="blue", { index: 2 }, "red")
     # ```
-    def select_option(values, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('select_option is not implemented yet.')
+    def select_option(
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      wrap_impl(@impl.select_option(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
 
     # This method waits for [actionability](./actionability.md) checks, then focuses the element and selects all its text
     # content.
     def select_text(timeout: nil)
-      raise NotImplementedError.new('select_text is not implemented yet.')
+      wrap_impl(@impl.select_text(timeout: unwrap_impl(timeout)))
     end
 
     # This method expects `elementHandle` to point to an
@@ -481,7 +489,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(files, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('set_input_files is not implemented yet.')
+      wrap_impl(@impl.set_input_files(unwrap_impl(files), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
     alias_method :input_files=, :set_input_files
 
@@ -503,12 +511,12 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('tap_point is not implemented yet.')
+      wrap_impl(@impl.tap_point(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the `node.textContent`.
     def text_content
-      raise NotImplementedError.new('text_content is not implemented yet.')
+      wrap_impl(@impl.text_content)
     end
 
     # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
@@ -551,8 +559,8 @@ module Playwright
     # element_handle.type("some text")
     # element_handle.press("Enter")
     # ```
-    def type_text(text, delay: nil, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.type_text(text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+    def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method checks the element by performing the following steps:
@@ -569,7 +577,7 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     def uncheck(force: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('uncheck is not implemented yet.')
+      wrap_impl(@impl.uncheck(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when the element satisfies the `state`.
@@ -587,7 +595,7 @@ module Playwright
     # 
     # If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
     def wait_for_element_state(state, timeout: nil)
-      raise NotImplementedError.new('wait_for_element_state is not implemented yet.')
+      wrap_impl(@impl.wait_for_element_state(unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
     # Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
@@ -622,25 +630,29 @@ module Playwright
     # 
     # > NOTE: This method does not work across navigations, use [`method: Page.waitForSelector`] instead.
     def wait_for_selector(selector, state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_selector is not implemented yet.')
+      wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     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