playwright-ruby-client 0.6.0 → 0.6.1

data/lib/playwright_api/android_device.rb

@@ -160,14 +160,20 @@ module Playwright
       raise NotImplementedError.new('web_views is not implemented yet.')
     end
 
+    # @nodoc
+    def tree
+      wrap_impl(@impl.tree)
+    end
+
     # @nodoc
     def tap_on(selector, duration: nil, timeout: nil)
       wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def tree
-      wrap_impl(@impl.tree)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
@@ -182,12 +188,6 @@ module Playwright
       event_emitter_proxy.once(event, callback)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
-    end
-
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/browser.rb

@@ -1,136 +1,42 @@
 module Playwright
   # - extends: [EventEmitter]
-  # 
+  #
   # A Browser is created via [`method: BrowserType.launch`]. An example of using a `Browser` to create a `Page`:
-  # 
   #
-  # ```js
-  # const { firefox } = require('playwright');  // Or 'chromium' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await firefox.launch();
-  #   const page = await browser.newPage();
-  #   await page.goto('https://example.com');
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```java
-  # import com.microsoft.playwright.*;
-  # 
-  # public class Example {
-  #   public static void main(String[] args) {
-  #     try (Playwright playwright = Playwright.create()) {
-  #       BrowserType firefox = playwright.firefox()
-  #       Browser browser = firefox.launch();
-  #       Page page = browser.newPage();
-  #       page.navigate('https://example.com');
-  #       browser.close();
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     firefox = playwright.firefox
-  #     browser = await firefox.launch()
-  #     page = await browser.new_page()
-  #     await page.goto("https://example.com")
-  #     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):
   #     firefox = playwright.firefox
   #     browser = firefox.launch()
   #     page = browser.new_page()
   #     page.goto("https://example.com")
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
-  # ```csharp
-  # using Microsoft.Playwright;
-  # using System.Threading.Tasks;
-  # 
-  # class BrowserExamples
-  # {
-  #     public static async Task Main()
-  #     {
-  #         using var playwright = await Playwright.CreateAsync();
-  #         var firefox = playwright.Firefox;
-  #         var browser = await firefox.LaunchAsync(headless: false);
-  #         var page = await browser.NewPageAsync();
-  #         await page.GotoAsync("https://www.bing.com");
-  #         await browser.CloseAsync();
-  #     }
-  # }
-  # ```
   class Browser < PlaywrightApi
 
     # In case this browser is obtained using [`method: BrowserType.launch`], closes the browser and all of its pages (if any
     # were opened).
-    # 
+    #
     # In case this browser is connected to, clears all created contexts belonging to this browser and disconnects from the
     # browser server.
-    # 
+    #
     # The `Browser` object itself is considered to be disposed and cannot be used anymore.
     def close
       wrap_impl(@impl.close)
     end
 
     # Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
-    # 
     #
-    # ```js
-    # const browser = await pw.webkit.launch();
-    # console.log(browser.contexts().length); // prints `0`
-    # 
-    # const context = await browser.newContext();
-    # console.log(browser.contexts().length); // prints `1`
-    # ```
-    # 
-    # ```java
-    # Browser browser = pw.webkit().launch();
-    # System.out.println(browser.contexts().size()); // prints "0"
-    # BrowserContext context = browser.newContext();
-    # System.out.println(browser.contexts().size()); // prints "1"
-    # ```
-    # 
-    # ```python async
-    # browser = await pw.webkit.launch()
-    # print(len(browser.contexts())) # prints `0`
-    # context = await browser.new_context()
-    # print(len(browser.contexts())) # prints `1`
-    # ```
-    # 
     # ```python sync
     # browser = pw.webkit.launch()
     # print(len(browser.contexts())) # prints `0`
     # context = browser.new_context()
     # print(len(browser.contexts())) # prints `1`
     # ```
-    # 
-    # ```csharp
-    # using var playwright = await Playwright.CreateAsync();
-    # var browser = await playwright.Webkit.LaunchAsync();
-    # System.Console.WriteLine(browser.Contexts.Count); // prints "0"
-    # var context = await browser.NewContextAsync();
-    # System.Console.WriteLine(browser.Contexts.Count); // prints "1"
-    # ```
     def contexts
       wrap_impl(@impl.contexts)
     end
@@ -141,44 +47,14 @@ module Playwright
     end
 
     # > NOTE: CDP Sessions are only supported on Chromium-based browsers.
-    # 
+    #
     # Returns the newly created browser session.
     def new_browser_cdp_session
       raise NotImplementedError.new('new_browser_cdp_session is not implemented yet.')
     end
 
     # Creates a new browser context. It won't share cookies/cache with other browser contexts.
-    # 
     #
-    # ```js
-    # (async () => {
-    #   const browser = await playwright.firefox.launch();  // Or 'chromium' or 'webkit'.
-    #   // Create a new incognito browser context.
-    #   const context = await browser.newContext();
-    #   // Create a new page in a pristine context.
-    #   const page = await context.newPage();
-    #   await page.goto('https://example.com');
-    # })();
-    # ```
-    # 
-    # ```java
-    # Browser browser = playwright.firefox().launch();  // Or 'chromium' or 'webkit'.
-    # // Create a new incognito browser context.
-    # BrowserContext context = browser.newContext();
-    # // Create a new page in a pristine context.
-    # Page page = context.newPage();
-    # page.navigate('https://example.com');
-    # ```
-    # 
-    # ```python async
-    # browser = await playwright.firefox.launch() # or "chromium" or "webkit".
-    # # create a new incognito browser context.
-    # context = await browser.new_context()
-    # # create a new page in a pristine context.
-    # page = await context.new_page()
-    # await page.goto("https://example.com")
-    # ```
-    # 
     # ```python sync
     # browser = playwright.firefox.launch() # or "chromium" or "webkit".
     # # create a new incognito browser context.
@@ -187,16 +63,6 @@ module Playwright
     # page = context.new_page()
     # page.goto("https://example.com")
     # ```
-    # 
-    # ```csharp
-    # using var playwright = await Playwright.CreateAsync();
-    # var browser = await playwright.Firefox.LaunchAsync();
-    # // Create a new incognito browser context.
-    # var context = await browser.NewContextAsync();
-    # // Create a new page in a pristine context.
-    # var page = await context.NewPageAsync(); ;
-    # await page.GotoAsync("https://www.bing.com");
-    # ```
     def new_context(
           acceptDownloads: nil,
           bypassCSP: nil,
@@ -228,7 +94,7 @@ module Playwright
     end
 
     # Creates a new page in a new browser context. Closing this page will close the context as well.
-    # 
+    #
     # This is a convenience API that should only be used for the single-page scenarios and short snippets. Production code and
     # testing frameworks should explicitly create [`method: Browser.newContext`] followed by the
     # [`method: BrowserContext.newPage`] to control their exact life times.
@@ -262,30 +128,10 @@ module Playwright
     end
 
     # > NOTE: Tracing is only supported on Chromium-based browsers.
-    # 
+    #
     # You can use [`method: Browser.startTracing`] and [`method: Browser.stopTracing`] to create a trace file that can be
     # opened in Chrome DevTools performance panel.
-    # 
     #
-    # ```js
-    # await browser.startTracing(page, {path: 'trace.json'});
-    # await page.goto('https://www.google.com');
-    # await browser.stopTracing();
-    # ```
-    # 
-    # ```java
-    # browser.startTracing(page, new Browser.StartTracingOptions()
-    #   .setPath(Paths.get("trace.json")));
-    # page.goto('https://www.google.com');
-    # browser.stopTracing();
-    # ```
-    # 
-    # ```python async
-    # await browser.start_tracing(page, path="trace.json")
-    # await page.goto("https://www.google.com")
-    # await browser.stop_tracing()
-    # ```
-    # 
     # ```python sync
     # browser.start_tracing(page, path="trace.json")
     # page.goto("https://www.google.com")
@@ -296,7 +142,7 @@ module Playwright
     end
 
     # > NOTE: Tracing is only supported on Chromium-based browsers.
-    # 
+    #
     # Returns the buffer with trace data.
     def stop_tracing
       wrap_impl(@impl.stop_tracing)
@@ -309,20 +155,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/browser_context.rb

@@ -1,45 +1,14 @@
 module Playwright
   # - extends: [EventEmitter]
-  # 
+  #
   # BrowserContexts provide a way to operate multiple independent browser sessions.
-  # 
+  #
   # If a page opens another page, e.g. with a `window.open` call, the popup will belong to the parent page's browser
   # context.
-  # 
+  #
   # Playwright allows creation of "incognito" browser contexts with `browser.newContext()` method. "Incognito" browser
   # contexts don't write any browsing data to disk.
-  # 
   #
-  # ```js
-  # // Create a new incognito browser context
-  # const context = await browser.newContext();
-  # // Create a new page inside context.
-  # const page = await context.newPage();
-  # await page.goto('https://example.com');
-  # // Dispose context once it's no longer needed.
-  # await context.close();
-  # ```
-  # 
-  # ```java
-  # // Create a new incognito browser context
-  # BrowserContext context = browser.newContext();
-  # // Create a new page inside context.
-  # Page page = context.newPage();
-  # page.navigate("https://example.com");
-  # // Dispose context once it is no longer needed.
-  # context.close();
-  # ```
-  # 
-  # ```python async
-  # # create a new incognito browser context
-  # context = await browser.new_context()
-  # # create a new page inside context.
-  # page = await context.new_page()
-  # await page.goto("https://example.com")
-  # # dispose context once it is no longer needed.
-  # await context.close()
-  # ```
-  # 
   # ```python sync
   # # create a new incognito browser context
   # context = browser.new_context()
@@ -49,18 +18,6 @@ module Playwright
   # # dispose context once it is no longer needed.
   # context.close()
   # ```
-  # 
-  # ```csharp
-  # using var playwright = await Playwright.CreateAsync();
-  # var browser = await playwright.Firefox.LaunchAsync(headless: false);
-  # // Create a new incognito browser context
-  # var context = await browser.NewContextAsync();
-  # // Create a new page inside context.
-  # var page = await context.NewPageAsync();
-  # await page.GotoAsync("https://bing.com");
-  # // Dispose context once it is no longer needed.
-  # await context.CloseAsync();
-  # ```
   class BrowserContext < PlaywrightApi
 
     def tracing # property
@@ -69,27 +26,10 @@ module Playwright
 
     # Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies can be
     # obtained via [`method: BrowserContext.cookies`].
-    # 
     #
-    # ```js
-    # await browserContext.addCookies([cookieObject1, cookieObject2]);
-    # ```
-    # 
-    # ```java
-    # browserContext.addCookies(Arrays.asList(cookieObject1, cookieObject2));
-    # ```
-    # 
-    # ```python async
-    # await browser_context.add_cookies([cookie_object1, cookie_object2])
-    # ```
-    # 
     # ```python sync
     # browser_context.add_cookies([cookie_object1, cookie_object2])
     # ```
-    # 
-    # ```csharp
-    # await context.AddCookiesAsync(new[] { cookie1, cookie2 });
-    # ```
     def add_cookies(cookies)
       wrap_impl(@impl.add_cookies(unwrap_impl(cookies)))
     end
@@ -98,45 +38,17 @@ module Playwright
     # - Whenever a page is created in the browser context or is navigated.
     # - Whenever a child frame is attached or navigated in any page in the browser context. In this case, the script is
     #   evaluated in the context of the newly attached frame.
-    # 
+    #
     # The script is evaluated after the document was created but before any of its scripts were run. This is useful to amend
     # the JavaScript environment, e.g. to seed `Math.random`.
-    # 
-    # An example of overriding `Math.random` before the page loads:
-    # 
     #
-    # ```js browser
-    # // preload.js
-    # Math.random = () => 42;
-    # ```
-    # 
+    # An example of overriding `Math.random` before the page loads:
     #
-    # ```js
-    # // In your playwright script, assuming the preload.js file is in same directory.
-    # await browserContext.addInitScript({
-    #   path: 'preload.js'
-    # });
-    # ```
-    # 
-    # ```java
-    # // In your playwright script, assuming the preload.js file is in same directory.
-    # browserContext.addInitScript(Paths.get("preload.js"));
-    # ```
-    # 
-    # ```python async
-    # # in your playwright script, assuming the preload.js file is in same directory.
-    # await browser_context.add_init_script(path="preload.js")
-    # ```
-    # 
     # ```python sync
     # # in your playwright script, assuming the preload.js file is in same directory.
     # browser_context.add_init_script(path="preload.js")
     # ```
-    # 
-    # ```csharp
-    # await context.AddInitScriptAsync(scriptPath: "preload.js");
-    # ```
-    # 
+    #
     # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
     def add_init_script(path: nil, script: nil)
@@ -144,7 +56,7 @@ module Playwright
     end
 
     # > NOTE: Background pages are only supported on Chromium-based browsers.
-    # 
+    #
     # All existing background pages in the context.
     def background_pages
       raise NotImplementedError.new('background_pages is not implemented yet.')
@@ -161,50 +73,19 @@ module Playwright
     end
 
     # Clears all permission overrides for the browser context.
-    # 
     #
-    # ```js
-    # const context = await browser.newContext();
-    # await context.grantPermissions(['clipboard-read']);
-    # // do stuff ..
-    # context.clearPermissions();
-    # ```
-    # 
-    # ```java
-    # BrowserContext context = browser.newContext();
-    # context.grantPermissions(Arrays.asList("clipboard-read"));
-    # // do stuff ..
-    # context.clearPermissions();
-    # ```
-    # 
-    # ```python async
-    # context = await browser.new_context()
-    # await context.grant_permissions(["clipboard-read"])
-    # # do stuff ..
-    # context.clear_permissions()
-    # ```
-    # 
     # ```python sync
     # context = browser.new_context()
     # context.grant_permissions(["clipboard-read"])
     # # do stuff ..
     # context.clear_permissions()
     # ```
-    # 
-    # ```csharp
-    # var context = await browser.NewContextAsync();
-    # await context.GrantPermissionsAsync(new[] { "clipboard-read" });
-    # // Alternatively, you can use the helper class ContextPermissions 
-    # //  to specify the permissions...
-    # // do stuff ...
-    # await context.ClearPermissionsAsync();
-    # ```
     def clear_permissions
       wrap_impl(@impl.clear_permissions)
     end
 
     # Closes the browser context. All the pages that belong to the browser context will be closed.
-    # 
+    #
     # > NOTE: The default browser context cannot be closed.
     def close
       wrap_impl(@impl.close)
@@ -219,90 +100,17 @@ module Playwright
     # The method adds a function called `name` on the `window` object of every frame in every page in the context. When
     # called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`. If
     # the `callback` returns a [Promise], it will be awaited.
-    # 
+    #
     # The first argument of the `callback` function contains information about the caller: `{ browserContext: BrowserContext,
     # page: Page, frame: Frame }`.
-    # 
+    #
     # See [`method: Page.exposeBinding`] for page-only version.
-    # 
+    #
     # An example of exposing page URL to all frames in all pages in the context:
-    # 
-    #
-    # ```js
-    # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch({ headless: false });
-    #   const context = await browser.newContext();
-    #   await context.exposeBinding('pageURL', ({ page }) => page.url());
-    #   const page = await context.newPage();
-    #   await page.setContent(`
-    #     <script>
-    #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.pageURL();
-    #       }
-    #     </script>
-    #     <button onclick="onClick()">Click me</button>
-    #     <div></div>
-    #   `);
-    #   await page.click('button');
-    # })();
-    # ```
-    # 
-    # ```java
-    # import com.microsoft.playwright.*;
-    # 
-    # public class Example {
-    #   public static void main(String[] args) {
-    #     try (Playwright playwright = Playwright.create()) {
-    #       BrowserType webkit = playwright.webkit()
-    #       Browser browser = webkit.launch(new BrowserType.LaunchOptions().setHeadless(false));
-    #       BrowserContext context = browser.newContext();
-    #       context.exposeBinding("pageURL", (source, args) -> source.page().url());
-    #       Page page = context.newPage();
-    #       page.setContent("<script>\n" +
-    #         "  async function onClick() {\n" +
-    #         "    document.querySelector('div').textContent = await window.pageURL();\n" +
-    #         "  }\n" +
-    #         "</script>\n" +
-    #         "<button onclick=\"onClick()\">Click me</button>\n" +
-    #         "<div></div>");
-    #       page.click("button");
-    #     }
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # from playwright.async_api import async_playwright
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     browser = await webkit.launch(headless=false)
-    #     context = await browser.new_context()
-    #     await context.expose_binding("pageURL", lambda source: source["page"].url)
-    #     page = await context.new_page()
-    #     await page.set_content("""
-    #     <script>
-    #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.pageURL();
-    #       }
-    #     </script>
-    #     <button onclick="onClick()">Click me</button>
-    #     <div></div>
-    #     """)
-    #     await page.click("button")
-    # 
-    # 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):
     #     webkit = playwright.webkit
     #     browser = webkit.launch(headless=false)
@@ -319,85 +127,17 @@ module Playwright
     #     <div></div>
     #     """)
     #     page.click("button")
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
-    # 
-    # ```csharp
-    # using Microsoft.Playwright;
-    # using System.Threading.Tasks;
-    # 
-    # class Program
-    # {
-    #     public static async Task Main()
-    #     {
-    #         using var playwright = await Playwright.CreateAsync();
-    #         var browser = await playwright.Webkit.LaunchAsync(headless: false);
-    #         var context = await browser.NewContextAsync();
-    # 
-    #         await context.ExposeBindingAsync("pageURL", source => source.Page.Url);
-    #         var page = await context.NewPageAsync();
-    #         await page.SetContentAsync("<script>\n" +
-    #         "  async function onClick() {\n" +
-    #         "    document.querySelector('div').textContent = await window.pageURL();\n" +
-    #         "  }\n" +
-    #         "</script>\n" +
-    #         "<button onclick=\"onClick()\">Click me</button>\n" +
-    #         "<div></div>");
-    #         await page.ClickAsync("button");
-    #     }
-    # }
-    # ```
-    # 
+    #
     # An example of passing an element handle:
-    # 
     #
-    # ```js
-    # await context.exposeBinding('clicked', async (source, element) => {
-    #   console.log(await element.textContent());
-    # }, { handle: true });
-    # await page.setContent(`
-    #   <script>
-    #     document.addEventListener('click', event => window.clicked(event.target));
-    #   </script>
-    #   <div>Click me</div>
-    #   <div>Or click me</div>
-    # `);
-    # ```
-    # 
-    # ```java
-    # context.exposeBinding("clicked", (source, args) -> {
-    #   ElementHandle element = (ElementHandle) args[0];
-    #   System.out.println(element.textContent());
-    #   return null;
-    # }, new BrowserContext.ExposeBindingOptions().setHandle(true));
-    # page.setContent("" +
-    #   "<script>\n" +
-    #   "  document.addEventListener('click', event => window.clicked(event.target));\n" +
-    #   "</script>\n" +
-    #   "<div>Click me</div>\n" +
-    #   "<div>Or click me</div>\n");
-    # ```
-    # 
-    # ```python async
-    # async def print(source, element):
-    #     print(await element.text_content())
-    # 
-    # await context.expose_binding("clicked", print, handle=true)
-    # await page.set_content("""
-    #   <script>
-    #     document.addEventListener('click', event => window.clicked(event.target));
-    #   </script>
-    #   <div>Click me</div>
-    #   <div>Or click me</div>
-    # """)
-    # ```
-    # 
     # ```python sync
     # def print(source, element):
     #     print(element.text_content())
-    # 
+    #
     # context.expose_binding("clicked", print, handle=true)
     # page.set_content("""
     #   <script>
@@ -407,144 +147,29 @@ module Playwright
     #   <div>Or click me</div>
     # """)
     # ```
-    # 
-    # ```csharp
-    # var result = new TaskCompletionSource<string>();
-    # var page = await Context.NewPageAsync();
-    # await Context.ExposeBindingAsync("clicked", async (BindingSource _, IJSHandle t) =>
-    # {
-    #     return result.TrySetResult(await t.AsElement.TextContentAsync());
-    # });
-    # 
-    # await page.SetContentAsync("<script>\n" +
-    #   "  document.addEventListener('click', event => window.clicked(event.target));\n" +
-    #   "</script>\n" +
-    #   "<div>Click me</div>\n" +
-    #   "<div>Or click me</div>\n");
-    # 
-    # await page.ClickAsync("div");
-    # // Note: it makes sense to await the result here, because otherwise, the context 
-    # //  gets closed and the binding function will throw an exception.
-    # Assert.Equal("Click me", await result.Task);
-    # ```
     def expose_binding(name, callback, handle: nil)
       wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback), handle: unwrap_impl(handle)))
     end
 
     # The method adds a function called `name` on the `window` object of every frame in every page in the context. When
     # called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
-    # 
+    #
     # If the `callback` returns a [Promise], it will be awaited.
-    # 
+    #
     # See [`method: Page.exposeFunction`] for page-only version.
-    # 
+    #
     # An example of adding an `md5` function to all pages in the context:
-    # 
-    #
-    # ```js
-    # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
-    # const crypto = require('crypto');
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch({ headless: false });
-    #   const context = await browser.newContext();
-    #   await context.exposeFunction('md5', text => crypto.createHash('md5').update(text).digest('hex'));
-    #   const page = await context.newPage();
-    #   await page.setContent(`
-    #     <script>
-    #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.md5('PLAYWRIGHT');
-    #       }
-    #     </script>
-    #     <button onclick="onClick()">Click me</button>
-    #     <div></div>
-    #   `);
-    #   await page.click('button');
-    # })();
-    # ```
-    # 
-    # ```java
-    # import com.microsoft.playwright.*;
-    # 
-    # import java.nio.charset.StandardCharsets;
-    # import java.security.MessageDigest;
-    # import java.security.NoSuchAlgorithmException;
-    # import java.util.Base64;
-    # 
-    # public class Example {
-    #   public static void main(String[] args) {
-    #     try (Playwright playwright = Playwright.create()) {
-    #       BrowserType webkit = playwright.webkit()
-    #       Browser browser = webkit.launch(new BrowserType.LaunchOptions().setHeadless(false));
-    #       context.exposeFunction("sha1", args -> {
-    #         String text = (String) args[0];
-    #         MessageDigest crypto;
-    #         try {
-    #           crypto = MessageDigest.getInstance("SHA-1");
-    #         } catch (NoSuchAlgorithmException e) {
-    #           return null;
-    #         }
-    #         byte[] token = crypto.digest(text.getBytes(StandardCharsets.UTF_8));
-    #         return Base64.getEncoder().encodeToString(token);
-    #       });
-    #       Page page = context.newPage();
-    #       page.setContent("<script>\n" +
-    #         "  async function onClick() {\n" +
-    #         "    document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');\n" +
-    #         "  }\n" +
-    #         "</script>\n" +
-    #         "<button onclick=\"onClick()\">Click me</button>\n" +
-    #         "<div></div>\n");
-    #       page.click("button");
-    #     }
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # import hashlib
-    # from playwright.async_api import async_playwright
-    # 
-    # async def sha1(text):
-    #     m = hashlib.sha1()
-    #     m.update(bytes(text, "utf8"))
-    #     return m.hexdigest()
-    # 
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     browser = await webkit.launch(headless=False)
-    #     context = await browser.new_context()
-    #     await context.expose_function("sha1", sha1)
-    #     page = await context.new_page()
-    #     await page.set_content("""
-    #         <script>
-    #           async function onClick() {
-    #             document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
-    #           }
-    #         </script>
-    #         <button onclick="onClick()">Click me</button>
-    #         <div></div>
-    #     """)
-    #     await page.click("button")
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
+    #
     # ```python sync
     # import hashlib
     # from playwright.sync_api import sync_playwright
-    # 
+    #
     # def sha1(text):
     #     m = hashlib.sha1()
     #     m.update(bytes(text, "utf8"))
     #     return m.hexdigest()
-    # 
-    # 
+    #
+    #
     # def run(playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch(headless=False)
@@ -562,47 +187,10 @@ module Playwright
     #         <div></div>
     #     """)
     #     page.click("button")
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
-    # 
-    # ```csharp
-    # using Microsoft.Playwright;
-    # using System;
-    # using System.Security.Cryptography;
-    # using System.Threading.Tasks;
-    # 
-    # class BrowserContextExamples
-    # {
-    #     public static async Task AddMd5FunctionToAllPagesInContext()
-    #     {
-    #         using var playwright = await Playwright.CreateAsync();
-    #         var browser = await playwright.Webkit.LaunchAsync(headless: false);
-    #         var context = await browser.NewContextAsync();
-    # 
-    #         // NOTE: md5 is inherently insecure, and we strongly discourage using
-    #         // this in production in any shape or form
-    #         await context.ExposeFunctionAsync("sha1", (string input) =>
-    #         {
-    #             return Convert.ToBase64String(
-    #                 MD5.Create().ComputeHash(System.Text.Encoding.UTF8.GetBytes(input)));
-    #         });
-    # 
-    #         var page = await context.NewPageAsync();
-    #         await page.SetContentAsync("<script>\n" +
-    #         "  async function onClick() {\n" +
-    #         "    document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');\n" +
-    #         "  }\n" +
-    #         "</script>\n" +
-    #         "<button onclick=\"onClick()\">Click me</button>\n" +
-    #         "<div></div>");
-    # 
-    #         await page.ClickAsync("button");
-    #         Console.WriteLine(await page.TextContentAsync("div"));
-    #     }
-    # }
-    # ```
     def expose_function(name, callback)
       wrap_impl(@impl.expose_function(unwrap_impl(name), unwrap_impl(callback)))
     end
@@ -614,7 +202,7 @@ module Playwright
     end
 
     # > NOTE: CDP sessions are only supported on Chromium-based browsers.
-    # 
+    #
     # Returns the newly created session.
     def new_cdp_session(page)
       raise NotImplementedError.new('new_cdp_session is not implemented yet.')
@@ -632,34 +220,9 @@ module Playwright
 
     # Routing provides the capability to modify network requests that are made by any page in the browser context. Once route
     # is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.
-    # 
+    #
     # An example of a naive handler that aborts all image requests:
-    # 
-    #
-    # ```js
-    # const context = await browser.newContext();
-    # await context.route('**/*.{png,jpg,jpeg}', route => route.abort());
-    # const page = await context.newPage();
-    # await page.goto('https://example.com');
-    # await browser.close();
-    # ```
-    # 
-    # ```java
-    # BrowserContext context = browser.newContext();
-    # context.route("**/*.{png,jpg,jpeg}", route -> route.abort());
-    # Page page = context.newPage();
-    # page.navigate("https://example.com");
-    # browser.close();
-    # ```
-    # 
-    # ```python async
-    # context = await browser.new_context()
-    # page = await context.new_page()
-    # await context.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
-    # await page.goto("https://example.com")
-    # await browser.close()
-    # ```
-    # 
+    #
     # ```python sync
     # context = browser.new_context()
     # page = context.new_page()
@@ -667,43 +230,9 @@ module Playwright
     # page.goto("https://example.com")
     # browser.close()
     # ```
-    # 
-    # ```csharp
-    # var context = await browser.NewContextAsync();
-    # var page = await context.NewPageAsync();
-    # await context.RouteAsync("**/*.{png,jpg,jpeg}", r => r.AbortAsync());
-    # await page.GotoAsync("https://theverge.com");
-    # await browser.CloseAsync();
-    # ```
-    # 
+    #
     # or the same snippet using a regex pattern instead:
-    # 
-    #
-    # ```js
-    # const context = await browser.newContext();
-    # await context.route(/(\.png$)|(\.jpg$)/, route => route.abort());
-    # const page = await context.newPage();
-    # await page.goto('https://example.com');
-    # await browser.close();
-    # ```
-    # 
-    # ```java
-    # BrowserContext context = browser.newContext();
-    # context.route(Pattern.compile("(\\.png$)|(\\.jpg$)"), route -> route.abort());
-    # Page page = context.newPage();
-    # page.navigate("https://example.com");
-    # browser.close();
-    # ```
-    # 
-    # ```python async
-    # context = await browser.new_context()
-    # page = await context.new_page()
-    # await context.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
-    # page = await context.new_page()
-    # await page.goto("https://example.com")
-    # await browser.close()
-    # ```
-    # 
+    #
     # ```python sync
     # context = browser.new_context()
     # page = context.new_page()
@@ -713,46 +242,10 @@ module Playwright
     # page.goto("https://example.com")
     # browser.close()
     # ```
-    # 
-    # ```csharp
-    # var context = await browser.NewContextAsync();
-    # var page = await context.NewPageAsync();
-    # await context.RouteAsync(new Regex("(\\.png$)|(\\.jpg$)"), r => r.AbortAsync());
-    # await page.GotoAsync("https://theverge.com");
-    # await browser.CloseAsync();
-    # ```
-    # 
+    #
     # It is possible to examine the request to decide the route action. For example, mocking all requests that contain some
     # post data, and leaving all other requests as is:
-    # 
     #
-    # ```js
-    # await context.route('/api/**', route => {
-    #   if (route.request().postData().includes('my-string'))
-    #     route.fulfill({ body: 'mocked-data' });
-    #   else
-    #     route.continue();
-    # });
-    # ```
-    # 
-    # ```java
-    # context.route("/api/**", route -> {
-    #   if (route.request().postData().contains("my-string"))
-    #     route.fulfill(new Route.FulfillOptions().setBody("mocked-data"));
-    #   else
-    #     route.resume();
-    # });
-    # ```
-    # 
-    # ```python async
-    # def handle_route(route):
-    #   if ("my-string" in route.request.post_data)
-    #     route.fulfill(body="mocked-data")
-    #   else
-    #     route.continue_()
-    # await context.route("/api/**", handle_route)
-    # ```
-    # 
     # ```python sync
     # def handle_route(route):
     #   if ("my-string" in route.request.post_data)
@@ -761,29 +254,19 @@ module Playwright
     #     route.continue_()
     # context.route("/api/**", handle_route)
     # ```
-    # 
-    # ```csharp
-    # await page.RouteAsync("/api/**", async r =>
-    # {
-    #     if (r.Request.PostData.Contains("my-string"))
-    #         await r.FulfillAsync(body: "mocked-data");
-    #     else
-    #         await r.ContinueAsync();
-    # });
-    # ```
-    # 
+    #
     # Page routes (set up with [`method: Page.route`]) take precedence over browser context routes when request matches both
     # handlers.
-    # 
+    #
     # To remove a route with its handler you can use [`method: BrowserContext.unroute`].
-    # 
+    #
     # > NOTE: Enabling routing disables http cache.
     def route(url, handler)
       wrap_impl(@impl.route(unwrap_impl(url), unwrap_impl(handler)))
     end
 
     # > NOTE: Service workers are only supported on Chromium-based browsers.
-    # 
+    #
     # All existing service workers in the context.
     def service_workers
       raise NotImplementedError.new('service_workers is not implemented yet.')
@@ -796,7 +279,7 @@ module Playwright
     # - [`method: Page.reload`]
     # - [`method: Page.setContent`]
     # - [`method: Page.waitForNavigation`]
-    # 
+    #
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`] and [`method: Page.setDefaultTimeout`] take priority over
     # [`method: BrowserContext.setDefaultNavigationTimeout`].
     def set_default_navigation_timeout(timeout)
@@ -805,7 +288,7 @@ module Playwright
     alias_method :default_navigation_timeout=, :set_default_navigation_timeout
 
     # This setting will change the default maximum time for all the methods accepting `timeout` option.
-    # 
+    #
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`], [`method: Page.setDefaultTimeout`] and
     # [`method: BrowserContext.setDefaultNavigationTimeout`] take priority over [`method: BrowserContext.setDefaultTimeout`].
     def set_default_timeout(timeout)
@@ -816,7 +299,7 @@ module Playwright
     # The extra HTTP headers will be sent with every request initiated by any page in the context. These headers are merged
     # with page-specific extra HTTP headers set with [`method: Page.setExtraHTTPHeaders`]. If page overrides a particular
     # header, page-specific header value will be used instead of the browser context header value.
-    # 
+    #
     # > NOTE: [`method: BrowserContext.setExtraHTTPHeaders`] does not guarantee the order of headers in the outgoing requests.
     def set_extra_http_headers(headers)
       wrap_impl(@impl.set_extra_http_headers(unwrap_impl(headers)))
@@ -824,32 +307,11 @@ module Playwright
     alias_method :extra_http_headers=, :set_extra_http_headers
 
     # Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.
-    # 
     #
-    # ```js
-    # await browserContext.setGeolocation({latitude: 59.95, longitude: 30.31667});
-    # ```
-    # 
-    # ```java
-    # browserContext.setGeolocation(new Geolocation(59.95, 30.31667));
-    # ```
-    # 
-    # ```python async
-    # await browser_context.set_geolocation({"latitude": 59.95, "longitude": 30.31667})
-    # ```
-    # 
     # ```python sync
     # browser_context.set_geolocation({"latitude": 59.95, "longitude": 30.31667})
     # ```
-    # 
-    # ```csharp
-    # await context.SetGeolocationAsync(new Geolocation()
-    # {
-    #     Latitude = 59.95f,
-    #     Longitude = 30.31667f
-    # });
-    # ```
-    # 
+    #
     # > NOTE: Consider using [`method: BrowserContext.grantPermissions`] to grant permissions for the browser context pages to
     # read its geolocation.
     def set_geolocation(geolocation)
@@ -875,36 +337,12 @@ module Playwright
 
     # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
     # value. Will throw an error if the context closes before the event is fired. Returns the event data value.
-    # 
     #
-    # ```js
-    # const [page, _] = await Promise.all([
-    #   context.waitForEvent('page'),
-    #   page.click('button')
-    # ]);
-    # ```
-    # 
-    # ```java
-    # Page newPage = context.waitForPage(() -> page.click("button"));
-    # ```
-    # 
-    # ```python async
-    # async with context.expect_event("page") as event_info:
-    #     await page.click("button")
-    # page = await event_info.value
-    # ```
-    # 
     # ```python sync
     # with context.expect_event("page") as event_info:
     #     page.click("button")
     # page = event_info.value
     # ```
-    # 
-    # ```csharp
-    # var waitForPageEvent = context.WaitForPageAsync();
-    # await page.ClickAsync("button");
-    # var page = await waitForPageEvent;
-    # ```
     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
@@ -917,10 +355,10 @@ module Playwright
     end
 
     # > NOTE: In most cases, you should use [`method: BrowserContext.waitForEvent`].
-    # 
+    #
     # Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and
-    # waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the `event` is
-    # fired.
+    # waits for `predicate(event)` to return a truthy value. Will throw an error if the browser context is closed before the
+    # `event` is fired.
     def wait_for_event(event, predicate: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end
@@ -947,20 +385,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     private def event_emitter_proxy