playwright-ruby-client 0.2.0 → 0.5.4

data/lib/playwright_api/file_chooser.rb

@@ -1,5 +1,5 @@
 module Playwright
-  # `FileChooser` objects are dispatched by the page in the [`event: Page.filechooser`] event.
+  # `FileChooser` objects are dispatched by the page in the [`event: Page.fileChooser`] event.
   # 
   #
   # ```js
@@ -10,6 +10,11 @@ module Playwright
   # await fileChooser.setFiles('myfile.pdf');
   # ```
   # 
+  # ```java
+  # FileChooser fileChooser = page.waitForFileChooser(() -> page.click("upload"));
+  # fileChooser.setFiles(Paths.get("myfile.pdf"));
+  # ```
+  # 
   # ```python async
   # async with page.expect_file_chooser() as fc_info:
   #     await page.click("upload")

data/lib/playwright_api/frame.rb

@@ -3,10 +3,10 @@ module Playwright
   # [`method: Frame.childFrames`] methods.
   # 
   # `Frame` object's lifecycle is controlled by three events, dispatched on the page object:
-  # - [`event: Page.frameattached`] - fired when the frame gets attached to the page. A Frame can be attached to the page
+  # - [`event: Page.frameAttached`] - fired when the frame gets attached to the page. A Frame can be attached to the page
   #   only once.
-  # - [`event: Page.framenavigated`] - fired when the frame commits navigation to a different URL.
-  # - [`event: Page.framedetached`] - fired when the frame gets detached from the page.  A Frame can be detached from the
+  # - [`event: Page.frameNavigated`] - fired when the frame commits navigation to a different URL.
+  # - [`event: Page.frameDetached`] - fired when the frame gets detached from the page.  A Frame can be detached from the
   #   page only once.
   # 
   # An example of dumping frame tree:
@@ -31,6 +31,29 @@ module Playwright
   # })();
   # ```
   # 
+  # ```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://www.google.com/chrome/browser/canary.html");
+  #       dumpFrameTree(page.mainFrame(), "");
+  #       browser.close();
+  #     }
+  #   }
+  #   static void dumpFrameTree(Frame frame, String indent) {
+  #     System.out.println(indent + frame.url());
+  #     for (Frame child : frame.childFrames()) {
+  #       dumpFrameTree(child, indent + "  ");
+  #     }
+  #   }
+  # }
+  # ```
+  # 
   # ```python async
   # import asyncio
   # from playwright.async_api import async_playwright
@@ -91,20 +114,25 @@ module Playwright
     end
 
     # This method checks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-    # 1. Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Ensure that matched 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 matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 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.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
-    def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.check(unwrap_impl(selector), 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(
+          selector,
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     def child_frames
@@ -112,15 +140,15 @@ module Playwright
     end
 
     # This method clicks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 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.
     # 
-    # 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(
           selector,
           button: nil,
@@ -140,16 +168,16 @@ module Playwright
     end
 
     # This method double clicks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 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.
     # 
-    # 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: `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
@@ -164,8 +192,8 @@ module Playwright
       wrap_impl(@impl.dblclick(unwrap_impl(selector), button: unwrap_impl(button), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
-    # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-    # 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).
     # 
     #
@@ -173,6 +201,10 @@ module Playwright
     # await frame.dispatchEvent('button#submit', 'click');
     # ```
     # 
+    # ```java
+    # frame.dispatchEvent("button#submit", "click");
+    # ```
+    # 
     # ```python async
     # await frame.dispatch_event("button#submit", "click")
     # ```
@@ -202,6 +234,14 @@ module Playwright
     # await frame.dispatchEvent('#source', 'dragstart', { dataTransfer });
     # ```
     # 
+    # ```java
+    # // Note you can only create DataTransfer in Chromium and Firefox
+    # JSHandle dataTransfer = frame.evaluateHandle("() => new DataTransfer()");
+    # Map<String, Object> arg = new HashMap<>();
+    # arg.put("dataTransfer", dataTransfer);
+    # frame.dispatchEvent("#source", "dragstart", arg);
+    # ```
+    # 
     # ```python async
     # # note you can only create data_transfer in chromium and firefox
     # data_transfer = await frame.evaluate_handle("new DataTransfer()")
@@ -235,6 +275,12 @@ module Playwright
     # const html = await frame.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
     # ```
     # 
+    # ```java
+    # String searchValue = (String) frame.evalOnSelector("#search", "el => el.value");
+    # String preloadHref = (String) frame.evalOnSelector("link[rel=preload]", "el => el.href");
+    # String html = (String) frame.evalOnSelector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello");
+    # ```
+    # 
     # ```python async
     # search_value = await frame.eval_on_selector("#search", "el => el.value")
     # preload_href = await frame.eval_on_selector("link[rel=preload]", "el => el.href")
@@ -265,6 +311,10 @@ module Playwright
     # const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);
     # ```
     # 
+    # ```java
+    # boolean divsCounts = (boolean) page.evalOnSelectorAll("div", "(divs, min) => divs.length >= min", 10);
+    # ```
+    # 
     # ```python async
     # divs_counts = await frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
     # ```
@@ -293,6 +343,13 @@ module Playwright
     # console.log(result); // prints "56"
     # ```
     # 
+    # ```java
+    # Object result = frame.evaluate("([x, y]) => {\n" +
+    #   "  return Promise.resolve(x * y);\n" +
+    #   "}", Arrays.asList(7, 8));
+    # System.out.println(result); // prints "56"
+    # ```
+    # 
     # ```python async
     # result = await frame.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
     # print(result) # prints "56"
@@ -310,6 +367,10 @@ module Playwright
     # console.log(await frame.evaluate('1 + 2')); // prints "3"
     # ```
     # 
+    # ```java
+    # System.out.println(frame.evaluate("1 + 2")); // prints "3"
+    # ```
+    # 
     # ```python async
     # print(await frame.evaluate("1 + 2")) # prints "3"
     # x = 10
@@ -331,6 +392,12 @@ module Playwright
     # await bodyHandle.dispose();
     # ```
     # 
+    # ```java
+    # ElementHandle bodyHandle = frame.querySelector("body");
+    # String html = (String) frame.evaluate("([body, suffix]) => body.innerHTML + suffix", Arrays.asList(bodyHandle, "hello"));
+    # bodyHandle.dispose();
+    # ```
+    # 
     # ```python async
     # body_handle = await frame.query_selector("body")
     # html = await frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
@@ -349,7 +416,7 @@ module Playwright
     # Returns the return value of `expression` as a `JSHandle`.
     # 
     # The only difference between [`method: Frame.evaluate`] and [`method: Frame.evaluateHandle`] is that
-    # [method: Frame.evaluateHandle`] returns `JSHandle`.
+    # [`method: Frame.evaluateHandle`] returns `JSHandle`.
     # 
     # If the function, passed to the [`method: Frame.evaluateHandle`], returns a [Promise], then
     # [`method: Frame.evaluateHandle`] would wait for the promise to resolve and return its value.
@@ -360,6 +427,11 @@ module Playwright
     # aWindowHandle; // Handle for the window object.
     # ```
     # 
+    # ```java
+    # // Handle for the window object.
+    # JSHandle aWindowHandle = frame.evaluateHandle("() => Promise.resolve(window)");
+    # ```
+    # 
     # ```python async
     # a_window_handle = await frame.evaluate_handle("Promise.resolve(window)")
     # a_window_handle # handle for the window object.
@@ -377,6 +449,10 @@ module Playwright
     # const aHandle = await frame.evaluateHandle('document'); // Handle for the 'document'.
     # ```
     # 
+    # ```java
+    # JSHandle aHandle = frame.evaluateHandle("document"); // Handle for the "document".
+    # ```
+    # 
     # ```python async
     # a_handle = await page.evaluate_handle("document") # handle for the "document"
     # ```
@@ -395,6 +471,13 @@ module Playwright
     # await resultHandle.dispose();
     # ```
     # 
+    # ```java
+    # JSHandle aHandle = frame.evaluateHandle("() => document.body");
+    # JSHandle resultHandle = frame.evaluateHandle("([body, suffix]) => body.innerHTML + suffix", Arrays.asList(aHandle, "hello"));
+    # System.out.println(resultHandle.jsonValue());
+    # resultHandle.dispose();
+    # ```
+    # 
     # ```python async
     # a_handle = await page.evaluate_handle("document.body")
     # result_handle = await page.evaluate_handle("body => body.innerHTML", a_handle)
@@ -443,6 +526,12 @@ module Playwright
     # console.log(frame === contentFrame);  // -> true
     # ```
     # 
+    # ```java
+    # ElementHandle frameElement = frame.frameElement();
+    # Frame contentFrame = frameElement.contentFrame();
+    # System.out.println(frame == contentFrame);  // -> true
+    # ```
+    # 
     # ```python async
     # frame_element = await frame.frame_element()
     # content_frame = await frame_element.content_frame()
@@ -486,15 +575,15 @@ module Playwright
     end
 
     # This method hovers over an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 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.
     # 
-    # 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(
           selector,
           force: nil,
@@ -539,12 +628,14 @@ module Playwright
       wrap_impl(@impl.enabled?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
-    # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).
+    # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).  `selector` that does not
+    # match any elements is considered hidden.
     def hidden?(selector, timeout: nil)
       wrap_impl(@impl.hidden?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
-    # Returns whether the element is [visible](./actionability.md#visible).
+    # Returns whether the element is [visible](./actionability.md#visible). `selector` that does not match any elements is
+    # considered not visible.
     def visible?(selector, timeout: nil)
       wrap_impl(@impl.visible?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
@@ -582,7 +673,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(
           selector,
@@ -628,6 +719,15 @@ module Playwright
     # frame.selectOption('select#colors', 'red', 'green', 'blue');
     # ```
     # 
+    # ```java
+    # // single selection matching the value
+    # frame.selectOption("select#colors", "blue");
+    # // single selection matching both the value and the label
+    # frame.selectOption("select#colors", new SelectOption().setLabel("Blue"));
+    # // multiple selection
+    # frame.selectOption("select#colors", new String[] {"red", "green", "blue"});
+    # ```
+    # 
     # ```python async
     # # single selection matching the value
     # await frame.select_option("select#colors", "blue")
@@ -671,15 +771,15 @@ module Playwright
     end
 
     # This method taps an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 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.
     # 
-    # 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: `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
@@ -713,6 +813,13 @@ module Playwright
     # await frame.type('#mytextarea', 'World', {delay: 100}); // Types slower, like a user
     # ```
     # 
+    # ```java
+    # // Types instantly
+    # frame.type("#mytextarea", "Hello");
+    # // Types slower, like a user
+    # frame.type("#mytextarea", "World", new Frame.TypeOptions().setDelay(100));
+    # ```
+    # 
     # ```python async
     # await frame.type("#mytextarea", "hello") # types instantly
     # await frame.type("#mytextarea", "world", delay=100) # types slower, like a user
@@ -732,20 +839,25 @@ module Playwright
     end
 
     # This method checks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-    # 1. Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Ensure that matched 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 matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 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.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
-    def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.uncheck(unwrap_impl(selector), 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(
+          selector,
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns frame's url.
@@ -771,6 +883,23 @@ module Playwright
     # })();
     # ```
     # 
+    # ```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.setViewportSize(50, 50);
+    #       page.mainFrame().waitForFunction("window.innerWidth < 100");
+    #       browser.close();
+    #     }
+    #   }
+    # }
+    # ```
+    # 
     # ```python async
     # import asyncio
     # from playwright.async_api import async_playwright
@@ -812,6 +941,11 @@ module Playwright
     # await frame.waitForFunction(selector => !!document.querySelector(selector), selector);
     # ```
     # 
+    # ```java
+    # String selector = ".foo";
+    # frame.waitForFunction("selector => !!document.querySelector(selector)", selector);
+    # ```
+    # 
     # ```python async
     # selector = ".foo"
     # await frame.wait_for_function("selector => !!document.querySelector(selector)", selector)
@@ -836,6 +970,11 @@ module Playwright
     # await frame.waitForLoadState(); // Waits for 'load' state by default.
     # ```
     # 
+    # ```java
+    # frame.click("button"); // Click triggers navigation.
+    # frame.waitForLoadState(); // Waits for "load" state by default.
+    # ```
+    # 
     # ```python async
     # await frame.click("button") # click triggers navigation.
     # await frame.wait_for_load_state() # the promise resolves after "load" event.
@@ -864,6 +1003,14 @@ module Playwright
     # ]);
     # ```
     # 
+    # ```java
+    # // The method returns after navigation has finished
+    # Response response = frame.waitForNavigation(() -> {
+    #   // Clicking the link will indirectly cause a navigation
+    #   frame.click("a.delayed-navigation");
+    # });
+    # ```
+    # 
     # ```python async
     # async with frame.expect_navigation():
     #     await frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
@@ -907,6 +1054,26 @@ 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();
+    #       for (String currentURL : Arrays.asList("https://google.com", "https://bbc.com")) {
+    #         page.navigate(currentURL);
+    #         ElementHandle element = page.mainFrame().waitForSelector("img");
+    #         System.out.println("Loaded image: " + element.getAttribute("src"));
+    #       }
+    #       browser.close();
+    #     }
+    #   }
+    # }
+    # ```
+    # 
     # ```python async
     # import asyncio
     # from playwright.async_api import async_playwright
@@ -955,6 +1122,32 @@ module Playwright
       raise NotImplementedError.new('wait_for_timeout is not implemented yet.')
     end
 
+    # Waits for the frame to navigate to the given URL.
+    # 
+    #
+    # ```js
+    # await frame.click('a.delayed-navigation'); // Clicking the link will indirectly cause a navigation
+    # await frame.waitForURL('**/target.html');
+    # ```
+    # 
+    # ```java
+    # frame.click("a.delayed-navigation"); // Clicking the link will indirectly cause a navigation
+    # frame.waitForURL("**/target.html");
+    # ```
+    # 
+    # ```python async
+    # await frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # await frame.wait_for_url("**/target.html")
+    # ```
+    # 
+    # ```python sync
+    # frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # frame.wait_for_url("**/target.html")
+    # ```
+    def wait_for_url(url, timeout: nil, waitUntil: nil)
+      wrap_impl(@impl.wait_for_url(unwrap_impl(url), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
+    end
+
     # @nodoc
     def detached=(req)
       wrap_impl(@impl.detached=(unwrap_impl(req)))