playwright-ruby-client 0.0.4 → 0.0.9

data/lib/playwright_api/playwright.rb

@@ -15,18 +15,46 @@ module Playwright
   # })();
   # ```
   # 
-  # By default, the `playwright` NPM package automatically downloads browser executables during installation. The
-  # `playwright-core` NPM package can be used to skip automatic downloads.
+  # ```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()
+  #     page = browser.new_page()
+  #     page.goto("http://example.com")
+  #     # other actions...
+  #     browser.close()
+  # 
+  # with sync_playwright() as playwright:
+  #     run(playwright)
+  # ```
   class Playwright < PlaywrightApi
 
     # This object can be used to launch or connect to Chromium, returning instances of `ChromiumBrowser`.
     def chromium # property
-      wrap_channel_owner(@channel_owner.chromium)
+      wrap_impl(@impl.chromium)
     end
 
-    # Returns a list of devices to be used with [`method: Browser.newContext`] or [`method: Browser.newPage`]. Actual list of
-    # devices can be found in
-    # [src/server/deviceDescriptors.ts](https://github.com/Microsoft/playwright/blob/master/src/server/deviceDescriptors.ts).
+    # Returns a dictionary of devices to be used with [`method: Browser.newContext`] or [`method: Browser.newPage`].
     # 
     #
     # ```js
@@ -44,8 +72,45 @@ module Playwright
     #   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"]
+    #     browser = webkit.launch()
+    #     context = browser.new_context(**iphone)
+    #     page = context.new_page()
+    #     page.goto("http://example.com")
+    #     # other actions...
+    #     browser.close()
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
+    # ```
     def devices # property
-      wrap_channel_owner(@channel_owner.devices)
+      wrap_impl(@impl.devices)
     end
 
     # Playwright methods might throw errors if they are unable to fulfill a request. For example,
@@ -66,34 +131,71 @@ module Playwright
     #   }
     # }
     # ```
+    # 
+    # ```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`.
     def firefox # property
-      wrap_channel_owner(@channel_owner.firefox)
+      wrap_impl(@impl.firefox)
     end
 
-    # Selectors can be used to install custom selector engines. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more information.
+    # 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.')
     end
 
     # This object can be used to launch or connect to WebKit, returning instances of `WebKitBrowser`.
     def webkit # property
-      wrap_channel_owner(@channel_owner.webkit)
+      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.')
+    end
+
+    # @nodoc
+    def electron
+      wrap_impl(@impl.electron)
     end
 
     # @nodoc
     def android
-      wrap_channel_owner(@channel_owner.android)
+      wrap_impl(@impl.android)
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def electron
-      wrap_channel_owner(@channel_owner.electron)
+    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/request.rb

@@ -7,8 +7,8 @@ module Playwright
   # 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.
+  # > 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.
@@ -24,46 +24,42 @@ module Playwright
     #   console.log(request.url() + ' ' + request.failure().errorText);
     # });
     # ```
+    # 
+    # ```py
+    # page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
+    # ```
     def failure
-      raise NotImplementedError.new('failure is not implemented yet.')
+      wrap_impl(@impl.failure)
     end
 
     # Returns the `Frame` that initiated this request.
     def frame
-      raise NotImplementedError.new('frame is not implemented yet.')
+      wrap_impl(@impl.frame)
     end
 
     # An object with HTTP headers associated with the request. All header names are lower-case.
     def headers
-      raise NotImplementedError.new('headers is not implemented yet.')
+      wrap_impl(@impl.headers)
     end
 
     # Whether this request is driving frame's navigation.
     def navigation_request?
-      raise NotImplementedError.new('navigation_request? is not implemented yet.')
+      wrap_impl(@impl.navigation_request?)
     end
 
     # Request's method (GET, POST, etc.)
     def method
-      wrap_channel_owner(@channel_owner.method)
+      wrap_impl(@impl.method)
     end
 
     # Request's post body, if any.
     def post_data
-      raise NotImplementedError.new('post_data is not implemented yet.')
+      wrap_impl(@impl.post_data)
     end
 
     # Request's post body in a binary form, if any.
     def post_data_buffer
-      raise NotImplementedError.new('post_data_buffer is not implemented yet.')
-    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
-      raise NotImplementedError.new('post_data_json is not implemented yet.')
+      wrap_impl(@impl.post_data_buffer)
     end
 
     # Request that was redirected by the server to this one, if any.
@@ -80,6 +76,16 @@ module Playwright
     # console.log(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:
     # 
     #
@@ -87,8 +93,18 @@ module Playwright
     # const response = await page.goto('https://google.com');
     # console.log(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
+    # ```
     def redirected_from
-      raise NotImplementedError.new('redirected_from is not implemented yet.')
+      wrap_impl(@impl.redirected_from)
     end
 
     # New request issued by the browser if the server responded with redirect.
@@ -99,20 +115,24 @@ module Playwright
     # ```js
     # console.log(request.redirectedFrom().redirectedTo() === request); // true
     # ```
+    # 
+    # ```py
+    # assert request.redirected_from.redirected_to == request
+    # ```
     def redirected_to
-      raise NotImplementedError.new('redirected_to is not implemented yet.')
+      wrap_impl(@impl.redirected_to)
     end
 
     # Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the
     # following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`, `eventsource`,
     # `websocket`, `manifest`, `other`.
     def resource_type
-      raise NotImplementedError.new('resource_type is not implemented yet.')
+      wrap_impl(@impl.resource_type)
     end
 
     # Returns the matching `Response` object, or `null` if the response was not received due to error.
     def response
-      raise NotImplementedError.new('response is not implemented yet.')
+      wrap_impl(@impl.response)
     end
 
     # Returns resource timing information for given request. Most of the timing values become available upon the response,
@@ -123,17 +143,59 @@ module Playwright
     # ```js
     # const [request] = await Promise.all([
     #   page.waitForEvent('requestfinished'),
-    #   page.goto(httpsServer.EMPTY_PAGE)
+    #   page.goto('http://example.com')
     # ]);
     # console.log(request.timing());
     # ```
+    # 
+    # ```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)
+    # ```
     def timing
-      raise NotImplementedError.new('timing is not implemented yet.')
+      wrap_impl(@impl.timing)
     end
 
     # URL of the request.
     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 post_data_json
+      wrap_impl(@impl.post_data_json)
+    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/response.rb

@@ -22,13 +22,6 @@ module Playwright
       raise NotImplementedError.new('headers is not implemented yet.')
     end
 
-    # Returns the JSON representation of response body.
-    # 
-    # This method will throw if the response body is not parsable via `JSON.parse`.
-    def json
-      raise NotImplementedError.new('json is not implemented yet.')
-    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.')
@@ -58,5 +51,23 @@ module Playwright
     def url
       raise NotImplementedError.new('url is not implemented yet.')
     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/route.rb

@@ -22,6 +22,32 @@ module Playwright
     #   route.continue({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
+    #     headers = {
+    #         **request.headers,
+    #         "foo": "bar" # set "foo" header
+    #         "origin": None # remove "origin" header
+    #     }
+    #     route.continue(headers=headers)
+    # }
+    # page.route("**/*", handle)
+    # ```
     def continue_(headers: nil, method: nil, postData: nil, url: nil)
       raise NotImplementedError.new('continue_ is not implemented yet.')
     end
@@ -41,14 +67,37 @@ module Playwright
     # });
     # ```
     # 
+    # ```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' }));
     # ```
+    # 
+    # ```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"))
+    # ```
     def fulfill(
           body: nil,
+          bodyBytes: nil,
           contentType: nil,
           headers: nil,
           path: nil,