playwright-ruby-client 0.1.0 → 0.5.3

data/lib/playwright_api/playwright.rb

@@ -15,6 +15,23 @@ module Playwright
   # })();
   # ```
   # 
+  # ```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
@@ -49,7 +66,7 @@ module Playwright
   # ```
   class Playwright < PlaywrightApi
 
-    # This object can be used to launch or connect to Chromium, returning instances of `ChromiumBrowser`.
+    # This object can be used to launch or connect to Chromium, returning instances of `Browser`.
     def chromium # property
       wrap_impl(@impl.chromium)
     end
@@ -113,43 +130,7 @@ module Playwright
       wrap_impl(@impl.devices)
     end
 
-    # Playwright methods might throw errors if they are unable to fulfill a request. For example,
-    # [`method: Page.waitForSelector`] might fail if the selector doesn't match any nodes during the given timeframe.
-    # 
-    # For certain types of errors Playwright uses specific error classes. These classes are available via
-    # [`playwright.errors`](#playwrighterrors).
-    # 
-    # An example of handling a timeout error:
-    # 
-    #
-    # ```js
-    # try {
-    #   await page.waitForSelector('.foo');
-    # } catch (e) {
-    #   if (e instanceof playwright.errors.TimeoutError) {
-    #     // Do something if this is a timeout.
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # try:
-    #     await page.wait_for_selector(".foo")
-    # except TimeoutError as e:
-    #     # do something if this is a timeout.
-    # ```
-    # 
-    # ```python sync
-    # try:
-    #     page.wait_for_selector(".foo")
-    # except TimeoutError as e:
-    #     # do something if this is a timeout.
-    # ```
-    def errors # property
-      raise NotImplementedError.new('errors is not implemented yet.')
-    end
-
-    # This object can be used to launch or connect to Firefox, returning instances of `FirefoxBrowser`.
+    # This object can be used to launch or connect to Firefox, returning instances of `Browser`.
     def firefox # property
       wrap_impl(@impl.firefox)
     end
@@ -157,27 +138,42 @@ module Playwright
     # Selectors can be used to install custom selector engines. See [Working with selectors](./selectors.md) for more
     # information.
     def selectors # property
-      raise NotImplementedError.new('selectors is not implemented yet.')
+      wrap_impl(@impl.selectors)
     end
 
-    # This object can be used to launch or connect to WebKit, returning instances of `WebKitBrowser`.
+    # This object can be used to launch or connect to WebKit, returning instances of `Browser`.
     def webkit # property
       wrap_impl(@impl.webkit)
     end
 
-    # Terminates this instance of Playwright, will also close all created browsers if they are still running.
-    def close
-      raise NotImplementedError.new('close is not implemented yet.')
+    # 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
+      raise NotImplementedError.new('stop is not implemented yet.')
     end
 
     # @nodoc
-    def electron
-      wrap_impl(@impl.electron)
+    def android
+      wrap_impl(@impl.android)
     end
 
     # @nodoc
-    def android
-      wrap_impl(@impl.android)
+    def electron
+      wrap_impl(@impl.electron)
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/request.rb

@@ -2,10 +2,10 @@ module Playwright
   # Whenever the page sends a request for a network resource the following sequence of events are emitted by `Page`:
   # - [`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.
+  # - [`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.
+  # 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.
@@ -25,6 +25,12 @@ module Playwright
     # });
     # ```
     # 
+    # ```java
+    # page.onRequestFailed(request -> {
+    #   System.out.println(request.url() + " " + request.failure());
+    # });
+    # ```
+    # 
     # ```py
     # page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
     # ```
@@ -62,6 +68,14 @@ module Playwright
       wrap_impl(@impl.post_data_buffer)
     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
+      wrap_impl(@impl.post_data_json)
+    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
@@ -76,6 +90,11 @@ module Playwright
     # 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"
@@ -94,6 +113,11 @@ module Playwright
     # 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
@@ -116,6 +140,10 @@ module Playwright
     # console.log(request.redirectedFrom().redirectedTo() === request); // true
     # ```
     # 
+    # ```java
+    # System.out.println(request.redirectedFrom().redirectedTo() == request); // true
+    # ```
+    # 
     # ```py
     # assert request.redirected_from.redirected_to == request
     # ```
@@ -148,6 +176,14 @@ module Playwright
     # 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")
@@ -170,16 +206,6 @@ module Playwright
       wrap_impl(@impl.url)
     end
 
-    # @nodoc
-    def post_data_json
-      wrap_impl(@impl.post_data_json)
-    end
-
-    # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)

data/lib/playwright_api/response.rb

@@ -4,52 +4,69 @@ module Playwright
 
     # Returns the buffer with response body.
     def body
-      raise NotImplementedError.new('body is not implemented yet.')
+      wrap_impl(@impl.body)
     end
 
     # Waits for this response to finish, returns failure error if request failed.
     def finished
-      raise NotImplementedError.new('finished is not implemented yet.')
+      wrap_impl(@impl.finished)
     end
 
     # Returns the `Frame` that initiated this response.
     def frame
-      raise NotImplementedError.new('frame is not implemented yet.')
+      wrap_impl(@impl.frame)
     end
 
     # Returns the object with HTTP headers associated with the response. All header names are lower-case.
     def headers
-      raise NotImplementedError.new('headers is not implemented yet.')
+      wrap_impl(@impl.headers)
+    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)
     end
 
     # Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
     def ok
-      raise NotImplementedError.new('ok is not implemented yet.')
+      wrap_impl(@impl.ok)
     end
 
     # Returns the matching `Request` object.
     def request
-      raise NotImplementedError.new('request is not implemented yet.')
+      wrap_impl(@impl.request)
     end
 
     # Contains the status code of the response (e.g., 200 for a success).
     def status
-      raise NotImplementedError.new('status is not implemented yet.')
+      wrap_impl(@impl.status)
     end
 
     # Contains the status text of the response (e.g. usually an "OK" for a success).
     def status_text
-      raise NotImplementedError.new('status_text is not implemented yet.')
+      wrap_impl(@impl.status_text)
     end
 
     # Returns the text representation of response body.
     def text
-      raise NotImplementedError.new('text is not implemented yet.')
+      wrap_impl(@impl.text)
     end
 
     # Contains the URL of the response.
     def url
-      raise NotImplementedError.new('url is not implemented yet.')
+      wrap_impl(@impl.url)
+    end
+
+    # @nodoc
+    def after_initialize
+      wrap_impl(@impl.after_initialize)
+    end
+
+    # @nodoc
+    def ok?
+      wrap_impl(@impl.ok?)
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/route.rb

@@ -5,7 +5,7 @@ module Playwright
 
     # Aborts the route's request.
     def abort(errorCode: nil)
-      raise NotImplementedError.new('abort is not implemented yet.')
+      wrap_impl(@impl.abort(errorCode: unwrap_impl(errorCode)))
     end
 
     # Continues route's request with optional overrides.
@@ -23,6 +23,16 @@ module Playwright
     # });
     # ```
     # 
+    # ```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
@@ -48,8 +58,8 @@ module Playwright
     # }
     # page.route("**/*", handle)
     # ```
-    def continue_(headers: nil, method: nil, postData: nil, url: nil)
-      raise NotImplementedError.new('continue_ is not implemented yet.')
+    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.
@@ -67,6 +77,15 @@ module Playwright
     # });
     # ```
     # 
+    # ```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,
@@ -88,6 +107,11 @@ module Playwright
     # 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"))
     # ```
@@ -97,17 +121,38 @@ module Playwright
     # ```
     def fulfill(
           body: nil,
-          bodyBytes: nil,
           contentType: nil,
           headers: nil,
           path: nil,
           status: nil)
-      raise NotImplementedError.new('fulfill is not implemented yet.')
+      wrap_impl(@impl.fulfill(body: unwrap_impl(body), contentType: unwrap_impl(contentType), headers: unwrap_impl(headers), path: unwrap_impl(path), status: unwrap_impl(status)))
     end
 
     # A request to be routed.
     def request
-      raise NotImplementedError.new('request is not implemented yet.')
+      wrap_impl(@impl.request)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      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
   end
 end

data/lib/playwright_api/selectors.rb

@@ -41,6 +41,32 @@ module Playwright
     # })();
     # ```
     # 
+    # ```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
     # ```
@@ -48,8 +74,8 @@ module Playwright
     # ```python sync
     # # FIXME: add snippet
     # ```
-    def register(name, script, contentScript: nil)
-      raise NotImplementedError.new('register is not implemented yet.')
+    def register(name, contentScript: nil, path: nil, script: nil)
+      wrap_impl(@impl.register(unwrap_impl(name), contentScript: unwrap_impl(contentScript), path: unwrap_impl(path), script: unwrap_impl(script)))
     end
 
     # -- inherited from EventEmitter --