mrpin-amf 2.1.8

data/lib/amf/pure/mapping/class_mapper.rb

@@ -0,0 +1,159 @@
+require 'amf/pure/mapping/mapping_set'
+
+module AMF
+
+  # Handles class name mapping between other language and ruby and assists in
+  # serializing and deserializing data between them. Simply map an other-language class to a
+  # ruby class and when the object is (de)serialized it will end up as the
+  # appropriate class.
+  #
+  # Example:
+  #
+  #   AMF.class_mapper.register_class_alias('SomeClass', 'RubyClass')
+  #
+  #   class_map =
+  #     {
+  #         'ClassNameLocal0' => 'ClassNameRemote0',
+  #         'ClassNameLocal1' => 'ClassNameRemote1'
+  #     }
+  #   AMF::Root.register_classes(class_map)
+
+  #
+  class ClassMapper
+
+    class << self
+
+      attr_reader :map
+
+      #
+      # Methods
+      #
+
+      public
+      def initialize
+        @map = MappingSet.new
+      end
+
+      public
+      def register_class_alias(class_local, class_remote)
+        @map.register_class_alias(class_local, class_remote)
+      end
+
+      public
+      def register_classes(map)
+        map.each do |class_local, class_remote|
+          self.register_class_alias(class_local, class_remote)
+        end
+      end
+
+      # Reset all class mappings except the defaults
+      public
+      def reset
+        @map = MappingSet.new
+        nil
+      end
+    end #end of static
+
+    # init static
+    self.initialize
+
+    #
+    # Methods
+    #
+
+    public
+    def initialize
+      #cache static variable
+      @map           = ClassMapper.map
+      @ignored_props = Object.new.public_methods
+    end
+
+    # Returns the other-language class name for the given ruby object.
+    public
+    def get_class_name_remote(object)
+      # Get class name
+      return object.class_type if object.is_a?(HashWithType)
+      return nil if object.is_a?(Hash)
+
+      class_name_local = object.class.name
+
+      # Get mapped remote class name
+      @map.get_class_name_remote(class_name_local)
+    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>AMF::HashWithType</tt> with the serialized class name.
+    public
+    def create_object(class_name_remote)
+      result = nil
+
+      if class_name_remote.nil? || class_name_remote.empty?
+        return {}
+      end
+
+      class_name_local = @map.get_class_name_local(class_name_remote)
+
+      if class_name_local.nil?
+        # Populate a simple hash, since no mapping
+        result = HashWithType.new(class_name_remote)
+      else
+        ruby_class = class_name_local.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 will be hashes with symbols for keys.
+    public
+    def object_deserialize(target, props)
+      # Don't even bother checking if it responds to setter methods if it's a TypedHash
+      if target.is_a?(HashWithType)
+        target.merge! props
+        return target
+      end
+
+      # Some type of object
+      hash_like = target.respond_to?('[]=')
+
+      props.each do |key, value|
+        if target.respond_to?("#{key}=")
+          target.send("#{key}=", value)
+        elsif hash_like
+          target[key] = value
+        end
+      end
+
+      target
+    end
+
+    # Extracts all exportable properties from the given ruby object and returns
+    # them in a hash. If overriding, make sure to return a hash wth string keys
+    # 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.
+    public
+    def object_serialize(ruby_obj)
+      result = {}
+
+      # Handle hashes
+      if ruby_obj.is_a?(Hash)
+
+        # Stringify keys to make it easier later on and allow sorting
+        ruby_obj.each { |k, v| result[k.to_s] = v }
+
+      else
+
+        # Generic object serializer
+        (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
+
+      result
+    end # props_for_serialization
+  end #ClassMapping
+end #AMF

data/lib/amf/pure/mapping/mapping_set.rb

@@ -0,0 +1,49 @@
+module AMF
+
+  # Container for all mapped classes
+  class MappingSet
+
+    #
+    # Methods
+    #
+
+    # Creates a mapping set object and populates the default mappings
+    public
+    def initialize
+      @mappings_remote = {}
+      @mappings_local  = {}
+    end
+
+    # Map a given other-language class to a ruby class.
+    #
+    # Use fully qualified names for both.
+    #
+    # Example:
+    #
+    #   register_class_alias('Example::Date', 'com.example.Date')
+    public
+    def register_class_alias(class_local, class_remote)
+      # Convert params to strings
+      class_remote = class_remote.to_s
+      class_local  = class_local.to_s
+
+      @mappings_remote[class_remote] = class_local
+      @mappings_local[class_local]   = class_remote
+    end
+
+    # Returns the ruby class name for the given other-language class name
+    # returning nil if not found
+    public
+    def get_class_name_local(class_name_remote) #:nodoc:
+      @mappings_remote[class_name_remote.to_s]
+    end
+
+    # Returns the other-language class name for the given ruby class name,
+    # returning nil if not found
+    public
+    def get_class_name_remote(class_name_local) #:nodoc:
+      @mappings_local[class_name_local.to_s]
+    end
+  end
+
+end

data/lib/amf/pure/serializer.rb

@@ -0,0 +1,318 @@
+module AMF
+  module Pure
+    # Pure ruby serializer for AMF3
+    class Serializer
+
+      #
+      # Modules
+      #
+
+      private
+      include AMF::Pure::IOHelperWrite
+      include AMF::AMFConstants
+
+      #
+      # Properties
+      #
+
+      #
+      # Methods
+      #
+
+      # Pass in the class mapper instance to use when serializing. This enables
+      # better caching behavior in the class mapper and allows one to change
+      # mappings between serialization attempts.
+      public
+      def initialize(class_mapper)
+        @class_mapper = class_mapper
+        @stream       = ''
+        @depth        = 0
+      end
+
+      # Serialize the given object using AMF3. Can be called from inside
+      # encode_amf.
+      def serialize(obj)
+        # Initialize caches
+        if @depth == 0
+          @cache_strings = CacheStrings.new
+          @cache_objects = CacheObjects.new
+          @cache_traits  = CacheStrings.new
+        end
+        @depth += 1
+
+        # Perform serialization
+        amf3_serialize(obj)
+
+        # Cleanup
+        @depth -= 1
+
+        if @depth == 0
+          @cache_strings = nil
+          @cache_objects = nil
+          @cache_traits  = nil
+        end
+
+        @stream
+      end
+
+      private
+      def amf3_serialize(object)
+        case true
+          when object.is_a?(NilClass)
+            amf3_write_null
+          when object.respond_to?(:encode_amf)
+            object.encode_amf(self)
+          when object.is_a?(TrueClass)
+            amf3_write_true
+          when object.is_a?(FalseClass)
+            amf3_write_false
+          when object.is_a?(Numeric)
+            amf3_write_numeric(object)
+          when object.is_a?(Symbol), object.is_a?(String)
+            amf3_write_string(object.to_s)
+          when object.is_a?(Time)
+            amf3_write_time object
+          when object.is_a?(Date)
+            amf3_write_date(object)
+          when object.is_a?(StringIO)
+            amf3_write_byte_array(object)
+          when object.is_a?(Array)
+            amf3_write_array(object)
+          when object.is_a?(Hash), object.is_a?(Object)
+            amf3_write_object(object)
+          else
+            raise AMFError, 'unknown type for serialize'
+        end
+      end
+
+      # Helper for writing arrays inside encode_amf.
+      public
+      def write_array(value)
+        amf3_write_array(value)
+      end
+
+      # Helper for writing objects inside encode_amf. If you pass in a property hash, it will use
+      # it rather than having the class mapper determine properties.
+      # You can also specify a traits hash, which can be used to reduce serialized
+      # data size or serialize things as externalizable.
+      public
+      def write_object(obj, props = nil, traits = nil)
+        amf3_write_object(obj, props, traits)
+      end
+
+      private
+      def amf3_write_reference(index)
+        header = index << 1 # shift value left to leave a low bit of 0
+        @stream << pack_integer(header)
+      end
+
+      private
+      def amf3_write_null
+        # no data is serialized except their type marker
+        @stream << AMF3_MARKER_NULL
+      end
+
+      private
+      def amf3_write_true
+        # no data is serialized except their type marker
+        @stream << AMF3_MARKER_TRUE
+      end
+
+      private
+      def amf3_write_false
+        # no data is serialized except their type marker
+        @stream << AMF3_MARKER_FALSE
+      end
+
+      private
+      def amf3_write_numeric(value)
+        if !value.integer? || value < INTEGER_MIN || value > INTEGER_MAX # Check valid range for 29 bits
+          @stream << AMF3_MARKER_DOUBLE
+          @stream << pack_double(value)
+        else
+          @stream << AMF3_MARKER_INTEGER
+          @stream << pack_integer(value)
+        end
+      end
+
+      private
+      def amf3_write_time(value)
+        @stream << AMF3_MARKER_DATE
+
+        if @cache_objects[value] != nil
+          amf3_write_reference(@cache_objects[value])
+        else
+          # Cache time
+          @cache_objects.add_object(value)
+
+          # Build AMF string
+          value = value.getutc # Dup and convert to UTC
+          milli = (value.to_f * 1000).to_i
+          @stream << AMF3_MARKER_NULL
+          @stream << pack_double(milli)
+        end
+      end
+
+      private
+      def amf3_write_date(value)
+        @stream << AMF3_MARKER_DATE
+
+        if @cache_objects[value] != nil
+          amf3_write_reference(@cache_objects[value])
+        else
+          # Cache date
+          @cache_objects.add_object(value)
+
+          # Build AMF string
+          @stream << AMF3_MARKER_NULL
+          @stream << pack_double(value.strftime('%Q').to_i)
+        end
+      end
+
+      private
+      def amf3_write_byte_array(value)
+        @stream << AMF3_MARKER_BYTE_ARRAY
+
+        if @cache_objects[value] != nil
+          amf3_write_reference(@cache_objects[value])
+        else
+          @cache_objects.add_object(value)
+          str = value.string
+          @stream << pack_integer(str.bytesize << 1 | 1)
+          @stream << str
+        end
+      end
+
+      private
+      def amf3_write_array(value)
+        # Write type marker
+        @stream << AMF3_MARKER_ARRAY
+
+        # Write reference or cache array
+        if @cache_objects[value] != nil
+          amf3_write_reference(@cache_objects[value])
+          return
+        end
+
+        @cache_objects.add_object(value)
+
+        # Build AMF string for array
+        header = value.length << 1 # make room for a low bit of 1
+        header = header | 1 # set the low bit to 1
+        @stream << pack_integer(header)
+
+        @stream << AMF3_CLOSE_DYNAMIC_ARRAY
+
+        value.each do |elem|
+          amf3_serialize elem
+        end
+      end
+
+      private
+      def amf3_write_object(value, properties = nil, traits = nil)
+        @stream << AMF3_MARKER_OBJECT
+
+        # Caching...
+        if @cache_objects[value] != nil
+          amf3_write_reference(@cache_objects[value])
+          return
+        end
+
+        @cache_objects.add_object(value)
+
+        # Calculate traits if not given
+        use_default_class_name = false
+
+        if traits.nil?
+          traits     =
+              {
+                  class_name: @class_mapper.get_class_name_remote(value),
+                  members:    [],
+                  dynamic:    true
+              }
+          use_default_class_name = true unless traits[:class_name]
+        end
+
+        class_name = use_default_class_name ? '__default__' : traits[:class_name]
+
+        # Write out traits
+        if !class_name.nil? && @cache_traits[class_name] != nil
+          @stream << pack_integer(@cache_traits[class_name] << 2 | 0x01)
+        else
+          @cache_traits.add_string(class_name) unless class_name.nil?
+
+          # Write out trait header
+          header = 0x03 # Not object ref and not trait ref
+          header |= 0x02 << 2 if traits[:dynamic]
+          header |= traits[:members].length << 4
+          @stream << pack_integer(header)
+
+          # Write out class name
+          if use_default_class_name
+            amf3_write_string_internal('')
+          else
+            amf3_write_string_internal(class_name.to_s)
+          end
+
+          # Write out members
+          traits[:members].each { |m| amf3_write_string_internal(m) }
+        end
+
+        # Extract properties if not given
+        properties = @class_mapper.object_serialize(value) if properties.nil?
+
+        # Write out sealed properties
+        traits[:members].each do |m|
+          amf3_serialize(properties[m])
+          properties.delete(m)
+        end
+
+        # Write out dynamic properties
+        if traits[:dynamic]
+          # Write out dynamic properties
+          properties.each do |key, val|
+            amf3_write_string_internal(key.to_s)
+            amf3_serialize(val)
+          end
+
+          # Write close
+          @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+      end
+
+      private
+      def amf3_write_string(value)
+        @stream << AMF3_MARKER_STRING
+        amf3_write_string_internal value
+      end
+
+
+      private
+      def amf3_write_string_internal(value)
+        if value.respond_to?(:encode)
+          value = value.dup if value.frozen?
+
+          value = value.encode('UTF-8')
+
+          value.force_encoding('ASCII-8BIT')
+        end
+
+        if value == ''
+          @stream << AMF3_EMPTY_STRING
+        elsif @cache_strings[value] != nil
+          amf3_write_reference(@cache_strings[value])
+        else
+
+          # Cache string
+          @cache_strings.add_string(value)
+
+          # Build AMF string
+          @stream << pack_integer(value.bytesize << 1 | 1)
+          @stream << value
+        end
+      end
+
+    end # Serializer
+
+  end #Pure
+end #AMF

data/lib/amf/pure.rb

@@ -0,0 +1,16 @@
+require 'amf/pure/deserializer'
+require 'amf/pure/serializer'
+
+module AMF
+  # This module holds all the modules/classes that implement AMF's functionality
+  # in pure ruby
+  module Pure
+    $DEBUG and warn 'Using pure library for AMF.'
+  end
+
+  #:stopdoc:
+  # Import serializer/deserializer
+  Deserializer = AMF::Pure::Deserializer
+  Serializer = AMF::Pure::Serializer
+  #:startdoc:
+end

data/lib/amf.rb

@@ -0,0 +1,140 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.unshift "#{File.expand_path(File.dirname(__FILE__))}/tamf/"
+$:.unshift "#{File.expand_path(File.dirname(__FILE__))}/amf/types/"
+
+require 'date'
+require 'stringio'
+require 'amf/common/hash_with_type'
+require 'amf/pure/errors/all_files'
+require 'amf/pure/helpers/all_files'
+require 'amf/pure/mapping/class_mapper'
+
+
+#todo: implement C version
+# begin
+#   require 'rocketamf/ext'
+# rescue LoadError
+
+require 'amf/pure'
+# end
+
+# AMF is a full featured AMF3 serializer/deserializer with support for
+# bi-directional other language to ruby class mapping, custom serialization and mapping,
+# remoting gateway helpers that follow AMF3 messaging specs, and a suite of specs
+# to ensure adherence to the specification documents put out by Adobe. If the C
+# components compile, then RocketAMF automatically takes advantage of them to
+# provide a substantial performance benefit. In addition, RocketAMF is fully
+# compatible with Ruby 2.0, 2.1.
+#
+# == Performance
+#   # 100.000 objects
+#   # Ruby 2.0
+#   Testing pure AMF3:
+#     minimum serialize time: 49.294496s
+#     minimum deserialize time: 6.600238s
+#
+# == Example
+#
+#
+# test_object =
+#   {
+#      first_name: "Greg",
+#      last_name:  "House"
+#   }
+#
+# data            = AMF::Root.serialize(test_object)
+#
+# restored_object = AMF::Root.serialize(data)
+#
+# == Mapping Classes Between Other language and Ruby
+#
+# RocketAMF provides a simple class mapping tool to facilitate serialization and
+# deserialization of typed objects. Refer to the documentation of
+# <tt>RocketAMF::ClassMapping</tt> for more details. If the provided class
+# mapping tool is not sufficient for your needs, you also have the option to
+# replace it with a class mapper of your own devising that matches the documented
+# API.
+#
+# == Advanced Serialization (encode_amf and IExternalizable)
+#
+# RocketAMF provides some additional functionality to support advanced
+# serialization techniques. If you define an <tt>encode_amf</tt> method on your
+# object, it will get called during serialization. It is passed a single argument,
+# the serializer, and it can use the serializer stream, the <tt>serialize</tt>
+# method, the <tt>write_array</tt> method, the <tt>write_object</tt> method, and
+# the serializer version. Below is a simple example that uses <tt>write_object</tt>
+# to customize the property hash that is used for serialization.
+#
+# Example:
+#
+#   class TestObject
+#     def encode_amf serializer
+#       serializer.write_object self, @attributes
+#     end
+#   end
+#
+# If you plan on using the <tt>serialize</tt> method, make sure to pass in the
+# current serializer version, or you could create a message that cannot be deserialized.
+#
+# Example:
+#
+#   class VariableObject
+#     def encode_amf serializer
+#         serializer.serialize(false)
+#     end
+#   end
+#
+module AMF
+
+  class Root
+    # Deserialize the AMF string _source_ of the given AMF version into a Ruby
+    # data structure and return it. Creates an instance of <tt>AMF::Deserializer</tt>
+    # with a new instance of <tt>AMF::Root.class_mapper</tt> and calls deserialize
+    # on it with the given source, returning the result.
+    public
+    def self.deserialize(source)
+      deserializer = AMF::Deserializer.new(@class_mapper.new)
+      deserializer.deserialize(source)
+    end
+
+    # Serialize the given Ruby data structure _obj_ into an AMF3 stream.
+    # Creates an instance of <tt>AMF::Serializer</tt>
+    # with a new instance of <tt>AMF::Root.class_mapper</tt> and calls serialize
+    # on it with the given object, returning the result.
+    public
+    def self.serialize(obj)
+      serializer = AMF::Serializer.new(@class_mapper.new)
+      serializer.serialize(obj)
+    end
+
+    public
+    def self.register_class_alias(class_name_local, class_name_remote)
+      @class_mapper.register_class_alias(class_name_local, class_name_remote)
+    end
+
+    public
+    def self.register_classes(map)
+      @class_mapper.register_classes(map)
+    end
+
+    public
+    def self.clear_class_aliases
+      @class_mapper.reset
+    end
+
+    private
+    def self.init_class_mapper
+      #todo: use c version
+      # Activating the C Class Mapper:
+      #   require 'rubygems'
+      #   require 'amf'
+      #   AMF::ClassMapper = AMF::Ext::FastClassMapping
+
+      @class_mapper = AMF::ClassMapper
+    end
+
+    init_class_mapper
+
+  end
+
+end

data/mrpin-amf.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |spec|
+  spec.name                          = 'mrpin-amf'
+  spec.version                       = '2.1.8'
+  spec.platform                      = Gem::Platform::RUBY
+  spec.authors                       = ['Jacob Henry', 'Stephen Augenstein', "Joc O'Connor", 'Gregory Tkach']
+  spec.email                         = %w(gregory.tkach@gmail.com)
+  spec.homepage                      = 'https://github.com/mrpin/mrpin-amf-ruby'
+  spec.license                       = 'MIT'
+  spec.summary                       = 'Fast AMF3 serializer/deserializer'
+  spec.description                   = 'Fast AMF3 serializer/deserializer with remoting request/response wrappers to simplify integration'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = Dir[*['spec/**/*_spec.rb']]
+  spec.extensions    = Dir[*['ext/**/extconf.rb']]
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake-compiler', '~> 0'
+
+  spec.has_rdoc         = true
+  spec.extra_rdoc_files = %w( README.rdoc )
+  spec.rdoc_options     = %w(--line-numbers --main README.rdoc)
+end

data/spec/fixtures/objects/complex/amf3-associative-array.bin

@@ -0,0 +1 @@
+		asdf	fdsafoobar42
	bar1	bar2	bar3