playwright-ruby-client 0.0.5 → 0.1.0

data/lib/playwright/channel_owners/request.rb

@@ -1,5 +1,103 @@
+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
+      @redirected_from = ChannelOwners::Request.from_nullable(@initializer['redirectedFrom'])
+      @redirected_from&.send(:update_redirected_to, self)
+      @timing = {
+        startTime: 0,
+        domainLookupStart: -1,
+        domainLookupEnd: -1,
+        connectStart: -1,
+        secureConnectionStart: -1,
+        connectEnd: -1,
+        requestStart: -1,
+        responseStart: -1,
+        responseEnd: -1,
+      }
+      @headers = parse_headers(@initializer['headers'])
+    end
+
+    def url
+      @initializer['url']
+    end
+
+    def resource_type
+      @initializer['resourceType']
+    end
+
+    def method
+      @initialize['method']
+    end
+
+    def post_data
+      post_data_buffer
+    end
+
+    def post_data_json
+      data = post_data
+      return unless data
+
+      content_type = @headers['content-type']
+      return unless content_type
+
+      if content_type == "application/x-www-form-urlencoded"
+        URI.decode_www_form(data).to_h
+      else
+        JSON.parse(data)
+      end
+    end
+
+    def post_data_buffer
+      base64_content = @initializer['postData']
+      if base64_content
+        Base64.strict_decode64(base64_content)
+      else
+        nil
+      end
+    end
+
+    def headers
+      @headers
+    end
+
+    def response
+      resp = @channel.send_message_to_server('response')
+      ChannelOwners::Response.from_nullable(resp)
+    end
+
+    def frame
+      @initializer['frame']
+    end
+
+    def navigation_request?
+      @initializer['isNavigationRequest']
+    end
+
+    def failure
+      @failure_text
+    end
+
+    attr_reader :headers, :redirected_from, :redirected_to, :timing
+
+    private def update_redirected_to(request)
+      @redirected_to = request
+    end
+
+    private def update_failure_text(failure_text)
+      @failure_text = failure_text
+    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']]
+      end.to_h
+    end
   end
 end

data/lib/playwright/channel_owners/webkit_browser.rb

@@ -2,7 +2,7 @@ require_relative './browser'
 
 module Playwright
   module ChannelOwners
-    class WebkitBrowser < Browser
+    class WebKitBrowser < Browser
     end
   end
 end

data/lib/playwright/connection.rb

@@ -55,10 +55,13 @@ module Playwright
           method: method,
           params: replace_channels_with_guids(params),
         }
-        @transport.send_message(message)
-      rescue Transport::AlreadyDisconnectedError => err
-        @callbacks.delete(id)
-        callback.reject(err)
+        begin
+          @transport.send_message(message)
+        rescue => err
+          @callbacks.delete(id)
+          callback.reject(err)
+          raise unless err.is_a?(Transport::AlreadyDisconnectedError)
+        end
       end
 
       callback
@@ -132,7 +135,7 @@ module Playwright
         unless object
           raise "Cannot find object to dispose: #{guid}"
         end
-        object.dispose
+        object.send(:dispose!)
         return
       end
 
@@ -153,7 +156,7 @@ module Playwright
       end
 
       if payload.is_a?(Channel)
-        { guid: payload.guid }
+        return { guid: payload.guid }
       end
 
       if payload.is_a?(Hash)

data/lib/playwright/errors.rb

@@ -3,7 +3,7 @@ module Playwright
     # ref: https://github.com/microsoft/playwright-python/blob/0b4a980fed366c4c1dee9bfcdd72662d629fdc8d/playwright/_impl/_helper.py#L155
     def self.parse(error_payload)
       if error_payload['name'] == 'TimeoutError'
-        Playwright::TimeoutError.new(
+        TimeoutError.new(
           message: error_payload['message'],
           stack: error_payload['stack'].split("\n"),
         )
@@ -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

@@ -0,0 +1,42 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  class InputFiles
+    def initialize(files)
+      @params = convert(files)
+    end
+
+    def as_params
+      @params
+    end
+
+    private def convert(files)
+      return convert([files]) unless files.is_a?(Array)
+
+      files.map do |file|
+        case file
+        when String
+          {
+            name: File.basename(file),
+            mimeType: mime_type_for(file),
+            buffer: Base64.strict_encode64(File.read(file)),
+          }
+        when File
+          {
+            name: File.basename(file.path),
+            mimeType: mime_type_for(file.path),
+            buffer: Base64.strict_encode64(file.read),
+          }
+        else
+          raise ArgumentError.new('file must be a String or File.')
+        end
+      end
+    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/javascript/expression.rb

@@ -25,6 +25,43 @@ module Playwright
         )
         ::Playwright::ChannelOwner.from(resp)
       end
+
+      def eval_on_selector(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelector',
+          selector: selector,
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def eval_on_selector_all(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelectorAll',
+          selector: selector,
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def wait_for_function(channel, polling:, timeout:)
+        params = {
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+          polling: polling,
+          timeout: timeout,
+        }.compact
+        if polling.is_a?(Numeric)
+          params[:pollingInterval] = polling
+        end
+        resp = channel.send_message_to_server('waitForFunction', params)
+        ChannelOwners::JSHandle.from(resp)
+      end
     end
   end
 end

data/lib/playwright/javascript/function.rb

@@ -25,6 +25,43 @@ module Playwright
         )
         ::Playwright::ChannelOwner.from(resp)
       end
+
+      def eval_on_selector(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelector',
+          selector: selector,
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def eval_on_selector_all(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelectorAll',
+          selector: selector,
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def wait_for_function(channel, polling:, timeout:)
+        params = {
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+          polling: polling,
+          timeout: timeout,
+        }.compact
+        if polling.is_a?(Numeric)
+          params[:pollingInterval] = polling
+        end
+        resp = channel.send_message_to_server('waitForFunction', params)
+        ChannelOwners::JSHandle.from(resp)
+      end
     end
   end
 end

data/lib/playwright/javascript/value_parser.rb

@@ -61,7 +61,7 @@ module Playwright
         end
 
         if hash.key?('o')
-          return hash['o'].map { |key, value| [key, parse_hash(value)].to_h }
+          return hash['o'].map { |obj| [obj['k'], parse_hash(obj['v'])] }.to_h
         end
 
         if hash.key?('h')

data/lib/playwright/javascript/value_serializer.rb

@@ -15,9 +15,9 @@ module Playwright
       # ref: https://github.com/microsoft/playwright-python/blob/25a99d53e00e35365cf5113b9525272628c0e65f/playwright/_impl/_js_handle.py#L99
       private def serialize_value(value)
         case value
-        when JSHandle
+        when ChannelOwners::JSHandle
           index = @handles.count
-          @handles << v
+          @handles << value.channel
           { h: index }
         when nil
           { v: 'undefined' }
@@ -28,23 +28,23 @@ module Playwright
         when -Float::INFINITY
           { v: '-Infinity' }
         when true, false
-          { b: v }
+          { b: value }
         when Numeric
-          { n: v }
+          { n: value }
         when String
-          { s: v }
+          { s: value }
         when Time
           require 'time'
-          { d: v.utc.iso8601 }
+          { d: value.utc.iso8601 }
         when Regexp
           flags = []
-          flags << 'ms' if (v.options & Regexp::MULTILINE) != 0
-          flags << 'i' if (v.options & Regexp::IGNORECASE) != 0
-          { r: { p: v.source, f: flags.join('') } }
+          flags << 'ms' if (value.options & Regexp::MULTILINE) != 0
+          flags << 'i' if (value.options & Regexp::IGNORECASE) != 0
+          { r: { p: value.source, f: flags.join('') } }
         when Array
-          { a: v.map { |value| serialize_value(value) } }
+          { a: value.map { |v| serialize_value(v) } }
         when Hash
-          { o: v.map { |key, value| [key, serialize_value(value)] }.to_h }
+          { o: value.map { |key, v| { k: key, v: serialize_value(v) } } }
         else
           raise ArgumentError.new("Unexpected value: #{value}")
         end