playwright-ruby-client 0.0.3 → 0.0.8

data/lib/playwright_api/js_handle.rb

@@ -1,47 +1,86 @@
 module Playwright
-  # JSHandle represents an in-page JavaScript object. JSHandles can be created with the `page.evaluateHandle(pageFunction[, arg])` method.
+  # JSHandle represents an in-page JavaScript object. JSHandles can be created with the [`method: Page.evaluateHandle`]
+  # method.
+  # 
   #
   # ```js
   # const windowHandle = await page.evaluateHandle(() => window);
   # // ...
   # ```
-  # JSHandle prevents the referenced JavaScript object being garbage collected unless the handle is exposed with `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 `page.$eval(selector, pageFunction[, arg])`, `page.evaluate(pageFunction[, arg])` and `page.evaluateHandle(pageFunction[, arg])` methods.
+  # 
+  # ```python async
+  # window_handle = await page.evaluate_handle("window")
+  # # ...
+  # ```
+  # 
+  # ```python sync
+  # window_handle = page.evaluate_handle("window")
+  # # ...
+  # ```
+  # 
+  # JSHandle prevents the referenced JavaScript object being garbage collected unless the handle is exposed with
+  # [`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
+  # [`method: Page.evaluateHandle`] methods.
   class JSHandle < PlaywrightApi
 
-    # Returns either `null` or the object handle itself, if the object handle is an instance of ElementHandle.
+    # Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
     def as_element
-      raise NotImplementedError.new('as_element is not implemented yet.')
+      wrap_impl(@impl.as_element)
     end
 
     # The `jsHandle.dispose` method stops referencing the element handle.
     def dispose
-      raise NotImplementedError.new('dispose is not implemented yet.')
+      wrap_impl(@impl.dispose)
     end
 
     # Returns the return value of `pageFunction`
+    # 
     # This method passes this handle as the first argument to `pageFunction`.
-    # If `pageFunction` returns a Promise, then `handle.evaluate` would wait for the promise to resolve and return its value.
+    # 
+    # If `pageFunction` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its
+    # value.
+    # 
     # Examples:
+    # 
     #
     # ```js
     # const tweetHandle = await page.$('.tweet .retweets');
-    # expect(await tweetHandle.evaluate((node, suffix) => node.innerText, ' retweets')).toBe('10 retweets');
+    # expect(await tweetHandle.evaluate(node => node.innerText)).toBe('10 retweets');
+    # ```
+    # 
+    # ```python async
+    # tweet_handle = await page.query_selector(".tweet .retweets")
+    # assert await tweet_handle.evaluate("node => node.innerText") == "10 retweets"
+    # ```
+    # 
+    # ```python sync
+    # tweet_handle = page.query_selector(".tweet .retweets")
+    # assert tweet_handle.evaluate("node => node.innerText") == "10 retweets"
     # ```
     def evaluate(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate is not implemented yet.')
+      wrap_impl(@impl.evaluate(unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
     end
 
     # Returns the return value of `pageFunction` as in-page object (JSHandle).
+    # 
     # This method passes this handle as the first argument to `pageFunction`.
-    # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns in-page object (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 `page.evaluateHandle(pageFunction[, arg])` for more details.
+    # 
+    # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
+    # in-page object (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)
-      raise NotImplementedError.new('evaluate_handle is not implemented yet.')
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(pageFunction), arg: unwrap_impl(arg)))
     end
 
     # The method returns a map with **own property names** as keys and JSHandle instances for the property values.
+    # 
     #
     # ```js
     # const handle = await page.evaluateHandle(() => ({window, document}));
@@ -50,20 +89,61 @@ module Playwright
     # const documentHandle = properties.get('document');
     # await handle.dispose();
     # ```
+    # 
+    # ```python async
+    # handle = await page.evaluate_handle("{window, document}")
+    # properties = await handle.get_properties()
+    # window_handle = properties.get("window")
+    # document_handle = properties.get("document")
+    # await handle.dispose()
+    # ```
+    # 
+    # ```python sync
+    # handle = page.evaluate_handle("{window, document}")
+    # properties = handle.get_properties()
+    # window_handle = properties.get("window")
+    # document_handle = properties.get("document")
+    # handle.dispose()
+    # ```
     def get_properties
-      raise NotImplementedError.new('get_properties is not implemented yet.')
+      wrap_impl(@impl.get_properties)
     end
+    alias_method :properties, :get_properties
 
     # Fetches a single property from the referenced object.
     def get_property(propertyName)
-      raise NotImplementedError.new('get_property is not implemented yet.')
+      wrap_impl(@impl.get_property(unwrap_impl(propertyName)))
     end
 
     # Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.
     # 
-    # **NOTE** The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an error if the object has circular references.
+    # > NOTE: The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an
+    # error if the object has circular references.
     def json_value
-      raise NotImplementedError.new('json_value is not implemented yet.')
+      wrap_impl(@impl.json_value)
+    end
+
+    # @nodoc
+    def after_initialize
+      wrap_impl(@impl.after_initialize)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
     end
   end
 end

data/lib/playwright_api/keyboard.rb

@@ -1,7 +1,12 @@
 module Playwright
-  # Keyboard provides an api for managing a virtual keyboard. The high level api is `keyboard.type(text[, options])`, which takes raw characters and generates proper keydown, keypress/input, and keyup events on your page.
-  # For finer control, you can use `keyboard.down(key)`, `keyboard.up(key)`, and `keyboard.insertText(text)` to manually fire events as if they were generated from a real keyboard.
+  # Keyboard provides an api for managing a virtual keyboard. The high level api is [`method: Keyboard.type`], which takes
+  # raw characters and generates proper keydown, keypress/input, and keyup events on your page.
+  # 
+  # For finer control, you can use [`method: Keyboard.down`], [`method: Keyboard.up`], and [`method: Keyboard.insertText`]
+  # to manually fire events as if they were generated from a real keyboard.
+  # 
   # An example of holding down `Shift` in order to select and delete some text:
+  # 
   #
   # ```js
   # await page.keyboard.type('Hello World!');
@@ -15,14 +20,52 @@ module Playwright
   # await page.keyboard.press('Backspace');
   # // Result text will end up saying 'Hello!'
   # ```
+  # 
+  # ```python async
+  # await page.keyboard.type("Hello World!")
+  # await page.keyboard.press("ArrowLeft")
+  # await page.keyboard.down("Shift")
+  # for i in range(6):
+  #     await page.keyboard.press("ArrowLeft")
+  # await page.keyboard.up("Shift")
+  # await page.keyboard.press("Backspace")
+  # # result text will end up saying "Hello!"
+  # ```
+  # 
+  # ```python sync
+  # page.keyboard.type("Hello World!")
+  # page.keyboard.press("ArrowLeft")
+  # page.keyboard.down("Shift")
+  # for i in range(6):
+  #     page.keyboard.press("ArrowLeft")
+  # page.keyboard.up("Shift")
+  # page.keyboard.press("Backspace")
+  # # result text will end up saying "Hello!"
+  # ```
+  # 
   # An example of pressing uppercase `A`
+  # 
   #
   # ```js
   # await page.keyboard.press('Shift+KeyA');
   # // or
   # await page.keyboard.press('Shift+A');
   # ```
+  # 
+  # ```python async
+  # await page.keyboard.press("Shift+KeyA")
+  # # or
+  # await page.keyboard.press("Shift+A")
+  # ```
+  # 
+  # ```python sync
+  # page.keyboard.press("Shift+KeyA")
+  # # or
+  # page.keyboard.press("Shift+A")
+  # ```
+  # 
   # An example to trigger select-all with the keyboard
+  # 
   #
   # ```js
   # // on Windows and Linux
@@ -30,39 +73,87 @@ module Playwright
   # // on macOS
   # await page.keyboard.press('Meta+A');
   # ```
+  # 
+  # ```python async
+  # # on windows and linux
+  # await page.keyboard.press("Control+A")
+  # # on mac_os
+  # await page.keyboard.press("Meta+A")
+  # ```
+  # 
+  # ```python sync
+  # # on windows and linux
+  # page.keyboard.press("Control+A")
+  # # on mac_os
+  # page.keyboard.press("Meta+A")
+  # ```
   class Keyboard < PlaywrightApi
 
     # Dispatches a `keydown` event.
-    # `key` can specify the intended keyboardEvent.key value or a single character to generate the text for. A superset of the `key` values can be found here. Examples of the keys are:
-    # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`, `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
-    # Following modification shortcuts are also suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+    # 
+    # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
+    # value or a single character to generate the text for. A superset of the `key` values can be found
+    # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
+    # 
+    # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
+    # `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
+    # 
+    # Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+    # 
     # Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-    # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective texts.
-    # If `key` is a modifier key, `Shift`, `Meta`, `Control`, or `Alt`, subsequent key presses will be sent with that modifier active. To release the modifier key, use `keyboard.up(key)`.
-    # After the key is pressed once, subsequent calls to `keyboard.down(key)` will have repeat set to true. To release the key, use `keyboard.up(key)`.
     # 
-    # **NOTE** Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
+    # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
+    # texts.
+    # 
+    # If `key` is a modifier key, `Shift`, `Meta`, `Control`, or `Alt`, subsequent key presses will be sent with that modifier
+    # active. To release the modifier key, use [`method: Keyboard.up`].
+    # 
+    # After the key is pressed once, subsequent calls to [`method: Keyboard.down`] will have
+    # [repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) set to true. To release the key, use
+    # [`method: Keyboard.up`].
+    # 
+    # > NOTE: Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
     def down(key)
-      raise NotImplementedError.new('down is not implemented yet.')
+      @impl.down(unwrap_impl(key))
     end
 
     # Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
+    # 
     #
     # ```js
     # page.keyboard.insertText('嗨');
     # ```
     # 
-    # **NOTE** Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
+    # ```python async
+    # await page.keyboard.insert_text("嗨")
+    # ```
+    # 
+    # ```python sync
+    # page.keyboard.insert_text("嗨")
+    # ```
+    # 
+    # > NOTE: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
     def insert_text(text)
-      raise NotImplementedError.new('insert_text is not implemented yet.')
+      @impl.insert_text(unwrap_impl(text))
     end
 
-    # `key` can specify the intended keyboardEvent.key value or a single character to generate the text for. A superset of the `key` values can be found here. Examples of the keys are:
-    # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`, `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
-    # Following modification shortcuts are also suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+    # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
+    # value or a single character to generate the text for. A superset of the `key` values can be found
+    # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
+    # 
+    # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
+    # `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
+    # 
+    # Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+    # 
     # Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-    # 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 modifier, modifier is pressed and being held while the subsequent key is being pressed.
+    # 
+    # 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
+    # modifier, modifier is pressed and being held while the subsequent key is being pressed.
+    # 
     #
     # ```js
     # const page = await browser.newPage();
@@ -75,27 +166,64 @@ module Playwright
     # await page.screenshot({ path: 'O.png' });
     # await browser.close();
     # ```
-    # Shortcut for `keyboard.down(key)` and `keyboard.up(key)`.
+    # 
+    # ```python async
+    # page = await browser.new_page()
+    # await page.goto("https://keycode.info")
+    # await page.keyboard.press("a")
+    # await page.screenshot(path="a.png")
+    # await page.keyboard.press("ArrowLeft")
+    # await page.screenshot(path="arrow_left.png")
+    # await page.keyboard.press("Shift+O")
+    # await page.screenshot(path="o.png")
+    # await browser.close()
+    # ```
+    # 
+    # ```python sync
+    # page = browser.new_page()
+    # page.goto("https://keycode.info")
+    # page.keyboard.press("a")
+    # page.screenshot(path="a.png")
+    # page.keyboard.press("ArrowLeft")
+    # page.screenshot(path="arrow_left.png")
+    # page.keyboard.press("Shift+O")
+    # page.screenshot(path="o.png")
+    # browser.close()
+    # ```
+    # 
+    # Shortcut for [`method: Keyboard.down`] and [`method: Keyboard.up`].
     def press(key, delay: nil)
-      raise NotImplementedError.new('press is not implemented yet.')
+      @impl.press(unwrap_impl(key), delay: unwrap_impl(delay))
     end
 
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
-    # To press a special key, like `Control` or `ArrowDown`, use `keyboard.press(key[, options])`.
+    # 
+    # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
+    # 
     #
     # ```js
     # await page.keyboard.type('Hello'); // Types instantly
     # await page.keyboard.type('World', {delay: 100}); // Types slower, like a user
     # ```
     # 
-    # **NOTE** Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
-    def type_text(text, delay: nil)
-      raise NotImplementedError.new('type_text is not implemented yet.')
+    # ```python async
+    # await page.keyboard.type("Hello") # types instantly
+    # await page.keyboard.type("World", delay=100) # types slower, like a user
+    # ```
+    # 
+    # ```python sync
+    # page.keyboard.type("Hello") # types instantly
+    # page.keyboard.type("World", delay=100) # types slower, like a user
+    # ```
+    # 
+    # > NOTE: Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
+    def type(text, delay: nil)
+      @impl.type(unwrap_impl(text), delay: unwrap_impl(delay))
     end
 
     # Dispatches a `keyup` event.
     def up(key)
-      raise NotImplementedError.new('up is not implemented yet.')
+      @impl.up(unwrap_impl(key))
     end
   end
 end

data/lib/playwright_api/mouse.rb

@@ -1,6 +1,8 @@
 module Playwright
   # The Mouse class operates in main-frame CSS pixels relative to the top-left corner of the viewport.
-  # Every `page` object has its own Mouse, accessible with page.mouse.
+  # 
+  # Every `page` object has its own Mouse, accessible with [`property: Page.mouse`].
+  # 
   #
   # ```js
   # // Using ‘page.mouse’ to trace a 100x100 square.
@@ -12,9 +14,31 @@ module Playwright
   # await page.mouse.move(0, 0);
   # await page.mouse.up();
   # ```
+  # 
+  # ```python async
+  # # using ‘page.mouse’ to trace a 100x100 square.
+  # await page.mouse.move(0, 0)
+  # await page.mouse.down()
+  # await page.mouse.move(0, 100)
+  # await page.mouse.move(100, 100)
+  # await page.mouse.move(100, 0)
+  # await page.mouse.move(0, 0)
+  # await page.mouse.up()
+  # ```
+  # 
+  # ```python sync
+  # # using ‘page.mouse’ to trace a 100x100 square.
+  # page.mouse.move(0, 0)
+  # page.mouse.down()
+  # page.mouse.move(0, 100)
+  # page.mouse.move(100, 100)
+  # page.mouse.move(100, 0)
+  # page.mouse.move(0, 0)
+  # page.mouse.up()
+  # ```
   class Mouse < PlaywrightApi
 
-    # Shortcut for `mouse.move(x, y[, options])`, `mouse.down([options])`, `mouse.up([options])`.
+    # Shortcut for [`method: Mouse.move`], [`method: Mouse.down`], [`method: Mouse.up`].
     def click(
           x,
           y,
@@ -24,7 +48,8 @@ module Playwright
       raise NotImplementedError.new('click is not implemented yet.')
     end
 
-    # Shortcut for `mouse.move(x, y[, options])`, `mouse.down([options])`, `mouse.up([options])`, `mouse.down([options])` and `mouse.up([options])`.
+    # Shortcut for [`method: Mouse.move`], [`method: Mouse.down`], [`method: Mouse.up`], [`method: Mouse.down`] and
+    # [`method: Mouse.up`].
     def dblclick(x, y, button: nil, delay: nil)
       raise NotImplementedError.new('dblclick is not implemented yet.')
     end