playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/javascript/value_parser.rb

@@ -1,10 +1,12 @@
-require 'date'
+require 'base64'
+require 'time'
 
 module Playwright
   module JavaScript
     class ValueParser
       def initialize(hash)
         @hash = hash
+        @refs = {}
       end
 
       # @return [Hash]
@@ -23,26 +25,52 @@ 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'
-              nil
-            when 'null'
-              nil
-            when 'NaN'
-              Float::NAN
-            when 'Infinity'
-              Float::INFINITY
-            when '-Infinity'
-              -Float::INFINITY
-            when '-0'
-              -0
-            end
+          return case hash['v']
+                 when 'undefined'
+                  nil
+                 when 'null'
+                  nil
+                 when 'NaN'
+                  Float::NAN
+                 when 'Infinity'
+                  Float::INFINITY
+                 when '-Infinity'
+                  -Float::INFINITY when '-0'
+                  -0
+                 end
         end
 
         if hash.key?('d')
-          return DateTime.parse(hash['d'])
+          return Time.parse(hash['d'])
+        end
+
+        if hash.key?('u')
+          return URI(hash['u'])
+        end
+
+        if hash.key?('bi')
+          return hash['bi'].to_i
+        end
+
+        if hash.key?('e')
+          return ::Playwright::Error.new(
+            message: hash['e']['m'],
+            name: hash['e']['n'],
+            stack: hash['e']['s'].split("\n"),
+          )
+        end
+
+        if hash.key?('m')
+          return parse_hash(hash['m']).to_h
+        end
+
+        if hash.key?('se')
+          return Set.new(parse_hash(hash['se']))
         end
 
         if hash.key?('r')
@@ -57,17 +85,78 @@ 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')
           return @handles[hash['h']]
         end
 
+        if hash.key?('ta')
+          encoded_bytes = hash['ta']['b']
+          decoded_bytes = Base64.strict_decode64(encoded_bytes)
+          array_type = hash['ta']['k']
+
+          if array_type == 'i8'
+            word_size = 1
+            unpack_format = 'c*' # signed char
+          elsif array_type == 'ui8' || array_type == 'ui8c'
+            word_size = 1
+            unpack_format = 'C*' # unsigned char
+          elsif array_type == 'i16'
+            word_size = 2
+            unpack_format = 's<*' # signed short, little-endian
+          elsif array_type == 'ui16'
+            word_size = 2
+            unpack_format = 'S<*' # unsigned short, little-endian
+          elsif array_type == 'i32'
+            word_size = 4
+            unpack_format = 'l<*' # signed long, little-endian
+          elsif array_type == 'ui32'
+            word_size = 4
+            unpack_format = 'L<*' # unsigned long, little-endian
+          elsif array_type == 'f32'
+            word_size = 4
+            unpack_format = 'e*' # float, little-endian
+          elsif array_type == 'f64'
+            word_size = 8
+            unpack_format = 'E*' # double, little-endian
+          elsif array_type == 'bi64'
+            word_size = 8
+            unpack_format = 'q<*' # signed long long, little-endian
+          elsif array_type == 'bui64'
+            word_size = 8
+            unpack_format = 'Q<*' # unsigned long long, little-endian
+          else
+            raise ArgumentError, "Unsupported array type: #{array_type}"
+          end
+
+          byte_len = decoded_bytes.bytesize
+          if byte_len.zero?
+            return []
+          end
+
+          if byte_len % word_size != 0
+            raise ArgumentError, "Decoded bytes length #{byte_len} is not a multiple of word size #{word_size} for type #{array_type}"
+          end
+
+          return decoded_bytes.unpack(unpack_format)
+        end
+
         raise ArgumentError.new("Unexpected value: #{hash}")
       end
     end

data/lib/playwright/javascript/value_serializer.rb

@@ -1,8 +1,13 @@
+require_relative './visitor_info'
+require_relative './regex'
+require 'uri'
+
 module Playwright
   module JavaScript
     class ValueSerializer
       def initialize(ruby_value)
         @value = ruby_value
+        @visited = VisitorInfo.new
       end
 
       # @return [Hash]
@@ -20,31 +25,65 @@ module Playwright
           @handles << value.channel
           { h: index }
         when nil
-          { v: 'undefined' }
+          { v: 'null' }
         when Float::NAN
           { v: 'NaN'}
         when Float::INFINITY
           { v: 'Infinity' }
         when -Float::INFINITY
           { v: '-Infinity' }
+        when ::Playwright::Error
+          {
+            e: {
+              n: value.name,
+              m: value.message,
+              s: value.stack.join("\n")
+            }
+          }
+        when StandardError
+          {
+            e: {
+              n: value.class.name,
+              m: value.message,
+              s: (value.backtrace || []).join("\n")
+            }
+          }
         when true, false
           { b: value }
         when Numeric
-          { n: value }
+          if !value.is_a?(Integer) || (-9007199254740992..9007199254740991).include?(value)
+            { n: value }
+          else
+            { bi: value.to_s }
+          end
         when String
           { s: value }
         when Time
           require 'time'
           { d: value.utc.iso8601 }
+        when ::URI
+          { u: value.to_s }
         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 Set
+          { se: serialize_value(value.to_a) }
         when Hash
-          { o: value.map { |key, v| { k: key, v: serialize_value(v) } } }
+          if value.any? { |k, v| !k.is_a?(String) && !k.is_a?(Symbol) } # Map
+            { m: serialize_value(value.to_a) }
+          else
+            id = @visited.log(value)
+            result = []
+            value.each { |key, v| result << { k: key, v: serialize_value(v) } }
+            { o: result, id: id }
+          end
         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,13 +1,5 @@
 require_relative './javascript/expression'
-require_relative './javascript/function'
 require_relative './javascript/value_parser'
 require_relative './javascript/value_serializer'
-
-module Playwright
-  module JavaScript
-    # Detect if str is likely to be a function
-    module_function def function?(str)
-      ['async', 'function'].any? { |key| str.strip.start_with?(key) } || str.include?('=>')
-    end
-  end
-end
+require_relative './javascript/regex'
+require_relative './javascript/source_url'

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

@@ -1,12 +1,16 @@
 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
     end
 
     def up(key)
-      @channel.send_message_to_server('keyboardDown', key: key)
+      @channel.send_message_to_server('keyboardUp', key: key)
     end
 
     def insert_text(text)