playwright-ruby-client 0.2.0 → 0.5.2

data/lib/playwright_api/browser_type.rb

@@ -15,6 +15,23 @@ module Playwright
   # })();
   # ```
   # 
+  # ```java
+  # import com.microsoft.playwright.*;
+  # 
+  # public class Example {
+  #   public static void main(String[] args) {
+  #     try (Playwright playwright = Playwright.create()) {
+  #       BrowserType chromium = playwright.chromium();
+  #       Browser browser = chromium.launch();
+  #       Page page = browser.newPage();
+  #       page.navigate("https://example.com");
+  #       // other actions...
+  #       browser.close();
+  #     }
+  #   }
+  # }
+  # ```
+  # 
   # ```python async
   # import asyncio
   # from playwright.async_api import async_playwright
@@ -65,6 +82,12 @@ module Playwright
     # });
     # ```
     # 
+    # ```java
+    # // Or "firefox" or "webkit".
+    # Browser browser = chromium.launch(new BrowserType.LaunchOptions()
+    #   .setIgnoreDefaultArgs(Arrays.asList("--mute-audio")));
+    # ```
+    # 
     # ```python async
     # browser = await playwright.chromium.launch( # or "firefox" or "webkit".
     #     ignore_default_args=["--mute-audio"]
@@ -77,22 +100,23 @@ module Playwright
     # )
     # ```
     # 
-    # > **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.
+    # > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, 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.
     # >
     # > If Google Chrome (rather than Chromium) is preferred, a
     # [Chrome Canary](https://www.google.com/chrome/browser/canary.html) or
     # [Dev Channel](https://www.chromium.org/getting-involved/dev-channel) build is suggested.
     # >
-    # > In [`method: BrowserType.launch`] above, any mention of Chromium also applies to Chrome.
-    # >
-    # > See [`this article`](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for
-    # a description of the differences between Chromium and Chrome.
-    # [`This article`](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)
+    # > Stock browsers like Google Chrome and Microsoft Edge are suitable for tests that require proprietary media codecs for
+    # video playback. See
+    # [this article](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for other
+    # differences between Chromium and Chrome.
+    # [This article](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)
     # describes some differences for Linux users.
     def launch(
           args: nil,
+          channel: nil,
           chromiumSandbox: nil,
           devtools: nil,
           downloadsPath: nil,
@@ -108,7 +132,7 @@ module Playwright
           slowMo: nil,
           timeout: nil,
           &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)))
+      wrap_impl(@impl.launch(args: unwrap_impl(args), channel: unwrap_impl(channel), 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.
@@ -120,6 +144,7 @@ module Playwright
           acceptDownloads: nil,
           args: nil,
           bypassCSP: nil,
+          channel: nil,
           chromiumSandbox: nil,
           colorScheme: nil,
           deviceScaleFactor: nil,
@@ -148,6 +173,7 @@ module Playwright
           record_har_path: nil,
           record_video_dir: nil,
           record_video_size: nil,
+          screen: nil,
           slowMo: nil,
           timeout: nil,
           timezoneId: nil,
@@ -161,6 +187,11 @@ module Playwright
       wrap_impl(@impl.name)
     end
 
+    # @nodoc
+    def connect_over_cdp(endpointURL, slowMo: nil, timeout: nil, &block)
+      wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)

data/lib/playwright_api/dialog.rb

@@ -13,12 +13,32 @@ module Playwright
   #   page.on('dialog', async dialog => {
   #     console.log(dialog.message());
   #     await dialog.dismiss();
-  #     await browser.close();
   #   });
-  #   page.evaluate(() => alert('1'));
+  #   await page.evaluate(() => alert('1'));
+  #   await browser.close();
   # })();
   # ```
   # 
+  # ```java
+  # import com.microsoft.playwright.*;
+  # 
+  # public class Example {
+  #   public static void main(String[] args) {
+  #     try (Playwright playwright = Playwright.create()) {
+  #       BrowserType chromium = playwright.chromium();
+  #       Browser browser = chromium.launch();
+  #       Page page = browser.newPage();
+  #       page.onDialog(dialog -> {
+  #         System.out.println(dialog.message());
+  #         dialog.dismiss();
+  #       });
+  #       page.evaluate("alert('1')");
+  #       browser.close();
+  #     }
+  #   }
+  # }
+  # ```
+  # 
   # ```python async
   # import asyncio
   # from playwright.async_api import async_playwright
@@ -68,27 +88,54 @@ module Playwright
 
     # Returns when the dialog has been accepted.
     def accept(promptText: nil)
-      raise NotImplementedError.new('accept is not implemented yet.')
+      wrap_impl(@impl.accept(promptText: unwrap_impl(promptText)))
     end
 
     # If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
     def default_value
-      raise NotImplementedError.new('default_value is not implemented yet.')
+      wrap_impl(@impl.default_value)
     end
 
     # Returns when the dialog has been dismissed.
     def dismiss
-      raise NotImplementedError.new('dismiss is not implemented yet.')
+      wrap_impl(@impl.dismiss)
     end
 
     # A message displayed in the dialog.
     def message
-      raise NotImplementedError.new('message is not implemented yet.')
+      wrap_impl(@impl.message)
     end
 
     # Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
     def type
-      raise NotImplementedError.new('type is not implemented yet.')
+      wrap_impl(@impl.type)
+    end
+
+    # @nodoc
+    def accept_async(promptText: nil)
+      wrap_impl(@impl.accept_async(promptText: unwrap_impl(promptText)))
+    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

@@ -20,6 +20,24 @@ module Playwright
   # })();
   # ```
   # 
+  # ```java
+  # import com.microsoft.playwright.*;
+  # 
+  # public class Example {
+  #   public static void main(String[] args) {
+  #     try (Playwright playwright = Playwright.create()) {
+  #       BrowserType chromium = playwright.chromium();
+  #       Browser browser = chromium.launch();
+  #       Page page = browser.newPage();
+  #       page.navigate("https://example.com");
+  #       ElementHandle hrefElement = page.querySelector("a");
+  #       hrefElement.click();
+  #       // ...
+  #     }
+  #   }
+  # }
+  # ```
+  # 
   # ```python async
   # import asyncio
   # from playwright.async_api import async_playwright
@@ -81,6 +99,11 @@ module Playwright
     # await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
     # ```
     # 
+    # ```java
+    # BoundingBox box = elementHandle.boundingBox();
+    # 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)
@@ -95,20 +118,20 @@ module Playwright
     end
 
     # This method checks the element by performing the following steps:
-    # 1. Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already
-    #    checked, this method returns immediately.
+    # 1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already checked,
+    #    this method returns immediately.
     # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to click in the center of the element.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 1. Ensure that the element is now checked. If not, this method rejects.
+    # 1. Ensure that the element is now checked. If not, this method throws.
     # 
-    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # If the element is detached from the DOM at any moment during the action, this method throws.
     # 
-    # 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)
-      wrap_impl(@impl.check(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
+    def check(force: nil, noWaitAfter: nil, position: nil, timeout: nil)
+      wrap_impl(@impl.check(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # This method clicks the element by performing the following steps:
@@ -117,10 +140,10 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 
-    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # If the element is detached from the DOM at any moment during the action, this method throws.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     def click(
           button: nil,
           clickCount: nil,
@@ -143,12 +166,12 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to double click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the
-    #    first click of the `dblclick()` triggers a navigation event, this method will reject.
+    #    first click of the `dblclick()` triggers a navigation event, this method will throw.
     # 
-    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # If the element is detached from the DOM at any moment during the action, this method throws.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # > NOTE: `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
@@ -162,8 +185,8 @@ module Playwright
       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`
-    # is dispatched. This is equivalend to calling
+    # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,
+    # `click` is dispatched. This is equivalent to calling
     # [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).
     # 
     #
@@ -171,6 +194,10 @@ module Playwright
     # await elementHandle.dispatchEvent('click');
     # ```
     # 
+    # ```java
+    # elementHandle.dispatchEvent("click");
+    # ```
+    # 
     # ```python async
     # await element_handle.dispatch_event("click")
     # ```
@@ -200,6 +227,14 @@ module Playwright
     # await elementHandle.dispatchEvent('dragstart', { dataTransfer });
     # ```
     # 
+    # ```java
+    # // Note you can only create DataTransfer in Chromium and Firefox
+    # JSHandle dataTransfer = page.evaluateHandle("() => new DataTransfer()");
+    # Map<String, Object> arg = new HashMap<>();
+    # arg.put("dataTransfer", dataTransfer);
+    # elementHandle.dispatchEvent("dragstart", arg);
+    # ```
+    # 
     # ```python async
     # # note you can only create data_transfer in chromium and firefox
     # data_transfer = await page.evaluate_handle("new DataTransfer()")
@@ -233,6 +268,12 @@ module Playwright
     # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
     # ```
     # 
+    # ```java
+    # ElementHandle tweetHandle = page.querySelector(".tweet");
+    # assertEquals("100", tweetHandle.evalOnSelector(".like", "node => node.innerText"));
+    # assertEquals("10", tweetHandle.evalOnSelector(".retweets", "node => node.innerText"));
+    # ```
+    # 
     # ```python async
     # tweet_handle = await page.query_selector(".tweet")
     # assert await tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
@@ -271,6 +312,11 @@ module Playwright
     # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
     # ```
     # 
+    # ```java
+    # ElementHandle feedHandle = page.querySelector(".feed");
+    # assertEquals(Arrays.asList("Hello!", "Hi!"), feedHandle.evalOnSelectorAll(".tweet", "nodes => nodes.map(n => n.innerText)"));
+    # ```
+    # 
     # ```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!"]
@@ -310,10 +356,10 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to hover over the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 
-    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # If the element is detached from the DOM at any moment during the action, this method throws.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
       wrap_impl(@impl.hover(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
@@ -379,7 +425,7 @@ module Playwright
     # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
     # texts.
     # 
-    # Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
+    # Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified 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(unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
@@ -439,6 +485,15 @@ module Playwright
     # handle.selectOption(['red', 'green', 'blue']);
     # ```
     # 
+    # ```java
+    # // single selection matching the value
+    # handle.selectOption("blue");
+    # // single selection matching the label
+    # handle.selectOption(new SelectOption().setLabel("Blue"));
+    # // multiple selection
+    # handle.selectOption(new String[] {"red", "green", "blue"});
+    # ```
+    # 
     # ```python async
     # # single selection matching the value
     # await handle.select_option("blue")
@@ -499,10 +554,10 @@ module Playwright
     # 1. Use [`property: Page.touchscreen`] to tap the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 
-    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # If the element is detached from the DOM at any moment during the action, this method throws.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # > NOTE: `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
@@ -529,6 +584,11 @@ module Playwright
     # await elementHandle.type('World', {delay: 100}); // Types slower, like a user
     # ```
     # 
+    # ```java
+    # elementHandle.type("Hello"); // Types instantly
+    # elementHandle.type("World", new ElementHandle.TypeOptions().setDelay(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
@@ -548,6 +608,12 @@ module Playwright
     # await elementHandle.press('Enter');
     # ```
     # 
+    # ```java
+    # ElementHandle elementHandle = page.querySelector("input");
+    # elementHandle.type("some text");
+    # elementHandle.press("Enter");
+    # ```
+    # 
     # ```python async
     # element_handle = await page.query_selector("input")
     # await element_handle.type("some text")
@@ -564,20 +630,20 @@ module Playwright
     end
 
     # This method checks the element by performing the following steps:
-    # 1. Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    # 1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already
     #    unchecked, this method returns immediately.
     # 1. Wait for [actionability](./actionability.md) checks on the element, unless `force` option is set.
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to click in the center of the element.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 1. Ensure that the element is now unchecked. If not, this method rejects.
+    # 1. Ensure that the element is now unchecked. If not, this method throws.
     # 
-    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # If the element is detached from the DOM at any moment during the action, this method throws.
     # 
-    # 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)
-      wrap_impl(@impl.uncheck(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
+    def uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil)
+      wrap_impl(@impl.uncheck(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when the element satisfies the `state`.
@@ -614,6 +680,14 @@ module Playwright
     # const span = await div.waitForSelector('span', { state: 'attached' });
     # ```
     # 
+    # ```java
+    # page.setContent("<div><span></span></div>");
+    # ElementHandle div = page.querySelector("div");
+    # // Waiting for the "span" selector relative to the div.
+    # ElementHandle span = div.waitForSelector("span", new ElementHandle.WaitForSelectorOptions()
+    #   .setState(WaitForSelectorState.ATTACHED));
+    # ```
+    # 
     # ```python async
     # await page.set_content("<div><span></span></div>")
     # div = await page.query_selector("div")