playwright-ruby-client 0.0.3

data/lib/playwright_api/chromium_browser_context.rb

@@ -0,0 +1,26 @@
+require_relative './browser_context.rb'
+
+module Playwright
+  # Chromium-specific features including background pages, service worker support, etc.
+  #
+  # ```js
+  # const backgroundPage = await context.waitForEvent('backgroundpage');
+  # ```
+  class ChromiumBrowserContext < BrowserContext
+
+    # All existing background pages in the context.
+    def background_pages
+      raise NotImplementedError.new('background_pages is not implemented yet.')
+    end
+
+    # Returns the newly created session.
+    def new_cdp_session(page)
+      raise NotImplementedError.new('new_cdp_session is not implemented yet.')
+    end
+
+    # All existing service workers in the context.
+    def service_workers
+      raise NotImplementedError.new('service_workers is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/console_message.rb

@@ -0,0 +1,22 @@
+module Playwright
+  # ConsoleMessage objects are dispatched by page via the page.on('console') event.
+  class ConsoleMessage < PlaywrightApi
+
+    def args
+      raise NotImplementedError.new('args is not implemented yet.')
+    end
+
+    def location
+      raise NotImplementedError.new('location is not implemented yet.')
+    end
+
+    def text
+      raise NotImplementedError.new('text is not implemented yet.')
+    end
+
+    # One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`, `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`, `'count'`, `'timeEnd'`.
+    def type_text
+      raise NotImplementedError.new('type_text is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/dialog.rb

@@ -0,0 +1,46 @@
+module Playwright
+  # Dialog objects are dispatched by page via the page.on('dialog') event.
+  # An example of using `Dialog` class:
+  #
+  # ```js
+  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
+  # 
+  # (async () => {
+  #   const browser = await chromium.launch();
+  #   const page = await browser.newPage();
+  #   page.on('dialog', async dialog => {
+  #     console.log(dialog.message());
+  #     await dialog.dismiss();
+  #     await browser.close();
+  #   });
+  #   page.evaluate(() => alert('1'));
+  # })();
+  # ```
+  class Dialog < PlaywrightApi
+
+    # Returns when the dialog has been accepted.
+    def accept(promptText: nil)
+      raise NotImplementedError.new('accept is not implemented yet.')
+    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.')
+    end
+
+    # Returns when the dialog has been dismissed.
+    def dismiss
+      raise NotImplementedError.new('dismiss is not implemented yet.')
+    end
+
+    # A message displayed in the dialog.
+    def message
+      raise NotImplementedError.new('message is not implemented yet.')
+    end
+
+    # Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
+    def type_text
+      raise NotImplementedError.new('type_text is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/download.rb

@@ -0,0 +1,54 @@
+module Playwright
+  # Download objects are dispatched by page via the page.on('download') event.
+  # All the downloaded files belonging to the browser context are deleted when the browser context is closed. All downloaded files are deleted when the browser closes.
+  # Download event is emitted once the download starts. Download path becomes available once download completes:
+  #
+  # ```js
+  # const [ download ] = await Promise.all([
+  #   page.waitForEvent('download'), // wait for download to start
+  #   page.click('a')
+  # ]);
+  # // wait for download to complete
+  # const path = await download.path();
+  # ...
+  # ```
+  # 
+  # **NOTE** Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the downloaded content. If `acceptDownloads` is not set or set to `false`, download events are emitted, but the actual download is not performed and user has no access to the downloaded files.
+  class Download < PlaywrightApi
+
+    # Returns readable stream for current download or `null` if download failed.
+    def create_read_stream
+      raise NotImplementedError.new('create_read_stream is not implemented yet.')
+    end
+
+    # Deletes the downloaded file.
+    def delete
+      raise NotImplementedError.new('delete is not implemented yet.')
+    end
+
+    # Returns download error if any.
+    def failure
+      raise NotImplementedError.new('failure is not implemented yet.')
+    end
+
+    # Returns path to the downloaded file in case of successful download.
+    def path
+      raise NotImplementedError.new('path is not implemented yet.')
+    end
+
+    # Saves the download to a user-specified path.
+    def save_as(path)
+      raise NotImplementedError.new('save_as is not implemented yet.')
+    end
+
+    # Returns suggested filename for this download. It is typically computed by the browser from the `Content-Disposition` response header or the `download` attribute. See the spec on whatwg. Different browsers can use different logic for computing it.
+    def suggested_filename
+      raise NotImplementedError.new('suggested_filename is not implemented yet.')
+    end
+
+    # Returns downloaded url.
+    def url
+      raise NotImplementedError.new('url is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/element_handle.rb

@@ -0,0 +1,361 @@
+require_relative './js_handle.rb'
+
+module Playwright
+  # ElementHandle represents an in-page DOM element. ElementHandles can be created with the `page.$(selector)` method.
+  #
+  # ```js
+  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
+  # 
+  # (async () => {
+  #   const browser = await chromium.launch();
+  #   const page = await browser.newPage();
+  #   await page.goto('https://example.com');
+  #   const hrefElement = await page.$('a');
+  #   await hrefElement.click();
+  #   // ...
+  # })();
+  # ```
+  # ElementHandle prevents DOM element from garbage collection unless the handle is disposed with `jsHandle.dispose()`. ElementHandles are auto-disposed when their origin frame gets navigated.
+  # ElementHandle instances can be used as an argument in `page.$eval(selector, pageFunction[, arg])` and `page.evaluate(pageFunction[, arg])` methods.
+  class ElementHandle < JSHandle
+
+    # The method finds an element matching the specified selector in the `ElementHandle`'s subtree. See Working with selectors for more details. If no elements match the selector, returns `null`.
+    def S(selector)
+      raise NotImplementedError.new('S is not implemented yet.')
+    end
+
+    # The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See Working with selectors for more details. If no elements match the selector, returns empty array.
+    def SS(selector)
+      raise NotImplementedError.new('SS is not implemented yet.')
+    end
+
+    # Returns the return value of `pageFunction`
+    # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first argument to `pageFunction`. See 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 tweetHandle = await page.$('.tweet');
+    # expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');
+    # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
+    # ```
+    def Seval(selector, pageFunction, arg: nil)
+      raise NotImplementedError.new('Seval is not implemented yet.')
+    end
+
+    # Returns the return value of `pageFunction`
+    # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of matched elements as a first argument to `pageFunction`. See 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:
+    # ```html
+    # <div class="feed">
+    #   <div class="tweet">Hello!</div>
+    #   <div class="tweet">Hi!</div>
+    # </div>
+    # ```
+    #
+    # ```js
+    # const feedHandle = await page.$('.feed');
+    # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
+    # ```
+    def SSeval(selector, pageFunction, arg: nil)
+      raise NotImplementedError.new('SSeval is not implemented yet.')
+    end
+
+    # This method returns the bounding box of the element, or `null` if the element is not visible. The bounding box is calculated relative to the main frame viewport - which is usually the same as the browser window.
+    # Scrolling affects the returned bonding box, similarly to Element.getBoundingClientRect. That means `x` and/or `y` may be negative.
+    # Elements from child frames return the bounding box relative to the main frame, unlike the Element.getBoundingClientRect.
+    # Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the following snippet should click the center of the element.
+    #
+    # ```js
+    # const box = await elementHandle.boundingBox();
+    # await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    # ```
+    def bounding_box
+      raise NotImplementedError.new('bounding_box is not implemented yet.')
+    end
+
+    # This method checks the element by performing the following steps:
+    # 
+    # 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.
+    # Wait for actionability checks on the element, unless `force` option is set.
+    # Scroll the element into view if needed.
+    # Use page.mouse to click in the center of the element.
+    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # Ensure that the element is now checked. If not, this method rejects.
+    # 
+    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # 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)
+      raise NotImplementedError.new('check is not implemented yet.')
+    end
+
+    # This method clicks the element by performing the following steps:
+    # 
+    # Wait for actionability checks on the element, unless `force` option is set.
+    # Scroll the element into view if needed.
+    # Use page.mouse to click in the center of the element, or the specified `position`.
+    # 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.
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
+    def click(
+          button: nil,
+          clickCount: nil,
+          delay: nil,
+          position: nil,
+          modifiers: nil,
+          force: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      raise NotImplementedError.new('click is not implemented yet.')
+    end
+
+    # Returns the content frame for element handles referencing iframe nodes, or `null` otherwise
+    def content_frame
+      raise NotImplementedError.new('content_frame is not implemented yet.')
+    end
+
+    # This method double clicks the element by performing the following steps:
+    # 
+    # Wait for actionability checks on the element, unless `force` option is set.
+    # Scroll the element into view if needed.
+    # Use page.mouse to double click in the center of the element, or the specified `position`.
+    # 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.
+    # 
+    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
+    # 
+    # **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
+    def dblclick(
+          button: nil,
+          delay: nil,
+          position: nil,
+          modifiers: nil,
+          force: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      raise NotImplementedError.new('dblclick is not implemented yet.')
+    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 element.click().
+    #
+    # ```js
+    # await elementHandle.dispatchEvent('click');
+    # ```
+    # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+    # Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+    # 
+    # DragEvent
+    # FocusEvent
+    # KeyboardEvent
+    # MouseEvent
+    # PointerEvent
+    # TouchEvent
+    # Event
+    # 
+    # You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
+    #
+    # ```js
+    # // Note you can only create DataTransfer in Chromium and Firefox
+    # const dataTransfer = await page.evaluateHandle(() => new DataTransfer());
+    # await elementHandle.dispatchEvent('dragstart', { dataTransfer });
+    # ```
+    def dispatch_event(type, eventInit: nil)
+      raise NotImplementedError.new('dispatch_event is not implemented yet.')
+    end
+
+    # This method waits for actionability checks, focuses the element, fills it and triggers an `input` event after filling. If the element 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.
+    def fill(value, noWaitAfter: nil, timeout: nil)
+      raise NotImplementedError.new('fill is not implemented yet.')
+    end
+
+    # Calls focus on the element.
+    def focus
+      raise NotImplementedError.new('focus is not implemented yet.')
+    end
+
+    # Returns element attribute value.
+    def get_attribute(name)
+      raise NotImplementedError.new('get_attribute is not implemented yet.')
+    end
+
+    # This method hovers over the element by performing the following steps:
+    # 
+    # Wait for actionability checks on the element, unless `force` option is set.
+    # Scroll the element into view if needed.
+    # Use page.mouse to hover over the center of the element, or the specified `position`.
+    # 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.
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError. Passing zero timeout disables this.
+    def hover(position: nil, modifiers: nil, force: nil, timeout: nil)
+      raise NotImplementedError.new('hover is not implemented yet.')
+    end
+
+    # Returns the `element.innerHTML`.
+    def inner_html
+      raise NotImplementedError.new('inner_html is not implemented yet.')
+    end
+
+    # Returns the `element.innerText`.
+    def inner_text
+      raise NotImplementedError.new('inner_text is not implemented yet.')
+    end
+
+    # Returns the frame containing the given element.
+    def owner_frame
+      raise NotImplementedError.new('owner_frame is not implemented yet.')
+    end
+
+    # Focuses the element, and then uses `keyboard.down(key)` and `keyboard.up(key)`.
+    # `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`.
+    # 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.
+    def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
+      raise NotImplementedError.new('press is not implemented yet.')
+    end
+
+    # Returns the buffer with the captured screenshot.
+    # This method waits for the actionability checks, then scrolls element into view before taking a screenshot. If the element is detached from DOM, the method throws an error.
+    def screenshot(
+          path: nil,
+          type: nil,
+          quality: nil,
+          omitBackground: nil,
+          timeout: nil)
+      raise NotImplementedError.new('screenshot is not implemented yet.')
+    end
+
+    # This method waits for actionability checks, then tries to scroll element into view, unless it is completely visible as defined by IntersectionObserver's `ratio`.
+    # Throws when `elementHandle` does not point to an element connected to a Document or a ShadowRoot.
+    def scroll_into_view_if_needed(timeout: nil)
+      raise NotImplementedError.new('scroll_into_view_if_needed is not implemented yet.')
+    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 element is not a `<select>` element, the method throws an error.
+    #
+    # ```js
+    # // single selection matching the value
+    # handle.selectOption('blue');
+    # 
+    # // single selection matching both the value and the label
+    # handle.selectOption({ label: 'Blue' });
+    # 
+    # // multiple selection
+    # handle.selectOption('red', 'green', 'blue');
+    # 
+    # // multiple selection for blue, red and second option
+    # handle.selectOption({ value: 'blue' }, { index: 2 }, 'red');
+    # ```
+    def select_option(values, noWaitAfter: nil, timeout: nil)
+      raise NotImplementedError.new('select_option is not implemented yet.')
+    end
+
+    # This method waits for actionability checks, then focuses the element and selects all its text content.
+    def select_text(timeout: nil)
+      raise NotImplementedError.new('select_text is not implemented yet.')
+    end
+
+    # This method expects `elementHandle` to point to an input element.
+    # Sets the value of the file input to these file paths or files. 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_input_files(files, noWaitAfter: nil, timeout: nil)
+      raise NotImplementedError.new('set_input_files is not implemented yet.')
+    end
+
+    # This method taps the element by performing the following steps:
+    # 
+    # Wait for actionability checks on the element, unless `force` option is set.
+    # Scroll the element into view if needed.
+    # Use page.touchscreen to tap in the center of the element, or the specified `position`.
+    # 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.
+    # When all steps combined have not finished during the specified `timeout`, this method rejects with 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(
+          position: nil,
+          modifiers: nil,
+          force: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      raise NotImplementedError.new('tap_point is not implemented yet.')
+    end
+
+    # Returns the `node.textContent`.
+    def text_content
+      raise NotImplementedError.new('text_content is not implemented yet.')
+    end
+
+    def to_string
+      raise NotImplementedError.new('to_string is not implemented yet.')
+    end
+
+    # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+    # To press a special key, like `Control` or `ArrowDown`, use `elementHandle.press(key[, options])`.
+    #
+    # ```js
+    # await elementHandle.type('Hello'); // Types instantly
+    # await elementHandle.type('World', {delay: 100}); // Types slower, like a user
+    # ```
+    # An example of typing into a text field and then submitting the form:
+    #
+    # ```js
+    # const elementHandle = await page.$('input');
+    # await elementHandle.type('some text');
+    # await elementHandle.press('Enter');
+    # ```
+    def type_text(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      raise NotImplementedError.new('type_text is not implemented yet.')
+    end
+
+    # This method checks the element by performing the following steps:
+    # 
+    # Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
+    # Wait for actionability checks on the element, unless `force` option is set.
+    # Scroll the element into view if needed.
+    # Use page.mouse to click in the center of the element.
+    # Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+    # Ensure that the element is now unchecked. If not, this method rejects.
+    # 
+    # If the element is detached from the DOM at any moment during the action, this method rejects.
+    # 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)
+      raise NotImplementedError.new('uncheck is not implemented yet.')
+    end
+
+    # Returns the element satisfies the `state`.
+    # Depending on the `state` parameter, this method waits for one of the actionability checks to pass. This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
+    # 
+    # `"visible"` Wait until the element is visible.
+    # `"hidden"` Wait until the element is not visible or not attached. Note that waiting for hidden does not throw when the element detaches.
+    # `"stable"` Wait until the element is both visible and stable.
+    # `"enabled"` Wait until the element is enabled.
+    # `"disabled"` Wait until the element is not enabled.
+    # 
+    # If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
+    def wait_for_element_state(state, timeout: nil)
+      raise NotImplementedError.new('wait_for_element_state is not implemented yet.')
+    end
+
+    # Returns element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or `detached`.
+    # Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+    #
+    # ```js
+    # await page.setContent(`<div><span></span></div>`);
+    # const div = await page.$('div');
+    # // Waiting for the 'span' selector relative to the div.
+    # const span = await div.waitForSelector('span', { state: 'attached' });
+    # ```
+    # 
+    # **NOTE** This method does not work across navigations, use `page.waitForSelector(selector[, options])` instead.
+    def wait_for_selector(selector, state: nil, timeout: nil)
+      raise NotImplementedError.new('wait_for_selector is not implemented yet.')
+    end
+  end
+end