ruby_sol 0.1

data/lib/ruby_sol/constants.rb

@@ -0,0 +1,50 @@
+module RubySol
+  # AMF0 Type Markers
+  AMF0_NUMBER_MARKER        = 0x00 #"\000"
+  AMF0_BOOLEAN_MARKER       = 0x01 #"\001"
+  AMF0_STRING_MARKER        = 0x02 #"\002"
+  AMF0_OBJECT_MARKER        = 0x03 #"\003"
+  AMF0_MOVIE_CLIP_MARKER    = 0x04 #"\004" # Unused
+  AMF0_NULL_MARKER          = 0x05 #"\005"
+  AMF0_UNDEFINED_MARKER     = 0x06 #"\006"
+  AMF0_REFERENCE_MARKER     = 0x07 #"\a"
+  AMF0_HASH_MARKER          = 0x08 #"\b"
+  AMF0_OBJECT_END_MARKER    = 0x09 #"\t"
+  AMF0_STRICT_ARRAY_MARKER  = 0x0A #"\n"
+  AMF0_DATE_MARKER          = 0x0B #"\v"
+  AMF0_LONG_STRING_MARKER   = 0x0C #"\f"
+  AMF0_UNSUPPORTED_MARKER   = 0x0D #"\r"
+  AMF0_RECORDSET_MARKER     = 0x0E #"\016" # Unused
+  AMF0_XML_MARKER           = 0x0F #"\017"
+  AMF0_TYPED_OBJECT_MARKER  = 0x10 #"\020"
+  AMF0_AMF3_MARKER          = 0x11 #"\021"
+
+  # AMF3 Type Markers
+  AMF3_UNDEFINED_MARKER     =  0x00 #"\000"
+  AMF3_NULL_MARKER          =  0x01 #"\001"
+  AMF3_FALSE_MARKER         =  0x02 #"\002"
+  AMF3_TRUE_MARKER          =  0x03 #"\003"
+  AMF3_INTEGER_MARKER       =  0x04 #"\004"
+  AMF3_DOUBLE_MARKER        =  0x05 #"\005"
+  AMF3_STRING_MARKER        =  0x06 #"\006"
+  AMF3_XML_DOC_MARKER       =  0x07 #"\a"
+  AMF3_DATE_MARKER          =  0x08 #"\b"
+  AMF3_ARRAY_MARKER         =  0x09 #"\t"
+  AMF3_OBJECT_MARKER        =  0x0A #"\n"
+  AMF3_XML_MARKER           =  0x0B #"\v"
+  AMF3_BYTE_ARRAY_MARKER    =  0x0C #"\f"
+  AMF3_VECTOR_INT_MARKER    =  0x0D #"\r"
+  AMF3_VECTOR_UINT_MARKER   =  0x0E #"\016"
+  AMF3_VECTOR_DOUBLE_MARKER =  0x0F #"\017"
+  AMF3_VECTOR_OBJECT_MARKER =  0x10 #"\020"
+  AMF3_DICT_MARKER          =  0x11 #"\021"
+
+  # Other AMF3 Markers
+  AMF3_EMPTY_STRING         = 0x01
+  AMF3_CLOSE_DYNAMIC_OBJECT = 0x01
+  AMF3_CLOSE_DYNAMIC_ARRAY  = 0x01
+
+  # Other Constants
+  MAX_INTEGER               = 268435455
+  MIN_INTEGER               = -268435456
+end

data/lib/ruby_sol/extensions.rb

@@ -0,0 +1,22 @@
+# Joc's monkeypatch for string bytesize (only available in 1.8.7+)
+if !"amf".respond_to? :bytesize
+  class String #:nodoc:
+    def bytesize
+      self.size
+    end
+  end
+end
+
+# Add <tt>ArrayCollection</tt> override to arrays
+class Array
+  # Override <tt>RubySol::ClassMapper.use_array_collection</tt> setting for
+  # this array. Adds <tt>is_array_collection?</tt> method, which is used by the
+  # serializer over the global config if defined.
+  def is_array_collection= a
+    @is_array_collection = a
+
+    def self.is_array_collection? #:nodoc:
+      @is_array_collection
+    end
+  end
+end

data/lib/ruby_sol/pure/deserializer.rb

@@ -0,0 +1,461 @@
+require 'ruby_sol/pure/io_helpers'
+
+module RubySol
+  module Pure
+    # Pure ruby deserializer for AMF0 and AMF3
+    class Deserializer
+      attr_accessor :source
+
+      # Pass in the class mapper instance to use when deserializing. This
+      # enables better caching behavior in the class mapper and allows
+      # one to change mappings between deserialization attempts.
+      def initialize class_mapper
+        @class_mapper = class_mapper
+        reset_caches()
+      end
+
+      def reset_caches
+        @ref_cache = []
+        @string_cache = []
+        @object_cache = []
+        @trait_cache = []
+      end
+
+      # Deserialize the source using AMF0 or AMF3. Source should either
+      # be a string or StringIO object. If you pass a StringIO object,
+      # it will have its position updated to the end of the deserialized
+      # data.
+      def deserialize version, source
+        raise ArgumentError, "unsupported version #{version}" unless [0,3].include?(version)
+        @version = version
+
+        if StringIO === source
+          @source = source
+        elsif source
+          @source = StringIO.new(source)
+        elsif @source.nil?
+          raise AMFError, "no source to deserialize"
+        end
+
+        reset_caches()
+
+        if @version == 0
+          return amf0_deserialize
+        else
+          return amf3_deserialize
+        end
+      end
+
+      # Reads an object from the deserializer's stream and returns it.
+      def read_object
+        if @version == 0
+          return amf0_deserialize
+        else
+          return amf3_deserialize
+        end
+      end
+
+   #   private
+      include RubySol::Pure::ReadIOHelpers
+
+      def amf0_deserialize type=nil
+        type = read_int8 @source unless type
+        case type
+        when AMF0_NUMBER_MARKER
+          amf0_read_number
+        when AMF0_BOOLEAN_MARKER
+          amf0_read_boolean
+        when AMF0_STRING_MARKER
+          amf0_read_string
+        when AMF0_OBJECT_MARKER
+          amf0_read_object
+        when AMF0_NULL_MARKER
+          nil
+        when AMF0_UNDEFINED_MARKER
+          nil
+        when AMF0_REFERENCE_MARKER
+          amf0_read_reference
+        when AMF0_HASH_MARKER
+          amf0_read_hash
+        when AMF0_STRICT_ARRAY_MARKER
+          amf0_read_array
+        when AMF0_DATE_MARKER
+          amf0_read_date
+        when AMF0_LONG_STRING_MARKER
+          amf0_read_string true
+        when AMF0_UNSUPPORTED_MARKER
+          nil
+        when AMF0_XML_MARKER
+          amf0_read_string true
+        when AMF0_TYPED_OBJECT_MARKER
+          amf0_read_typed_object
+        when AMF0_AMF3_MARKER
+          deserialize(3, nil)
+        else
+          raise AMFError, "Invalid type: #{type}"
+        end
+      end
+
+      def amf0_read_number
+        res = read_double @source
+        (res.is_a?(Float) && res.nan?) ? nil : res # check for NaN and convert them to nil
+      end
+
+      def amf0_read_boolean
+        read_int8(@source) != 0
+      end
+
+      def amf0_read_string long=false
+        len = long ? read_word32_network(@source) : read_word16_network(@source)
+        str = @source.read(len)
+        str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)
+        str
+      end
+
+      def amf0_read_reference
+        index = read_word16_network(@source)
+        @ref_cache[index]
+      end
+
+      def amf0_read_array
+        len = read_word32_network(@source)
+        array = []
+        @ref_cache << array
+
+        0.upto(len - 1) do
+          array << amf0_deserialize
+        end
+        array
+      end
+
+      def amf0_read_date
+        seconds = read_double(@source).to_f/1000
+        time = Time.at(seconds)
+        tz = read_word16_network(@source) # Unused
+        time
+      end
+
+      def amf0_read_props obj={}
+        while true
+          key = amf0_read_string
+          type = read_int8 @source
+          break if type == AMF0_OBJECT_END_MARKER
+          obj[key] = amf0_deserialize(type)
+        end
+        obj
+      end
+
+      def amf0_read_hash
+        len = read_word32_network(@source) # Read and ignore length
+        obj = {}
+        @ref_cache << obj
+        amf0_read_props obj
+      end
+
+      def amf0_read_object add_to_ref_cache=true
+        # Create "object" and add to ref cache (it's always a Hash)
+        obj = @class_mapper.get_ruby_obj ""
+        @ref_cache << obj
+
+        # Populate object
+        props = amf0_read_props
+        @class_mapper.populate_ruby_obj obj, props
+        return obj
+      end
+
+      def amf0_read_typed_object
+        # Create object to add to ref cache
+        class_name = amf0_read_string
+        obj = @class_mapper.get_ruby_obj class_name
+        @ref_cache << obj
+
+        # Populate object
+        props = amf0_read_props
+        @class_mapper.populate_ruby_obj obj, props
+        return obj
+      end
+
+      def amf3_deserialize
+        type = read_int8 @source
+        case type
+        when AMF3_UNDEFINED_MARKER
+          nil
+        when AMF3_NULL_MARKER
+          nil
+        when AMF3_FALSE_MARKER
+          false
+        when AMF3_TRUE_MARKER
+          true
+        when AMF3_INTEGER_MARKER
+          amf3_read_integer
+        when AMF3_DOUBLE_MARKER
+          amf3_read_number
+        when AMF3_STRING_MARKER
+          amf3_read_string
+        when AMF3_XML_DOC_MARKER, AMF3_XML_MARKER
+          amf3_read_xml
+        when AMF3_DATE_MARKER
+          amf3_read_date
+        when AMF3_ARRAY_MARKER
+          amf3_read_array
+        when AMF3_OBJECT_MARKER
+          amf3_read_object
+        when AMF3_BYTE_ARRAY_MARKER
+          amf3_read_byte_array
+        when AMF3_VECTOR_INT_MARKER, AMF3_VECTOR_UINT_MARKER, AMF3_VECTOR_DOUBLE_MARKER, AMF3_VECTOR_OBJECT_MARKER
+          amf3_read_vector type
+        when AMF3_DICT_MARKER
+          amf3_read_dict
+        else
+          raise AMFError, "Invalid type: #{type}"
+        end
+      end
+
+      def amf3_read_integer
+        n = 0
+        b = read_word8(@source) || 0
+        result = 0
+
+        while ((b & 0x80) != 0 && n < 3)
+          result = result << 7
+          result = result | (b & 0x7f)
+          b = read_word8(@source) || 0
+          n = n + 1
+        end
+
+        if (n < 3)
+          result = result << 7
+          result = result | b
+        else
+          #Use all 8 bits from the 4th byte
+          result = result << 8
+          result = result | b
+
+          #Check if the integer should be negative
+          if (result > MAX_INTEGER)
+            result -= (1 << 29)
+          end
+        end
+        result
+      end
+
+      def amf3_read_number
+        res = read_double @source
+        (res.is_a?(Float) && res.nan?) ? nil : res # check for NaN and convert them to nil
+      end
+
+      def amf3_read_string
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @string_cache[reference]
+        else
+          length = type >> 1
+          str = ""
+          if length > 0
+            str = @source.read(length)
+            str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)
+            @string_cache << str
+          end
+          return str
+        end
+      end
+
+      def amf3_read_xml
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          length = type >> 1
+          str = ""
+          if length > 0
+            str = @source.read(length)
+            str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)
+            @object_cache << str
+          end
+          return str
+        end
+      end
+
+      def amf3_read_byte_array
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          length = type >> 1
+          obj = StringIO.new @source.read(length)
+          @object_cache << obj
+          obj
+        end
+      end
+
+      def amf3_read_array
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          length = type >> 1
+          property_name = amf3_read_string
+          array = property_name.length > 0 ? {} : []
+          @object_cache << array
+
+          while property_name.length > 0
+            value = amf3_deserialize
+            array[property_name] = value
+            property_name = amf3_read_string
+          end
+          0.upto(length - 1) {|i| array[i] = amf3_deserialize }
+
+          array
+        end
+      end
+
+      def amf3_read_object
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          class_type = type >> 1
+          class_is_reference = (class_type & 0x01) == 0
+
+          if class_is_reference
+            reference = class_type >> 1
+            traits = @trait_cache[reference]
+          else
+            externalizable = (class_type & 0x02) != 0
+            dynamic = (class_type & 0x04) != 0
+            attribute_count = class_type >> 3
+            class_name = amf3_read_string
+
+            class_attributes = []
+            attribute_count.times{class_attributes << amf3_read_string} # Read class members
+
+            traits = {
+                      :class_name => class_name,
+                      :members => class_attributes,
+                      :externalizable => externalizable,
+                      :dynamic => dynamic
+                     }
+            @trait_cache << traits
+          end
+
+          # Optimization for deserializing ArrayCollection
+          if traits[:class_name] == "flex.messaging.io.ArrayCollection"
+            arr = amf3_deserialize # Adds ArrayCollection array to object cache
+            @object_cache << arr # Add again for ArrayCollection source array
+            return arr
+          end
+
+          obj = @class_mapper.get_ruby_obj traits[:class_name]
+          @object_cache << obj
+
+          if traits[:externalizable]
+            obj.read_external self
+          else
+            props = {}
+            traits[:members].each do |key|
+              value = amf3_deserialize
+              props[key] = value
+            end
+
+            dynamic_props = nil
+            if traits[:dynamic]
+              dynamic_props = {}
+              while (key = amf3_read_string) && key.length != 0  do # read next key
+                value = amf3_deserialize
+                dynamic_props[key] = value
+              end
+            end
+
+            @class_mapper.populate_ruby_obj obj, props, dynamic_props
+          end
+          obj
+        end
+      end
+
+      def amf3_read_date
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          seconds = read_double(@source).to_f/1000
+          time = Time.at(seconds)
+          @object_cache << time
+          time
+        end
+      end
+
+      def amf3_read_dict
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          dict = {}
+          @object_cache << dict
+          length = type >> 1
+          weak_keys = read_int8 @source # Ignore: Not supported in ruby
+          0.upto(length - 1) do |i|
+            dict[amf3_deserialize] = amf3_deserialize
+          end
+          dict
+        end
+      end
+
+      def amf3_read_vector vector_type
+        type = amf3_read_integer
+        is_reference = (type & 0x01) == 0
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          vec = []
+          @object_cache << vec
+          length = type >> 1
+          fixed_vector = read_int8 @source # Ignore
+          case vector_type
+          when AMF3_VECTOR_INT_MARKER
+            0.upto(length - 1) do |i|
+              int = read_word32_network(@source)
+              int = int - 2**32 if int > MAX_INTEGER
+              vec << int
+            end
+          when AMF3_VECTOR_UINT_MARKER
+            0.upto(length - 1) do |i|
+              vec << read_word32_network(@source)
+         #     puts vec[i].to_s(2)
+            end
+          when AMF3_VECTOR_DOUBLE_MARKER
+            0.upto(length - 1) do |i|
+              vec << amf3_read_number
+            end
+          when AMF3_VECTOR_OBJECT_MARKER
+            vector_class = amf3_read_string # Ignore
+        #    puts vector_class
+            0.upto(length - 1) do |i|
+              vec << amf3_deserialize
+            end
+          end
+          vec
+        end
+      end
+    end
+  end
+end