playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/download_impl.rb

@@ -0,0 +1,32 @@
+module Playwright
+  define_api_implementation :DownloadImpl do
+    def initialize(page:, url:, suggested_filename:, artifact:)
+      @page = page
+      @url = url
+      @suggested_filename = suggested_filename
+      @artifact = artifact
+    end
+
+    attr_reader :page, :url, :suggested_filename
+
+    def delete
+      @artifact.delete
+    end
+
+    def failure
+      @artifact.failure
+    end
+
+    def path
+      @artifact.path_after_finished
+    end
+
+    def save_as(path)
+      @artifact.save_as(path)
+    end
+
+    def cancel
+      @artifact.cancel
+    end
+  end
+end

data/lib/playwright/errors.rb

@@ -5,13 +5,18 @@ module Playwright
       if error_payload['name'] == 'TimeoutError'
         TimeoutError.new(
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
+        )
+      elsif error_payload['name'] == 'TargetClosedError'
+        TargetClosedError.new(
+          message: error_payload['message'],
+          stack: error_payload['stack'],
         )
       else
         new(
           name: error_payload['name'],
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       end
     end
@@ -19,17 +24,49 @@ module Playwright
     # @param name [String]
     # @param message [String]
     # @param stack [Array<String>]
-    def initialize(name:, message:, stack:)
-      super("#{name}: #{message}")
+    def initialize(message:, name: nil, stack: nil)
+      super(message)
       @name = name
       @message = message
       @stack = stack
     end
+
+    attr_reader :name, :message, :stack
+
+    def log=(log)
+      return unless log
+      format_call_log = log.join("\n  - ")
+      @message = "#{@message}\nCall log:\n#{format_call_log}\n"
+    end
+  end
+
+  class DriverCrashedError < StandardError
+    def initialize
+      super("[BUG] Playwright driver is crashed!")
+    end
   end
 
   class TimeoutError < Error
-    def initialize(message:, stack:)
+    def initialize(message:, stack: [])
       super(name: 'TimeoutError', message: message, stack: stack)
     end
   end
+
+  class TargetClosedError < Error
+    def initialize(message: nil, stack: [])
+      _message = message || 'Target page, context or browser has been closed'
+      super(name: 'TargetClosedError', message: _message, stack: stack)
+    end
+  end
+
+  class WebError
+    def initialize(error, page)
+      @error = error
+      @page = PlaywrightApi.wrap(page)
+    end
+
+    attr_reader :error, :page
+  end
+
+  class AssertionError < StandardError; end
 end

data/lib/playwright/event_emitter.rb

@@ -34,11 +34,25 @@ module Playwright
   # A subset of Events/EventEmitter in Node.js
   module EventEmitter
     # @param event [String]
+    # @returns [Boolean]
     def emit(event, *args)
-      (@__event_emitter ||= {})[event.to_s]&.each do |callback|
-        callback.call(*args)
+      handled = false
+      if (callbacks = (@__event_emitter ||= {})[event.to_s])
+        callbacks.dup.each do |callback|
+          perform_event_emitter_callback(event, callback, args)
+          handled = true
+        end
       end
-      self
+      handled
+    end
+
+    private def listener_count(event)
+      ((@__event_emitter ||= {})[event.to_s] ||= Set.new).count
+    end
+
+    # can be overriden
+    private def perform_event_emitter_callback(event, callback, args)
+      callback.call(*args)
     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/events.rb

@@ -24,8 +24,17 @@ end
   },
 
   BrowserContext: {
+    BackgroundPage: 'backgroundpage',
     Close: 'close',
+    Console: 'console',
+    Dialog: 'dialog',
     Page: 'page',
+    WebError: 'weberror',
+    ServiceWorker: 'serviceworker',
+    Request: 'request',
+    Response: 'response',
+    RequestFailed: 'requestfailed',
+    RequestFinished: 'requestfinished',
   },
 
   BrowserServer: {
@@ -65,11 +74,7 @@ end
 
   Worker: {
     Close: 'close',
-  },
-
-  ChromiumBrowserContext: {
-    BackgroundPage: 'backgroundpage',
-    ServiceWorker: 'serviceworker',
+    Console: 'console',
   },
 
   ElectronApplication: {

data/lib/playwright/file_chooser_impl.rb

@@ -0,0 +1,24 @@
+module Playwright
+  define_api_implementation :FileChooserImpl do
+    def initialize(page:, timeout_settings:, element_handle:, is_multiple:)
+      @page = page
+      @timeout_settings = timeout_settings
+      @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_settings.timeout(timeout))
+    end
+  end
+end

data/lib/playwright/frame_locator_impl.rb

@@ -0,0 +1,66 @@
+require_relative './locator_utils'
+
+module Playwright
+  define_api_implementation :FrameLocatorImpl do
+    include LocatorUtils
+
+    def initialize(frame:, frame_selector:)
+      @frame = frame
+      @frame_selector = frame_selector
+    end
+
+    private def _timeout(timeout)
+      @frame.send(:_timeout, timeout)
+    end
+
+    def locator(
+      selector,
+      has: nil,
+      hasNot: nil,
+      hasNotText: nil,
+      hasText: nil)
+      LocatorImpl.new(
+        frame: @frame,
+        selector: "#{@frame_selector} >> internal:control=enter-frame >> #{selector}",
+        has: has,
+        hasNot: hasNot,
+        hasNotText: hasNotText,
+        hasText: hasText)
+    end
+
+    def owner
+      LocatorImpl.new(
+        frame: @frame,
+        selector: @frame_selector,
+      )
+    end
+
+    def frame_locator(selector)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        frame_selector: "#{@frame_selector} >> internal:control=enter-frame >> #{selector}",
+      )
+    end
+
+    def first
+      FrameLocatorImpl.new(
+        frame: @frame,
+        frame_selector: "#{@frame_selector} >> nth=0",
+      )
+    end
+
+    def last
+      FrameLocatorImpl.new(
+        frame: @frame,
+        frame_selector: "#{@frame_selector} >> nth=-1",
+      )
+    end
+
+    def nth(index)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        frame_selector: "#{@frame_selector} >> nth=#{index}",
+      )
+    end
+  end
+end

data/lib/playwright/har_router.rb

@@ -0,0 +1,89 @@
+module Playwright
+  class HarRouter
+    # @param local_utils [LocalUtils]
+    # @param file [String]
+    # @param not_found_action [String] 'abort' or 'fallback'
+    # @param url_match [String||Regexp|nil]
+    def self.create(local_utils, file, not_found_action, url_match: nil)
+      har_id = local_utils.har_open(file)
+
+      new(
+        local_utils: local_utils,
+        har_id: har_id,
+        not_found_action: not_found_action,
+        url_match: url_match,
+      )
+    end
+
+    # @param local_utils [LocalUtils]
+    # @param har_id [String]
+    # @param not_found_action [String] 'abort' or 'fallback'
+    # @param url_match [String||Regexp|nil]
+    def initialize(local_utils:, har_id:, not_found_action:,  url_match: nil)
+      unless ['abort', 'fallback'].include?(not_found_action)
+        raise ArgumentError.new("not_found_action must be either 'abort' or 'fallback'. '#{not_found_action}' is specified.")
+      end
+
+      @local_utils = local_utils
+      @har_id = har_id
+      @not_found_action = not_found_action
+      @url_match = url_match || '**/*'
+      @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+    end
+
+    private def handle(route, request)
+      response = @local_utils.har_lookup(
+        har_id: @har_id,
+        url: request.url,
+        method: request.method,
+        headers: request.headers_array,
+        post_data: request.post_data_buffer,
+        is_navigation_request: request.navigation_request?,
+      )
+      case response['action']
+      when 'redirect'
+        redirect_url = response['redirectURL']
+        puts "pw:api HAR: #{request.url} redirected to #{redirect_url}" if @debug
+        route.redirect_navigation_request(redirect_url)
+      when 'fulfill'
+        # If the response status is -1, the request was canceled or stalled, so we just stall it here.
+        # See https://github.com/microsoft/playwright/issues/29311.
+        # TODO: it'd be better to abort such requests, but then we likely need to respect the timing,
+        # because the request might have been stalled for a long time until the very end of the
+        # test when HAR was recorded but we'd abort it immediately.
+        return if response['status'] == -1
+
+        route.fulfill(
+          status: response['status'],
+          headers: response['headers'].map { |header| [header['name'], header['value']] }.to_h,
+          body: Base64.strict_decode64(response['body']),
+        )
+      else
+        # Report the error, but fall through to the default handler.
+        if response['action'] == 'error'
+          puts "pw:api HAR: #{response['message']} redirected to #{redirect_url}" if @debug
+        end
+
+        if @not_found_action == 'abort'
+          route.abort
+        else
+          route.fallback
+        end
+      end
+    end
+
+    def add_context_route(context)
+      context.route(@url_match, method(:handle))
+      context.once(Events::BrowserContext::Close, method(:dispose))
+    end
+
+    def add_page_route(page)
+      page.route(@url_match, method(:handle))
+      page.once(Events::Page::Close, method(:dispose))
+    end
+
+    def dispose
+      @local_utils.async_har_close(@har_id)
+    end
+  end
+end

data/lib/playwright/http_headers.rb

@@ -0,0 +1,14 @@
+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
+  end
+end

data/lib/playwright/input_files.rb

@@ -1,42 +1,129 @@
 require 'base64'
-require 'mime/types'
 
 module Playwright
   class InputFiles
-    def initialize(files)
-      @params = convert(files)
+    def initialize(context, files)
+      @context = context
+      if files.is_a?(File)
+        files_to_resolve = [files]
+      elsif files.is_a?(Enumerable)
+        files_to_resolve = files
+      else
+        files_to_resolve = [files]
+      end
+      resolve_paths_and_directory_for_input_files(files_to_resolve)
     end
 
-    def as_params
-      @params
+    def as_method_and_params
+      if @local_directory || has_large_file?
+        ['setInputFiles', params_for_set_input_file_paths]
+      else
+        ['setInputFiles', params_for_set_input_files]
+      end
     end
 
-    private def convert(files)
-      return convert([files]) unless files.is_a?(Array)
+    private def has_large_file?
+      max_bufsize = 1024 * 1024 # 1MB
 
-      files.map do |file|
+      @local_files.any? do |file|
+        case file
+        when String
+          File::Stat.new(file).size > max_bufsize
+        when File
+          file.stat.size > max_bufsize
+        end
+      end
+    end
+
+    private def resolve_paths_and_directory_for_input_files(files)
+      # filter_map is not available in Ruby < 2.7
+      @local_files = files.map do |item|
+        case item
+        when String
+          if File.directory?(item)
+            raise ArgumentError.new('Multiple directories are not supported') if @local_directory
+            @local_directory = item
+            next
+          end
+
+          item
+        when File
+          if File.directory?(item.path)
+            raise ArgumentError.new('Multiple directories are not supported') if @local_directory
+            @local_directory = item
+            next
+          end
+
+          item
+        else
+          raise ArgumentError.new('file must be a String or File or Directory.')
+        end
+      end.compact
+
+      if @local_directory && !@local_files.empty?
+        raise ArgumentError.new('File paths must be all files or a single directory')
+      end
+    end
+
+    private def params_for_set_input_file_paths
+      if @local_directory
+        filenames = Dir["#{@local_directory}/**/*"].reject { |file| File.directory?(file) }
+        directory_stream, writable_streams = @context.send(:create_temp_files, @local_directory, filenames)
+
+        filenames.zip(writable_streams).each do |filename, writable_stream|
+          File.open(filename, 'rb') do |file|
+            writable_stream.write(file)
+          end
+        end
+
+        { directoryStream: directory_stream.channel }
+      else
+        filenames = @local_files.map do |file|
+          case file
+          when String
+            file
+          when File
+            file.path
+          end
+        end
+
+        _, writable_streams = @context.send(:create_temp_files, nil, filenames)
+        @local_files.zip(writable_streams).each do |file, writable_stream|
+          case file
+          when String
+            File.open(file, 'rb') do |file|
+              writable_stream.write(file)
+            end
+          when File
+            writable_stream.write(file)
+          end
+        end
+
+        { streams: writable_streams.map(&:channel) }
+      end
+    end
+
+    private def params_for_set_input_files
+      file_payloads = @local_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
+
+      { payloads: file_payloads }
     end
 
-    private def mime_type_for(filepath)
-      mime_types = MIME::Types.type_for(filepath)
-      mime_types.first || 'application/octet-stream'
+    private def raise_argument_error
+      raise ArgumentError.new('file must be a String or File.')
     end
   end
 end

data/lib/playwright/javascript/expression.rb

@@ -1,16 +1,15 @@
 module Playwright
   module JavaScript
     class Expression
-      def initialize(expression)
+      def initialize(expression, arg)
         @expression = expression
-        @serialized_arg = ValueSerializer.new(nil).serialize
+        @serialized_arg = ValueSerializer.new(arg).serialize
       end
 
       def evaluate(channel)
         value = channel.send_message_to_server(
           'evaluateExpression',
           expression: @expression,
-          isFunction: false,
           arg: @serialized_arg,
         )
         ValueParser.new(value).parse
@@ -20,20 +19,19 @@ module Playwright
         resp = channel.send_message_to_server(
           'evaluateExpressionHandle',
           expression: @expression,
-          isFunction: false,
           arg: @serialized_arg,
         )
         ::Playwright::ChannelOwner.from(resp)
       end
 
-      def eval_on_selector(channel, selector)
-        value = channel.send_message_to_server(
-          'evalOnSelector',
+      def eval_on_selector(channel, selector, strict: nil)
+        params = {
           selector: selector,
           expression: @expression,
-          isFunction: false,
           arg: @serialized_arg,
-        )
+        }
+        params[:strict] = strict if strict
+        value = channel.send_message_to_server('evalOnSelector', params)
         ValueParser.new(value).parse
       end
 
@@ -42,7 +40,6 @@ module Playwright
           'evalOnSelectorAll',
           selector: selector,
           expression: @expression,
-          isFunction: false,
           arg: @serialized_arg,
         )
         ValueParser.new(value).parse
@@ -51,7 +48,6 @@ module Playwright
       def wait_for_function(channel, polling:, timeout:)
         params = {
           expression: @expression,
-          isFunction: false,
           arg: @serialized_arg,
           polling: polling,
           timeout: timeout,

data/lib/playwright/javascript/regex.rb

@@ -0,0 +1,23 @@
+module Playwright
+  module JavaScript
+    class Regex
+      def initialize(regexp)
+        unless regexp.is_a?(Regexp)
+          raise ArgumentError("Argument must be a Regexp: #{regexp} (#{regexp.class})")
+        end
+
+        @source = regexp.source
+        @flag = flag_for(regexp)
+      end
+
+      attr_reader :source, :flag
+
+      private def flag_for(regexp)
+        flags = []
+        flags << 'ms' if (regexp.options & Regexp::MULTILINE) != 0
+        flags << 'i' if (regexp.options & Regexp::IGNORECASE) != 0
+        flags.join('')
+      end
+    end
+  end
+end

data/lib/playwright/javascript/source_url.rb

@@ -0,0 +1,16 @@
+module Playwright
+  module JavaScript
+    class SourceUrl
+      # @param source [String]
+      # @param path [String]
+      def initialize(source, path)
+        @source = source
+        @source_url = path.to_s.gsub("\n", '')
+      end
+
+      def to_s
+        "#{@source}\n//# sourceURL=#{@source_url}"
+      end
+    end
+  end
+end