revent 0.1 → 0.2

data/lib/revent/amf3/io/amf_serializer.rb

@@ -0,0 +1,184 @@
+module RubyAMF
+  module IO
+    class AMFSerializer
+
+      require "#{File.dirname(__FILE__)}/read_write"
+
+      include RubyAMF::Configuration
+      include RubyAMF::IO::BinaryWriter
+      include RubyAMF::IO::Constants
+      include RubyAMF::VoHelper
+
+      attr_accessor :stream
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @stream = ''
+        reset_referencables
+      end
+
+      def reset_referencables
+        @stored_strings = {} # hash is way faster than array
+        @stored_strings[""] = true # add this in automatically
+        @write_amf3_integer_results = {} # cache the integers
+        @current_strings_index = 0
+      end
+
+      def write_amf3(value)
+        if !value
+          @stream << "\001" # represents an amf3 null
+
+        elsif (value.is_a?(TrueClass) || value.is_a?(FalseClass))
+          value ? (@stream << "\003")  : (@stream << "\002")   # represents an amf3 true  and  false
+
+        elsif value.is_a?(Numeric)
+          if value.is_a?(Integer) # Aryk: This was also incorrect before because you has Bignum check AFTER the Integer check, which means the Bignum's were getting picked up by Integers
+            if value.is_a?(Bignum)
+              @stream << "\005" # represents an amf3 complex number
+              write_double(value)
+            else
+              write_amf3_number(value)
+            end
+          elsif(value.is_a?(Float))
+            @stream << "\005" # represents an amf3 complex number
+            write_double(value)
+          elsif value.is_a?(BigDecimal) # Aryk: BigDecimal does not relate to Float, so keep it as a seperate check.
+            # TODO: Aryk: Not quite sure why you do value.to_s.to_f? can't you just do value.to_f?
+            value = value.to_s('F').to_f #this is turning a string into a Ruby Float, but because there are no further operations on it it is safe          
+            @stream << "\005" # represents an amf3 complex number
+            write_double(value)
+          end
+
+        elsif(value.is_a?(String))
+          @stream << "\006" # represents an amf3 string
+          write_amf3_string(value)
+
+        elsif(value.is_a?(Array))
+          write_amf3_array(value)
+
+        elsif(value.is_a?(Hash))
+          write_amf3_object(value)
+
+        elsif (value.is_a?(Time)||value.is_a?(Date))
+          @stream << "\b" # represents an amf3 date
+          write_amf3_date(value)
+
+          # I know we can combine this with the last condition, but don't  ; the Rexml and Beautiful Soup test is expensive, and for large record sets with many AR its better to be able to skip the next step
+        elsif value.is_a?(ActiveRecord::Base) # Aryk: this way, we can bypass the "['REXML::Document', 'BeautifulSoup'].include?(value.class.to_s) " operation
+          write_amf3_object(VoUtil.get_vo_hash_for_outgoing(value))
+
+        elsif ['REXML::Document', 'BeautifulSoup'].include?(value.class.to_s) 
+          write_byte(AMF3_XML)
+          write_amf3_xml(value)
+
+        elsif value.is_a?(Object)
+          write_amf3_object(VoUtil.get_vo_hash_for_outgoing(value) )
+        end
+      end
+
+      def write_amf3_integer(int)
+        @stream << (@write_amf3_integer_results[int] ||= (
+            int = int & 0x1fffffff
+            if(int < 0x80)
+              [int].pack('c')
+            elsif(int < 0x4000)
+              [int >> 7 & 0x7f | 0x80].pack('c')+
+                [int & 0x7f].pack('c')
+            elsif(int < 0x200000)
+              [int >> 14 & 0x7f | 0x80].pack('c')+
+                [int >> 7 & 0x7f | 0x80].pack('c')+
+                [int & 0x7f].pack('c')
+            else
+              [int >> 22 & 0x7f | 0x80].pack('c')+
+                [int >> 15 & 0x7f | 0x80].pack('c')+
+                [int >> 8 & 0x7f | 0x80].pack('c')+
+                [int & 0xff].pack('c')
+            end
+          ))
+      end
+
+      def write_amf3_number(number)
+        if(number >= AMF3_INTEGER_MIN && number <= AMF3_INTEGER_MAX) #check valid range for 29bits
+          @stream << "\004" # represents an amf3 integer
+          write_amf3_integer(number)
+        else #overflow condition otherwise
+          @stream << "\005" # represents an amf3 complex number
+          write_double(number)
+        end
+      end
+
+      def write_amf3_string(string)
+        if index = @stored_strings[string]
+          if string == "" # store this initially so it gets caught by the stored_strings check
+            @stream << "\001" # represents an amf3 empty string
+          else
+            reference = index << 1
+            write_amf3_integer(reference)
+          end
+        else
+          @stored_strings[string] = @current_strings_index
+          @current_strings_index += 1 # increment the index
+          reference = string.length
+          reference = reference << 1
+          reference = reference | 1
+          write_amf3_integer(reference)
+          writen(string)
+        end
+      end
+
+      def write_amf3_object(hash)   
+        not_vo_hash = !hash.is_a?(VoHash) # is this not a vohash - then doesnt have an _explicitType parameter
+        @stream << "\n\v" # represents an amf3 object and dynamic object  
+        not_vo_hash || !hash._explicitType ? (@stream << "\001") : write_amf3_string(hash._explicitType)
+        hash.each do |attr, value| # Aryk: no need to remove any "_explicitType" or "rmember" key since they werent added as keys
+          if not_vo_hash # then that means that the attr might not be symbols and it hasn't gone through camelizing if thats needed
+            attr = attr.to_s.dup # need this just in case its frozen
+            attr.to_camel! if ClassMappings.translate_case 
+          end
+          write_amf3_string(attr) 
+          value ? write_amf3(value) : (@stream << "\001") # represents an amf3 null
+        end        
+        @stream << "\001" # represents an amf3 empty string #close open object
+      end
+
+      def write_amf3_array(array)
+        num_objects = array.length * 2 + 1
+        if ClassMappings.use_array_collection
+          @stream << "\n\a" # AMF3_OBJECT and AMF3_XML
+          write_amf3_string("flex.messaging.io.ArrayCollection")
+        end
+        @stream << "\t" # represents an amf3 array
+        write_amf3_integer(num_objects)
+        @stream << "\001" # represents an amf3 empty string #write empty for string keyed elements here, as it's never allowed from ruby
+        array.each{|v| write_amf3(v) }
+      end
+
+      def write_amf3_date(datetime) # Aryk: Dates will almost never be the same, so turn off the storing_objects
+        write_amf3_integer(1)
+        seconds = if datetime.is_a?(Time)
+          datetime.utc unless datetime.utc?
+          datetime.to_f
+        elsif datetime.is_a?(Date) # this also handles the case for DateTime
+          datetime.strftime("%s").to_i
+          # datetime = Time.gm( datetime.year, datetime.month, datetime.day )
+          # datetime = Time.gm( datetime.year, datetime.month, datetime.day, datetime.hour, datetime.min, datetime.sec )      
+        end
+        write_double( (seconds*1000).to_i ) # used to be total_milliseconds = datetime.to_i * 1000 + ( datetime.usec/1000 )
+      end
+
+      def write_amf3_xml(value)
+        xml = value.to_s
+        a = xml.strip
+        if(a != nil)
+          b = a.gsub!(/\>(\n|\r|\r\n| |\t)*\</,'><') #clean whitespace
+        else
+          b = xml.gsub!(/\>(\n|\r|\r\n| |\t)*\</,'><') #clean whitespace
+        end
+        write_amf3_string(b)
+      end
+    end
+  end
+end

data/lib/revent/amf3/io/read_write.rb

@@ -0,0 +1,308 @@
+begin
+  module RubyAMF
+  module IO
+    module Constants
+      AMF3_TYPE = 0x11
+      AMF3_UNDEFINED = 0x00
+      AMF3_NULL = 0x01
+      AMF3_FALSE = 0x02
+      AMF3_TRUE = 0x03
+      AMF3_INTEGER = 0x04
+      AMF3_NUMBER = 0x05
+      AMF3_STRING = 0x06
+      AMF3_XML = 0x07
+      AMF3_DATE = 0x08
+      AMF3_ARRAY = 0x09
+      AMF3_OBJECT = 0x0A
+      AMF3_XML_STRING = 0x0B
+      AMF3_BYTE_ARRAY = 0x0C
+      AMF3_INTEGER_MAX = 268435455
+      AMF3_INTEGER_MIN = -268435456
+    end
+    module BinaryReader
+
+      Native = :Native
+      Big = BigEndian = Network = :BigEndian
+      Little = LittleEndian = :LittleEndian
+
+      #examines the locale byte order on the running machine
+      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
+
+      def byte_order_big?
+        (byte_order == :BigEndian) ? true : false;
+      end
+      alias :byte_order_network? :byte_order_big?
+
+      #read N length from stream starting at position
+      def readn(length)
+        self.stream_position ||= 0
+        str = self.stream[self.stream_position, length]
+        self.stream_position += length
+        str
+      end
+
+      #reada a boolean
+      def read_boolean
+        d = self.stream[self.stream_position,1].unpack('c').first
+        self.stream_position += 1
+        (d == 1) ? true : false;
+      end
+
+      #8bits no byte order
+      def read_int8
+        d = self.stream[self.stream_position,1].unpack('c').first
+        self.stream_position += 1
+        d
+      end
+      alias :read_byte :read_int8  
+
+      # Aryk: TODO: This needs to be written more cleanly. Using rescue and then regex checks on top of that slows things down
+      def read_word8
+        begin
+          d = self.stream[self.stream_position,1].unpack('C').first
+          self.stream_position += 1
+          d
+        rescue Exception => e
+          #this handles an exception condition when Rails' 
+          #ActionPack strips off the last "\000" of the AMF stream
+          self.stream_position += 1
+          return 0
+        end
+      end
+
+      #16 bits Unsigned
+      def read_word16_native
+        d = self.stream[self.stream_position,2].unpack('S').first
+        self.stream_position += 2
+        d
+      end
+
+      def read_word16_little
+        d = self.stream[self.stream_position,2].unpack('v').first
+        self.stream_position += 2
+        d
+      end
+
+      def read_word16_network
+        d = self.stream[self.stream_position,2].unpack('n').first
+        self.stream_position += 2
+        d
+      end
+
+      #16 bits Signed
+      def read_int16_native
+        str = self.readn(2).unpack('s').first
+      end
+
+      def read_int16_little
+        str = self.readn(2)
+        str.reverse! if byte_order_network? # swap bytes as native=network (and we want little)
+        str.unpack('s').first
+      end
+
+      def read_int16_network
+        str = self.readn(2)
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str.unpack('s').first
+      end
+
+      #32 bits unsigned
+      def read_word32_native
+        d = self.stream[self.stream_position,4].unpack('L').first
+        self.stream_position += 4
+        d
+      end
+
+      def read_word32_little
+        d = self.stream[self.stream_position,4].unpack('V').first
+        self.stream_position += 4
+        d
+      end
+
+      def read_word32_network
+        d = self.stream[self.stream_position,4].unpack('N').first
+        self.stream_position += 4
+        d
+      end
+
+      #32 bits signed
+      def read_int32_native
+        d = self.stream[self.stream_position,4].unpack('l').first
+        self.stream_position += 4
+        d
+      end
+
+      def read_int32_little
+        str = readn(4)
+        str.reverse! if byte_order_network? # swap bytes as native=network (and we want little)
+        str.unpack('l').first
+      end
+
+      def read_int32_network
+        str = readn(4)
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str.unpack('l').first
+      end
+
+
+      #UTF string
+      def read_utf
+        length = self.read_word16_network
+        readn(length)
+      end
+
+      def read_int32_network
+        str = self.readn(4)
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str.unpack('l').first
+      end
+
+      def read_double
+        d = self.stream[self.stream_position,8].unpack('G').first
+        self.stream_position += 8
+        d
+      end
+
+      def read_long_utf(length)
+        length = read_word32_network #get the length of the string (1st 4 bytes)
+        self.readn(length) #read length number of bytes
+      end
+    end
+
+
+    module BinaryWriter
+
+      #examines the locale byte order on the running machine
+      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
+
+      def byte_order_big?
+        (byte_order == :BigEndian) ? true : false;
+      end
+      alias :byte_order_network? :byte_order_big?
+
+      def writen(val)
+        @stream << val
+      end
+
+      #8 bit no byteorder
+      def write_word8(val)
+        self.stream << [val].pack('C')
+      end
+
+      def write_int8(val)
+        self.stream << [val].pack('c')
+      end
+
+      #16 bit unsigned
+      def write_word16_native(val)
+        self.stream << [val].pack('S')
+      end
+
+      def write_word16_little(val)
+        str = [val].pack('S')
+        str.reverse! if byte_order_network? # swap bytes as native=network (and we want little)
+        self.stream << str
+      end
+
+      def write_word16_network(val)
+        str = [val].pack('S')
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        self.stream << str
+      end
+
+      #16 bits signed
+      def write_int16_native(val)
+        self.stream << [val].pack('s')
+      end
+
+      def write_int16_little(val)
+        self.stream << [val].pack('v')
+      end
+
+      def write_int16_network(val)
+        self.stream << [val].pack('n')
+      end
+
+      #32 bit unsigned
+      def write_word32_native(val)
+        self.stream << [val].pack('L')
+      end
+
+      def write_word32_little(val)
+        str = [val].pack('L')
+        str.reverse! if byte_order_network? # swap bytes as native=network (and we want little)
+        self.stream << str
+      end
+
+      def write_word32_network(val)
+        str = [val].pack('L')
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        self.stream << str
+      end
+
+      #32 signed
+      def write_int32_native(val)
+        self.stream << [val].pack('l')
+      end
+
+      def write_int32_little(val)
+        self.stream << [val].pack('V')
+      end
+
+      def write_int32_network(val)
+        self.stream << [val].pack('N')
+      end
+
+      # write utility methods
+      def write_byte(val)
+        #self.write_int8(val)
+        @stream << [val].pack('c')
+      end
+
+      def write_boolean(val)
+        if val then self.write_byte(1) else self.write_byte(0) end
+      end
+
+      def write_utf(str)
+        self.write_int16_network(str.length)
+        self.stream << str
+      end
+
+      def write_long_utf(str)
+        self.write_int32_network(str.length)
+        self.stream << str
+      end
+
+      def write_double(val)
+        self.stream << ( @floats_cache[val] ||= 
+          [val].pack('G')
+        )
+        #puts "WRITE DOUBLE"
+        #puts @floats_cache
+      end
+    end
+  end
+  end
+rescue Exception => e
+  raise RUBYAMFException.new(RUBYAMFException.AMF_ERROR, "The AMF data is incorrect or incomplete.")
+end