playwright-ruby-client 1.20.2 → 1.23.0

data/lib/playwright/channel_owners/route.rb

@@ -3,13 +3,28 @@ require 'mime/types'
 
 module Playwright
   define_channel_owner :Route do
+    private def set_handling_future(future)
+      @handling_future = future
+    end
+
+    private def handling_with_result(done, &block)
+      chain = @handling_future
+      raise 'Route is already handled!' unless chain
+      block.call
+      @handling_future = nil
+      chain.fulfill(done)
+    end
+
     def request
       ChannelOwners::Request.from(@initializer['request'])
     end
 
     def abort(errorCode: nil)
-      params = { errorCode: errorCode }.compact
-      @channel.async_send_message_to_server('abort', params)
+      handling_with_result(true) do
+        params = { errorCode: errorCode }.compact
+        # TODO _race_with_page_close
+        @channel.async_send_message_to_server('abort', params)
+      end
     end
 
     def fulfill(
@@ -19,69 +34,113 @@ module Playwright
           path: nil,
           status: nil,
           response: nil)
-      params = {
-        contentType: contentType,
-        status: status,
-      }.compact
-      option_body = body
+      handling_with_result(true) do
+        params = {
+          contentType: contentType,
+          status: status,
+        }.compact
+        option_body = body
 
-      if response
-        params[:status] ||= response.status
-        params[:headers] ||= response.headers
+        if response
+          params[:status] ||= response.status
+          params[:headers] ||= response.headers
 
-        if !body && !path && response.is_a?(APIResponse)
-          if response.send(:_request).send(:same_connection?, self)
-            params[:fetchResponseUid] = response.send(:fetch_uid)
-          else
-            option_body = response.body
+          if !body && !path && response.is_a?(APIResponse)
+            if response.send(:_request).send(:same_connection?, self)
+              params[:fetchResponseUid] = response.send(:fetch_uid)
+            else
+              option_body = response.body
+            end
           end
         end
-      end
 
-      content =
-        if option_body
-          option_body
+        content =
+          if option_body
+            option_body
+          elsif path
+            File.read(path)
+          else
+            nil
+          end
+
+        param_headers = headers || {}
+        if contentType
+          param_headers['content-type'] = contentType
         elsif path
-          File.read(path)
-        else
-          nil
+          param_headers['content-type'] = mime_type_for(path)
         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
+        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
-        param_headers['content-length'] ||= content.length.to_s
+
+        params[:headers] = HttpHeaders.new(param_headers).as_serialized
+
+        @channel.async_send_message_to_server('fulfill', params)
       end
+    end
 
-      params[:headers] = HttpHeaders.new(param_headers).as_serialized
+    def fallback(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = {
+        headers: headers,
+        method: method,
+        postData: postData,
+        url: url,
+      }.compact
 
-      @channel.async_send_message_to_server('fulfill', params)
+      handling_with_result(false) do
+        request.apply_fallback_overrides(overrides)
+      end
     end
 
     def continue(headers: nil, method: nil, postData: nil, url: nil)
-      overrides = { url: url, method: method }.compact
+      overrides = {
+        headers: headers,
+        method: method,
+        postData: postData,
+        url: url,
+      }.compact
 
-      if headers
-        overrides[:headers] = HttpHeaders.new(headers).as_serialized
+      handling_with_result(true) do
+        request.apply_fallback_overrides(overrides)
+        async_continue_route
       end
+    end
 
-      if postData
-        overrides[:postData] = Base64.strict_encode64(postData)
+    private def async_continue_route
+      post_data_for_wire =
+        if (post_data_from_overrides = request.send(:fallback_overrides)[:postData])
+          post_data_for_wire = Base64.strict_encode64(post_data_from_overrides)
+        else
+          nil
+        end
+
+      params = request.send(:fallback_overrides).dup
+
+      if params[:headers]
+        params[:headers] = HttpHeaders.new(params[:headers]).as_serialized
+      end
+
+      if post_data_for_wire
+        params[:postData] = post_data_for_wire
       end
 
-      @channel.async_send_message_to_server('continue', overrides)
+      # TODO _race_with_page_close
+      @channel.async_send_message_to_server('continue', params)
+    end
+
+    def redirect_navigation_request(url)
+      handling_with_result(true) do
+        # TODO _race_with_page_close
+        @channel.send_message_to_server('redirectNavigationRequest', { url: url })
+      end
     end
 
     private def mime_type_for(filepath)

data/lib/playwright/channel_owners/writable_stream.rb

@@ -0,0 +1,14 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :WritableStream do
+    # @param readable [File|IO]
+    def write(readable, bufsize = 1048576)
+      while buf = readable.read(bufsize)
+        binary = Base64.strict_encode64(buf)
+        @channel.send_message_to_server('write', binary: binary)
+      end
+      @channel.send_message_to_server('close')
+    end
+  end
+end

data/lib/playwright/connection.rb

@@ -24,6 +24,8 @@ module Playwright
       @remote = false
     end
 
+    attr_reader :local_utils
+
     def mark_as_remote
       @remote = true
     end
@@ -127,12 +129,15 @@ module Playwright
       params = msg['params']
 
       if method == "__create__"
-        create_remote_object(
+        remote_object = create_remote_object(
           parent_guid: guid,
           type: params["type"],
           guid: params["guid"],
           initializer: params["initializer"],
         )
+        if remote_object.is_a?(ChannelOwners::LocalUtils)
+          @local_utils = remote_object
+        end
         return
       end
 

data/lib/playwright/har_router.rb

@@ -0,0 +1,82 @@
+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'
+        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

@@ -7,7 +7,7 @@ module Playwright
 
     def as_serialized
       @headers.map do |key, value|
-        { name: key, value: value }
+        { 'name' => key, 'value' => value }
       end
     end
   end

data/lib/playwright/input_files.rb

@@ -2,18 +2,64 @@ require 'base64'
 
 module Playwright
   class InputFiles
-    def initialize(files)
-      @params = convert(files)
+    def initialize(context, files)
+      @context = context
+      if files.is_a?(Enumerable)
+        @files = files
+      else
+        @files = [files]
+      end
     end
 
-    def as_params
-      @params
+    def as_method_and_params
+      if has_large_file?
+        ['setInputFilePaths', 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|
+      @files.any? do |file|
+        case file
+        when String
+          File::Stat.new(file).size > max_bufsize
+        when File
+          file.stat.size > max_bufsize
+        else
+          raise_argument_error
+        end
+      end
+    end
+
+    private def params_for_set_input_file_paths
+      writable_streams = @files.map do |file|
+        case file
+        when String
+          writable_stream = @context.send(:create_temp_file, File.basename(file))
+
+          File.open(file, 'rb') do |file|
+            writable_stream.write(file)
+          end
+
+          writable_stream.channel
+        when File
+          writable_stream = @context.send(:create_temp_file, File.basename(file.path))
+          writable_stream.write(file)
+
+          writable_stream.channel
+        else
+          raise_argument_error
+        end
+      end
+
+      { streams: writable_streams }
+    end
+
+    private def params_for_set_input_files
+      file_payloads = @files.map do |file|
         case file
         when String
           {
@@ -26,9 +72,15 @@ module Playwright
             buffer: Base64.strict_encode64(file.read),
           }
         else
-          raise ArgumentError.new('file must be a String or File.')
+          raise_argument_error
         end
       end
+
+      { files: file_payloads }
+    end
+
+    private def raise_argument_error
+      raise ArgumentError.new('file must be a String or File.')
     end
   end
 end

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/value_parser.rb

@@ -5,6 +5,7 @@ module Playwright
     class ValueParser
       def initialize(hash)
         @hash = hash
+        @refs = {}
       end
 
       # @return [Hash]
@@ -23,6 +24,10 @@ module Playwright
           return hash[key] if hash.key?(key)
         end
 
+        if hash.key?('ref')
+          return @refs[hash['ref']]
+        end
+
         if hash.key?('v')
           return case hash['v']
                  when 'undefined'
@@ -55,11 +60,21 @@ module Playwright
         end
 
         if hash.key?('a')
-          return hash['a'].map { |value| parse_hash(value) }
+          result = []
+          if hash['id']
+            @refs[hash['id']] = result
+          end
+          hash['a'].each { |value| result << parse_hash(value) }
+          return result
         end
 
         if hash.key?('o')
-          return hash['o'].map { |obj| [obj['k'], parse_hash(obj['v'])] }.to_h
+          result = {}
+          if hash['id']
+            @refs[hash['id']] = result
+          end
+          hash['o'].each { |obj| result[obj['k']] = parse_hash(obj['v']) }
+          return result
         end
 
         if hash.key?('h')

data/lib/playwright/javascript/value_serializer.rb

@@ -1,8 +1,12 @@
+require_relative './visitor_info'
+require_relative './regex'
+
 module Playwright
   module JavaScript
     class ValueSerializer
       def initialize(ruby_value)
         @value = ruby_value
+        @visited = VisitorInfo.new
       end
 
       # @return [Hash]
@@ -37,14 +41,20 @@ module Playwright
           require 'time'
           { d: value.utc.iso8601 }
         when Regexp
-          flags = []
-          flags << 'ms' if (value.options & Regexp::MULTILINE) != 0
-          flags << 'i' if (value.options & Regexp::IGNORECASE) != 0
-          { r: { p: value.source, f: flags.join('') } }
+          regex_value = Regex.new(value)
+          { r: { p: regex_value.source, f: regex_value.flag } }
+        when -> (value) { @visited.ref(value) }
+          { ref: @visited.ref(value) }
         when Array
-          { a: value.map { |v| serialize_value(v) } }
+          id = @visited.log(value)
+          result = []
+          value.each { |v| result << serialize_value(v) }
+          { a: result, id: id }
         when Hash
-          { o: value.map { |key, v| { k: key, v: serialize_value(v) } } }
+          id = @visited.log(value)
+          result = []
+          value.each { |key, v| result << { k: key, v: serialize_value(v) } }
+          { o: result, id: id }
         else
           raise ArgumentError.new("Unexpected value: #{value}")
         end

data/lib/playwright/javascript/visitor_info.rb

@@ -0,0 +1,26 @@
+module Playwright
+  module JavaScript
+    class VisitorInfo
+      def initialize
+        @data = {}
+        @last_id = 0
+      end
+
+      # returns [Integer|nil]
+      def ref(object)
+        @data[object]
+      end
+
+      def log(object)
+        if @data[object]
+          raise ArgumentError.new("Already visited")
+        end
+
+        id = @last_id + 1
+        @last_id = id # FIXME: should thread-safe
+
+        @data[object] = id
+      end
+    end
+  end
+end

data/lib/playwright/javascript.rb

@@ -1,3 +1,4 @@
 require_relative './javascript/expression'
 require_relative './javascript/value_parser'
 require_relative './javascript/value_serializer'
+require_relative './javascript/regex'

data/lib/playwright/locator_impl.rb

@@ -31,11 +31,9 @@ module Playwright
 
       case hasText
       when Regexp
-        source = EscapeWithQuotes.new(hasText.source, '"')
-        flags = []
-        flags << 'ms' if (hasText.options & Regexp::MULTILINE) != 0
-        flags << 'i' if (hasText.options & Regexp::IGNORECASE) != 0
-        selector_scopes << ":scope:text-matches(#{source}, \"#{flags.join('')}\")"
+        regex = JavaScript::Regex.new(hasText)
+        source = EscapeWithQuotes.new(regex.source, '"')
+        selector_scopes << ":scope:text-matches(#{source}, \"#{regex.flag}\")"
       when String
         text = EscapeWithQuotes.new(hasText, '"')
         selector_scopes << ":scope:has-text(#{text})"
@@ -239,6 +237,16 @@ module Playwright
       @frame.query_selector_all(@selector)
     end
 
+    def filter(has: nil, hasText: nil)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: @selector,
+        hasText: hasText,
+        has: has,
+      )
+    end
+
     def first
       LocatorImpl.new(
         frame: @frame,
@@ -314,19 +322,24 @@ module Playwright
 
     def screenshot(
           animations: nil,
+          caret: nil,
           mask: nil,
           omitBackground: nil,
           path: nil,
           quality: nil,
+          scale: nil,
           timeout: nil,
           type: nil)
+
       with_element(timeout: timeout) do |handle, options|
         handle.screenshot(
           animations: animations,
+          caret: caret,
           mask: mask,
           omitBackground: omitBackground,
           path: path,
           quality: quality,
+          scale: scale,
           timeout: options[:timeout],
           type: type)
       end

data/lib/playwright/playwright_api.rb

@@ -122,21 +122,41 @@ module Playwright
       }
     end
 
-    private def wrap_impl(object)
+    private def wrap_impl(object, visited: {})
       if object.is_a?(Array)
-        object.map { |obj| wrap_impl(obj) }
+        unless visited[object]
+          visited[object] = []
+          object.each { |obj| visited[object] << wrap_impl(obj) }
+        end
+        visited[object]
       elsif object.is_a?(Hash)
-        object.map { |key, obj| [key, wrap_impl(obj)] }.to_h
+        unless visited[object]
+          visited[object] = {}
+          object.each do |key, obj|
+            visited[object][key] = wrap_impl(obj, visited: visited)
+          end
+        end
+        visited[object]
       else
         ::Playwright::PlaywrightApi.wrap(object)
       end
     end
 
-    private def unwrap_impl(object)
+    private def unwrap_impl(object, visited: {})
       if object.is_a?(Array)
-        object.map { |obj| unwrap_impl(obj) }
+        unless visited[object]
+          visited[object] = []
+          object.each { |obj| visited[object] << unwrap_impl(obj) }
+        end
+        visited[object]
       elsif object.is_a?(Hash)
-        object.map { |key, obj| [key, unwrap_impl(obj)] }.to_h
+        unless visited[object]
+          visited[object] = {}
+          object.each do |key, obj|
+            visited[object][key] = unwrap_impl(obj, visited: visited)
+          end
+        end
+        visited[object]
       elsif object.is_a?(PlaywrightApi)
         ::Playwright::PlaywrightApi.unwrap(object)
       else

data/lib/playwright/route_handler.rb

@@ -50,12 +50,8 @@ module Playwright
     def async_handle(route, request)
       @counter.increment
 
-      Concurrent::Promises.future do
-        begin
-          @handler.call(route, request)
-        rescue => err
-          puts err, err.backtrace
-        end
+      Concurrent::Promises.future { @handler.call(route, request) }.rescue do |err|
+        puts err, err.backtrace
       end
     end