playwright-ruby-client 0.0.8 → 0.3.0

data/lib/playwright/channel_owners/playwright.rb

@@ -20,6 +20,10 @@ module Playwright
       @electron ||= ::Playwright::ChannelOwners::Electron.from(@initializer['electron'])
     end
 
+    def selectors
+      @selectors ||= ::Playwright::ChannelOwners::Selectors.from(@initializer['selectors'])
+    end
+
     class DeviceDescriptor
       class Viewport
         def initialize(hash)

data/lib/playwright/channel_owners/request.rb

@@ -3,7 +3,7 @@ require 'base64'
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Request do
-    def after_initialize
+    private def after_initialize
       @redirected_from = ChannelOwners::Request.from_nullable(@initializer['redirectedFrom'])
       @redirected_from&.send(:update_redirected_to, self)
       @timing = {
@@ -29,7 +29,7 @@ module Playwright
     end
 
     def method
-      @initialize['method']
+      @initializer['method']
     end
 
     def post_data
@@ -69,7 +69,7 @@ module Playwright
     end
 
     def frame
-      @initializer['frame']
+      ChannelOwners::Frame.from(@initializer['frame'])
     end
 
     def navigation_request?
@@ -86,6 +86,38 @@ module Playwright
       @redirected_to = request
     end
 
+    private def update_failure_text(failure_text)
+      @failure_text = failure_text
+    end
+
+    private def update_timings(
+                  start_time:,
+                  domain_lookup_start:,
+                  domain_lookup_end:,
+                  connect_start:,
+                  secure_connection_start:,
+                  connect_end:,
+                  request_start:,
+                  response_start:)
+
+      @timing["startTime"] = start_time
+      @timing["domainLookupStart"] = domain_lookup_start
+      @timing["domainLookupEnd"] = domain_lookup_end
+      @timing["connectStart"] = connect_start
+      @timing["secureConnectionStart"] = secure_connection_start
+      @timing["connectEnd"] = connect_end
+      @timing["requestStart"] = request_start
+      @timing["responseStart"] = response_start
+    end
+
+    private def update_headers(headers)
+      @headers = parse_headers(headers)
+    end
+
+    private def update_response_end_timing(response_end_timing)
+      @timing[:responseEnd] = response_end_timing
+    end
+
     private def parse_headers(headers)
       headers.map do |header|
         [header['name'].downcase, header['value']]

data/lib/playwright/channel_owners/response.rb

@@ -1,5 +1,65 @@
+require 'base64'
+require 'json'
+
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Response do
+    def after_initialize
+      @request = ChannelOwners::Request.from(@initializer['request'])
+      timing = @initializer['timing']
+      @request.send(:update_timings,
+        start_time: timing["startTime"],
+        domain_lookup_start: timing["domainLookupStart"],
+        domain_lookup_end: timing["domainLookupEnd"],
+        connect_start: timing["connectStart"],
+        secure_connection_start: timing["secureConnectionStart"],
+        connect_end: timing["connectEnd"],
+        request_start: timing["requestStart"],
+        response_start: timing["responseStart"],
+      )
+      @request.send(:update_headers, @initializer['requestHeaders'])
+    end
+    attr_reader :request
+
+    def url
+      @initializer['url']
+    end
+
+    def ok
+      status == 0 || (200...300).include?(status)
+    end
+    alias_method :ok?, :ok
+
+    def status
+      @initializer['status']
+    end
+
+    def status_text
+      @initializer['statusText']
+    end
+
+    def headers
+      @initializer['headers'].map do |header|
+        [header['name'].downcase, header['value']]
+      end.to_h
+    end
+
+    def finished
+      @channel.send_message_to_server('finished')
+    end
+
+    def body
+      binary = @channel.send_message_to_server("body")
+      Base64.strict_decode64(binary)
+    end
+    alias_method :text, :body
+
+    def json
+      JSON.parse(text)
+    end
+
+    def frame
+      @request.frame
+    end
   end
 end

data/lib/playwright/channel_owners/route.rb

@@ -0,0 +1,78 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  define_channel_owner :Route do
+    def request
+      ChannelOwners::Request.from(@initializer['request'])
+    end
+
+    def abort(errorCode: nil)
+      params = { errorCode: errorCode }.compact
+      @channel.async_send_message_to_server('abort', params)
+    end
+
+    def fulfill(
+          body: nil,
+          contentType: nil,
+          headers: nil,
+          path: nil,
+          status: nil)
+      params = {
+        contentType: contentType,
+        status: status,
+      }.compact
+
+      length = 0
+      content =
+        if body
+          body
+        elsif path
+          File.read(path)
+        else
+          nil
+        end
+
+      param_headers = headers || {}
+      if contentType
+        param_headers['content-type'] = contentType
+      elsif path
+        param_headers['content-type'] = mime_type_for(path)
+      end
+
+      if content
+        if content.is_a?(String)
+          params[:body] = content
+          params[:isBase64] = false
+        else
+          params[:body] = Base64.strict_encode64(content)
+          params[:isBase64] = true
+        end
+        param_headers['content-length'] ||= content.length.to_s
+      end
+
+      params[:headers] = HttpHeaders.new(param_headers).as_serialized
+
+      @channel.async_send_message_to_server('fulfill', params)
+    end
+
+    def continue(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = { url: url, method: method }.compact
+
+      if headers
+        overrides[:headers] = HttpHeaders.new(headers).as_serialized
+      end
+
+      if postData
+        overrides[:postData] = Base64.strict_encode64(postData)
+      end
+
+      @channel.async_send_message_to_server('continue', overrides)
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first.to_s || 'application/octet-stream'
+    end
+  end
+end

data/lib/playwright/channel_owners/selectors.rb

@@ -1,4 +1,22 @@
 module Playwright
   # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_selectors.py
-  define_channel_owner :Selectors
+  define_channel_owner :Selectors do
+    def register(name, contentScript: nil, path: nil, script: nil)
+      source =
+        if path
+          File.read(path)
+        elsif script
+          script
+        else
+          raise ArgumentError.new('Either path or script parameter must be specified')
+        end
+      params = { name: name, source: source }
+      if contentScript
+        params[:contentScript] = true
+      end
+      @channel.send_message_to_server('register', params)
+
+      nil
+    end
+  end
 end

data/lib/playwright/errors.rb

@@ -28,7 +28,7 @@ module Playwright
   end
 
   class TimeoutError < Error
-    def initialize(message:, stack:)
+    def initialize(message:, stack: [])
       super(name: 'TimeoutError', message: message, stack: stack)
     end
   end

data/lib/playwright/event_emitter.rb

@@ -34,11 +34,18 @@ module Playwright
   # A subset of Events/EventEmitter in Node.js
   module EventEmitter
     # @param event [String]
+    # @returns [Boolean]
     def emit(event, *args)
+      handled = false
       (@__event_emitter ||= {})[event.to_s]&.each do |callback|
         callback.call(*args)
+        handled = true
       end
-      self
+      handled
+    end
+
+    private def listener_count(event)
+      ((@__event_emitter ||= {})[event.to_s] ||= Set.new).count
     end
 
     # @param event [String]

data/lib/playwright/event_emitter_proxy.rb

@@ -0,0 +1,49 @@
+module Playwright
+  class EventEmitterProxy
+    include EventEmitter
+
+    # @param src [PlaywrightApi]
+    # @param dest [EventEmitter]
+    def initialize(api, impl)
+      @api = api
+      @impl = impl
+      @listeners = {}
+    end
+
+    def on(event, callback)
+      if listener_count(event) == 0
+        subscribe(event)
+      end
+      super
+    end
+
+    def once(event, callback)
+      if listener_count(event) == 0
+        subscribe(event)
+      end
+      super
+    end
+
+    def off(event, callback)
+      super
+      if listener_count(event) == 0
+        unsubscribe(event)
+      end
+    end
+
+    private def subscribe(event)
+      @listeners[event] = ->(*args) {
+        wrapped_args = args.map { |arg| ::Playwright::PlaywrightApi.wrap(arg) }
+        emit(event, *wrapped_args)
+      }
+      @impl.on(event, @listeners[event])
+    end
+
+    private def unsubscribe(event)
+      listener = @listeners.delete(event)
+      if listener
+        @impl.off(event, listener)
+      end
+    end
+  end
+end

data/lib/playwright/file_chooser_impl.rb

@@ -0,0 +1,23 @@
+module Playwright
+  define_api_implementation :FileChooserImpl do
+    def initialize(page:, element_handle:, is_multiple:)
+      @page = page
+      @element_handle = element_handle
+      @is_multiple = is_multiple
+    end
+
+    attr_reader :page
+
+    def element
+      @element_handle
+    end
+
+    def multiple?
+      @is_multiple
+    end
+
+    def set_files(files, noWaitAfter: nil, timeout: nil)
+      @element_handle.set_input_files(files, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+  end
+end

data/lib/playwright/http_headers.rb

@@ -0,0 +1,20 @@
+module Playwright
+  class HttpHeaders
+    # @param headers [Hash]
+    def initialize(headers)
+      @headers = headers
+    end
+
+    def as_serialized
+      @headers.map do |key, value|
+        { name: key, value: value }
+      end
+    end
+
+    def self.parse_serialized(serialized_headers)
+      new(serialized_headers.map do |header|
+        [header['name'].downcase, header['value']]
+      end.to_h)
+    end
+  end
+end

data/lib/playwright/input_files.rb

@@ -36,7 +36,7 @@ module Playwright
 
     private def mime_type_for(filepath)
       mime_types = MIME::Types.type_for(filepath)
-      mime_types.first || 'application/octet-stream'
+      mime_types.first.to_s || 'application/octet-stream'
     end
   end
 end

data/lib/playwright/{input_types/keyboard.rb → keyboard_impl.rb}

@@ -1,5 +1,9 @@
 module Playwright
-  define_input_type :Keyboard do
+  define_api_implementation :KeyboardImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
     def down(key)
       @channel.send_message_to_server('keyboardDown', key: key)
       nil

data/lib/playwright/mouse_impl.rb

@@ -0,0 +1,7 @@
+module Playwright
+  define_api_implementation :MouseImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+  end
+end

data/lib/playwright/playwright_api.rb

@@ -1,27 +1,34 @@
 module Playwright
   class PlaywrightApi
-    # Wrap ChannelOwner.
+    # Wrap ChannelOwner / ApiImplementation.
     # Playwright::ChannelOwners::XXXXX will be wrapped as Playwright::XXXXX
+    # Playwright::YYYYImpl will be wrapped as Playwright::YYYY
     # Playwright::XXXXX is automatically generated by development/generate_api
     #
-    # @param channel_owner [ChannelOwner]
+    # @param channel_owner [ChannelOwner|ApiImplementation]
     # @note Intended for internal use only.
-    def self.from_channel_owner(channel_owner)
-      Factory.new(channel_owner, 'ChannelOwners').create
+    def self.wrap(channel_owner_or_api_implementation)
+      case channel_owner_or_api_implementation
+      when ChannelOwner
+        ChannelOwnerWrapper.new(channel_owner_or_api_implementation).wrap
+      when ApiImplementation
+        ApiImplementationWrapper.new(channel_owner_or_api_implementation).wrap
+      else
+        nil
+      end
     end
 
-    class Factory
-      def initialize(impl, module_name)
+    class ChannelOwnerWrapper
+      def initialize(impl)
         impl_class_name = impl.class.name
-        unless impl_class_name.include?("::#{module_name}::")
-          raise "#{impl_class_name} is not #{module_name}"
+        unless impl_class_name.include?("::ChannelOwners::")
+          raise "#{impl_class_name} is not ChannelOwners"
         end
 
         @impl = impl
-        @module_name = module_name
       end
 
-      def create
+      def wrap
         api_class = detect_class_for(@impl.class)
         if api_class
           api_class.new(@impl)
@@ -33,11 +40,11 @@ module Playwright
       private
 
       def expected_class_name_for(klass)
-        klass.name.split("::#{@module_name}::").last
+        klass.name.split("::ChannelOwners::").last
       end
 
       def superclass_exist?(klass)
-        ![::Playwright::ChannelOwner, ::Playwright::InputType, Object].include?(klass.superclass)
+        ![::Playwright::ChannelOwner, Object].include?(klass.superclass)
       end
 
       def detect_class_for(klass)
@@ -52,7 +59,44 @@ module Playwright
       end
     end
 
-    # @param impl [Playwright::ChannelOwner|Playwright::InputType]
+    class ApiImplementationWrapper
+      def initialize(impl)
+        impl_class_name = impl.class.name
+        unless impl_class_name.end_with?("Impl")
+          raise "#{impl_class_name} is not Impl"
+        end
+
+        @impl = impl
+      end
+
+      def wrap
+        api_class = detect_class_for(@impl.class)
+        if api_class
+          api_class.new(@impl)
+        else
+          raise NotImplementedError.new("Playwright::#{expected_class_name_for(@impl.class)} is not implemented")
+        end
+      end
+
+      private
+
+      def expected_class_name_for(klass)
+        # KeyboardImpl -> Keyboard
+        # MouseImpl -> Mouse
+        klass.name[0...-4].split("::").last
+      end
+
+      def detect_class_for(klass)
+        class_name = expected_class_name_for(klass)
+        if ::Playwright.const_defined?(class_name)
+          ::Playwright.const_get(class_name)
+        else
+          nil
+        end
+      end
+    end
+
+    # @param impl [Playwright::ChannelOwner|Playwright::ApiImplementation]
     def initialize(impl)
       @impl = impl
     end
@@ -72,15 +116,10 @@ module Playwright
     end
 
     private def wrap_impl(object)
-      case object
-      when ChannelOwner
-        PlaywrightApi.from_channel_owner(object)
-      when InputType
-        Factory.new(object, 'InputTypes').create
-      when Array
+      if object.is_a?(Array)
         object.map { |obj| wrap_impl(obj) }
       else
-        object
+        ::Playwright::PlaywrightApi.wrap(object) || object
       end
     end