active_model_serializers_binary 0.2.0 → 0.3.1

data/lib/active_model_serializers_binary/active_model_serializers_binary.rb

@@ -16,10 +16,7 @@ module ActiveModel
         class_attribute :attr_config
         class_attribute :serialize_options_global
         self.attr_config = []
-        self.serialize_options_global = {
-          align: false,    # Don't align data to byte/word/dword boundary
-          endianess: :little
-        }
+        self.serialize_options_global = {}
 
         def attributes
           keys = self.attr_config.select{ |attr| attr[:virtual]==true }.map{ |attr| attr[:name] }
@@ -37,6 +34,9 @@ module ActiveModel
         end
 
         after_initialize :initialize_serializer rescue nil
+
+        endianess :little
+        align     :dword
       end
 
       module ClassMethods
@@ -49,7 +49,11 @@ module ActiveModel
             true
           else
             attr_name = attr[:name].to_s
-            if !instance.respond_to? attr_name
+            if (instance.class.respond_to? :column_names) && (!instance.class.column_names.include? attr_name)
+              attr[:virtual] = true
+              attr_accessor attr_name
+              true
+            elsif !instance.respond_to? attr_name
               attr[:virtual] = true
               attr_accessor attr_name
               true
@@ -59,14 +63,6 @@ module ActiveModel
           end
         end
 
-        # todo: agrupar parametros en hash (rompe la compatibilidad hacia atras)
-        def serialize_options( attr_name, coder, count=1, length=1, virtual=false, &block )
-          self.attr_config.push({:coder => coder, :count => count, :length => length, :block => block, :name => attr_name.to_s, :virtual => virtual})
-          if virtual==true
-            attr_accessor attr_name
-          end
-        end
-
         def serialize_attribute_options( attr_name, options, &block )
           self.attr_config.push(options.merge({:name => attr_name.to_s, block: block }))
           if options[:virtual]==true
@@ -75,12 +71,12 @@ module ActiveModel
         end       
 
         def int8( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Int8}), &block
         end
 
         def int16( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Int16}), &block
         end
 
@@ -93,7 +89,7 @@ module ActiveModel
         end
 
         def int32( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Int32}), &block
         end
 
@@ -102,16 +98,16 @@ module ActiveModel
         end
 
         def int32be( attr_name, options = {}, &block )
-          int16( attr_name, options.merge({endianess: :big}), &block )
+          int32( attr_name, options.merge({endianess: :big}), &block )
         end
 
         def uint8( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::UInt8}), &block
         end
 
         def uint16( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::UInt16}), &block
         end
 
@@ -124,7 +120,7 @@ module ActiveModel
         end
 
         def uint32( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::UInt32}), &block
         end
 
@@ -137,55 +133,133 @@ module ActiveModel
         end       
 
         def bitfield( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
-          serialize_attribute_options attr_name, options.merge({coder: DataTypes::BitField}), &block
+          options = self.serialize_options_global.merge(options)
+          serialize_attribute_options attr_name, options.merge({coder: DataTypes::BitField, type: :bitfield}), &block
         end
 
         def float32( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Float32}), &block
         end
 
+        def float32le( attr_name, options = {}, &block )
+          float32( attr_name, options.merge({endianess: :little}), &block )
+        end        
+
+        def float32be( attr_name, options = {}, &block )
+          float32( attr_name, options.merge({endianess: :big}), &block )
+        end        
+
         def float64( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
-          serialize_attribute_options attr_name, options.merge({coder: DataTypes::Float32}), &block
+          options = self.serialize_options_global.merge(options)
+          serialize_attribute_options attr_name, options.merge({coder: DataTypes::Float64}), &block
         end
 
+        def float64le( attr_name, options = {}, &block )
+          float64( attr_name, options.merge({endianess: :little}), &block )
+        end        
+
+        def float64be( attr_name, options = {}, &block )
+          float64( attr_name, options.merge({endianess: :big}), &block )
+        end        
+
         def char( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Char}), &block
         end
 
         def bool( attr_name, options = {}, &block )
-          options = serialize_options_global.merge(options)
-          serialize_attribute_options attr_name, options.merge({coder: DataTypes::Bool}), &block
+          options = self.serialize_options_global.merge(options)
+          serialize_attribute_options attr_name, options.merge({coder: DataTypes::Bool, type: :bool}), &block
         end
 
         def nest( attr_name, options={}, &block )
-          options = serialize_options_global.merge(options)
+          options = self.serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({type: :nest}), &block
         end
 
         def endianess( type = :little )
-          serialize_options_global.merge!({endianess: type})
+          self.serialize_options_global.merge!({endianess: type})
+        end
+
+        def align( boundary = false )
+          self.serialize_options_global.merge!({align: boundary})
         end
       end
 
       class Serializer #:nodoc:
-        #attr_reader :options
+        attr_accessor :start_address
 
         def initialize(serializable, options = nil)
           @serializable = serializable
           @options = options ? options.dup : {}
+          @current_address = 0
+          @start_address = 0
+          @current_byte = 0
+          @current_bit = 0
+        end
+
+        def current_address= (value)
+          @current_address = value
+          @current_byte = value.floor
+          @current_bit = (value.modulo(1)*8).round
+        end
+
+        def current_address
+          @current_address
+        end
+
+        def current_byte= (value)
+          @current_byte = value
+          @current_address = (@current_byte+@current_bit/8.0)
+        end
+
+        def current_byte
+          @current_byte
+        end
+
+        def current_bit= (value)
+          @current_bit = value
+          @current_address = (@current_byte+@current_bit/8.0)
+        end
+
+        def current_bit
+          @current_bit
+        end
+
+        def align_data( attr_options, var )
+          # XXX: hay que sacar nest de acá
+          if !attr_options[:type].in? [:bitfield, :bool, :nest]
+            # Se posiciona al principio de un byte
+            if self.current_bit != 0
+              self.current_address = self.current_address.ceil
+            end
+            if @options[:align]==:dword
+              # Si el dato es una palabra simple, alinea los datos en el siguiente byte par
+              if var.bit_length > 8 and (self.current_address + self.start_address).modulo(2) != 0
+                self.current_byte += 1
+              end
+              # Si el dato es una palabra doble, alinea los datos en la siguiente palabra par
+              if var.bit_length > 16 and (self.current_address + self.start_address).modulo(4) != 0
+                self.current_byte += 4-self.current_byte%4
+              end
+            elsif @options[:align]==:word
+              # Si el dato es una palabra simple, alinea los datos en el siguiente byte par
+              if var.bit_length > 8 and (self.current_address + self.start_address).modulo(2) != 0
+                self.current_byte += 1
+              end
+            end
+          end
         end
 
         def dump
-          serializable_values = @serializable.serializable_hash(@options)
-          start_address = @options[:start_address] || 0
+          serializable_values = @serializable.attributes
+          self.start_address = @options[:start_address] || 0
 
           buffer = [] # Data Buffer
           tmp_buffer = [] # Aux Data Buffer
-          current_address = start_address*2 + 0.0 # Address in bytes
+
+          self.current_address = self.start_address # Address in bytes
 
           @serializable.attr_config.each do |attr_options|
             attr_name = attr_options[:name]
@@ -197,46 +271,24 @@ module ActiveModel
               var = attr_options[:coder].new(var_value)
             end
 
-            byte = current_address.floor
-            bit = (current_address.modulo(1)*8).round
-
             tmp_buffer = var.dump
 
-            if @options[:align]
-              if !attr_options[:type].in? [:bitfield, :bool, :nest]
-                # Se posiciona al principio de un byte
-                if bit != 0
-                  byte += 1
-                  bit = 0
-                  current_address = (byte+bit/8.0)
-                end
-                # Si el dato es una palabra simple, alinea los datos en el siguiente byte par
-                if var.bit_length > 8 and current_address.modulo(2) != 0
-                  byte += 1
-                  bit = 0
-                end
-                # Si el dato es una palabra doble, alinea los datos en la siguiente palabra par
-                if var.bit_length > 16 and (current_address + start_address*2).modulo(4) != 0
-                  byte += 4-byte%4
-                  bit = 0
-                end
-              end
-            end
+            align_data(attr_options, var) if @options[:align]
 
             # Si los datos ocupan mas de un byte concatena los arrays
             if !attr_options[:type].in? [:bitfield, :bool] and @options[:align]
-              buffer.insert(byte, tmp_buffer).flatten!
+              buffer.insert(self.current_byte, tmp_buffer).flatten!
             else # En caso de ser bits
               tmp_buffer.flatten!
               tmp_bits=tmp_buffer.pack('C*').unpack('b*').first.slice(0,var.size*8)
-              tmp_buffer=[tmp_bits.rjust(tmp_bits.length+bit,'0')].pack('b*').unpack('C*')
+              tmp_buffer=[tmp_bits.rjust(tmp_bits.length+self.current_bit,'0')].pack('b*').unpack('C*')
 
               tmp_buffer.each_with_index do |v,i|
-                buffer[byte+i] = (buffer[byte+i] || 0) | v
+                buffer[self.current_byte+i] = (buffer[self.current_byte+i] || 0) | v
               end
             end
 
-            current_address = (byte+bit/8.0)+var.size
+            self.current_address += var.size
           end
           buffer.map!{|el| el || 0}
         end
@@ -244,47 +296,26 @@ module ActiveModel
         #deserializado
         def load (buffer=[])
           serialized_values = {}
-          start_address = @options[:start_address] || 0
+          self.start_address = @options[:start_address] || 0
 
           buffer ||= [] # Buffer en bytes
           tmp_buffer = [] # Buffer temporal en bytes
 
-          current_address = start_address*2 + 0.0 # Dirección en bytes
+          self.current_address = self.start_address # Dirección en bytes
 
           @serializable.attr_config.each do |attr_options|
             attr_name = attr_options[:name]
-            byte = current_address.floor
-            bit = (current_address.modulo(1)*8).round
 
             var = attr_options[:coder].new(attr_options.merge(parent: @serializable)) #creo objeto del tipo de dato pasado
 
-            if @options[:align]
-              if !attr_options[:type].in? [:bitfield, :bool, :nest]
-                # Se posiciona al principio de un byte
-                if bit != 0
-                  byte += 1
-                  bit = 0
-                  current_address = (byte+bit/8.0)
-                end
-                # Si el dato es una palabra simple, alinea los datos en el siguiente byte par
-                if var.bit_length > 8 and current_address.modulo(2) != 0
-                  byte += 1
-                  bit = 0
-                end
-                # Si el dato es una palabra doble, alinea los datos en la siguiente palabra par
-                if var.bit_length > 16 and (current_address + start_address*2).modulo(4) != 0
-                  byte += 4-byte%4
-                  bit = 0
-                end
-              end
-            end
+            align_data(attr_options, var) if @options[:align]
 
             # Si los datos ocupan mas de un byte, obtiene los bytes completos del buffer original
             if !attr_options[:type].in? [:bitfield, :bool] and @options[:align]
-              result_deserialized=var.load(buffer.slice(byte, var.size))
+              result_deserialized=var.load(buffer.slice(self.current_byte, var.size))
             else # En caso de ser bits
-              tmp_buffer = buffer.slice(byte, (var.size+bit/8.0).ceil)
-              result_deserialized=var.load([tmp_buffer.pack('C*').unpack('b*').first.slice(bit,var.size*8)].pack('b*').unpack('C*'))
+              tmp_buffer = buffer.slice(self.current_byte, (var.size+self.current_bit/8.0).ceil)
+              result_deserialized=var.load([tmp_buffer.pack('C*').unpack('b*').first.slice(self.current_bit,var.size*8)].pack('b*').unpack('C*'))
             end
 
             if attr_options[:type] == :nest
@@ -292,7 +323,7 @@ module ActiveModel
             else
               serialized_values["#{attr_name}"] = result_deserialized.count>1 ? result_deserialized : result_deserialized.first
             end
-            current_address = (byte+bit/8.0)+var.size
+            self.current_address += var.size
           end
 
           # Asigno los datos leidos
@@ -304,40 +335,19 @@ module ActiveModel
 
         # Return size of object in bytes
         def size
-          serializable_values = @serializable.serializable_hash(@options)
-          start_address = @options[:start_address] || 0
+          serializable_values = @serializable.attributes
+          self.start_address = @options[:start_address] || 0
 
           current_address = 0.0 # Dirección en bytes
 
           @serializable.attr_config.each do |attr_options|
             var = attr_options[:coder].new(attr_options.merge(parent: @serializable))
 
-            byte = current_address.floor
-            bit = (current_address.modulo(1)*8).round
-
-            if @options[:align]
-              if !attr_options[:type].in? [:bitfield, :bool, :nest]
-                # Se posiciona al principio de un byte
-                if bit != 0
-                  byte += 1
-                  bit = 0
-                  current_address = (byte+bit/8.0)
-                end
-                # Si el dato es una palabra simple, alinea los datos en el siguiente byte par
-                if var.bit_length > 8 and current_address.modulo(2) != 0
-                  byte += 1
-                  bit = 0
-                end
-                # Si el dato es una palabra doble, alinea los datos en la siguiente palabra par
-                if var.bit_length > 16 and (current_address + start_address*2).modulo(4) != 0
-                  byte += 4-byte%4
-                  bit = 0
-                end
-              end
-            end
-            current_address = (byte+bit/8.0)+var.size
+            align_data(attr_options, var) if @options[:align]
+
+            self.current_address += var.size
           end
-          current_address-start_address
+          self.current_address-self.start_address
         end
 
       end #close class serializer
@@ -351,9 +361,9 @@ module ActiveModel
       #   => [98, 111, 98, 0, 0, 0, 0, 0, 0, 0, 22, 0, 1]
       #
       def to_bytes(options = {}, &block)
-        options = self.serialize_options_global.deep_merge(options)
+        options = self.serialize_options_global.merge(options)
         if block_given?
-            yield self
+            yield self, options
         end
         Serializer.new(self, options).dump
       end
@@ -362,8 +372,12 @@ module ActiveModel
 
       def to_words(options = {}, &block)
         data = to_bytes(options, &block)
-        byte_count = (data.count/2.0).ceil*2
-        data.fill(0, data.count...byte_count).pack('C*').unpack('v*')
+        data.push(0) if data.count.odd?
+        if self.serialize_options_global[:endianess]==:big
+          data.pack('C*').unpack('S>*')
+        else
+          data.pack('C*').unpack('S<*')
+        end
       end
 
       # Sets the model +attributes+ from an Binary string. Returns +self+.
@@ -403,11 +417,11 @@ module ActiveModel
       # @yield code block to execute after deserialization
       #
       def from_bytes(buffer, options = {}, &block)
-        options = self.serialize_options_global.deep_merge(options)
+        options = self.serialize_options_global.merge(options)
         retVal = Serializer.new(self, options).load buffer
         
         if block_given?
-          yield self
+          yield self, options
         end
         retVal
       end
@@ -415,12 +429,16 @@ module ActiveModel
       alias_method :load, :from_bytes
 
       def from_words(buffer = [], options = {}, &block)
-        data = buffer.pack('v*').unpack('C*')
+        if self.serialize_options_global[:endianess]==:big
+          data = buffer.pack('S>*').unpack('C*')
+        else
+          data = buffer.pack('S<*').unpack('C*')
+        end
         from_bytes(data, options, &block)
       end
 
       def size(options = {})
-        options = self.serialize_options_global.deep_merge(options)
+        options = self.serialize_options_global.merge(options)
         Serializer.new(self, options).size
       end
 

data/lib/active_model_serializers_binary/base_type.rb

@@ -48,7 +48,7 @@ module DataTypes
           default_value
         else
           case type
-            when :float32
+            when :float32, :float64
               v.to_f
             when :char
               v.to_s[0...length]