mrpin-rocketamf 1.0.4 → 2.0.0

data/lib/rocketamf/errors.rb

@@ -0,0 +1,2 @@
+require 'rocketamf/errors/amf_error'
+require 'rocketamf/errors/amf_error_incomplete'

data/lib/rocketamf/errors/amf_error.rb

@@ -0,0 +1,5 @@
+module RocketAMF
+  # The standard AMF error.
+  class AMFError < StandardError
+  end
+end

data/lib/rocketamf/errors/amf_error_incomplete.rb

@@ -0,0 +1,5 @@
+module RocketAMF
+  # Error for incomplete messages
+  class AMFErrorIncomplete < AMFError
+  end
+end

data/lib/rocketamf/ext.rb

@@ -18,11 +18,5 @@ module RocketAMF
   Deserializer = RocketAMF::Ext::Deserializer
   Serializer = RocketAMF::Ext::Serializer
 
-  # Modify envelope so it can serialize/deserialize
-  class Envelope
-    remove_method :populate_from_stream
-    remove_method :serialize
-    include RocketAMF::Ext::Envelope
-  end
   #:startdoc:
 end

data/lib/rocketamf/extensions.rb

@@ -1,5 +1,5 @@
 # Joc's monkeypatch for string bytesize (only available in 1.8.7+)
-if !"amf".respond_to? :bytesize
+unless 'amf'.respond_to?(:bytesize)
   class String #:nodoc:
     def bytesize
       self.size
@@ -9,11 +9,11 @@ end
 
 # Add <tt>ArrayCollection</tt> override to arrays
 class Array
-  # Override <tt>RocketAMF::ClassMapper.use_array_collection</tt> setting for
+  # Override <tt>RocketAMF::CLASS_MAPPER.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 is_array_collection=(value)
+    @is_array_collection = value
 
     def self.is_array_collection? #:nodoc:
       @is_array_collection

data/lib/rocketamf/{class_mapping.rb → mapping/class_mapping.rb}

@@ -1,67 +1,17 @@
-require 'rocketamf/values/typed_hash'
-require 'rocketamf/values/messages'
+require 'rocketamf/mapping/mapping_set'
 
 module RocketAMF
-  # Container for all mapped classes
-  class MappingSet
-    # Creates a mapping set object and populates the default mappings
-    def initialize
-      @as_mappings = {}
-      @ruby_mappings = {}
-      map_defaults
-    end
-
-    # Adds required mapping configs, calling map for the required base mappings.
-    # Designed to allow extenders to take advantage of required default mappings.
-    def 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 => 'DSA', :ruby => 'RocketAMF::Values::AsyncMessageExt'
-      map :as => 'flex.messaging.messages.CommandMessage', :ruby => 'RocketAMF::Values::CommandMessage'
-      map :as => 'DSC', :ruby => 'RocketAMF::Values::CommandMessageExt'
-      map :as => 'flex.messaging.messages.AcknowledgeMessage', :ruby => 'RocketAMF::Values::AcknowledgeMessage'
-      map :as => 'DSK', :ruby => 'RocketAMF::Values::AcknowledgeMessageExt'
-      map :as => 'flex.messaging.messages.ErrorMessage', :ruby => 'RocketAMF::Values::ErrorMessage'
-      self
-    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
 
-  # Handles class name mapping between actionscript and ruby and assists in
+  # Handles class name mapping between AS 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 => 'Model::User'
+  #   RocketAMF::CLASS_MAPPER.define do |m|
+  #     m.map as: 'AsClass', ruby: 'RubyClass'
+  #     m.map as: 'vo.User', ruby: 'Model::User'
   #   end
   #
   # == Object Population/Serialization
@@ -76,8 +26,8 @@ module RocketAMF
   #
   # In some cases, it may be beneficial to replace the default provider of class
   # mapping completely. In this case, simply assign your class mapper class to
-  # <tt>RocketAMF::ClassMapper</tt> after loading RocketAMF. Through the magic of
-  # <tt>const_missing</tt>, <tt>ClassMapper</tt> is only defined after the first
+  # <tt>RocketAMF::CLASS_MAPPER</tt> after loading RocketAMF. Through the magic of
+  # <tt>const_missing</tt>, <tt>CLASS_MAPPER</tt> is only defined after the first
   # access by default, so you get no annoying warning messages. Custom class mappers
   # must implement the following methods on instances: <tt>use_array_collection</tt>,
   # <tt>get_as_class_name</tt>, <tt>get_ruby_obj</tt>, <tt>populate_ruby_obj</tt>,
@@ -90,10 +40,8 @@ module RocketAMF
   #
   #   require 'rubygems'
   #   require 'rocketamf'
-  #   
-  #   RocketAMF::ClassMapper = MyCustomClassMapper
-  #   # No warning about already initialized constant ClassMapper
-  #   RocketAMF::ClassMapper # MyCustomClassMapper
+  #
+  #   RocketAMF.const_set(CLASS_MAPPER, MyCustomClassMapper)
   #
   # == C ClassMapper
   #
@@ -113,6 +61,7 @@ module RocketAMF
   #
   #   require 'rubygems'
   #   require 'rocketamf'
+  #todo:review
   #   RocketAMF::ClassMapper = RocketAMF::Ext::FastClassMapping
   class ClassMapping
     class << self
@@ -131,10 +80,10 @@ module RocketAMF
       #
       # Example:
       #
-      #   RocketAMF::ClassMapper.define do |m|
-      #     m.map :as => 'AsClass', :ruby => 'RubyClass'
+      #   RocketAMF::CLASS_MAPPER.define do |m|
+      #     m.map as: 'AsClass', ruby: 'RubyClass'
       #   end
-      def define &block #:yields: mapping_set
+      def define(&block) #:yields: mapping_set
         yield mappings
       end
 
@@ -142,25 +91,34 @@ module RocketAMF
       # <tt>use_array_collection</tt> to false
       def reset
         @use_array_collection = false
-        @mappings = nil
+        @mappings             = nil
       end
     end
 
+    #
+    # Properties
+    #
+
     attr_reader :use_array_collection
 
+    #
+    # Methods
+    #
+
     # Copies configuration from class level configs to populate object
+    public
     def initialize
-      @mappings = self.class.mappings
+      @mappings             = self.class.mappings
       @use_array_collection = self.class.use_array_collection === true
     end
 
     # Returns the ActionScript class name for the given ruby object. Will also
     # take a string containing the ruby class name.
-    def get_as_class_name obj
+    def get_as_class_name(obj)
       # Get class name
       if obj.is_a?(String)
         ruby_class_name = obj
-      elsif obj.is_a?(Values::TypedHash)
+      elsif obj.is_a?(Types::TypedHash)
         ruby_class_name = obj.type
       elsif obj.is_a?(Hash)
         return nil
@@ -169,44 +127,49 @@ module RocketAMF
       end
 
       # Get mapped AS class name
-      @mappings.get_as_class_name ruby_class_name
+      @mappings.get_as_class_name(ruby_class_name)
     end
 
     # Instantiates a ruby object using the mapping configuration based on the
     # source ActionScript class name. If there is no mapping defined, it returns
-    # a <tt>RocketAMF::Values::TypedHash</tt> with the serialized class name.
-    def get_ruby_obj as_class_name
-      ruby_class_name = @mappings.get_ruby_class_name as_class_name
+    # a <tt>RocketAMF::Types::TypedHash</tt> with the serialized class name.
+    public
+    def get_ruby_obj(as_class_name)
+      result = nil
+
+      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)
+        result = Types::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
+        ruby_class = ruby_class_name.split('::').inject(Kernel) { |scope, const_name| scope.const_get(const_name) }
+        result     = ruby_class.new
       end
+
+      result
     end
 
-    # Populates the ruby object using the given properties. props and
-    # dynamic_props will be hashes with symbols for keys.
-    def populate_ruby_obj obj, props, dynamic_props=nil
-      props.merge! dynamic_props if dynamic_props
+    # Populates the ruby object using the given properties. props will be hashes with symbols for keys.
+    public
+    def populate_ruby_obj(target, props)
 
       # Don't even bother checking if it responds to setter methods if it's a TypedHash
-      if obj.is_a?(Values::TypedHash)
-        obj.merge! props
-        return obj
+      if target.is_a?(Types::TypedHash)
+        target.merge! props
+        return target
       end
 
       # Some type of object
-      hash_like = obj.respond_to?("[]=")
+      hash_like = target.respond_to?("[]=")
       props.each do |key, value|
-        if obj.respond_to?("#{key}=")
-          obj.send("#{key}=", value)
+        if target.respond_to?("#{key}=")
+          target.send("#{key}=", value)
         elsif hash_like
-          obj[key] = value
+          target[key] = value
         end
       end
-      obj
+
+      target
     end
 
     # Extracts all exportable properties from the given ruby object and returns
@@ -214,24 +177,28 @@ module RocketAMF
     # unless you are only going to be using the native C extensions, as the pure
     # ruby serializer performs a sort on the keys to acheive consistent, testable
     # results.
-    def props_for_serialization ruby_obj
+    public
+    def props_for_serialization(ruby_obj)
+      result = {}
+
       # 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
+        ruby_obj.each { |k, v| result[k.to_s] = v }
+
+      else
 
-      # Generic object 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.to_s] = ruby_obj.send(method_name) if method_def.arity == 0
+        # Generic object serializer
+        @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)
+          result[method_name.to_s] = ruby_obj.send(method_name) if method_def.arity == 0
+        end
       end
-      props
-    end
-  end
-end
+
+      result
+    end # props_for_serialization
+  end #ClassMapping
+end #RocketAMF

data/lib/rocketamf/mapping/mapping_set.rb

@@ -0,0 +1,63 @@
+module RocketAMF
+
+  # Container for all mapped classes
+  class MappingSet
+
+    #
+    # Methods
+    #
+
+    # Creates a mapping set object and populates the default mappings
+    public
+    def initialize
+      @as_mappings   = {}
+      @ruby_mappings = {}
+      map_defaults
+    end
+
+    # Adds required mapping configs, calling map for the required base mappings.
+    # Designed to allow extenders to take advantage of required default mappings.
+    public
+    def map_defaults
+      map as: 'flex.messaging.messages.AbstractMessage', ruby: 'RocketAMF::Types::AbstractMessage'
+      map as: 'flex.messaging.messages.RemotingMessage', ruby: 'RocketAMF::Types::RemotingMessage'
+      map as: 'flex.messaging.messages.AsyncMessage', ruby: 'RocketAMF::Types::AsyncMessage'
+      map as: 'DSA', ruby: 'RocketAMF::Types::AsyncMessageExt'
+      map as: 'flex.messaging.messages.CommandMessage', ruby: 'RocketAMF::Types::CommandMessage'
+      map as: 'DSC', ruby: 'RocketAMF::Types::CommandMessageExt'
+      map as: 'flex.messaging.messages.AcknowledgeMessage', ruby: 'RocketAMF::Types::AcknowledgeMessage'
+      map as: 'DSK', ruby: 'RocketAMF::Types::AcknowledgeMessageExt'
+      map as: 'flex.messaging.messages.ErrorMessage', ruby: 'RocketAMF::Types::ErrorMessage'
+      self
+    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'
+    public
+    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,
+    # returning nil if not found
+    public
+    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
+    # returning nil if not found
+    public
+    def get_ruby_class_name(class_name) #:nodoc:
+      @as_mappings[class_name.to_s]
+    end
+  end
+
+end

data/lib/rocketamf/pure.rb

@@ -1,24 +1,16 @@
 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."
+    $DEBUG and warn 'Using pure library for RocketAMF.'
   end
 
   #:stopdoc:
   # Import serializer/deserializer
   Deserializer = RocketAMF::Pure::Deserializer
   Serializer = RocketAMF::Pure::Serializer
-
-  # Modify envelope so it can serialize/deserialize
-  class Envelope
-    remove_method :populate_from_stream
-    remove_method :serialize
-    include RocketAMF::Pure::Envelope
-  end
   #:startdoc:
 end

data/lib/rocketamf/pure/deserializer.rb

@@ -1,182 +1,80 @@
-require 'rocketamf/pure/io_helpers'
+require 'rocketamf/pure/helpers/io_helper_read'
 
 module RocketAMF
   module Pure
-    # Pure ruby deserializer for AMF0 and AMF3
+    # Pure ruby deserializer for AMF3 requests
     class Deserializer
-      attr_accessor :source
+
+      #
+      # Modules
+      #
+      private
+      include RocketAMF::Pure::IOHelperRead
+
+      #
+      # Properties
+      #
+
+      public
+      attr_reader :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.
+      public
       def initialize(class_mapper)
         @class_mapper = class_mapper
       end
 
-      # Deserialize the source using AMF0 or AMF3. Source should either
+      # Deserialize the source using 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)
-        result = []
-
-        @version = version
-
-        if source.is_a?(StringIO)
-          @source = source
-        elsif source
-          @source = StringIO.new(source)
-        elsif @source.nil?
-          raise AMFError, 'no source to deserialize'
-        end
-
-        case @version
-          when 0
-            until @source.eof?
-              @ref_cache = []
-              result << amf0_deserialize
-            end
-          when 3
-            until @source.eof?
-              @string_cache = []
-              @object_cache = []
-              @trait_cache  = []
-              result << amf3_deserialize
-            end
-          else
-            raise ArgumentError, "unsupported version #{version}"
-        end
-
-        result
-      end
-
-      # Reads an object from the deserializer's stream and returns it.
-      def read_object
-        @version == 0 ? amf0_deserialize : amf3_deserialize
-      end
-
-      private
-      include RocketAMF::Pure::ReadIOHelpers
+      # raise AMFError if error appeared in deserialize, source is nil
+      # return hash {requests: [], incomplete_request: String}
+      public
+      def deserialize(source)
+        raise AMFError, 'no source to deserialize' if source.nil?
 
-      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
-        result = read_double @source
-        (result.is_a?(Float) && result.nan?) ? nil : result # check for NaN and convert them to nil
-      end
+        @source = source.is_a?(StringIO) ? source : StringIO.new(source)
 
-      def amf0_read_boolean
-        read_int8(@source) != 0
-      end
+        requests = []
 
-      def amf0_read_string(long=false)
-        len    = long ? read_word32_network(@source) : read_word16_network(@source)
-        result = @source.read(len)
-        result.force_encoding('UTF-8') if result.respond_to?(:force_encoding)
-        result
-      end
+        incomplete_request = nil
 
-      def amf0_read_reference
-        index = read_word16_network(@source)
-        @ref_cache[index]
-      end
+        until @source.eof?
+          begin
+            @string_cache = []
+            @object_cache = []
+            @trait_cache  = []
 
-      def amf0_read_array
-        len    = read_word32_network(@source)
-        result = []
-        @ref_cache << result
+            @position_request_read = @source.pos
 
-        0.upto(len - 1) do
-          result << amf0_deserialize
-        end
-        result
-      end
+            requests << amf3_deserialize
+          rescue AMFErrorIncomplete => e
+            @source.pos = @position_request_read
 
-      def amf0_read_date
-        seconds = read_double(@source).to_f/1000
-        time    = Time.at(seconds)
-        tz      = read_word16_network(@source) # Unused
-        time
-      end
+            incomplete_request = @source.read
 
-      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)
+            break
+          end
         end
-        obj
-      end
 
-      def amf0_read_hash
-        len = read_word32_network(@source) # Read and ignore length
-        obj = {}
-        @ref_cache << obj
-        amf0_read_props obj
+        {
+            requests:           requests,
+            incomplete_request: incomplete_request
+        }
       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
+      # Reads an object from the deserializer stream and returns it.
+      public
+      def read_object
+        amf3_deserialize
       end
 
+      private
       def amf3_deserialize
-        type = read_int8 @source
+        type = read_int8(@source)
         case type
           when AMF3_UNDEFINED_MARKER
             nil
@@ -203,7 +101,7 @@ module RocketAMF
           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
+            amf3_read_vector(type)
           when AMF3_DICT_MARKER
             amf3_read_dict
           else
@@ -211,12 +109,38 @@ module RocketAMF
         end
       end
 
+      private
+      def get_as_reference_object(type)
+        result = nil
+
+        if (type & 0x01) == 0 #is reference?
+          reference = type >> 1
+          result    = @object_cache[reference]
+        end
+
+        result
+      end
+
+      private
+      def get_as_reference_string(type)
+        result = nil
+
+        if (type & 0x01) == 0 #is reference?
+          reference = type >> 1
+          result    = @string_cache[reference]
+        end
+
+        result
+      end
+
+      private
       def amf3_read_integer
-        n      = 0
-        b      = read_word8(@source) || 0
         result = 0
 
-        while ((b & 0x80) != 0 && n < 3)
+        n = 0
+        b = read_word8(@source) || 0
+
+        while (b & 0x80) != 0 && n < 3
           result = result << 7
           result = result | (b & 0x7f)
           b      = read_word8(@source) || 0
@@ -236,103 +160,135 @@ module RocketAMF
             result -= (1 << 29)
           end
         end
+
         result
       end
 
+      private
       def amf3_read_number
-        res = read_double @source
-        (res.is_a?(Float) && res.nan?) ? nil : res # check for NaN and convert them to nil
+        result = read_double(@source)
+
+        #check for NaN and convert them to nil
+        if result.is_a?(Float) && result.nan?
+          result = nil
+        end
+
+        result
       end
 
+      private
       def amf3_read_string
-        type         = amf3_read_integer
-        is_reference = (type & 0x01) == 0
+        result = nil
 
-        if is_reference
-          reference = type >> 1
-          return @string_cache[reference]
-        else
+        type = amf3_read_integer
+
+        result = get_as_reference_string(type)
+
+        if result.nil?
           length = type >> 1
-          str    = ''
+          result = ''
+
           if length > 0
-            str = @source.read(length)
-            str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
-            @string_cache << str
+
+            if length > (@source.size - @source.pos)
+              raise AMFErrorIncomplete.new
+            end
+
+            result = @source.read(length)
+            result.force_encoding('UTF-8') if result.respond_to?(:force_encoding)
+            @string_cache << result
           end
-          return str
         end
+
+        result
       end
 
+      private
       def amf3_read_xml
         result = nil
 
-        type         = amf3_read_integer
-        is_reference = (type & 0x01) == 0
+        type = amf3_read_integer
 
-        if is_reference
-          reference = type >> 1
-          result    = @object_cache[reference]
-        else
+        result = get_as_reference_object(type)
+
+        if result.nil?
           length = type >> 1
-          str    = ""
+
+          result = ''
+
           if length > 0
-            str = @source.read(length)
-            str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)
-            @object_cache << str
+            if length > (@source.size - @source.pos)
+              raise AMFErrorIncomplete.new
+            end
+
+            result = @source.read(length)
+            result.force_encoding('UTF-8') if result.respond_to?(:force_encoding)
+            @object_cache << result
           end
-          result = str
         end
 
         result
       end
 
+      private
       def amf3_read_byte_array
-        type         = amf3_read_integer
-        is_reference = (type & 0x01) == 0
+        result = nil
 
-        if is_reference
-          reference = type >> 1
-          return @object_cache[reference]
-        else
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
           length = type >> 1
-          obj    = StringIO.new @source.read(length)
-          @object_cache << obj
-          obj
+
+          if length > (@source.size - @source.pos)
+            raise AMFErrorIncomplete.new
+          end
+
+          result = StringIO.new(@source.read(length))
+          @object_cache << result
         end
+
+        result
       end
 
+      private
       def amf3_read_array
-        type         = amf3_read_integer
-        is_reference = (type & 0x01) == 0
+        result = nil
 
-        if is_reference
-          reference = type >> 1
-          return @object_cache[reference]
-        else
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
           length        = type >> 1
           property_name = amf3_read_string
-          array         = property_name.length > 0 ? {} : []
-          @object_cache << array
+          result        = property_name.length > 0 ? {} : []
+          @object_cache << result
 
           while property_name.length > 0
-            value                = amf3_deserialize
-            array[property_name] = value
-            property_name        = amf3_read_string
+            value                 = amf3_deserialize
+            result[property_name] = value
+            property_name         = amf3_read_string
           end
-          0.upto(length - 1) { |i| array[i] = amf3_deserialize }
 
-          array
+          0.upto(length - 1) { |i| result[i] = amf3_deserialize }
         end
+
+        result
       end
 
+      # externalizable - an instance of a Class that implements flash.utils.IExternalizable and completely controls the serialization of its members (no property names are included in the trait information)
+      # dynamic - c an instance of a Class definition with the dynamic trait declared; public variable members can be added and removed from instances dynamically at runtime
+      private
       def amf3_read_object
-        type         = amf3_read_integer
-        is_reference = (type & 0x01) == 0
+        result = nil
 
-        if is_reference
-          reference = type >> 1
-          return @object_cache[reference]
-        else
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
           class_type         = type >> 1
           class_is_reference = (class_type & 0x01) == 0
 
@@ -359,108 +315,124 @@ module RocketAMF
           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
+          if traits[:class_name] == 'flex.messaging.io.ArrayCollection'
+            result = amf3_deserialize # Adds ArrayCollection array to object cache
+            @object_cache << result # Add again for ArrayCollection source array
+            return result
           end
 
-          obj = @class_mapper.get_ruby_obj traits[:class_name]
-          @object_cache << obj
+          result = @class_mapper.get_ruby_obj(traits[:class_name])
+          @object_cache << result
 
           if traits[:externalizable]
-            obj.read_external self
+            result.read_external(self)
           else
-            props = {}
+            properties = {}
+
             traits[:members].each do |key|
-              value      = amf3_deserialize
-              props[key] = value
+              value           = amf3_deserialize
+              properties[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
+                value           = amf3_deserialize
+                properties[key] = value
               end
             end
 
-            @class_mapper.populate_ruby_obj obj, props, dynamic_props
+            @class_mapper.populate_ruby_obj(result, properties)
           end
-          obj
+
         end
+
+        result
       end
 
+      private
       def amf3_read_date
-        type         = amf3_read_integer
-        is_reference = (type & 0x01) == 0
-        if is_reference
-          reference = type >> 1
-          return @object_cache[reference]
-        else
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
           seconds = read_double(@source).to_f/1000
-          time    = Time.at(seconds)
-          @object_cache << time
-          time
+          result  = Time.at(seconds)
+          @object_cache << result
         end
+
+        result
       end
 
+      private
       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
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+          result = {}
+          @object_cache << result
           length    = type >> 1
-          weak_keys = read_int8 @source # Ignore: Not supported in ruby
+          weak_keys = read_int8(@source) # Ignore: Not supported in ruby
+
           0.upto(length - 1) do |i|
-            dict[amf3_deserialize] = amf3_deserialize
+            result[amf3_deserialize] = amf3_deserialize
           end
-          dict
+
         end
+
+        result
       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
+      private
+      def amf3_read_vector(vector_type)
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+
+          result = []
+          @object_cache << result
+
           length       = type >> 1
-          fixed_vector = read_int8 @source # Ignore
+          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
+                result << int
               end
             when AMF3_VECTOR_UINT_MARKER
               0.upto(length - 1) do |i|
-                vec << read_word32_network(@source)
-                puts vec[i].to_s(2)
+                result << read_word32_network(@source)
               end
             when AMF3_VECTOR_DOUBLE_MARKER
               0.upto(length - 1) do |i|
-                vec << amf3_read_number
+                result << 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
+                result << amf3_deserialize
               end
+            else
+              #do nothing
           end
-          vec
-        end
-      end
-    end
-  end
+        end #if
+
+        result
+      end #read_vector
+
+    end #Deserializer
+  end #Pure
 end