playwright-ruby-client 0.5.8 → 0.6.2

data/lib/playwright_api/playwright.rb

@@ -1,58 +1,10 @@
 module Playwright
   # Playwright module provides a method to launch a browser instance. The following is a typical example of using Playwright
   # to drive automation:
-  # 
   #
-  # ```js
-  # const { chromium, firefox, webkit } = require('playwright');
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();  // Or 'firefox' or 'webkit'.
-  #   const page = await browser.newPage();
-  #   await page.goto('http://example.com');
-  #   // other actions...
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```java
-  # import com.microsoft.playwright.*;
-  # 
-  # public class Example {
-  #   public static void main(String[] args) {
-  #     try (Playwright playwright = Playwright.create()) {
-  #       BrowserType chromium = playwright.chromium();
-  #       Browser browser = chromium.launch();
-  #       Page page = browser.newPage();
-  #       page.navigate("http://example.com");
-  #       // other actions...
-  #       browser.close();
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium # or "firefox" or "webkit".
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     await page.goto("http://example.com")
-  #     # other actions...
-  #     await browser.close()
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
   # from playwright.sync_api import sync_playwright
-  # 
+  #
   # def run(playwright):
   #     chromium = playwright.chromium # or "firefox" or "webkit".
   #     browser = chromium.launch()
@@ -60,7 +12,7 @@ module Playwright
   #     page.goto("http://example.com")
   #     # other actions...
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
@@ -72,47 +24,10 @@ module Playwright
     end
 
     # Returns a dictionary of devices to be used with [`method: Browser.newContext`] or [`method: Browser.newPage`].
-    # 
     #
-    # ```js
-    # const { webkit, devices } = require('playwright');
-    # const iPhone = devices['iPhone 6'];
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch();
-    #   const context = await browser.newContext({
-    #     ...iPhone
-    #   });
-    #   const page = await context.newPage();
-    #   await page.goto('http://example.com');
-    #   // other actions...
-    #   await browser.close();
-    # })();
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # from playwright.async_api import async_playwright
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     iphone = playwright.devices["iPhone 6"]
-    #     browser = await webkit.launch()
-    #     context = await browser.new_context(**iphone)
-    #     page = await context.new_page()
-    #     await page.goto("http://example.com")
-    #     # other actions...
-    #     await browser.close()
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
     # ```python sync
     # from playwright.sync_api import sync_playwright
-    # 
+    #
     # def run(playwright):
     #     webkit = playwright.webkit
     #     iphone = playwright.devices["iPhone 6"]
@@ -122,7 +37,7 @@ module Playwright
     #     page.goto("http://example.com")
     #     # other actions...
     #     browser.close()
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
@@ -148,18 +63,18 @@ module Playwright
 
     # Terminates this instance of Playwright in case it was created bypassing the Python context manager. This is useful in
     # REPL applications.
-    # 
+    #
     # ```py
     # >>> from playwright.sync_api import sync_playwright
-    # 
+    #
     # >>> playwright = sync_playwright().start()
-    # 
+    #
     # >>> browser = playwright.chromium.launch()
     # >>> page = browser.new_page()
     # >>> page.goto("http://whatsmyuseragent.org/")
     # >>> page.screenshot(path="example.png")
     # >>> browser.close()
-    # 
+    #
     # >>> playwright.stop()
     # ```
     def stop

data/lib/playwright_api/request.rb

@@ -3,34 +3,21 @@ module Playwright
   # - [`event: Page.request`] emitted when the request is issued by the page.
   # - [`event: Page.response`] emitted when/if the response status and headers are received for the request.
   # - [`event: Page.requestFinished`] emitted when the response body is downloaded and the request is complete.
-  # 
+  #
   # If request fails at some point, then instead of `'requestfinished'` event (and possibly instead of 'response' event),
   # the  [`event: Page.requestFailed`] event is emitted.
-  # 
+  #
   # > NOTE: HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will
   # complete with `'requestfinished'` event.
-  # 
+  #
   # If request gets a 'redirect' response, the request is successfully finished with the 'requestfinished' event, and a new
   # request is  issued to a redirected url.
   class Request < PlaywrightApi
 
     # The method returns `null` unless this request has failed, as reported by `requestfailed` event.
-    # 
+    #
     # Example of logging of all the failed requests:
-    # 
     #
-    # ```js
-    # page.on('requestfailed', request => {
-    #   console.log(request.url() + ' ' + request.failure().errorText);
-    # });
-    # ```
-    # 
-    # ```java
-    # page.onRequestFailed(request -> {
-    #   System.out.println(request.url() + " " + request.failure());
-    # });
-    # ```
-    # 
     # ```py
     # page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
     # ```
@@ -69,7 +56,7 @@ module Playwright
     end
 
     # Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.
-    # 
+    #
     # When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned.
     # Otherwise it will be parsed as JSON.
     def post_data_json
@@ -77,52 +64,20 @@ module Playwright
     end
 
     # Request that was redirected by the server to this one, if any.
-    # 
+    #
     # When the server responds with a redirect, Playwright creates a new `Request` object. The two requests are connected by
     # `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
     # construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
-    # 
+    #
     # For example, if the website `http://example.com` redirects to `https://example.com`:
-    # 
     #
-    # ```js
-    # const response = await page.goto('http://example.com');
-    # console.log(response.request().redirectedFrom().url()); // 'http://example.com'
-    # ```
-    # 
-    # ```java
-    # Response response = page.navigate("http://example.com");
-    # System.out.println(response.request().redirectedFrom().url()); // "http://example.com"
-    # ```
-    # 
-    # ```python async
-    # response = await page.goto("http://example.com")
-    # print(response.request.redirected_from.url) # "http://example.com"
-    # ```
-    # 
     # ```python sync
     # response = page.goto("http://example.com")
     # print(response.request.redirected_from.url) # "http://example.com"
     # ```
-    # 
+    #
     # If the website `https://google.com` has no redirects:
-    # 
     #
-    # ```js
-    # const response = await page.goto('https://google.com');
-    # console.log(response.request().redirectedFrom()); // null
-    # ```
-    # 
-    # ```java
-    # Response response = page.navigate("https://google.com");
-    # System.out.println(response.request().redirectedFrom()); // null
-    # ```
-    # 
-    # ```python async
-    # response = await page.goto("https://google.com")
-    # print(response.request.redirected_from) # None
-    # ```
-    # 
     # ```python sync
     # response = page.goto("https://google.com")
     # print(response.request.redirected_from) # None
@@ -132,18 +87,9 @@ module Playwright
     end
 
     # New request issued by the browser if the server responded with redirect.
-    # 
+    #
     # This method is the opposite of [`method: Request.redirectedFrom`]:
-    # 
     #
-    # ```js
-    # console.log(request.redirectedFrom().redirectedTo() === request); // true
-    # ```
-    # 
-    # ```java
-    # System.out.println(request.redirectedFrom().redirectedTo() == request); // true
-    # ```
-    # 
     # ```py
     # assert request.redirected_from.redirected_to == request
     # ```
@@ -166,31 +112,7 @@ module Playwright
     # Returns resource timing information for given request. Most of the timing values become available upon the response,
     # `responseEnd` becomes available when request finishes. Find more information at
     # [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).
-    # 
     #
-    # ```js
-    # const [request] = await Promise.all([
-    #   page.waitForEvent('requestfinished'),
-    #   page.goto('http://example.com')
-    # ]);
-    # console.log(request.timing());
-    # ```
-    # 
-    # ```java
-    # page.onRequestFinished(request -> {
-    #   Timing timing = request.timing();
-    #   System.out.println(timing.responseEnd - timing.startTime);
-    # });
-    # page.navigate("http://example.com");
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_event("requestfinished") as request_info:
-    #     await page.goto("http://example.com")
-    # request = await request_info.value
-    # print(request.timing)
-    # ```
-    # 
     # ```python sync
     # with page.expect_event("requestfinished") as request_info:
     #     page.goto("http://example.com")

data/lib/playwright_api/response.rb

@@ -23,7 +23,7 @@ module Playwright
     end
 
     # Returns the JSON representation of response body.
-    # 
+    #
     # This method will throw if the response body is not parsable via `JSON.parse`.
     def json
       wrap_impl(@impl.json)

data/lib/playwright_api/route.rb

@@ -9,43 +9,7 @@ module Playwright
     end
 
     # Continues route's request with optional overrides.
-    # 
     #
-    # ```js
-    # await page.route('**/*', (route, request) => {
-    #   // Override headers
-    #   const headers = {
-    #     ...request.headers(),
-    #     foo: 'bar', // set "foo" header
-    #     origin: undefined, // remove "origin" header
-    #   };
-    #   route.continue({headers});
-    # });
-    # ```
-    # 
-    # ```java
-    # page.route("**/*", route -> {
-    #   // Override headers
-    #   Map<String, String> headers = new HashMap<>(route.request().headers());
-    #   headers.put("foo", "bar"); // set "foo" header
-    #   headers.remove("origin"); // remove "origin" header
-    #   route.resume(new Route.ResumeOptions().setHeaders(headers));
-    # });
-    # ```
-    # 
-    # ```python async
-    # async def handle(route, request):
-    #     # override headers
-    #     headers = {
-    #         **request.headers,
-    #         "foo": "bar" # set "foo" header
-    #         "origin": None # remove "origin" header
-    #     }
-    #     await route.continue(headers=headers)
-    # }
-    # await page.route("**/*", handle)
-    # ```
-    # 
     # ```python sync
     # def handle(route, request):
     #     # override headers
@@ -54,7 +18,7 @@ module Playwright
     #         "foo": "bar" # set "foo" header
     #         "origin": None # remove "origin" header
     #     }
-    #     route.continue(headers=headers)
+    #     route.continue_(headers=headers)
     # }
     # page.route("**/*", handle)
     # ```
@@ -63,59 +27,18 @@ module Playwright
     end
 
     # Fulfills route's request with given response.
-    # 
+    #
     # An example of fulfilling all requests with 404 responses:
-    # 
     #
-    # ```js
-    # await page.route('**/*', route => {
-    #   route.fulfill({
-    #     status: 404,
-    #     contentType: 'text/plain',
-    #     body: 'Not Found!'
-    #   });
-    # });
-    # ```
-    # 
-    # ```java
-    # page.route("**/*", route -> {
-    #   route.fulfill(new Route.FulfillOptions()
-    #     .setStatus(404)
-    #     .setContentType("text/plain")
-    #     .setBody("Not Found!"));
-    # });
-    # ```
-    # 
-    # ```python async
-    # await page.route("**/*", lambda route: route.fulfill(
-    #     status=404,
-    #     content_type="text/plain",
-    #     body="not found!"))
-    # ```
-    # 
     # ```python sync
     # page.route("**/*", lambda route: route.fulfill(
     #     status=404,
     #     content_type="text/plain",
     #     body="not found!"))
     # ```
-    # 
+    #
     # An example of serving static file:
-    # 
     #
-    # ```js
-    # await page.route('**/xhr_endpoint', route => route.fulfill({ path: 'mock_data.json' }));
-    # ```
-    # 
-    # ```java
-    # page.route("**/xhr_endpoint", route -> route.fulfill(
-    #   new Route.FulfillOptions().setPath(Paths.get("mock_data.json")));
-    # ```
-    # 
-    # ```python async
-    # await page.route("**/xhr_endpoint", lambda route: route.fulfill(path="mock_data.json"))
-    # ```
-    # 
     # ```python sync
     # page.route("**/xhr_endpoint", lambda route: route.fulfill(path="mock_data.json"))
     # ```

data/lib/playwright_api/selectors.rb

@@ -4,73 +4,7 @@ module Playwright
   class Selectors < PlaywrightApi
 
     # An example of registering selector engine that queries elements based on a tag name:
-    # 
     #
-    # ```js
-    # const { selectors, firefox } = require('playwright');  // Or 'chromium' or 'webkit'.
-    # 
-    # (async () => {
-    #   // Must be a function that evaluates to a selector engine instance.
-    #   const createTagNameEngine = () => ({
-    #     // Returns the first element matching given selector in the root's subtree.
-    #     query(root, selector) {
-    #       return root.querySelector(selector);
-    #     },
-    # 
-    #     // Returns all elements matching given selector in the root's subtree.
-    #     queryAll(root, selector) {
-    #       return Array.from(root.querySelectorAll(selector));
-    #     }
-    #   });
-    # 
-    #   // Register the engine. Selectors will be prefixed with "tag=".
-    #   await selectors.register('tag', createTagNameEngine);
-    # 
-    #   const browser = await firefox.launch();
-    #   const page = await browser.newPage();
-    #   await page.setContent(`<div><button>Click me</button></div>`);
-    # 
-    #   // Use the selector prefixed with its name.
-    #   const button = await page.$('tag=button');
-    #   // Combine it with other selector engines.
-    #   await page.click('tag=div >> text="Click me"');
-    #   // Can use it in any methods supporting selectors.
-    #   const buttonCount = await page.$$eval('tag=button', buttons => buttons.length);
-    # 
-    #   await browser.close();
-    # })();
-    # ```
-    # 
-    # ```java
-    # // Script that evaluates to a selector engine instance.
-    # String createTagNameEngine = "{\n" +
-    #   "  // Returns the first element matching given selector in the root's subtree.\n" +
-    #   "  query(root, selector) {\n" +
-    #   "    return root.querySelector(selector);\n" +
-    #   "  },\n" +
-    #   "  // Returns all elements matching given selector in the root's subtree.\n" +
-    #   "  queryAll(root, selector) {\n" +
-    #   "    return Array.from(root.querySelectorAll(selector));\n" +
-    #   "  }\n" +
-    #   "}";
-    # // Register the engine. Selectors will be prefixed with "tag=".
-    # playwright.selectors().register("tag", createTagNameEngine);
-    # Browser browser = playwright.firefox().launch();
-    # Page page = browser.newPage();
-    # page.setContent("<div><button>Click me</button></div>");
-    # // Use the selector prefixed with its name.
-    # ElementHandle button = page.querySelector("tag=button");
-    # // Combine it with other selector engines.
-    # page.click("tag=div >> text=\"Click me\"");
-    # // Can use it in any methods supporting selectors.
-    # int buttonCount = (int) page.evalOnSelectorAll("tag=button", "buttons => buttons.length");
-    # browser.close();
-    # ```
-    # 
-    # ```python async
-    # # FIXME: add snippet
-    # ```
-    # 
     # ```python sync
     # # FIXME: add snippet
     # ```