playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/{input_types/android_input.rb → android_input_impl.rb}

@@ -1,5 +1,9 @@
 module Playwright
-  define_input_type :AndroidInput do
+  define_api_implementation :AndroidInputImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
     def type(text)
       @channel.send_message_to_server('inputType', text: text)
     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/api_response_impl.rb

@@ -0,0 +1,77 @@
+module Playwright
+  define_api_implementation :APIResponseImpl do
+    include Utils::Errors::TargetClosedErrorMethods
+
+    # @params context [APIRequestContext]
+    # @params initializer [Hash]
+  	def initialize(context, initializer)
+      @request = context
+      @initializer = initializer
+      @headers = RawHeaders.new(initializer['headers'])
+    end
+
+    def to_s
+      "#<APIResponse url=#{url} status=#{status} status_text=#{status_text}>"
+    end
+
+    def url
+      @initializer['url']
+    end
+
+    def ok
+      (200...300).include?(status)
+    end
+    alias_method :ok?, :ok
+
+    def status
+      @initializer['status']
+    end
+
+    def status_text
+      @initializer['statusText']
+    end
+
+    def headers
+      @headers.headers
+    end
+
+    def headers_array
+      @headers.headers_array
+    end
+
+    class AlreadyDisposedError < StandardError
+      def initialize
+        super('Response has been disposed')
+      end
+    end
+
+    def body
+      binary = @request.channel.send_message_to_server("fetchResponseBody", fetchUid: fetch_uid)
+      raise AlreadyDisposedError.new unless binary
+      Base64.strict_decode64(binary)
+    rescue => err
+      if target_closed_error?(err)
+        raise AlreadyDisposedError.new
+      else
+        raise
+      end
+    end
+    alias_method :text, :body
+
+    def json
+      JSON.parse(text)
+    end
+
+    def dispose
+      @request.channel.send_message_to_server("disposeAPIResponse", fetchUid: fetch_uid)
+    end
+
+    private def _request
+      @request
+    end
+
+    private def fetch_uid
+      @initializer['fetchUid']
+    end
+  end
+end

data/lib/playwright/channel.rb

@@ -15,8 +15,9 @@ module Playwright
 
     # @param method [String]
     # @param params [Hash]
+    # @return [Playwright::ChannelOwner|nil]
     def send_message_to_server(method, params = {})
-      result = @connection.send_message_to_server(@guid, method, params)
+      result = send_message_to_server_result(method, params)
       if result.is_a?(Hash)
         _type, channel_owner = result.first
         channel_owner
@@ -24,5 +25,65 @@ module Playwright
         nil
       end
     end
+
+    # @param method [String]
+    # @param params [Hash]
+    # @return [Hash]
+    def send_message_to_server_result(title = nil, method, params)
+      check_not_collected
+      with_logging(title) do |metadata|
+        @connection.send_message_to_server(@guid, method, params, metadata: metadata)
+      end
+    end
+
+    # @param method [String]
+    # @param params [Hash]
+    # @returns [Concurrent::Promises::Future]
+    def async_send_message_to_server(method, params = {})
+      check_not_collected
+      with_logging do |metadata|
+        @connection.async_send_message_to_server(@guid, method, params, metadata: metadata)
+      end
+    end
+
+    private def with_logging(title = nil, &block)
+      locations = caller_locations
+      first_api_call_location_idx = locations.index { |loc| loc.absolute_path&.include?('playwright_api') }
+      unless first_api_call_location_idx
+        return block.call(nil)
+      end
+
+      locations = locations.slice(first_api_call_location_idx..-1)
+
+      api_call_location = locations.shift
+
+      api_class = File.basename(api_call_location.absolute_path, '.rb')
+      api_method = api_call_location.label
+      api_name = "#{api_class}##{api_method}"
+
+      stacks = locations
+
+      metadata = build_metadata_payload_from(api_name, stacks)
+      if title
+        metadata[:title] = title
+      end
+      block.call(metadata)
+    end
+
+    private def build_metadata_payload_from(api_name, stacks)
+      {
+        wallTime: (Time.now.to_f * 1000).to_i,
+        apiName: api_name,
+        stack: stacks.map do |loc|
+          { file: loc.absolute_path || '', line: loc.lineno, function: loc.label }
+        end,
+      }
+    end
+
+    private def check_not_collected
+      if @object.was_collected?
+        raise "The object has been collected to prevent unbounded heap growth."
+      end
+    end
   end
 end

data/lib/playwright/channel_owner.rb

@@ -10,6 +10,9 @@ module Playwright
       channel&.object
     end
 
+    # hidden field for caching API instance.
+    attr_accessor :_api
+
     # @param parent [Playwright::ChannelOwner|Playwright::Connection]
     # @param type [String]
     # @param guid [String]
@@ -33,23 +36,75 @@ module Playwright
       @type = type
       @guid = guid
       @initializer = initializer
+      @event_to_subscription_mapping = {}
 
       after_initialize
     end
 
     attr_reader :channel
 
+    private def adopt!(child)
+      unless child.is_a?(ChannelOwner)
+        raise ArgumentError.new("child must be a ChannelOwner: #{child.inspect}")
+      end
+      child.send(:update_parent, self)
+    end
+
+    def was_collected?
+      @was_collected
+    end
+
     # used only from Connection. Not intended for public use. So keep private.
-    private def dispose!
+    private def dispose!(reason: nil)
       # Clean up from parent and connection.
-      @parent&.send(:delete_object_from_child, @guid)
       @connection.send(:delete_object_from_channel_owner, @guid)
+      @was_collected = reason == 'gc'
 
       # Dispose all children.
-      @objects.each_value { |object| object.send(:dispose!) }
+      @objects.each_value { |object| object.send(:dispose!, reason: reason) }
       @objects.clear
     end
 
+    private def set_event_to_subscription_mapping(event_to_subscription_mapping)
+      @event_to_subscription_mapping = event_to_subscription_mapping
+    end
+
+    private def update_subscription(event, enabled)
+      protocol_event = @event_to_subscription_mapping[event]
+      if protocol_event
+        payload = {
+          event: protocol_event,
+          enabled: enabled,
+        }
+        @channel.async_send_message_to_server('updateSubscription', payload)
+      end
+    end
+
+    # @override
+    def on(event, callback)
+      if listener_count(event) == 0
+        update_subscription(event, true)
+      end
+      super
+    end
+
+    # @override
+    def once(event, callback)
+      if listener_count(event) == 0
+        update_subscription(event, true)
+      end
+      super
+    end
+
+    # @override
+    def off(event, callback)
+      super
+      if listener_count(event) == 0
+        update_subscription(event, false)
+      end
+    end
+
+
     # Suppress long long inspect log and avoid RSpec from hanging up...
     def inspect
       to_s
@@ -59,18 +114,26 @@ module Playwright
       "#<#{@guid}>"
     end
 
-    private
+    private def after_initialize
+    end
 
-    def after_initialize
+    private def update_parent(new_parent)
+      @parent.send(:delete_object_from_child, @guid)
+      new_parent.send(:update_object_from_child, @guid, self)
+      @parent = new_parent
     end
 
-    def update_object_from_child(guid, child)
+    private def update_object_from_child(guid, child)
       @objects[guid] = child
     end
 
-    def delete_object_from_child(guid)
+    private def delete_object_from_child(guid)
       @objects.delete(guid)
     end
+
+    private def same_connection?(other)
+      @connection == other.instance_variable_get(:@connection)
+    end
   end
 
   class RootChannelOwner < ChannelOwner

data/lib/playwright/channel_owners/android.rb

@@ -1,11 +1,24 @@
 module Playwright
   define_channel_owner :Android do
-    def after_initialize
+    private def after_initialize
       @timeout_settings = TimeoutSettings.new
     end
 
-    def devices
-      resp = @channel.send_message_to_server('devices')
+    def set_default_navigation_timeout(timeout)
+      @timeout_settings.default_navigation_timeout = timeout
+    end
+
+    def set_default_timeout(timeout)
+      @timeout_settings.default_timeout = timeout
+    end
+
+    private def _timeout_settings
+      @timeout_settings
+    end
+
+    def devices(host: nil, omitDriverInstall: nil, port: nil)
+      params = { host: host, port: port, omitDriverInstall: omitDriverInstall }.compact
+      resp = @channel.send_message_to_server('devices', params)
       resp.map { |device| ChannelOwners::AndroidDevice.from(device) }
     end
   end

data/lib/playwright/channel_owners/android_device.rb

@@ -2,8 +2,14 @@ module Playwright
   define_channel_owner :AndroidDevice do
     include Utils::PrepareBrowserContextOptions
 
-    def after_initialize
-      @input = InputTypes::AndroidInput.new(@channel)
+    private def after_initialize
+      @input = AndroidInputImpl.new(@channel)
+      @should_close_connection_on_close = false
+      @timeout_settings = @parent.send(:_timeout_settings)
+    end
+
+    def should_close_connection_on_close!
+      @should_close_connection_on_close = true
     end
 
     attr_reader :input
@@ -41,9 +47,9 @@ module Playwright
         enabled: selector[:enabled],
         focusable: selector[:focusable],
         focused: selector[:focused],
-        hasChild: selector[:hasChild] ? { selector: to_selector_channel(selector[:hasChild][:selector]) } : nil,
+        hasChild: selector[:hasChild] ? { androidSelector: to_selector_channel(selector[:hasChild][:selector]) } : nil,
         hasDescendant: selector[:hasDescendant] ? {
-          selector: to_selector_channel(selector[:hasDescendant][:selector]),
+          androidSelector: to_selector_channel(selector[:hasDescendant][:selector]),
           maxDepth: selector[:hasDescendant][:maxDepth],
         } : nil,
         longClickable: selector[:longClickable],
@@ -54,19 +60,15 @@ module Playwright
 
     def tap_on(selector, duration: nil, timeout: nil)
       params = {
-        selector: to_selector_channel(selector),
+        androidSelector: to_selector_channel(selector),
         duration: duration,
-        timeout: timeout,
+        timeout: @timeout_settings.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')
+      @channel.send_message_to_server('info', androidSelector: to_selector_channel(selector))
     end
 
     def screenshot(path: nil)
@@ -81,8 +83,12 @@ module Playwright
     end
 
     def close
-      @channel.send_message_to_server('close')
       emit(Events::AndroidDevice::Close)
+      if @should_close_connection_on_close
+        @connection.stop
+      else
+        @channel.send_message_to_server('close')
+      end
     end
 
     def shell(command)
@@ -90,60 +96,10 @@ module Playwright
       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
+    def launch_browser(pkg: nil, **options, &block)
+      params = options.dup
+      params[:pkg] = pkg
+      params.compact!
       prepare_browser_context_options(params)
 
       resp = @channel.send_message_to_server('launchBrowser', params)

data/lib/playwright/channel_owners/api_request_context.rb

@@ -0,0 +1,247 @@
+require 'base64'
+require 'cgi/escape'
+
+module Playwright
+  define_channel_owner :APIRequestContext do
+    private def after_initialize
+      @tracing = ChannelOwners::Tracing.from(@initializer['tracing'])
+      @timeout_settings = TimeoutSettings.new
+    end
+
+    private def _update_timeout_settings(timeout_settings)
+      @timeout_settings = timeout_settings
+    end
+
+    def dispose(reason: nil)
+      @close_reason = reason
+      @channel.send_message_to_server('dispose')
+    end
+
+    def delete(url, **options)
+      fetch_options = options.merge(method: 'DELETE')
+      fetch(url, **fetch_options)
+    end
+
+    def head(url, **options)
+      fetch_options = options.merge(method: 'HEAD')
+      fetch(url, **fetch_options)
+    end
+
+    def get(url, **options)
+      fetch_options = options.merge(method: 'GET')
+      fetch(url, **fetch_options)
+    end
+
+    def patch(url, **options)
+      fetch_options = options.merge(method: 'PATCH')
+      fetch(url, **fetch_options)
+    end
+
+    def put(url, **options)
+      fetch_options = options.merge(method: 'PUT')
+      fetch(url, **fetch_options)
+    end
+
+    def post(url, **options)
+      fetch_options = options.merge(method: 'POST')
+      fetch(url, **fetch_options)
+    end
+
+    def fetch(
+          urlOrRequest,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          maxRetries: nil,
+          method: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+
+      if [ChannelOwners::Request, String].none? { |type| urlOrRequest.is_a?(type) }
+        raise ArgumentError.new("First argument must be either URL string or Request")
+      end
+      if urlOrRequest.is_a?(ChannelOwners::Request)
+        request = urlOrRequest
+        url = nil
+      else
+        url = urlOrRequest
+        request = nil
+      end
+      _inner_fetch(
+        request,
+        url,
+        data: data,
+        failOnStatusCode: failOnStatusCode,
+        form: form,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        maxRedirects: maxRedirects,
+        maxRetries: maxRetries,
+        method: method,
+        multipart: multipart,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    private def _inner_fetch(
+          request,
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          maxRetries: nil,
+          method: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      if @close_reason
+        raise TargetClosedError.new(message: @close_reason)
+      end
+      if [data, form, multipart].compact.count > 1
+        raise ArgumentError.new("Only one of 'data', 'form' or 'multipart' can be specified")
+      end
+      if maxRedirects && maxRedirects < 0
+        raise ArgumentError.new("'maxRedirects' should be greater than or equal to '0'")
+      end
+      if maxRetries && maxRetries < 0
+        raise ArgumentError.new("'maxRetries' should be greater than or equal to '0'")
+      end
+
+      headers_obj = headers || request&.headers
+      fetch_params = {
+        url: url || request.url,
+        params: map_params_to_array(params),
+        method: method || request&.method || 'GET',
+        headers: headers_obj ? HttpHeaders.new(headers_obj).as_serialized : nil,
+      }
+
+      json_data = nil
+      form_data = nil
+      multipart_data = nil
+      post_data_buffer = nil
+      if data
+        case data
+        when String
+          if headers_obj&.any? { |key, value| key.downcase == 'content-type' && value == 'application/json' }
+            json_data = json_parsable?(data) ? data : data.to_json
+          else
+            post_data_buffer = data
+          end
+        when Hash, Array, Numeric, true, false
+          json_data = data.to_json
+        else
+          raise ArgumentError.new("Unsupported 'data' type: #{data.class}")
+        end
+      elsif form
+        form_data = object_to_array(form)
+      elsif multipart
+        multipart_data = multipart.map do |name, value|
+          if file_payload?(value)
+            { name: name, file: file_payload_to_json(value) }
+          else
+            { name: name, value: value.to_s }
+          end
+        end
+      end
+
+      if !json_data && !form_data && !multipart_data
+        post_data_buffer ||= request&.post_data_buffer
+      end
+      if post_data_buffer
+        fetch_params[:postData] = Base64.strict_encode64(post_data_buffer)
+      end
+      fetch_params[:jsonData] = json_data
+      fetch_params[:formData] = form_data
+      fetch_params[:multipartData] = multipart_data
+      fetch_params[:timeout] = @timeout_settings.timeout(timeout)
+      fetch_params[:failOnStatusCode] = failOnStatusCode
+      fetch_params[:ignoreHTTPSErrors] = ignoreHTTPSErrors
+      fetch_params[:maxRedirects] = maxRedirects
+      fetch_params[:maxRetries] = maxRetries
+      fetch_params.compact!
+      response = @channel.send_message_to_server('fetch', fetch_params)
+
+      APIResponseImpl.new(self, response)
+    end
+
+    private def file_payload?(value)
+      value.is_a?(Hash) &&
+        %w(name mimeType buffer).all? { |key| value.has_key?(key) || value.has_key?(key.to_sym) }
+    end
+
+    private def file_payload_to_json(payload)
+      {
+        name: payload[:name] || payload['name'],
+        mimeType: payload[:mimeType] || payload['mimeType'],
+        buffer: Base64.strict_encode64(payload[:buffer] || payload['buffer'])
+      }
+    end
+
+    private def map_params_to_array(params)
+      if params.is_a?(String)
+        unless params.start_with?('?')
+          raise ArgumentError.new("Query string must start with '?'")
+        end
+        query_string_to_array(params[1..-1])
+      else
+        object_to_array(params)
+      end
+    end
+
+    private def query_string_to_array(query_string)
+      params = cgi_parse(query_string)
+
+      params.map do |key, values|
+        values.map do |value|
+          { name: key, value: value }
+        end
+      end.flatten
+    end
+
+    # https://bugs.ruby-lang.org/issues/21258
+    # CGI.parse is defined in 'cgi' library.
+    # But it produces an error in Ruby 2.4 environment: undefined method `delete_prefix' for "CONTENT_LENGTH":String
+    # So we implement our own version of CGI.parse here.
+    private def cgi_parse(query)
+      # https://github.com/ruby/cgi/blob/master/lib/cgi/core.rb#L396
+      params = {}
+
+      query.split(/[&;]/).each do |pairs|
+        key, value = pairs.split('=',2).map do |v|
+          CGI.unescape(v)
+        end
+
+        next unless key
+        params[key] ||= []
+        next unless value
+        params[key] << value
+      end
+
+      params
+    end
+
+    private def object_to_array(hash)
+      hash&.map do |key, value|
+        { name: key, value: value.to_s }
+      end
+    end
+
+    private def json_parsable?(data)
+      return false unless data.is_a?(String)
+      begin
+        JSON.parse(data)
+        true
+      rescue JSON::ParserError
+        false
+      end
+    end
+  end
+end