RocketAMF 0.0.5

data/README.rdoc

@@ -0,0 +1,36 @@
+== DESCRIPTION:
+
+A fast AMF serializer/deserializer and request/response wrappers to simplify remoting implementation.
+
+== INSTALL:
+
+  gem install RocketAMF --source="http://gemcutter.org"
+
+== EXAMPLE:
+
+NEED TO WRITE SOMETHING HERE
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Tony Hillerson based on work by Aaron Smith
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+require 'spec/rake/spectask'
+
+desc 'Default: run the specs.'
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', 'spec/spec.opts']
+end
+
+desc 'Generate documentation for the RocketAMF plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RocketAMF'
+  rdoc.options << '--line-numbers' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name    = 'RocketAMF'
+  s.version = '0.0.5'
+  s.summary = 'Fast AMF serializer/deserializer and request/response wrappers to simplify remoting implementation'
+
+  s.files        = FileList['README.rdoc', 'Rakefile', 'lib/**/*.rb', 'spec/**/*.rb', 'spec/**/*.bin', 'spec/spec.opts']
+  s.require_path = 'lib'
+  s.test_files   = Dir[*['spec/**/*_spec.rb']]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options     = ['--line-numbers', '--main', 'README.rdoc']
+
+  s.authors  = ['Tony Hillerson', 'Stephen Augenstein']
+  s.email    = 'perl.programmer@gmail.com'
+  s.homepage = 'http://github.com/warhammerkid/rocket-amf'
+
+  s.platform = Gem::Platform::RUBY
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc 'Generate a gemspec file'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/lib/rocketamf.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.unshift "#{File.expand_path(File.dirname(__FILE__))}/rocketamf/"
+
+require 'rocketamf/common'
+
+module RocketAMF
+  begin
+    raise LoadError, 'C extensions not implemented'
+  rescue LoadError
+    require 'rocketamf/pure'
+  end
+end

data/lib/rocketamf/class_mapping.rb

@@ -0,0 +1,211 @@
+require 'rocketamf/values/typed_hash'
+require 'rocketamf/values/array_collection'
+require 'rocketamf/values/messages'
+
+module RocketAMF
+  # == Class Mapping
+  #
+  # Handles class name mapping between actionscript and ruby and assists in
+  # serializing and deserializing data between them. Simply map an AS class to a
+  # ruby class and when the object is (de)serialized it will end up as the
+  # appropriate class.
+  #
+  # Example:
+  #
+  #   RocketAMF::ClassMapper.define do |m|
+  #     m.map :as => 'AsClass', :ruby => 'RubyClass'
+  #     m.map :as => 'vo.User', :ruby => 'User'
+  #   end
+  #
+  # == Object Population/Serialization
+  #
+  # In addition to handling class name mapping, it also provides helper methods
+  # for populating ruby objects from AMF and extracting properties from ruby objects
+  # for serialization. Support for hash-like objects and objects using
+  # <tt>attr_accessor</tt> for properties is currently built in, but custom classes
+  # may need custom support. As such, it is possible to create a custom populator
+  # or serializer.
+  #
+  # Populators are processed in insert order and must respond to the <tt>can_handle?</tt>
+  # and <tt>populate</tt> methods.
+  #
+  # Example:
+  #
+  #   class CustomPopulator
+  #     def can_handle? obj
+  #       true
+  #     end
+  #   
+  #     def populate obj, props, dynamic_props
+  #       obj.merge! props
+  #       obj.merge!(dynamic_props) if dynamic_props
+  #     end
+  #   end
+  #   RocketAMF::ClassMapper.object_populators << CustomPopulator.new
+  #
+  # Serializers are also processed in insert order and must respond to the
+  # <tt>can_handle?</tt> and <tt>serialize</tt> methods.
+  #
+  # Example:
+  #
+  #   class CustomSerializer
+  #     def can_handle? obj
+  #       true
+  #     end
+  #   
+  #     def serialize obj
+  #       {}
+  #     end
+  #   end
+  #   RocketAMF::ClassMapper.object_serializers << CustomSerializer.new
+  class ClassMapping
+    # Container for all mapped classes
+    class MappingSet
+      def initialize #:nodoc:
+        @as_mappings = {}
+        @ruby_mappings = {}
+
+        # Map defaults
+        map :as => 'flex.messaging.messages.AbstractMessage', :ruby => 'RocketAMF::Values::AbstractMessage'
+        map :as => 'flex.messaging.messages.RemotingMessage', :ruby => 'RocketAMF::Values::RemotingMessage'
+        map :as => 'flex.messaging.messages.AsyncMessage', :ruby => 'RocketAMF::Values::AsyncMessage'
+        map :as => 'flex.messaging.messages.CommandMessage', :ruby => 'RocketAMF::Values::CommandMessage'
+        map :as => 'flex.messaging.messages.AcknowledgeMessage', :ruby => 'RocketAMF::Values::AcknowledgeMessage'
+        map :as => 'flex.messaging.messages.ErrorMessage', :ruby => 'RocketAMF::Values::ErrorMessage'
+        map :as => 'flex.messaging.io.ArrayCollection', :ruby => 'RocketAMF::Values::ArrayCollection'
+      end
+
+      # Map a given AS class to a ruby class.
+      #
+      # Use fully qualified names for both.
+      #
+      # Example:
+      #
+      #   m.map :as 'com.example.Date', :ruby => 'Example::Date'
+      def map params
+        [:as, :ruby].each {|k| params[k] = params[k].to_s} # Convert params to strings
+        @as_mappings[params[:as]] = params[:ruby]
+        @ruby_mappings[params[:ruby]] = params[:as]
+      end
+
+      # Returns the AS class name for the given ruby class name, returing nil if
+      # not found
+      def get_as_class_name class_name #:nodoc:
+        @ruby_mappings[class_name.to_s]
+      end
+
+      # Returns the ruby class name for the given AS class name, returing nil if
+      # not found
+      def get_ruby_class_name class_name #:nodoc:
+        @as_mappings[class_name.to_s]
+      end
+    end
+
+    # Array of custom object populators.
+    attr_reader :object_populators
+
+    # Array of custom object serializers.
+    attr_reader :object_serializers
+
+    def initialize #:nodoc:
+      @object_populators = []
+      @object_serializers = []
+    end
+
+    # Define class mappings in the block. Block is passed a MappingSet object as
+    # the first parameter.
+    #
+    # Example:
+    #
+    #   RocketAMF::ClassMapper.define do |m|
+    #     m.map :as => 'AsClass', :ruby => 'RubyClass'
+    #   end
+    def define #:yields: mapping_set
+      yield mappings
+    end
+
+    # Returns the AS class name for the given ruby object. Will also take a string
+    # containing the ruby class name
+    def get_as_class_name obj
+      # Get class name
+      if obj.is_a?(String)
+        ruby_class_name = obj
+      elsif obj.is_a?(Values::TypedHash)
+        ruby_class_name = obj.type
+      else
+        ruby_class_name = obj.class.name
+      end
+
+      # Get mapped AS class name
+      mappings.get_as_class_name ruby_class_name
+    end
+
+    # Instantiates a ruby object using the mapping configuration based on the
+    # source AS class name. If there is no mapping defined, it returns a hash.
+    def get_ruby_obj as_class_name
+      ruby_class_name = mappings.get_ruby_class_name as_class_name
+      if ruby_class_name.nil?
+        # Populate a simple hash, since no mapping
+        return Values::TypedHash.new(as_class_name)
+      else
+        ruby_class = ruby_class_name.split('::').inject(Kernel) {|scope, const_name| scope.const_get(const_name)}
+        return ruby_class.new
+      end
+    end
+
+    # Populates the ruby object using the given properties
+    def populate_ruby_obj obj, props, dynamic_props=nil
+      # Process custom populators
+      @object_populators.each do |p|
+        next unless p.can_handle?(obj)
+        p.populate obj, props, dynamic_props
+        return obj
+      end
+
+      # Fallback populator
+      props.merge! dynamic_props if dynamic_props
+      hash_like = obj.respond_to?("[]=")
+      props.each do |key, value|
+        if obj.respond_to?("#{key}=")
+          obj.send("#{key}=", value)
+        elsif hash_like
+          obj[key.to_sym] = value
+        end
+      end
+      obj
+    end
+
+    # Extracts all exportable properties from the given ruby object and returns
+    # them in a hash
+    def props_for_serialization ruby_obj
+      # Proccess custom serializers
+      @object_serializers.each do |s|
+        next unless s.can_handle?(ruby_obj)
+        return s.serialize(ruby_obj)
+      end
+
+      # Handle hashes
+      if ruby_obj.is_a?(Hash)
+        # Stringify keys to make it easier later on and allow sorting
+        h = {}
+        ruby_obj.each {|k,v| h[k.to_s] = v}
+        return h
+      end
+
+      # Fallback serializer
+      props = {}
+      @ignored_props ||= Object.new.public_methods
+      (ruby_obj.public_methods - @ignored_props).each do |method_name|
+        # Add them to the prop hash if they take no arguments
+        method_def = ruby_obj.method(method_name)
+        props[method_name] = ruby_obj.send(method_name) if method_def.arity == 0
+      end
+      props
+    end
+
+    private
+    def mappings
+      @mappings ||= MappingSet.new
+    end
+  end
+end

data/lib/rocketamf/common.rb

@@ -0,0 +1,35 @@
+require 'rocketamf/version'
+require 'rocketamf/class_mapping'
+require 'rocketamf/constants'
+require 'rocketamf/remoting'
+
+module RocketAMF
+  class << self
+    # Deserialize the AMF string _source_ into a Ruby data structure and return it.
+    def deserialize source, amf_version = 0
+      if amf_version == 0
+        RocketAMF::Deserializer.new.deserialize(source)
+      elsif amf_version == 3
+        RocketAMF::AMF3Deserializer.new.deserialize(source)
+      else
+        raise AMFError, "unsupported version #{amf_version}"
+      end
+    end
+
+    # Serialize the given Ruby data structure _obj_ into an AMF stream
+    def serialize obj, amf_version = 0
+      if amf_version == 0
+        RocketAMF::Serializer.new.serialize(obj)
+      elsif amf_version == 3
+        RocketAMF::AMF3Serializer.new.serialize(obj)
+      else
+        raise AMFError, "unsupported version #{amf_version}"
+      end
+    end
+  end
+
+  ClassMapper = RocketAMF::ClassMapping.new
+
+  # The base exception for AMF errors.
+  class AMFError < StandardError; end
+end

data/lib/rocketamf/constants.rb

@@ -0,0 +1,47 @@
+module RocketAMF
+  # 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"
+
+  # Other AMF3 Markers
+  AMF3_EMPTY_STRING             = 0x01
+  AMF3_ANONYMOUS_OBJECT         = 0x01
+  AMF3_DYNAMIC_OBJECT           = 0x0B
+  AMF3_CLOSE_DYNAMIC_OBJECT     = 0x01
+  AMF3_CLOSE_DYNAMIC_ARRAY      = 0x01
+
+  # Other Constants
+  MAX_INTEGER               = 268435455
+  MIN_INTEGER               = -268435456
+end

data/lib/rocketamf/pure.rb

@@ -0,0 +1,30 @@
+require 'rocketamf/pure/deserializer'
+require 'rocketamf/pure/serializer'
+require 'rocketamf/pure/remoting'
+
+module RocketAMF
+  # This module holds all the modules/classes that implement AMF's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for RocketAMF."
+  end
+
+  # Import Deserializer
+  Deserializer = RocketAMF::Pure::Deserializer
+  AMF3Deserializer = RocketAMF::Pure::AMF3Deserializer
+
+  # Import serializer
+  Serializer = RocketAMF::Pure::Serializer
+  AMF3Serializer = RocketAMF::Pure::AMF3Serializer
+
+  # Modify request and response so they can serialize/deserialize
+  class Request
+    remove_method :populate_from_stream
+    include RocketAMF::Pure::Request
+  end
+
+  class Response
+    remove_method :serialize
+    include RocketAMF::Pure::Response
+  end
+end

data/lib/rocketamf/pure/deserializer.rb

@@ -0,0 +1,361 @@
+require 'rocketamf/pure/io_helpers'
+
+module RocketAMF
+  module Pure
+    # Pure ruby deserializer
+    #--
+    # AMF0 deserializer, it switches over to AMF3 when it sees the switch flag
+    class Deserializer
+      def initialize
+        @ref_cache = []
+      end
+
+      def deserialize(source, type=nil)
+        source = StringIO.new(source) unless StringIO === source
+        type = read_int8 source unless type
+        case type
+        when AMF0_NUMBER_MARKER
+          read_number source
+        when AMF0_BOOLEAN_MARKER
+          read_boolean source
+        when AMF0_STRING_MARKER
+          read_string source
+        when AMF0_OBJECT_MARKER
+          read_object source
+        when AMF0_NULL_MARKER
+          nil
+        when AMF0_UNDEFINED_MARKER
+          nil
+        when AMF0_REFERENCE_MARKER
+          read_reference source
+        when AMF0_HASH_MARKER
+          read_hash source
+        when AMF0_STRICT_ARRAY_MARKER
+          read_array source
+        when AMF0_DATE_MARKER
+          read_date source
+        when AMF0_LONG_STRING_MARKER
+          read_string source, true
+        when AMF0_UNSUPPORTED_MARKER
+          nil
+        when AMF0_XML_MARKER
+          #read_xml source
+        when AMF0_TYPED_OBJECT_MARKER
+          read_typed_object source
+        when AMF0_AMF3_MARKER
+          AMF3Deserializer.new.deserialize(source)
+        end
+      end
+
+      private
+      include RocketAMF::Pure::ReadIOHelpers
+
+      def read_number source
+        res = read_double source
+        res.is_a?(Float)&&res.nan? ? nil : res # check for NaN and convert them to nil
+      end
+
+      def read_boolean source
+        read_int8(source) != 0
+      end
+
+      def read_string source, long=false
+        len = long ? read_word32_network(source) : read_word16_network(source)
+        source.read(len)
+      end
+
+      def read_object source, add_to_ref_cache=true
+        obj = {}
+        @ref_cache << obj if add_to_ref_cache
+        while true
+          key = read_string source
+          type = read_int8 source
+          break if type == AMF0_OBJECT_END_MARKER
+          obj[key.to_sym] = deserialize(source, type)
+        end
+        obj
+      end
+
+      def read_reference source
+        index = read_word16_network(source)
+        @ref_cache[index]
+      end
+
+      def read_hash source
+        len = read_word32_network(source) # Read and ignore length
+
+        # Read first pair
+        key = read_string source
+        type = read_int8 source
+        return [] if type == AMF0_OBJECT_END_MARKER
+
+        # We need to figure out whether this is a real hash, or whether some stupid serializer gave up
+        if key.to_i.to_s == key
+          # Array
+          obj = []
+          @ref_cache << obj
+
+          obj[key.to_i] = deserialize(source, type)
+          while true
+            key = read_string source
+            type = read_int8 source
+            break if type == AMF0_OBJECT_END_MARKER
+            obj[key.to_i] = deserialize(source, type)
+          end
+        else
+          # Hash
+          obj = {}
+          @ref_cache << obj
+
+          obj[key.to_sym] = deserialize(source, type)
+          while true
+            key = read_string source
+            type = read_int8 source
+            break if type == AMF0_OBJECT_END_MARKER
+            obj[key.to_sym] = deserialize(source, type)
+          end
+        end
+        obj
+      end
+
+      def read_array source
+        len = read_word32_network(source)
+        array = []
+        @ref_cache << array
+
+        0.upto(len - 1) do
+          array << deserialize(source)
+        end
+        array
+      end
+
+      def read_date source
+        seconds = read_double(source).to_f/1000
+        time = Time.at(seconds)
+        tz = read_word16_network(source) # Unused
+        time
+      end
+
+      def read_typed_object source
+        # Create object to add to ref cache
+        class_name = read_string source
+        obj = ClassMapper.get_ruby_obj class_name
+        @ref_cache << obj
+
+        # Read object props
+        props = read_object source, false
+
+        # Populate object
+        ClassMapper.populate_ruby_obj obj, props, {}
+        return obj
+      end
+    end
+
+    # AMF3 implementation of deserializer, loaded automatically by the AMF0
+    # deserializer when needed
+    class AMF3Deserializer
+      def initialize
+        @string_cache = []
+        @object_cache = []
+        @trait_cache = []
+      end
+
+      def deserialize(source, type=nil)
+        source = StringIO.new(source) unless StringIO === source
+        type = read_int8 source unless type
+        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
+            read_integer source
+          when AMF3_DOUBLE_MARKER
+            read_number source
+          when AMF3_STRING_MARKER
+            read_string source
+          when AMF3_XML_DOC_MARKER
+            #read_xml_string
+          when AMF3_DATE_MARKER
+            read_date source
+          when AMF3_ARRAY_MARKER
+            read_array source
+          when AMF3_OBJECT_MARKER
+            read_object source
+          when AMF3_XML_MARKER
+            #read_amf3_xml
+          when AMF3_BYTE_ARRAY_MARKER
+            #read_amf3_byte_array
+        end
+      end
+
+      private
+      include RocketAMF::Pure::ReadIOHelpers
+
+      def read_integer source
+        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 read_number source
+        res = read_double source
+        res.is_a?(Float)&&res.nan? ? nil : res # check for NaN and convert them to nil
+      end
+
+      def read_string source
+        type = read_integer source
+        isReference = (type & 0x01) == 0
+
+        if isReference
+          reference = type >> 1
+          return @string_cache[reference]
+        else
+          length = type >> 1
+          #HACK needed for ['',''] array of empty strings
+          #It may be better to take one more parameter that
+          #would specify whether or not they expect us to return
+          #a string
+          str = "" #if stringRequest
+          if length > 0
+            str = source.read(length)
+            @string_cache << str
+          end
+          return str
+        end
+      end
+
+      def read_array source
+        type = read_integer source
+        isReference = (type & 0x01) == 0
+
+        if isReference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          length = type >> 1
+          propertyName = read_string source
+          if propertyName != ""
+            array = {}
+            @object_cache << array
+            begin
+              while(propertyName.length)
+                value = deserialize(source)
+                array[propertyName] = value
+                propertyName = read_string source
+              end
+            rescue Exception => e #end of object exception, because propertyName.length will be non existent
+            end
+            0.upto(length - 1) do |i|
+              array["" + i.to_s] = deserialize(source)
+            end
+          else
+            array = []
+            @object_cache << array
+            0.upto(length - 1) do
+              array << deserialize(source)
+            end
+          end
+          array
+        end
+      end
+
+      def read_object source
+        type = read_integer source
+        isReference = (type & 0x01) == 0
+
+        if isReference
+          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
+            class_definition = @trait_cache[reference]
+          else
+            class_name = read_string source
+            externalizable = (class_type & 0x02) != 0
+            dynamic = (class_type & 0x04) != 0
+            attribute_count = class_type >> 3
+
+            class_attributes = []
+            attribute_count.times{class_attributes << read_string(source)} # Read class members
+
+            class_definition = {"class_name" => class_name,
+                                "members" => class_attributes,
+                                "externalizable" => externalizable,
+                                "dynamic" => dynamic}
+            @trait_cache << class_definition
+          end
+
+          obj = ClassMapper.get_ruby_obj class_definition["class_name"]
+          @object_cache << obj
+
+          if class_definition['externalizable']
+            obj.externalized_data = deserialize(source)
+          else
+            props = {}
+            class_definition['members'].each do |key|
+              value = deserialize(source)
+              props[key.to_sym] = value
+            end
+
+            dynamic_props = nil
+            if class_definition['dynamic']
+              dynamic_props = {}
+              while (key = read_string source) && key.length != 0  do # read next key
+                value = deserialize(source)
+                dynamic_props[key.to_sym] = value
+              end
+            end
+
+            ClassMapper.populate_ruby_obj obj, props, dynamic_props
+          end
+          obj
+        end
+      end
+
+      def read_date source
+        type = read_integer source
+        isReference = (type & 0x01) == 0
+        if isReference
+          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
+    end
+  end
+end