playwright-ruby-client 0.0.5 → 0.0.6

data/lib/playwright_api/browser_type.rb

@@ -14,6 +14,39 @@ module Playwright
   #   await browser.close();
   # })();
   # ```
+  # 
+  # ```python async
+  # import asyncio
+  # from playwright.async_api import async_playwright
+  # 
+  # async def run(playwright):
+  #     chromium = playwright.chromium
+  #     browser = await chromium.launch()
+  #     page = await browser.new_page()
+  #     await page.goto("https://example.com")
+  #     # other actions...
+  #     await browser.close()
+  # 
+  # async def main():
+  #     async with async_playwright() as playwright:
+  #         await run(playwright)
+  # asyncio.run(main())
+  # ```
+  # 
+  # ```python sync
+  # from playwright.sync_api import sync_playwright
+  # 
+  # def run(playwright):
+  #     chromium = playwright.chromium
+  #     browser = chromium.launch()
+  #     page = browser.new_page()
+  #     page.goto("https://example.com")
+  #     # other actions...
+  #     browser.close()
+  # 
+  # with sync_playwright() as playwright:
+  #     run(playwright)
+  # ```
   class BrowserType < PlaywrightApi
 
     # This methods attaches Playwright to an existing browser instance.
@@ -23,7 +56,7 @@ module Playwright
 
     # A path where Playwright expects to find a bundled browser executable.
     def executable_path
-      wrap_channel_owner(@channel_owner.executable_path)
+      wrap_impl(@impl.executable_path)
     end
 
     # Returns the browser instance.
@@ -37,6 +70,18 @@ module Playwright
     # });
     # ```
     # 
+    # ```python async
+    # browser = await playwright.chromium.launch( # or "firefox" or "webkit".
+    #     ignore_default_args=["--mute-audio"]
+    # )
+    # ```
+    # 
+    # ```python sync
+    # browser = playwright.chromium.launch( # or "firefox" or "webkit".
+    #     ignore_default_args=["--mute-audio"]
+    # )
+    # ```
+    # 
     # > **Chromium-only** Playwright can also be used to control the Chrome browser, but it works best with the version of
     # Chromium it is bundled with. There is no guarantee it will work with any other version. Use `executablePath` option with
     # extreme caution.
@@ -69,7 +114,7 @@ module Playwright
           slowMo: nil,
           timeout: nil,
           &block)
-      wrap_channel_owner(@channel_owner.launch(args: args, chromiumSandbox: chromiumSandbox, devtools: devtools, downloadsPath: downloadsPath, env: env, executablePath: executablePath, firefoxUserPrefs: firefoxUserPrefs, handleSIGHUP: handleSIGHUP, handleSIGINT: handleSIGINT, handleSIGTERM: handleSIGTERM, headless: headless, ignoreDefaultArgs: ignoreDefaultArgs, logger: logger, proxy: proxy, slowMo: slowMo, timeout: timeout, &wrap_block_call(block)))
+      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)))
     end
 
     # Returns the persistent browser context instance.
@@ -157,25 +202,25 @@ module Playwright
 
     # Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
     def name
-      wrap_channel_owner(@channel_owner.name)
+      wrap_impl(@impl.name)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end

data/lib/playwright_api/cdp_session.rb

@@ -1,5 +1,5 @@
 module Playwright
-  # - extends: [EventEmitter](https://nodejs.org/api/events.html#events_class_eventemitter)
+  # - extends: [EventEmitter]
   # 
   # The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:
   # - protocol methods can be called with `session.send` method.
@@ -22,6 +22,28 @@ module Playwright
   #   playbackRate: response.playbackRate / 2
   # });
   # ```
+  # 
+  # ```python async
+  # client = await page.context().new_cdp_session(page)
+  # await client.send("animation.enable")
+  # client.on("animation.animation_created", lambda: print("animation created!"))
+  # response = await client.send("animation.get_playback_rate")
+  # print("playback rate is " + response["playback_rate"])
+  # await client.send("animation.set_playback_rate", {
+  #     playback_rate: response["playback_rate"] / 2
+  # })
+  # ```
+  # 
+  # ```python sync
+  # client = page.context().new_cdp_session(page)
+  # client.send("animation.enable")
+  # client.on("animation.animation_created", lambda: print("animation created!"))
+  # response = client.send("animation.get_playback_rate")
+  # print("playback rate is " + response["playback_rate"])
+  # client.send("animation.set_playback_rate", {
+  #     playback_rate: response["playback_rate"] / 2
+  # })
+  # ```
   class CDPSession < PlaywrightApi
 
     # Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to

data/lib/playwright_api/chromium_browser_context.rb

@@ -9,6 +9,16 @@ module Playwright
   # ```js
   # const backgroundPage = await context.waitForEvent('backgroundpage');
   # ```
+  # 
+  # ```python async
+  # # FIXME
+  # background_page = await context.wait_for_event("backgroundpage")
+  # ```
+  # 
+  # ```python sync
+  # # FIXME
+  # background_page = context.wait_for_event("backgroundpage")
+  # ```
   class ChromiumBrowserContext < BrowserContext
 
     # All existing background pages in the context.
@@ -28,20 +38,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end

data/lib/playwright_api/console_message.rb

@@ -3,15 +3,15 @@ module Playwright
   class ConsoleMessage < PlaywrightApi
 
     def args
-      wrap_channel_owner(@channel_owner.args)
+      wrap_impl(@impl.args)
     end
 
     def location
-      wrap_channel_owner(@channel_owner.location)
+      wrap_impl(@impl.location)
     end
 
     def text
-      wrap_channel_owner(@channel_owner.text)
+      wrap_impl(@impl.text)
     end
 
     # One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
@@ -23,25 +23,25 @@ module Playwright
 
     # @nodoc
     def type
-      wrap_channel_owner(@channel_owner.type)
+      wrap_impl(@impl.type)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end

data/lib/playwright_api/dialog.rb

@@ -18,6 +18,48 @@ module Playwright
   #   page.evaluate(() => alert('1'));
   # })();
   # ```
+  # 
+  # ```python async
+  # import asyncio
+  # from playwright.async_api import async_playwright
+  # 
+  # async def handle_dialog(dialog):
+  #     print(dialog.message)
+  #     await dialog.dismiss()
+  # 
+  # async def run(playwright):
+  #     chromium = playwright.chromium
+  #     browser = await chromium.launch()
+  #     page = await browser.new_page()
+  #     page.on("dialog", handle_dialog)
+  #     page.evaluate("alert('1')")
+  #     await browser.close()
+  # 
+  # async def main():
+  #     async with async_playwright() as playwright:
+  #         await run(playwright)
+  # asyncio.run(main())
+  # ```
+  # 
+  # ```python sync
+  # # FIXME
+  # from playwright.sync_api import sync_playwright
+  # 
+  # def handle_dialog(dialog):
+  #     print(dialog.message)
+  #     dialog.dismiss()
+  # 
+  # def run(playwright):
+  #     chromium = playwright.chromium
+  #     browser = chromium.launch()
+  #     page = browser.new_page()
+  #     page.on("dialog", handle_dialog)
+  #     page.evaluate("alert('1')")
+  #     browser.close()
+  # 
+  # with sync_playwright() as playwright:
+  #     run(playwright)
+  # ```
   class Dialog < PlaywrightApi
 
     # Returns when the dialog has been accepted.

data/lib/playwright_api/download.rb

@@ -14,12 +14,27 @@ module Playwright
   # ]);
   # // wait for download to complete
   # const path = await download.path();
-  # ...
   # ```
   # 
-  # > **NOTE** Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
-  # downloaded content. If `acceptDownloads` is not set or set to `false`, download events are emitted, but the actual
-  # download is not performed and user has no access to the downloaded files.
+  # ```python async
+  # async with page.expect_download() as download_info:
+  #     await page.click("a")
+  # download = await download_info.value
+  # # waits for download to complete
+  # path = await download.path()
+  # ```
+  # 
+  # ```python sync
+  # with page.expect_download() as download_info:
+  #     page.click("a")
+  # download = download_info.value
+  # # wait for download to complete
+  # path = download.path()
+  # ```
+  # 
+  # > NOTE: Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
+  # downloaded content. If `acceptDownloads` is not set, download events are emitted, but the actual download is not
+  # performed and user has no access to the downloaded files.
   class Download < PlaywrightApi
 
     # Returns readable stream for current download or `null` if download failed.

data/lib/playwright_api/element_handle.rb

@@ -19,6 +19,41 @@ module Playwright
   # })();
   # ```
   # 
+  # ```python async
+  # import asyncio
+  # from playwright.async_api import async_playwright
+  # 
+  # async def run(playwright):
+  #     chromium = playwright.chromium
+  #     browser = await chromium.launch()
+  #     page = await browser.new_page()
+  #     await page.goto("https://example.com")
+  #     href_element = await page.query_selector("a")
+  #     await href_element.click()
+  #     # ...
+  # 
+  # async def main():
+  #     async with async_playwright() as playwright:
+  #         await run(playwright)
+  # asyncio.run(main())
+  # ```
+  # 
+  # ```python sync
+  # from playwright.sync_api import sync_playwright
+  # 
+  # def run(playwright):
+  #     chromium = playwright.chromium
+  #     browser = chromium.launch()
+  #     page = browser.new_page()
+  #     page.goto("https://example.com")
+  #     href_element = page.query_selector("a")
+  #     href_element.click()
+  #     # ...
+  # 
+  # with sync_playwright() as playwright:
+  #     run(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.
   # 
@@ -29,14 +64,14 @@ module Playwright
     # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
     # returns `null`.
     def query_selector(selector)
-      raise NotImplementedError.new('query_selector is not implemented yet.')
+      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)
-      raise NotImplementedError.new('query_selector_all is not implemented yet.')
+      wrap_impl(@impl.query_selector_all(selector))
     end
 
     # Returns the return value of `pageFunction`
@@ -55,8 +90,20 @@ module Playwright
     # 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)
-      raise NotImplementedError.new('eval_on_selector is not implemented yet.')
+      wrap_impl(@impl.eval_on_selector(selector, pageFunction, arg: arg))
     end
 
     # Returns the return value of `pageFunction`
@@ -81,8 +128,19 @@ module Playwright
     # 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)
-      raise NotImplementedError.new('eval_on_selector_all is not implemented yet.')
+      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
@@ -103,6 +161,16 @@ module Playwright
     # const box = await elementHandle.boundingBox();
     # await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
     # ```
+    # 
+    # ```python async
+    # box = await element_handle.bounding_box()
+    # await page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
+    # ```
+    # 
+    # ```python sync
+    # box = element_handle.bounding_box()
+    # 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.')
     end
@@ -143,7 +211,7 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('click is not implemented yet.')
+      wrap_impl(@impl.click(button: button, clickCount: clickCount, delay: delay, force: force, modifiers: modifiers, noWaitAfter: noWaitAfter, position: position, timeout: timeout))
     end
 
     # Returns the content frame for element handles referencing iframe nodes, or `null` otherwise
@@ -163,7 +231,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.
     # 
-    # > **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
+    # > NOTE: `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
           button: nil,
           delay: nil,
@@ -184,6 +252,14 @@ module Playwright
     # await elementHandle.dispatchEvent('click');
     # ```
     # 
+    # ```python async
+    # await element_handle.dispatch_event("click")
+    # ```
+    # 
+    # ```python sync
+    # element_handle.dispatch_event("click")
+    # ```
+    # 
     # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
     # and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
     # 
@@ -204,6 +280,18 @@ module Playwright
     # const dataTransfer = await page.evaluateHandle(() => new DataTransfer());
     # await elementHandle.dispatchEvent('dragstart', { dataTransfer });
     # ```
+    # 
+    # ```python async
+    # # note you can only create data_transfer in chromium and firefox
+    # data_transfer = await page.evaluate_handle("new DataTransfer()")
+    # await element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
+    # ```
+    # 
+    # ```python sync
+    # # note you can only create data_transfer in chromium and firefox
+    # data_transfer = page.evaluate_handle("new DataTransfer()")
+    # element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
+    # ```
     def dispatch_event(type, eventInit: nil)
       raise NotImplementedError.new('dispatch_event is not implemented yet.')
     end
@@ -303,7 +391,7 @@ 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)
-      raise NotImplementedError.new('press is not implemented yet.')
+      wrap_impl(@impl.press(key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
     end
 
     # Returns the buffer with the captured screenshot.
@@ -321,7 +409,7 @@ module Playwright
 
     # This method waits for [actionability](./actionability.md) checks, then tries to scroll element into view, unless it is
     # completely visible as defined by
-    # [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s ```ratio```.
+    # [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.
     # 
     # Throws when `elementHandle` does not point to an element
     # [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
@@ -334,19 +422,48 @@ module Playwright
     # Triggers a `change` and `input` event once all the provided options have been selected. If element is not a `<select>`
     # element, the method throws an error.
     # 
+    # Will wait until all specified options are present in the `<select>` element.
+    # 
     #
     # ```js
     # // single selection matching the value
     # handle.selectOption('blue');
     # 
-    # // single selection matching both the value and the label
+    # // single selection matching the label
     # handle.selectOption({ label: 'Blue' });
     # 
     # // multiple selection
-    # handle.selectOption('red', 'green', 'blue');
+    # handle.selectOption(['red', 'green', 'blue']);
+    # ```
     # 
-    # // multiple selection for blue, red and second option
-    # handle.selectOption({ value: 'blue' }, { index: 2 }, 'red');
+    # ```python async
+    # # single selection matching the value
+    # await handle.select_option("blue")
+    # # single selection matching the label
+    # await handle.select_option(label="blue")
+    # # multiple selection
+    # await handle.select_option(value=["red", "green", "blue"])
+    # ```
+    # 
+    # ```python sync
+    # # single selection matching the value
+    # handle.select_option("blue")
+    # # single selection matching both the label
+    # handle.select_option(label="blue")
+    # # multiple selection
+    # handle.select_option(value=["red", "green", "blue"])
+    # ```
+    # 
+    # ```python sync
+    # # FIXME
+    # # single selection matching the value
+    # handle.select_option("blue")
+    # # single selection matching both the value and the label
+    # handle.select_option(label="blue")
+    # # multiple selection
+    # handle.select_option("red", "green", "blue")
+    # # 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.')
@@ -379,7 +496,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.
     # 
-    # > **NOTE** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
+    # > NOTE: `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
           force: nil,
           modifiers: nil,
@@ -404,6 +521,16 @@ module Playwright
     # await elementHandle.type('World', {delay: 100}); // Types slower, like a user
     # ```
     # 
+    # ```python async
+    # await element_handle.type("hello") # types instantly
+    # await element_handle.type("world", delay=100) # types slower, like a user
+    # ```
+    # 
+    # ```python sync
+    # element_handle.type("hello") # types instantly
+    # element_handle.type("world", delay=100) # types slower, like a user
+    # ```
+    # 
     # An example of typing into a text field and then submitting the form:
     # 
     #
@@ -412,8 +539,20 @@ module Playwright
     # await elementHandle.type('some text');
     # await elementHandle.press('Enter');
     # ```
+    # 
+    # ```python async
+    # element_handle = await page.query_selector("input")
+    # await element_handle.type("some text")
+    # await element_handle.press("Enter")
+    # ```
+    # 
+    # ```python sync
+    # element_handle = page.query_selector("input")
+    # element_handle.type("some text")
+    # element_handle.press("Enter")
+    # ```
     def type_text(text, delay: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('type_text is not implemented yet.')
+      wrap_impl(@impl.type_text(text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
     end
 
     # This method checks the element by performing the following steps:
@@ -467,27 +606,41 @@ module Playwright
     # const span = await div.waitForSelector('span', { state: 'attached' });
     # ```
     # 
-    # > **NOTE** This method does not work across navigations, use [`method: Page.waitForSelector`] instead.
+    # ```python async
+    # await page.set_content("<div><span></span></div>")
+    # div = await page.query_selector("div")
+    # # waiting for the "span" selector relative to the div.
+    # span = await div.wait_for_selector("span", state="attached")
+    # ```
+    # 
+    # ```python sync
+    # page.set_content("<div><span></span></div>")
+    # div = page.query_selector("div")
+    # # waiting for the "span" selector relative to the div.
+    # span = div.wait_for_selector("span", state="attached")
+    # ```
+    # 
+    # > NOTE: This method does not work across navigations, use [`method: Page.waitForSelector`] instead.
     def wait_for_selector(selector, state: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_selector is not implemented yet.')
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end