playwright-ruby-client 0.0.8 → 0.3.0

data/lib/playwright_api/file_chooser.rb

@@ -1,41 +1,49 @@
 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
-  # page.on('filechooser', async (fileChooser) => {
-  #   await fileChooser.setFiles('/tmp/myfile.pdf');
-  # });
+  # const [fileChooser] = await Promise.all([
+  #   page.waitForEvent('filechooser'),
+  #   page.click('upload')
+  # ]);
+  # await fileChooser.setFiles('myfile.pdf');
   # ```
   # 
   # ```python async
-  # page.on("filechooser", lambda file_chooser: file_chooser.set_files("/tmp/myfile.pdf"))
+  # async with page.expect_file_chooser() as fc_info:
+  #     await page.click("upload")
+  # file_chooser = await fc_info.value
+  # await file_chooser.set_files("myfile.pdf")
   # ```
   # 
   # ```python sync
-  # page.on("filechooser", lambda file_chooser: file_chooser.set_files("/tmp/myfile.pdf"))
+  # with page.expect_file_chooser() as fc_info:
+  #     page.click("upload")
+  # file_chooser = fc_info.value
+  # file_chooser.set_files("myfile.pdf")
   # ```
   class FileChooser < PlaywrightApi
 
     # Returns input element associated with this file chooser.
     def element
-      raise NotImplementedError.new('element is not implemented yet.')
+      wrap_impl(@impl.element)
     end
 
     # Returns whether this file chooser accepts multiple files.
     def multiple?
-      raise NotImplementedError.new('multiple? is not implemented yet.')
+      wrap_impl(@impl.multiple?)
     end
 
     # Returns page this file chooser belongs to.
     def page
-      raise NotImplementedError.new('page is not implemented yet.')
+      wrap_impl(@impl.page)
     end
 
     # Sets the value of the file input this chooser is associated with. If some of the `filePaths` are relative paths, then
     # they are resolved relative to the the current working directory. For empty array, clears the selected files.
     def set_files(files, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('set_files is not implemented yet.')
+      wrap_impl(@impl.set_files(unwrap_impl(files), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
     alias_method :files=, :set_files
   end

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:
@@ -75,82 +75,6 @@ module Playwright
   # ```
   class Frame < PlaywrightApi
 
-    # Returns the ElementHandle pointing to the frame element.
-    # 
-    # The method finds an element matching the specified selector within the frame. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
-    # returns `null`.
-    def query_selector(selector)
-      wrap_impl(@impl.query_selector(unwrap_impl(selector)))
-    end
-
-    # Returns the ElementHandles pointing to the frame elements.
-    # 
-    # The method finds all elements matching the specified selector within the frame. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
-    # returns empty array.
-    def query_selector_all(selector)
-      wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
-    end
-
-    # Returns the return value of `pageFunction`
-    # 
-    # The method finds an element matching the specified selector within the frame and passes it as a first argument to
-    # `pageFunction`. See [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements
-    # match the selector, the method throws an error.
-    # 
-    # If `pageFunction` returns a [Promise], then `frame.$eval` would wait for the promise to resolve and return its value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const searchValue = await frame.$eval('#search', el => el.value);
-    # const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);
-    # const html = await frame.$eval('.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")
-    # html = await frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
-    # ```
-    # 
-    # ```python sync
-    # search_value = frame.eval_on_selector("#search", "el => el.value")
-    # preload_href = frame.eval_on_selector("link[rel=preload]", "el => el.href")
-    # html = frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
-    # ```
-    def eval_on_selector(selector, pageFunction, arg: nil)
-      wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
-    end
-
-    # Returns the return value of `pageFunction`
-    # 
-    # The method finds all elements matching the specified selector within the frame and passes an array of matched elements
-    # as a first argument to `pageFunction`. See [Working with selectors](./selectors.md#working-with-selectors) for more
-    # details.
-    # 
-    # If `pageFunction` returns a [Promise], then `frame.$$eval` would wait for the promise to resolve and return its value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);
-    # ```
-    # 
-    # ```python async
-    # divs_counts = await frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
-    # ```
-    # 
-    # ```python sync
-    # divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
-    # ```
-    def eval_on_selector_all(selector, pageFunction, arg: nil)
-      wrap_impl(@impl.eval_on_selector_all(unwrap_impl(selector), unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
-    end
-
     # Returns the added tag when the script's onload fires or when the script content was injected into frame.
     # 
     # Adds a `<script>` tag into the page with the desired url or content.
@@ -293,14 +217,73 @@ module Playwright
       wrap_impl(@impl.dispatch_event(unwrap_impl(selector), unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
 
-    # Returns the return value of `pageFunction`
+    # Returns the return value of `expression`.
+    # 
+    # The method finds an element matching the specified selector within the frame and passes it as a first argument to
+    # `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the selector, the
+    # method throws an error.
+    # 
+    # If `expression` returns a [Promise], then [`method: Frame.evalOnSelector`] would wait for the promise to resolve and
+    # return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const searchValue = await frame.$eval('#search', el => el.value);
+    # const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);
+    # const html = await frame.$eval('.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")
+    # html = await frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
+    # ```
+    # 
+    # ```python sync
+    # search_value = frame.eval_on_selector("#search", "el => el.value")
+    # preload_href = frame.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
+    # ```
+    def eval_on_selector(selector, expression, arg: nil)
+      wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
+    end
+
+    # Returns the return value of `expression`.
+    # 
+    # The method finds all elements matching the specified selector within the frame and passes an array of matched elements
+    # as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
+    # 
+    # If `expression` returns a [Promise], then [`method: Frame.evalOnSelectorAll`] would wait for the promise to resolve and
+    # return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);
+    # ```
+    # 
+    # ```python async
+    # divs_counts = await frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    # 
+    # ```python sync
+    # divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    def eval_on_selector_all(selector, expression, arg: nil)
+      wrap_impl(@impl.eval_on_selector_all(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
+    end
+
+    # Returns the return value of `expression`.
     # 
     # If the function passed to the [`method: Frame.evaluate`] returns a [Promise], then [`method: Frame.evaluate`] would wait
     # for the promise to resolve and return its value.
     # 
-    # If the function passed to the [`method: Frame.evaluate`] returns a non-[Serializable] value,
-    # then[ method: `Frame.evaluate`] returns `undefined`. DevTools Protocol also supports transferring some additional values
-    # that are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+    # If the function passed to the [`method: Frame.evaluate`] returns a non-[Serializable] value, then
+    # [`method: Frame.evaluate`] returns `undefined`. Playwright also supports transferring some additional values that are
+    # not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
     # 
     #
     # ```js
@@ -359,17 +342,17 @@ module Playwright
     # html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
-    def evaluate(pageFunction, arg: nil)
-      wrap_impl(@impl.evaluate(unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
-    # Returns the return value of `pageFunction` as in-page object (JSHandle).
+    # Returns the return value of `expression` as a `JSHandle`.
     # 
-    # The only difference between [`method: Frame.evaluate`] and [`method: Frame.evaluateHandle`] is
-    # that[ method: Fframe.evaluateHandle`] returns in-page object (JSHandle).
+    # The only difference between [`method: Frame.evaluate`] and [`method: Frame.evaluateHandle`] is that
+    # [method: Frame.evaluateHandle`] returns `JSHandle`.
     # 
-    # If the function, passed to the [`method: Frame.evaluateHandle`], returns a [Promise],
-    # then[ method: Fframe.evaluateHandle`] would wait for the promise to resolve and return its value.
+    # 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.
     # 
     #
     # ```js
@@ -378,7 +361,6 @@ module Playwright
     # ```
     # 
     # ```python async
-    # # FIXME
     # a_window_handle = await frame.evaluate_handle("Promise.resolve(window)")
     # a_window_handle # handle for the window object.
     # ```
@@ -426,14 +408,15 @@ module Playwright
     # print(result_handle.json_value())
     # result_handle.dispose()
     # ```
-    def evaluate_handle(pageFunction, arg: nil)
-      wrap_impl(@impl.evaluate_handle(unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # This method waits for an element matching `selector`, waits for [actionability](./actionability.md) checks, focuses the
-    # element, fills it and triggers an `input` event after filling. If the element matching `selector` is not an `<input>`,
-    # `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to
-    # clear the input field.
+    # element, fills it and triggers an `input` event after filling. If the element is inside the `<label>` element that has
+    # associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), that control will be
+    # filled instead. If the element to be filled is not an `<input>`, `<textarea>` or `[contenteditable]` element, this
+    # method throws an error. Note that you can pass an empty string to clear the input field.
     # 
     # To send fine-grained keyboard events, use [`method: Frame.type`].
     def fill(selector, value, noWaitAfter: nil, timeout: nil)
@@ -556,12 +539,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
@@ -610,6 +595,22 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(selector), unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
+    # Returns the ElementHandle pointing to the frame element.
+    # 
+    # The method finds an element matching the specified selector within the frame. See
+    # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns `null`.
+    def query_selector(selector)
+      wrap_impl(@impl.query_selector(unwrap_impl(selector)))
+    end
+
+    # Returns the ElementHandles pointing to the frame elements.
+    # 
+    # The method finds all elements matching the specified selector within the frame. See
+    # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns empty array.
+    def query_selector_all(selector)
+      wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
+    end
+
     # Returns the array of option values that have been successfully selected.
     # 
     # Triggers a `change` and `input` event once all the provided options have been selected. If there's no `<select>` element
@@ -646,8 +647,15 @@ module Playwright
     # # multiple selection
     # frame.select_option("select#colors", value=["red", "green", "blue"])
     # ```
-    def select_option(selector, values, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.select_option(unwrap_impl(selector), unwrap_impl(values), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    def select_option(
+          selector,
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      wrap_impl(@impl.select_option(unwrap_impl(selector), element: unwrap_impl(element), index: unwrap_impl(index), value: unwrap_impl(value), label: unwrap_impl(label), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     def set_content(html, timeout: nil, waitUntil: nil)
@@ -747,9 +755,9 @@ module Playwright
       wrap_impl(@impl.url)
     end
 
-    # Returns when the `pageFunction` returns a truthy value, returns that value.
+    # Returns when the `expression` returns a truthy value, returns that value.
     # 
-    # The `waitForFunction` can be used to observe viewport size change:
+    # The [`method: Frame.waitForFunction`] can be used to observe viewport size change:
     # 
     #
     # ```js
@@ -773,7 +781,7 @@ module Playwright
     #     webkit = playwright.webkit
     #     browser = await webkit.launch()
     #     page = await browser.new_page()
-    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);", force_expr=True)
+    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
     #     await page.main_frame.wait_for_function("() => window.x > 0")
     #     await browser.close()
     # 
@@ -790,7 +798,7 @@ module Playwright
     #     webkit = playwright.webkit
     #     browser = webkit.launch()
     #     page = browser.new_page()
-    #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);", force_expr=True)
+    #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
     #     page.main_frame.wait_for_function("() => window.x > 0")
     #     browser.close()
     # 
@@ -815,8 +823,8 @@ module Playwright
     # selector = ".foo"
     # frame.wait_for_function("selector => !!document.querySelector(selector)", selector)
     # ```
-    def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
-      wrap_impl(@impl.wait_for_function(unwrap_impl(pageFunction), arg: unwrap_impl(arg), polling: unwrap_impl(polling), timeout: unwrap_impl(timeout)))
+    def wait_for_function(expression, arg: nil, polling: nil, timeout: nil)
+      wrap_impl(@impl.wait_for_function(unwrap_impl(expression), arg: unwrap_impl(arg), polling: unwrap_impl(polling), timeout: unwrap_impl(timeout)))
     end
 
     # Waits for the required load state to be reached.
@@ -938,7 +946,7 @@ module Playwright
     #     run(playwright)
     # ```
     def wait_for_selector(selector, state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_selector is not implemented yet.')
+      wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
     # Waits for the given `timeout` in milliseconds.
@@ -954,27 +962,26 @@ module Playwright
       wrap_impl(@impl.detached=(unwrap_impl(req)))
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/js_handle.rb

@@ -22,7 +22,7 @@ module Playwright
   # [`method: JSHandle.dispose`]. JSHandles are auto-disposed when their origin frame gets navigated or the parent context
   # gets destroyed.
   # 
-  # JSHandle instances can be used as an argument in [`method: Page.$eval`], [`method: Page.evaluate`] and
+  # JSHandle instances can be used as an argument in [`method: Page.evalOnSelector`], [`method: Page.evaluate`] and
   # [`method: Page.evaluateHandle`] methods.
   class JSHandle < PlaywrightApi
 
@@ -36,12 +36,11 @@ module Playwright
       wrap_impl(@impl.dispose)
     end
 
-    # Returns the return value of `pageFunction`
+    # Returns the return value of `expression`.
     # 
-    # This method passes this handle as the first argument to `pageFunction`.
+    # This method passes this handle as the first argument to `expression`.
     # 
-    # If `pageFunction` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its
-    # value.
+    # If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.
     # 
     # Examples:
     # 
@@ -60,23 +59,23 @@ module Playwright
     # tweet_handle = page.query_selector(".tweet .retweets")
     # assert tweet_handle.evaluate("node => node.innerText") == "10 retweets"
     # ```
-    def evaluate(pageFunction, arg: nil)
-      wrap_impl(@impl.evaluate(unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
-    # Returns the return value of `pageFunction` as in-page object (JSHandle).
+    # Returns the return value of `expression` as a `JSHandle`.
     # 
-    # This method passes this handle as the first argument to `pageFunction`.
+    # This method passes this handle as the first argument to `expression`.
     # 
     # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
-    # in-page object (JSHandle).
+    # `JSHandle`.
     # 
     # If the function passed to the `jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would wait
     # for the promise to resolve and return its value.
     # 
     # See [`method: Page.evaluateHandle`] for more details.
-    def evaluate_handle(pageFunction, arg: nil)
-      wrap_impl(@impl.evaluate_handle(unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # The method returns a map with **own property names** as keys and JSHandle instances for the property values.
@@ -123,27 +122,26 @@ module Playwright
       wrap_impl(@impl.json_value)
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end