playwright-ruby-client 0.0.5 → 0.1.0

data/lib/playwright.rb

@@ -10,14 +10,20 @@ require 'concurrent'
 require 'playwright/errors'
 require 'playwright/events'
 require 'playwright/event_emitter'
+require 'playwright/event_emitter_proxy'
 require 'playwright/javascript'
 require 'playwright/utils'
 
+require 'playwright/api_implementation'
 require 'playwright/channel'
 require 'playwright/channel_owner'
+require 'playwright/http_headers'
+require 'playwright/input_files'
 require 'playwright/connection'
+require 'playwright/select_option_values'
 require 'playwright/timeout_settings'
 require 'playwright/transport'
+require 'playwright/url_matcher'
 require 'playwright/version'
 require 'playwright/wait_helper'
 
@@ -33,7 +39,7 @@ module Playwright
 
     playwright_promise = connection.async_wait_for_object_with_known_name('Playwright')
     Thread.new { connection.run }
-    playwright = PlaywrightApi.from_channel_owner(playwright_promise.value!)
+    playwright = PlaywrightApi.wrap(playwright_promise.value!)
     begin
       block.call(playwright)
     ensure

data/lib/playwright/android_input_impl.rb

@@ -0,0 +1,23 @@
+module Playwright
+  define_api_implementation :AndroidInputImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def type(text)
+      @channel.send_message_to_server('inputType', text: text)
+    end
+
+    def press(key)
+      @channel.send_message_to_server('inputPress', key: key)
+    end
+
+    def tap_point(point)
+      @channel.send_message_to_server('inputTap', point: point)
+    end
+
+    def drag(from, to, steps)
+      @channel.send_message_to_server('inputDrag', from: from, to: to, steps: steps)
+    end
+  end
+end

data/lib/playwright/api_implementation.rb

@@ -0,0 +1,18 @@
+module Playwright
+  # Each Impl class include this module.
+  # Used for detecting whether the object is a XXXXImpl or not.
+  module ApiImplementation ; end
+
+  def self.define_api_implementation(class_name, &block)
+    klass = Class.new
+    klass.include(ApiImplementation)
+    klass.class_eval(&block) if block
+    if ::Playwright.const_defined?(class_name)
+      raise ArgumentError.new("Playwright::#{class_name} already exist. Choose another class name.")
+    end
+    ::Playwright.const_set(class_name, klass)
+  end
+end
+
+# load subclasses
+Dir[File.join(__dir__, '*_impl.rb')].each { |f| require f }

data/lib/playwright/channel.rb

@@ -24,5 +24,12 @@ module Playwright
         nil
       end
     end
+
+    # @param method [String]
+    # @param params [Hash]
+    def send_no_reply(method, params)
+      @connection.async_send_message_to_server(@guid, method, params)
+      nil
+    end
   end
 end

data/lib/playwright/channel_owner.rb

@@ -39,13 +39,14 @@ module Playwright
 
     attr_reader :channel
 
-    def dispose
+    # used only from Connection. Not intended for public use. So keep private.
+    private def dispose!
       # Clean up from parent and connection.
       @parent&.send(:delete_object_from_child, @guid)
       @connection.send(:delete_object_from_channel_owner, @guid)
 
       # Dispose all children.
-      @objects.each_value(&:dispose)
+      @objects.each_value { |object| object.send(:dispose!) }
       @objects.clear
     end
 

data/lib/playwright/channel_owners/android.rb

@@ -1,3 +1,12 @@
 module Playwright
-  define_channel_owner :Android
+  define_channel_owner :Android do
+    def after_initialize
+      @timeout_settings = TimeoutSettings.new
+    end
+
+    def devices
+      resp = @channel.send_message_to_server('devices')
+      resp.map { |device| ChannelOwners::AndroidDevice.from(device) }
+    end
+  end
 end

data/lib/playwright/channel_owners/android_device.rb

@@ -0,0 +1,163 @@
+module Playwright
+  define_channel_owner :AndroidDevice do
+    include Utils::PrepareBrowserContextOptions
+
+    def after_initialize
+      @input = AndroidInputImpl.new(@channel)
+    end
+
+    attr_reader :input
+
+    def serial
+      @initializer['serial']
+    end
+
+    def model
+      @initializer['model']
+    end
+
+    private def to_regex(value)
+      case value
+      when nil
+        nil
+      when Regexp
+        value
+      else
+        Regexp.new("^#{value}$")
+      end
+    end
+
+    private def to_selector_channel(selector)
+      {
+        checkable: selector[:checkable],
+        checked: selector[:checked],
+        clazz: to_regex(selector[:clazz]),
+        pkg: to_regex(selector[:pkg]),
+        desc: to_regex(selector[:desc]),
+        res: to_regex(selector[:res]),
+        text: to_regex(selector[:text]),
+        clickable: selector[:clickable],
+        depth: selector[:depth],
+        enabled: selector[:enabled],
+        focusable: selector[:focusable],
+        focused: selector[:focused],
+        hasChild: selector[:hasChild] ? { selector: to_selector_channel(selector[:hasChild][:selector]) } : nil,
+        hasDescendant: selector[:hasDescendant] ? {
+          selector: to_selector_channel(selector[:hasDescendant][:selector]),
+          maxDepth: selector[:hasDescendant][:maxDepth],
+        } : nil,
+        longClickable: selector[:longClickable],
+        scrollable: selector[:scrollable],
+        selected: selector[:selected],
+      }.compact
+    end
+
+    def tap_on(selector, duration: nil, timeout: nil)
+      params = {
+        selector: to_selector_channel(selector),
+        duration: duration,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('tap', params)
+    end
+
+    def info(selector)
+      @channel.send_message_to_server('info', selector: to_selector_channel(selector))
+    end
+
+    def tree
+      @channel.send_message_to_server('tree')
+    end
+
+    def screenshot(path: nil)
+      encoded_binary = @channel.send_message_to_server('screenshot')
+      decoded_binary = Base64.strict_decode64(encoded_binary)
+      if path
+        File.open(path, 'wb') do |f|
+          f.write(decoded_binary)
+        end
+      end
+      decoded_binary
+    end
+
+    def close
+      @channel.send_message_to_server('close')
+      emit(Events::AndroidDevice::Close)
+    end
+
+    def shell(command)
+      resp = @channel.send_message_to_server('shell', command: command)
+      Base64.strict_decode64(resp)
+    end
+
+    def launch_browser(
+          pkg: nil,
+          acceptDownloads: nil,
+          bypassCSP: nil,
+          colorScheme: nil,
+          deviceScaleFactor: nil,
+          extraHTTPHeaders: nil,
+          geolocation: nil,
+          hasTouch: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          isMobile: nil,
+          javaScriptEnabled: nil,
+          locale: nil,
+          logger: nil,
+          offline: nil,
+          permissions: nil,
+          proxy: nil,
+          recordHar: nil,
+          recordVideo: nil,
+          storageState: nil,
+          timezoneId: nil,
+          userAgent: nil,
+          videoSize: nil,
+          videosPath: nil,
+          viewport: nil,
+          &block)
+      params = {
+        pkg: pkg,
+        acceptDownloads: acceptDownloads,
+        bypassCSP: bypassCSP,
+        colorScheme: colorScheme,
+        deviceScaleFactor: deviceScaleFactor,
+        extraHTTPHeaders: extraHTTPHeaders,
+        geolocation: geolocation,
+        hasTouch: hasTouch,
+        httpCredentials: httpCredentials,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        isMobile: isMobile,
+        javaScriptEnabled: javaScriptEnabled,
+        locale: locale,
+        logger: logger,
+        offline: offline,
+        permissions: permissions,
+        proxy: proxy,
+        recordHar: recordHar,
+        recordVideo: recordVideo,
+        storageState: storageState,
+        timezoneId: timezoneId,
+        userAgent: userAgent,
+        videoSize: videoSize,
+        videosPath: videosPath,
+        viewport: viewport,
+      }.compact
+      prepare_browser_context_options(params)
+
+      resp = @channel.send_message_to_server('launchBrowser', params)
+      context = ChannelOwners::BrowserContext.from(resp)
+
+      if block
+        begin
+          block.call(context)
+        ensure
+          context.close
+        end
+      else
+        context
+      end
+    end
+  end
+end

data/lib/playwright/channel_owners/browser.rb

@@ -2,6 +2,7 @@ module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser.py
   define_channel_owner :Browser do
     include Utils::Errors::SafeCloseError
+    include Utils::PrepareBrowserContextOptions
 
     def after_initialize
       @contexts = Set.new
@@ -16,26 +17,25 @@ module Playwright
       @connected
     end
 
-    def new_context(**options)
+    def new_context(**options, &block)
       params = options.dup
-      # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
-      if params[:viewport] == 0
-        params.delete(:viewport)
-        params[:noDefaultViewport] = true
-      end
-      if params[:extraHTTPHeaders]
-        # TODO
-      end
-      if params[:storageState].is_a?(String)
-        params[:storageState] = JSON.parse(File.read(params[:storageState]))
-      end
+      prepare_browser_context_options(params)
 
       resp = @channel.send_message_to_server('newContext', params.compact)
       context = ChannelOwners::BrowserContext.from(resp)
       @contexts << context
       context.browser = self
       context.options = params
-      context
+
+      if block
+        begin
+          block.call(context)
+        ensure
+          context.close
+        end
+      else
+        context
+      end
     end
 
     def new_page(**options)

data/lib/playwright/channel_owners/browser_context.rb

@@ -8,7 +8,10 @@ module Playwright
       @pages = Set.new
 
       @channel.once('close', ->(_) { on_close })
-      @channel.on('page', ->(hash) { on_page(ChannelOwners::Page.from(hash['page']) )})
+      @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
+      @channel.on('route', ->(params) {
+        on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+      })
     end
 
     private def on_page(page)
@@ -17,6 +20,11 @@ module Playwright
       emit(Events::BrowserContext::Page, page)
     end
 
+    private def on_route(route, request)
+      # @routes.each ...
+      route.continue_
+    end
+
     def pages
       @pages.to_a
     end

data/lib/playwright/channel_owners/download.rb

@@ -0,0 +1,27 @@
+module Playwright
+  define_channel_owner :Download do
+    def url
+      @initializer['url']
+    end
+
+    def suggested_filename
+      @initializer['suggestedFilename']
+    end
+
+    def delete
+      @channel.send_message_to_server('delete')
+    end
+
+    def failure
+      @channel.send_message_to_server('failure')
+    end
+
+    def path
+      @channel.send_message_to_server('path')
+    end
+
+    def save_as(path)
+      @channel.send_message_to_server('saveAs', path: path)
+    end
+  end
+end

data/lib/playwright/channel_owners/element_handle.rb

@@ -3,6 +3,312 @@ require_relative './js_handle'
 module Playwright
   module ChannelOwners
     class ElementHandle < JSHandle
+      def as_element
+        self
+      end
+
+      def owner_frame
+        resp = @channel.send_message_to_server('ownerFrame')
+        ChannelOwners::Frame.from_nullable(resp)
+      end
+
+      def content_frame
+        resp = @channel.send_message_to_server('contentFrame')
+        ChannelOwners::Frame.from_nullable(resp)
+      end
+
+      def get_attribute(name)
+        @channel.send_message_to_server('getAttribute', name: name)
+      end
+
+      def text_content
+        @channel.send_message_to_server('textContent')
+      end
+
+      def inner_text
+        @channel.send_message_to_server('innerText')
+      end
+
+      def inner_html
+        @channel.send_message_to_server('innerHTML')
+      end
+
+      def checked?
+        @channel.send_message_to_server('isChecked')
+      end
+
+      def disabled?
+        @channel.send_message_to_server('isDisabled')
+      end
+
+      def editable?
+        @channel.send_message_to_server('isEditable')
+      end
+
+      def enabled?
+        @channel.send_message_to_server('isEnabled')
+      end
+
+      def hidden?
+        @channel.send_message_to_server('isHidden')
+      end
+
+      def visible?
+        @channel.send_message_to_server('isVisible')
+      end
+
+      def dispatch_event(type, eventInit: nil)
+        params = {
+          type: type,
+          eventInit: JavaScript::ValueSerializer.new(eventInit).serialize,
+        }.compact
+        @channel.send_message_to_server('dispatchEvent', params)
+
+        nil
+      end
+
+      def scroll_into_view_if_needed(timeout: nil)
+        params = {
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('scrollIntoViewIfNeeded', params)
+
+        nil
+      end
+
+      def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
+        params = {
+          force: force,
+          modifiers: modifiers,
+          position: position,
+          timeout: timeout,
+        }
+        @channel.send_message_to_server('hover', params)
+
+        nil
+      end
+
+      def click(
+            button: nil,
+            clickCount: nil,
+            delay: nil,
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil)
+
+        params = {
+          button: button,
+          clickCount: clickCount,
+          delay: delay,
+          force: force,
+          modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
+          position: position,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('click', params)
+
+        nil
+      end
+
+      def dblclick(
+            button: nil,
+            delay: nil,
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil)
+
+        params = {
+          button: button,
+          delay: delay,
+          force: force,
+          modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
+          position: position,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('dblclick', params)
+
+        nil
+      end
+
+      def select_option(values, noWaitAfter: nil, timeout: nil)
+        base_params = SelectOptionValues.new(values).as_params
+        params = base_params + { noWaitAfter: noWaitAfter, timeout: timeout }.compact
+        @channel.send_message_to_server('selectOption', params)
+
+        nil
+      end
+
+      def tap_point(
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil)
+
+        params = {
+          force: force,
+          modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
+          position: position,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('tap', params)
+
+        nil
+      end
+
+      def fill(value, noWaitAfter: nil, timeout: nil)
+        params = {
+          value: value,
+          noWaitAfter: noWaitAfter,
+          timeout: timeout,
+        }
+        @channel.send_message_to_server('fill', params)
+
+        nil
+      end
+
+      def select_text(timeout: nil)
+        params = { timeout: timeout }.compact
+        @channel.send_message_to_server('selectText', params)
+
+        nil
+      end
+
+      def set_input_files(files, noWaitAfter: nil, timeout: nil)
+        file_payloads = InputFiles.new(files).as_params
+        params = { files: file_payloads, noWaitAfter: noWaitAfter, timeout: timeout }.compact
+        @channel.send_message_to_server('setInputFiles', params)
+
+        nil
+      end
+
+      def focus
+        @channel.send_message_to_server('focus')
+
+        nil
+      end
+
+      def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          text: text,
+          delay: delay,
+          noWaitAfter: noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('type', params)
+
+        nil
+      end
+
+      def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          key: key,
+          delay: delay,
+          noWaitAfter: noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('press', params)
+
+        nil
+      end
+
+      def check(force: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          force: force,
+          noWaitAfter:  noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('check', params)
+
+        nil
+      end
+
+      def uncheck(force: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          force: force,
+          noWaitAfter:  noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('uncheck', params)
+
+        nil
+      end
+
+      def bounding_box
+        @channel.send_message_to_server('boundingBox')
+      end
+
+      def screenshot(
+        omitBackground: nil,
+        path: nil,
+        quality: nil,
+        timeout: nil,
+        type: nil)
+
+        params = {
+          omitBackground: omitBackground,
+          path: path,
+          quality: quality,
+          timeout: timeout,
+          type: type,
+        }.compact
+        encoded_binary = @channel.send_message_to_server('screenshot', params)
+        decoded_binary = Base64.strict_decode64(encoded_binary)
+        if path
+          File.open(path, 'wb') do |f|
+            f.write(decoded_binary)
+          end
+        end
+        decoded_binary
+      end
+
+      def query_selector(selector)
+        resp = @channel.send_message_to_server('querySelector', selector: selector)
+        ChannelOwners::ElementHandle.from_nullable(resp)
+      end
+
+      def query_selector_all(selector)
+        @channel.send_message_to_server('querySelectorAll', selector: selector).map do |el|
+          ChannelOwners::ElementHandle.from(el)
+        end
+      end
+
+      def eval_on_selector(selector, pageFunction, arg: nil)
+        if JavaScript.function?(pageFunction)
+          JavaScript::Function.new(pageFunction, arg).eval_on_selector(@channel, selector)
+        else
+          JavaScript::Expression.new(pageFunction).eval_on_selector(@channel, selector)
+        end
+      end
+
+      def eval_on_selector_all(selector, pageFunction, arg: nil)
+        if JavaScript.function?(pageFunction)
+          JavaScript::Function.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
+        else
+          JavaScript::Expression.new(pageFunction).eval_on_selector_all(@channel, selector)
+        end
+      end
+
+      def wait_for_element_state(state, timeout: nil)
+        params = { state: state, timeout: timeout }.compact
+        @channel.send_message_to_server('waitForElementState', params)
+
+        nil
+      end
+
+      def wait_for_selector(selector, state: nil, timeout: nil)
+        params = { selector: selector, state: state, timeout: timeout }.compact
+        resp = @channel.send_message_to_server('waitForSelector', params)
+
+        ChannelOwners::ElementHandle.from_nullable(resp)
+      end
     end
   end
 end