playwright-ruby-client 0.6.0 → 0.6.5

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,28 +12,10 @@ module Playwright
   #     page.goto("http://example.com")
   #     # other actions...
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
-  # ```csharp
-  # using Microsoft.Playwright;
-  # using System.Threading.Tasks;
-  # 
-  # class PlaywrightExample
-  # {
-  #     public static async Task Main()
-  #     {
-  #         using var playwright = await Playwright.CreateAsync();
-  #         await using var browser = await playwright.Chromium.LaunchAsync();
-  #         var page = await browser.NewPageAsync();
-  # 
-  #         await page.GotoAsync("https://www.microsoft.com");
-  #         // other actions...
-  #     }
-  # }
-  # ```
   class Playwright < PlaywrightApi
 
     # This object can be used to launch or connect to Chromium, returning instances of `Browser`.
@@ -90,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"]
@@ -140,7 +37,7 @@ module Playwright
     #     page.goto("http://example.com")
     #     # other actions...
     #     browser.close()
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
@@ -166,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
@@ -194,12 +91,6 @@ module Playwright
       wrap_impl(@impl.electron)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -212,6 +103,12 @@ module Playwright
       event_emitter_proxy.on(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/request.rb

@@ -3,44 +3,24 @@ 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))
     # ```
-    # 
-    # ```csharp
-    # page.RequestFailed += (_, request) =>
-    # {
-    #     Console.WriteLine(request.Failure);
-    # };
-    # ```
     def failure
       wrap_impl(@impl.failure)
     end
@@ -76,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
@@ -84,90 +64,35 @@ 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"
     # ```
-    # 
-    # ```csharp
-    # var response = await page.GotoAsync("http://www.microsoft.com");
-    # Console.WriteLine(response.Request.RedirectedFrom?.Url); // http://www.microsoft.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
     # ```
-    # 
-    # ```csharp
-    # var response = await page.GotoAsync("https://www.google.com");
-    # Console.WriteLine(response.Request.RedirectedFrom?.Url); // null
-    # ```
     def redirected_from
       wrap_impl(@impl.redirected_from)
     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
     # ```
-    # 
-    # ```csharp
-    # Console.WriteLine(request.RedirectedFrom?.RedirectedTo == request); // True
-    # ```
     def redirected_to
       wrap_impl(@impl.redirected_to)
     end
@@ -187,44 +112,13 @@ 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")
     # request = request_info.value
     # print(request.timing)
     # ```
-    # 
-    # ```csharp
-    # var waitForEventTask = page.WaitForEventAsync(PageEvent.RequestFinished);
-    # await page.GotoAsync("https://www.microsoft.com");
-    # var request = await waitForEventTask;
-    # Console.WriteLine(request.Timing.ResponseEnd);
-    # ```
     def timing
       wrap_impl(@impl.timing)
     end
@@ -234,12 +128,6 @@ module Playwright
       wrap_impl(@impl.url)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -252,6 +140,12 @@ module Playwright
       event_emitter_proxy.on(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

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)
@@ -69,12 +69,6 @@ module Playwright
       wrap_impl(@impl.ok?)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -87,6 +81,12 @@ module Playwright
       event_emitter_proxy.on(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

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
@@ -58,87 +22,26 @@ module Playwright
     # }
     # page.route("**/*", handle)
     # ```
-    # 
-    # ```csharp
-    # await page.RouteAsync("**/*", route =>
-    # {
-    #     var headers = new Dictionary<string, string>(route.Request.Headers) { { "foo", "bar" } };
-    #     headers.Remove("origin");
-    #     route.ContinueAsync(headers);
-    # });
-    # ```
     def continue(headers: nil, method: nil, postData: nil, url: nil)
       wrap_impl(@impl.continue(headers: unwrap_impl(headers), method: unwrap_impl(method), postData: unwrap_impl(postData), url: unwrap_impl(url)))
     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!"))
     # ```
-    # 
-    # ```csharp
-    # await page.RouteAsync("**/*", route => route.FulfillAsync(
-    #     status: 404,
-    #     contentType: "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"))
     # ```
-    # 
-    # ```csharp
-    # await page.RouteAsync("**/xhr_endpoint", route => route.FulfillAsync(path: "mock_data.json"));
-    # ```
     def fulfill(
           body: nil,
           contentType: nil,
@@ -153,12 +56,6 @@ module Playwright
       wrap_impl(@impl.request)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -171,6 +68,12 @@ module Playwright
       event_emitter_proxy.on(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end