rack-amf 0.0.4 → 1.0.0

data/lib/amf/class_mapping.rb

@@ -1,211 +0,0 @@
-require 'amf/values/typed_hash'
-require 'amf/values/array_collection'
-require 'amf/values/messages'
-
-module AMF
-  # == 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:
-  #
-  #   AMF::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
-  #   AMF::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
-  #   AMF::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 => 'AMF::Values::AbstractMessage'
-        map :as => 'flex.messaging.messages.RemotingMessage', :ruby => 'AMF::Values::RemotingMessage'
-        map :as => 'flex.messaging.messages.AsyncMessage', :ruby => 'AMF::Values::AsyncMessage'
-        map :as => 'flex.messaging.messages.CommandMessage', :ruby => 'AMF::Values::CommandMessage'
-        map :as => 'flex.messaging.messages.AcknowledgeMessage', :ruby => 'AMF::Values::AcknowledgeMessage'
-        map :as => 'flex.messaging.messages.ErrorMessage', :ruby => 'AMF::Values::ErrorMessage'
-        map :as => 'flex.messaging.io.ArrayCollection', :ruby => 'AMF::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:
-    #
-    #   AMF::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/amf/common.rb

@@ -1,28 +0,0 @@
-module AMF
-  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
-        AMF::Deserializer.new.deserialize(source)
-      elsif amf_version == 3
-        AMF::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
-        AMF::Serializer.new.serialize(obj)
-      elsif amf_version == 3
-        AMF::AMF3Serializer.new.serialize(obj)
-      else
-        raise AMFError, "unsupported version #{amf_version}"
-      end
-    end
-  end
-
-  # The base exception for AMF errors.
-  class AMFError < StandardError; end
-end

data/lib/amf/constants.rb

@@ -1,47 +0,0 @@
-module AMF
-  # 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/amf/pure/deserializer.rb

@@ -1,361 +0,0 @@
-require 'amf/pure/io_helpers'
-
-module AMF
-  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 AMF::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 AMF::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