rack-amf 0.0.4 → 1.0.0

data/lib/amf/pure/io_helpers.rb

@@ -1,94 +0,0 @@
-module AMF
-  module Pure
-    module ReadIOHelpers #:nodoc:
-      def read_int8 source
-        source.read(1).unpack('c').first
-      end
-
-      def read_word8 source
-        source.read(1).unpack('C').first
-      end
-
-      def read_double source
-        source.read(8).unpack('G').first
-      end
-
-      def read_word16_network source
-        source.read(2).unpack('n').first
-      end
-
-      def read_int16_network source
-        str = source.read(2)
-        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
-        str.unpack('s').first
-      end
-
-      def read_word32_network source
-        source.read(4).unpack('N').first
-      end
-
-      def byte_order
-        if [0x12345678].pack("L") == "\x12\x34\x56\x78"
-          :BigEndian
-        else
-          :LittleEndian
-        end
-      end
-
-      def byte_order_little?
-        (byte_order == :LittleEndian) ? true : false;
-      end
-    end
-
-    module WriteIOHelpers #:nodoc:
-      def pack_integer(integer)
-        integer = integer & 0x1fffffff
-        if(integer < 0x80)
-          [integer].pack('c')
-        elsif(integer < 0x4000)
-          [integer >> 7 & 0x7f | 0x80].pack('c')+
-          [integer & 0x7f].pack('c')
-        elsif(integer < 0x200000)
-          [integer >> 14 & 0x7f | 0x80].pack('c') +
-          [integer >> 7 & 0x7f | 0x80].pack('c') +
-          [integer & 0x7f].pack('c')
-        else
-          [integer >> 22 & 0x7f | 0x80].pack('c')+
-          [integer >> 15 & 0x7f | 0x80].pack('c')+
-          [integer >> 8 & 0x7f | 0x80].pack('c')+
-          [integer & 0xff].pack('c')
-        end
-      end
-
-      def pack_double(double)
-        [double].pack('G')
-      end
-
-      def pack_int8(val)
-        [val].pack('c')
-      end
-
-      def pack_int16_network(val)
-        [val].pack('n')
-      end
-
-      def pack_word32_network(val)
-        str = [val].pack('L')
-        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
-        str
-      end
-
-      def byte_order
-        if [0x12345678].pack("L") == "\x12\x34\x56\x78"
-          :BigEndian
-        else
-          :LittleEndian
-        end
-      end
-
-      def byte_order_little?
-        (byte_order == :LittleEndian) ? true : false;
-      end
-    end
-  end
-end

data/lib/amf/pure/remoting.rb

@@ -1,120 +0,0 @@
-require 'amf/pure/io_helpers'
-
-module AMF
-  module Pure
-    # AMF request object wrapper, it is responsible for deserializing AMF requests
-    class Request
-      attr_reader :amf_version, :headers, :messages
-
-      def initialize
-        @amf_version = 0
-        @headers = []
-        @messages = []
-      end
-
-      def populate_from_stream stream
-        stream = StringIO.new(stream) unless StringIO === stream
-
-        # Read AMF version
-        @amf_version = read_word16_network stream
-
-        # Read in headers
-        header_count = read_word16_network stream
-        0.upto(header_count-1) do
-          name = stream.read(read_word16_network(stream))
-          must_understand = read_int8(stream) != 0
-          length = read_word32_network stream
-          data = AMF.deserialize stream
-          @headers << Header.new(name, must_understand, data)
-        end
-
-        # Read in messages
-        message_count = read_word16_network stream
-        0.upto(message_count-1) do
-          target_uri = stream.read(read_word16_network(stream))
-          response_uri = stream.read(read_word16_network(stream))
-          length = read_word32_network stream
-          data = AMF.deserialize stream
-          if data.is_a?(Array) && data.length == 1 && data[0].is_a?(::AMF::Values::AbstractMessage)
-            data = data[0]
-          end
-          @messages << Message.new(target_uri, response_uri, data)
-        end
-
-        self
-      end
-
-      private
-      include AMF::Pure::ReadIOHelpers
-    end
-
-    # AMF response object wrapper, it is responsible for serializing the AMF response
-    class Response
-      attr_accessor :amf_version, :headers, :messages
-
-      def initialize
-        @amf_version = 0
-        @headers = []
-        @messages = []
-      end
-
-      def serialize
-        stream = ""
-
-        # Write version
-        stream << pack_int16_network(@amf_version)
-
-        # Write headers
-        stream << pack_int16_network(@headers.length) # Header count
-        @headers.each do |h|
-          stream << pack_int16_network(h.name.length)
-          stream << h.name
-          stream << pack_int8(h.must_understand ? 1 : 0)
-          stream << pack_word32_network(-1)
-          stream << AMF.serialize(h.data, 0)
-        end
-
-        # Write messages
-        stream << pack_int16_network(@messages.length) # Message count
-        @messages.each do |m|
-          stream << pack_int16_network(m.target_uri.length)
-          stream << m.target_uri
-
-          stream << pack_int16_network(m.response_uri.length)
-          stream << m.response_uri
-
-          stream << pack_word32_network(-1)
-          stream << AMF0_AMF3_MARKER if @amf_version == 3
-          stream << AMF.serialize(m.data, @amf_version)
-        end
-
-        stream
-      end
-
-      private
-      include AMF::Pure::WriteIOHelpers
-    end
-
-    # AMF::Pure::Request or AMF::Pure::Response header
-    class Header
-      attr_accessor :name, :must_understand, :data
-
-      def initialize name, must_understand, data
-        @name = name
-        @must_understand = must_understand
-        @data = data
-      end
-    end
-
-    # AMF::Pure::Request or AMF::Pure::Response message
-    class Message
-      attr_accessor :target_uri, :response_uri, :data
-
-      def initialize target_uri, response_uri, data
-        @target_uri = target_uri
-        @response_uri = response_uri
-        @data = data
-      end
-    end
-  end
-end

data/lib/amf/pure/serializer.rb

@@ -1,327 +0,0 @@
-require 'amf/pure/io_helpers'
-
-module AMF
-  module Pure
-    # AMF0 implementation of serializer
-    class Serializer
-      def initialize
-        @ref_cache = SerializerCache.new :object
-      end
-
-      def version
-        0
-      end
-
-      def serialize obj, stream = ""
-        if obj.respond_to?(:to_amf)
-          stream << obj.to_amf(self)
-        elsif @ref_cache[obj] != nil
-          write_reference @ref_cache[obj], stream
-        elsif obj.is_a?(NilClass)
-          write_null stream
-        elsif obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
-          write_boolean obj, stream
-        elsif obj.is_a?(Float) || obj.is_a?(Integer)
-          write_number obj, stream
-        elsif obj.is_a?(Symbol) || obj.is_a?(String)
-          write_string obj.to_s, stream
-        elsif obj.is_a?(Time)
-          write_date obj, stream
-        elsif obj.is_a?(Array)
-          write_array obj, stream
-        elsif obj.is_a?(Hash)
-          write_hash obj, stream
-        elsif obj.is_a?(Object)
-          write_object obj, stream
-        end
-        stream
-      end
-
-      def write_null stream
-        stream << AMF0_NULL_MARKER
-      end
-
-      def write_boolean bool, stream
-        stream << AMF0_BOOLEAN_MARKER
-        stream << pack_int8(bool ? 1 : 0)
-      end
-
-      def write_number num, stream
-        stream << AMF0_NUMBER_MARKER
-        stream << pack_double(num)
-      end
-
-      def write_string str, stream
-        len = str.length
-        if len > 2**16-1
-          stream << AMF0_LONG_STRING_MARKER
-          stream << pack_word32_network(len)
-        else
-          stream << AMF0_STRING_MARKER
-          stream << pack_int16_network(len)
-        end
-        stream << str
-      end
-
-      def write_date date, stream
-        stream << AMF0_DATE_MARKER
-
-        date.utc unless date.utc?
-        seconds = (date.to_f * 1000).to_i
-        stream << pack_double(seconds)
-
-        stream << pack_int16_network(0)
-      end
-
-      def write_reference index, stream
-        stream << AMF0_REFERENCE_MARKER
-        stream << pack_int16_network(index)
-      end
-
-      def write_array array, stream
-        @ref_cache.add_obj array
-        stream << AMF0_STRICT_ARRAY_MARKER
-        stream << pack_word32_network(array.length)
-        array.each do |elem|
-          serialize elem, stream
-        end
-      end
-
-      def write_hash hash, stream
-        @ref_cache.add_obj hash
-        stream << AMF0_HASH_MARKER
-        stream << pack_word32_network(hash.length)
-        write_prop_list hash, stream
-      end
-
-      def write_object obj, stream
-        @ref_cache.add_obj obj
-
-        # Is it a typed object?
-        class_name = ClassMapper.get_as_class_name obj
-        if class_name
-          stream << AMF0_TYPED_OBJECT_MARKER
-          stream << pack_int16_network(class_name.length)
-          stream << class_name
-        else
-          stream << AMF0_OBJECT_MARKER
-        end
-
-        write_prop_list obj, stream
-      end
-
-      private
-      include AMF::Pure::WriteIOHelpers
-      def write_prop_list obj, stream
-        # Write prop list
-        props = ClassMapper.props_for_serialization obj
-        props.sort.each do |key, value| # Sort keys before writing
-          stream << pack_int16_network(key.length)
-          stream << key
-          serialize value, stream
-        end
-
-        # Write end
-        stream << pack_int16_network(0)
-        stream << AMF0_OBJECT_END_MARKER
-      end
-    end
-
-    # AMF3 implementation of serializer
-    class AMF3Serializer
-      attr_reader :string_cache
-
-      def initialize
-        @string_cache = SerializerCache.new :string
-        @object_cache = SerializerCache.new :object
-      end
-
-      def version
-        3
-      end
-
-      def serialize obj, stream = ""
-        if obj.respond_to?(:to_amf)
-          stream << obj.to_amf(self)
-        elsif obj.is_a?(NilClass)
-          write_null stream
-        elsif obj.is_a?(TrueClass)
-          write_true stream
-        elsif obj.is_a?(FalseClass)
-          write_false stream
-        elsif obj.is_a?(Float)
-          write_float obj, stream
-        elsif obj.is_a?(Integer)
-          write_integer obj, stream
-        elsif obj.is_a?(Symbol) || obj.is_a?(String)
-          write_string obj.to_s, stream
-        elsif obj.is_a?(Time)
-          write_date obj, stream
-        elsif obj.is_a?(Array)
-          write_array obj, stream
-        elsif obj.is_a?(Hash) || obj.is_a?(Object)
-          write_object obj, stream
-        end
-        stream
-      end
-
-      def write_reference index, stream
-        header = index << 1 # shift value left to leave a low bit of 0
-        stream << pack_integer(header)
-      end
-
-      def write_null stream
-        stream << AMF3_NULL_MARKER
-      end
-
-      def write_true stream
-        stream << AMF3_TRUE_MARKER
-      end
-
-      def write_false stream
-        stream << AMF3_FALSE_MARKER
-      end
-
-      def write_integer int, stream
-        if int < MIN_INTEGER || int > MAX_INTEGER # Check valid range for 29 bits
-          write_float int.to_f, stream
-        else
-          stream << AMF3_INTEGER_MARKER
-          stream << pack_integer(int)
-        end
-      end
-
-      def write_float float, stream
-        stream << AMF3_DOUBLE_MARKER
-        stream << pack_double(float)
-      end
-
-      def write_string str, stream
-        stream << AMF3_STRING_MARKER
-        write_utf8_vr str, stream
-      end
-
-      def write_date date, stream
-        stream << AMF3_DATE_MARKER
-        if @object_cache[date] != nil
-          write_reference @object_cache[date], stream
-        else
-          # Cache date
-          @object_cache.add_obj date
-
-          # Build AMF string
-          date.utc unless date.utc?
-          seconds = (date.to_f * 1000).to_i
-          stream << pack_integer(AMF3_NULL_MARKER)
-          stream << pack_double(seconds)
-        end
-      end
-
-      def write_array array, stream
-        stream << AMF3_ARRAY_MARKER
-        if @object_cache[array] != nil
-          write_reference @object_cache[array], stream
-        else
-          # Cache array
-          @object_cache.add_obj array
-
-          # Build AMF string
-          header = array.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
-          array.each do |elem|
-            serialize elem, stream
-          end
-        end
-      end
-
-      def write_object obj, stream
-        stream << AMF3_OBJECT_MARKER
-        if @object_cache[obj] != nil
-          write_reference @object_cache[obj], stream
-        else
-          # Cache object
-          @object_cache.add_obj obj
-
-          # Always serialize things as dynamic objects
-          stream << AMF3_DYNAMIC_OBJECT
-
-          # Write class name/anonymous
-          class_name = ClassMapper.get_as_class_name obj
-          if class_name
-            write_utf8_vr class_name, stream
-          else
-            stream << AMF3_ANONYMOUS_OBJECT
-          end
-
-          # Write out properties
-          props = ClassMapper.props_for_serialization obj
-          props.sort.each do |key, val| # Sort props until Ruby 1.9 becomes common
-            write_utf8_vr key.to_s, stream
-            serialize val, stream
-          end
-
-          # Write close
-          stream << AMF3_CLOSE_DYNAMIC_OBJECT
-        end
-      end
-
-      private
-      include AMF::Pure::WriteIOHelpers
-
-      def write_utf8_vr str, stream
-        if str == ''
-          stream << AMF3_EMPTY_STRING
-        elsif @string_cache[str] != nil
-          write_reference @string_cache[str], stream
-        else
-          # Cache string
-          @string_cache.add_obj str
-
-          # Build AMF string
-          header = str.length << 1 # make room for a low bit of 1
-          header = header | 1 # set the low bit to 1
-          stream << pack_integer(header)
-          stream << str
-        end
-      end
-    end
-
-    class SerializerCache #:nodoc:
-      def self.new type
-        if type == :string
-          StringCache.new
-        elsif type == :object
-          ObjectCache.new
-        end
-      end
-
-      class StringCache < Hash #:nodoc:
-        def initialize
-          @cache_index = 0
-        end
-
-        def add_obj str
-          self[str] = @cache_index
-          @cache_index += 1
-        end
-      end
-
-      class ObjectCache < Hash #:nodoc:
-        def initialize
-          @cache_index = 0
-        end
-
-        def [] obj
-          super(obj.object_id)
-        end
-
-        def add_obj obj
-          self[obj.object_id] = @cache_index
-          @cache_index += 1
-        end
-      end
-    end
-  end
-end

data/lib/amf/pure.rb

@@ -1,14 +0,0 @@
-require 'amf/constants'
-require 'amf/pure/deserializer'
-require 'amf/pure/serializer'
-require 'amf/pure/remoting'
-
-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
-
-  include AMF::Pure
-end

data/lib/amf/values/array_collection.rb

@@ -1,9 +0,0 @@
-module AMF
-  module Values #:nodoc:
-    class ArrayCollection
-      def externalized_data=(data)
-        @data = data
-      end
-    end
-  end
-end

data/lib/amf/values/messages.rb

@@ -1,133 +0,0 @@
-module AMF
-  module Values #:nodoc:
-    # Base class for all special AS3 response messages. Maps to
-    # <tt>flex.messaging.messages.AbstractMessage</tt>
-    class AbstractMessage
-      attr_accessor :clientId
-      attr_accessor :destination
-      attr_accessor :messageId
-      attr_accessor :timestamp
-      attr_accessor :timeToLive
-      attr_accessor :headers
-      attr_accessor :body
-
-      protected
-      def rand_uuid
-        [8,4,4,4,12].map {|n| rand_hex_3(n)}.join('-').to_s
-      end
-
-      def rand_hex_3(l)
-        "%0#{l}x" % rand(1 << l*4)
-      end
-    end
-
-    # Maps to <tt>flex.messaging.messages.RemotingMessage</tt>
-    class RemotingMessage < AbstractMessage
-      # The name of the service to be called including package name
-      attr_accessor :source
-
-      # The name of the method to be called
-      attr_accessor :operation
-
-      # The arguments to call the method with
-      attr_accessor :parameters
-
-      def initialize
-        @clientId = rand_uuid
-        @destination = nil
-        @messageId = rand_uuid
-        @timestamp = Time.new.to_i*100
-        @timeToLive = 0
-        @headers = {}
-        @body = nil
-      end
-    end
-
-    # Maps to <tt>flex.messaging.messages.AsyncMessage</tt>
-    class AsyncMessage < AbstractMessage
-      attr_accessor :correlationId
-    end
-
-    # Maps to <tt>flex.messaging.messages.CommandMessage</tt>
-    class CommandMessage < AsyncMessage
-      SUBSCRIBE_OPERATION = 0
-      UNSUSBSCRIBE_OPERATION = 1
-      POLL_OPERATION = 2
-      CLIENT_SYNC_OPERATION = 4
-      CLIENT_PING_OPERATION = 5
-      CLUSTER_REQUEST_OPERATION = 7
-      LOGIN_OPERATION = 8
-      LOGOUT_OPERATION = 9
-      SESSION_INVALIDATE_OPERATION = 10
-      MULTI_SUBSCRIBE_OPERATION = 11
-      DISCONNECT_OPERATION = 12
-      UNKNOWN_OPERATION = 10000
-
-      attr_accessor :operation
-
-      def initialize
-        @operation = UNKNOWN_OPERATION
-      end
-    end
-
-    # Maps to <tt>flex.messaging.messages.AcknowledgeMessage</tt>
-    class AcknowledgeMessage < AsyncMessage
-      def initialize message=nil
-        @clientId = rand_uuid
-        @destination = nil
-        @messageId = rand_uuid
-        @timestamp = Time.new.to_i*100
-        @timeToLive = 0
-        @headers = {}
-        @body = nil
-
-        if message.is_a?(AbstractMessage)
-          @correlationId = message.messageId
-        end
-      end
-    end
-
-    # Maps to <tt>flex.messaging.messages.ErrorMessage</tt> in AMF3 mode
-    class ErrorMessage < AcknowledgeMessage
-      # Extended data that will facilitate custom error processing on the client
-      attr_accessor :extendedData
-
-      # The fault code for the error, which defaults to the class name of the
-      # causing exception
-      attr_accessor :faultCode
-
-      # Detailed description of what caused the error
-      attr_accessor :faultDetail
-
-      # A simple description of the error
-      attr_accessor :faultString
-
-      # Optional "root cause" of the error
-      attr_accessor :rootCause
-
-      def initialize message, exception
-        super message
-
-        @e = exception
-        @faultCode = @e.class.name
-        @faultDetail = @e.backtrace.join("\n")
-        @faultString = @e.message
-      end
-
-      def to_amf serializer
-        stream = ""
-        if serializer.version == 0
-          data = {
-            :faultCode => @faultCode,
-            :faultDetail => @faultDetail,
-            :faultString => @faultString
-          }
-          serializer.write_hash(data, stream)
-        else
-          serializer.write_object(self, stream)
-        end
-        stream
-      end
-    end
-  end
-end

data/lib/amf/values/typed_hash.rb

@@ -1,13 +0,0 @@
-module AMF
-  module Values #:nodoc:
-    # Hash-like object that can store a type string. Used to preserve type information
-    # for unmapped objects after deserialization.
-    class TypedHash < Hash
-      attr_reader :type
-
-      def initialize type
-        @type = type
-      end
-    end
-  end
-end