active_model_serializers_binary 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 876801a003f61b57070687c4049198f3a7407a21
-  data.tar.gz: e9c677a84305f640f0f77280d01767246da97f9d
+  metadata.gz: 596d98d9d3ebdccccb17e210ba65d1c21f3402a1
+  data.tar.gz: c8b0dfdb53e10abb64d79185687d6530a440e0fb
 SHA512:
-  metadata.gz: 34ed74da0e671a9be0e153940416150b8550e091d8e5ee10ab8c74caf89c30cbe963dfe62cdb47b3926b13b9cd9e7140d1617473e42d27197f7873e1fa0ba859
-  data.tar.gz: f7e0803f4e919c2c7b2c3d7e32718f0b912aaeff3be7288b86016c26bc21b3dbeb1ff1edc4bea9af6783dcb189d929fcae2ac1a8d961d389e36edd4c89c027d9
+  metadata.gz: 524d45fbc3dc9b1208cf49a5efe72a3beac8860b0ddc98e6897999f4f60f532e37512db7f2fa76cdbbf15681d250e0c899386933ab02ff39124949209521b7ad
+  data.tar.gz: c6b4b8d0e2a58b39d111fad53e10ef3ea40d2b540bcc6ad00b0661c4ed2174864a0e57465e997c4802d0d58f642d1d4a58e06cf7c59f33ea79272a238b2fd5fd

data/lib/active_model_serializers_binary/active_model_serializers_binary.rb

@@ -7,6 +7,7 @@ module ActiveModel
     # == Active Model Binary serializer
     module Binary
       extend ActiveSupport::Concern
+      include ActiveModel::Model
       include ActiveModel::Serialization
       include DataTypes
 
@@ -16,10 +17,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] }
@@ -28,8 +26,8 @@ module ActiveModel
         end
 
         def initialize( *args )
-          super rescue super()
           initialize_serializer
+          super rescue super()
         end
 
         def initialize_serializer
@@ -37,6 +35,9 @@ module ActiveModel
         end
 
         after_initialize :initialize_serializer rescue nil
+
+        endianess :little
+        align     false
       end
 
       module ClassMethods
@@ -59,14 +60,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 +68,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 +86,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 +95,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 +117,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 +130,117 @@ 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 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 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
+          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 +252,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 +277,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 +304,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
@@ -305,39 +317,18 @@ module ActiveModel
         # Return size of object in bytes
         def size
           serializable_values = @serializable.serializable_hash(@options)
-          start_address = @options[:start_address] || 0
+          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

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]

data/lib/active_model_serializers_binary/data_types.rb

@@ -1,251 +1,251 @@
-require_relative 'base_type.rb'
-
-module DataTypes
-
-  class Int8 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 8, :sign => :signed
-    end
-
-    def dump(value=nil)
-      before_dump( value ).pack('c*').unpack('C*')
-      @raw_value = @value
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('c*')
-      after_load
-    end
-  end
-
-  class Int16 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 16, :sign => :signed
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      if @endianess == :big
-        @raw_value = @value.pack('s>*').unpack('C*')
-      else
-        @raw_value = @value.pack('s<*').unpack('C*')
-      end
-    end
-
-    def load(raw_value)
-      if @endianess == :big
-        self.value = check_raw_value(raw_value).pack('C*').unpack('s>*')
-      else
-        self.value = check_raw_value(raw_value).pack('C*').unpack('s<*')
-      end
-      after_load
-    end
-  end
-
-  class Int32 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 32, :sign => :signed
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      if @endianess == :big
-        @raw_value = @value.pack('l>*').unpack('C*')
-      else
-        @raw_value = @value.pack('l<*').unpack('C*')
-      end
-    end
-
-    def load(raw_value)
-      if @endianess == :big
-        self.value = check_raw_value(raw_value).pack('C*').unpack('l>*') if !value.nil?
-      else
-        self.value = check_raw_value(raw_value).pack('C*').unpack('l<*') if !value.nil?
-      end
-      after_load
-    end
-  end
-
-  class UInt16 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 16, :sign => :unsigned
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      if @endianess == :big
-        @raw_value = @value.pack('S>*').unpack('C*')
-      else
-        @raw_value = @value.pack('S<*').unpack('C*')
-      end
-    end
-
-    def load(raw_value) 
-      @raw_value = check_raw_value(raw_value)
-      if @endianess == :big
-        self.value = @raw_value.pack('C*').unpack('S>*')
-      else
-        self.value = @raw_value.pack('C*').unpack('S<*')
-      end
-      after_load
-    end
-  end
-
-  class UInt32 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 32, :sign => :unsigned
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      if @endianess == :big
-        @raw_value = @value.pack('L>*').unpack('C*')
-      else
-        @raw_value = @value.pack('L<*').unpack('C*')
-      end
-    end
-
-    def load(raw_value)
-      if @endianess == :big
-        self.value = check_raw_value(raw_value).pack('C*').unpack('L>*') if !value.nil?
-      else
-        self.value = check_raw_value(raw_value).pack('C*').unpack('L<*') if !value.nil?
-      end
-      after_load
-    end
-  end
-
-  class UInt8 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 8, :sign => :unsigned
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      @raw_value = @value
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value)
-      after_load
-    end
-  end
-
-  class BitField < BaseType
-    def initialize(options = {})
-      length = options[:bin_length].blank? ? 1 : (options[:bin_length] > 32 ? 32 : options[:bin_length])
-      super options.merge :bit_length => length, :sign => :unsigned
-    end
-
-    def format
-      if bit_length <= 8 # 8 bits
-        'C*'
-      elsif bit_length <= 16 # 16 bits
-        'v*'
-      else # 32 bits
-        'l*'
-      end
-    end
-
-    def word_length
-      if bit_length <= 8 # 8 bits
-        8
-      elsif bit_length <= 16 # 16 bits
-        16
-      else # 32 bits
-        32
-      end
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      data = @value.pack(format).unpack('b*').first.chars.each_slice(word_length).map(&:join).map{|n| n.slice(0,bit_length)}
-      @raw_value = [data.join].pack('b*').unpack('C*')
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('b*').first.chars.slice(0,@bit_length*@count).each_slice(bit_length).map(&:join).map{|n| [n].pack('b*').unpack('C*').first}
-      after_load
-    end
-  end
-
-  class Char < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 8, :sign => nil, :default_value => "\x0"
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      @raw_value = @value.map{|v| v.ljust(@length, @default_value).slice(0,@length).unpack('C*')}
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack("Z#{@length}") if !value.nil?
-      after_load
-    end
-  end
-
-  class Bool < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 1, :default_value => false
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      @raw_value = Array(@value.map{|v| v ? 1 : 0}.join).pack('b*').unpack('C*')
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('b*').first.slice(0,size*8).split('').map(&:to_i) if !value.nil?
-      after_load
-    end
-  end
-
-  class Float32 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 32, :sign => nil, :default_value => 0.0
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      if @endianess == :big
-        @raw_value = @value.pack('g*').unpack('C*')
-      else
-        @raw_value = @value.pack('e*').unpack('C*')
-      end
-    end
-
-    def load(raw_value)
-      if @endianess == :big
-        self.value = check_raw_value(raw_value).pack('C*').unpack('g*') if !value.nil?
-      else
-        self.value = check_raw_value(raw_value).pack('C*').unpack('e*') if !value.nil?
-      end
-      after_load
-    end
-  end
-
-  class Float64 < BaseType
-    def initialize(options = {})
-      super options.merge :bit_length => 64, :sign => nil, :default_value => 0.0
-    end
-
-    def dump(value=nil)
-      before_dump( value )
-      if @endianess == :big
-        @raw_value = @value.pack('G*').unpack('C*')
-      else
-        @raw_value = @value.pack('E*').unpack('C*')
-      end
-    end
-
-    def load(raw_value)
-      if @endianess == :big
-        self.value = check_raw_value(raw_value).pack('C*').unpack('G*') if !value.nil?
-      else
-        self.value = check_raw_value(raw_value).pack('C*').unpack('E*') if !value.nil?
-      end
-      after_load
-    end
-  end
+require_relative 'base_type.rb'
+
+module DataTypes
+
+  class Int8 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 8, :sign => :signed
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      @raw_value = @value.pack('c*').unpack('C*')
+    end
+
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('c*')
+      after_load
+    end
+  end
+
+  class Int16 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 16, :sign => :signed
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      if @endianess == :big
+        @raw_value = @value.pack('s>*').unpack('C*')
+      else
+        @raw_value = @value.pack('s<*').unpack('C*')
+      end
+    end
+
+    def load(raw_value)
+      if @endianess == :big
+        self.value = check_raw_value(raw_value).pack('C*').unpack('s>*')
+      else
+        self.value = check_raw_value(raw_value).pack('C*').unpack('s<*')
+      end
+      after_load
+    end
+  end
+
+  class Int32 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 32, :sign => :signed
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      if @endianess == :big
+        @raw_value = @value.pack('l>*').unpack('C*')
+      else
+        @raw_value = @value.pack('l<*').unpack('C*')
+      end
+    end
+
+    def load(raw_value)
+      if @endianess == :big
+        self.value = check_raw_value(raw_value).pack('C*').unpack('l>*') if !value.nil?
+      else
+        self.value = check_raw_value(raw_value).pack('C*').unpack('l<*') if !value.nil?
+      end
+      after_load
+    end
+  end
+
+  class UInt16 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 16, :sign => :unsigned
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      if @endianess == :big
+        @raw_value = @value.pack('S>*').unpack('C*')
+      else
+        @raw_value = @value.pack('S<*').unpack('C*')
+      end
+    end
+
+    def load(raw_value) 
+      @raw_value = check_raw_value(raw_value)
+      if @endianess == :big
+        self.value = @raw_value.pack('C*').unpack('S>*')
+      else
+        self.value = @raw_value.pack('C*').unpack('S<*')
+      end
+      after_load
+    end
+  end
+
+  class UInt32 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 32, :sign => :unsigned
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      if @endianess == :big
+        @raw_value = @value.pack('L>*').unpack('C*')
+      else
+        @raw_value = @value.pack('L<*').unpack('C*')
+      end
+    end
+
+    def load(raw_value)
+      if @endianess == :big
+        self.value = check_raw_value(raw_value).pack('C*').unpack('L>*') if !value.nil?
+      else
+        self.value = check_raw_value(raw_value).pack('C*').unpack('L<*') if !value.nil?
+      end
+      after_load
+    end
+  end
+
+  class UInt8 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 8, :sign => :unsigned
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      @raw_value = @value
+    end
+
+    def load(raw_value)
+      self.value = check_raw_value(raw_value)
+      after_load
+    end
+  end
+
+  class BitField < BaseType
+    def initialize(options = {})
+      length = options[:bin_length].blank? ? 1 : (options[:bin_length] > 32 ? 32 : options[:bin_length])
+      super options.merge :bit_length => length, :sign => :unsigned
+    end
+
+    def format
+      if bit_length <= 8 # 8 bits
+        'C*'
+      elsif bit_length <= 16 # 16 bits
+        'v*'
+      else # 32 bits
+        'l*'
+      end
+    end
+
+    def word_length
+      if bit_length <= 8 # 8 bits
+        8
+      elsif bit_length <= 16 # 16 bits
+        16
+      else # 32 bits
+        32
+      end
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      data = @value.pack(format).unpack('b*').first.chars.each_slice(word_length).map(&:join).map{|n| n.slice(0,bit_length)}
+      @raw_value = [data.join].pack('b*').unpack('C*')
+    end
+
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('b*').first.chars.slice(0,@bit_length*@count).each_slice(bit_length).map(&:join).map{|n| [n].pack('b*').unpack('C*').first}
+      after_load
+    end
+  end
+
+  class Char < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 8, :sign => nil, :default_value => "\x0"
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      @raw_value = @value.map{|v| v.ljust(@length, @default_value).slice(0,@length).unpack('C*')}
+    end
+
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack("Z#{@length}") if !value.nil?
+      after_load
+    end
+  end
+
+  class Bool < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 1, :default_value => false
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      @raw_value = Array(@value.map{|v| v ? 1 : 0}.join).pack('b*').unpack('C*')
+    end
+
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('b*').first.slice(0,size*8).split('').map(&:to_i) if !value.nil?
+      after_load
+    end
+  end
+
+  class Float32 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 32, :sign => nil, :default_value => 0.0
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      if @endianess == :big
+        @raw_value = @value.pack('g*').unpack('C*')
+      else
+        @raw_value = @value.pack('e*').unpack('C*')
+      end
+    end
+
+    def load(raw_value)
+      if @endianess == :big
+        self.value = check_raw_value(raw_value).pack('C*').unpack('g*') if !value.nil?
+      else
+        self.value = check_raw_value(raw_value).pack('C*').unpack('e*') if !value.nil?
+      end
+      after_load
+    end
+  end
+
+  class Float64 < BaseType
+    def initialize(options = {})
+      super options.merge :bit_length => 64, :sign => nil, :default_value => 0.0
+    end
+
+    def dump(value=nil)
+      before_dump( value )
+      if @endianess == :big
+        @raw_value = @value.pack('G*').unpack('C*')
+      else
+        @raw_value = @value.pack('E*').unpack('C*')
+      end
+    end
+
+    def load(raw_value)
+      if @endianess == :big
+        self.value = check_raw_value(raw_value).pack('C*').unpack('G*') if !value.nil?
+      else
+        self.value = check_raw_value(raw_value).pack('C*').unpack('E*') if !value.nil?
+      end
+      after_load
+    end
+  end
 end

data/lib/active_model_serializers_binary/version.rb

@@ -1,3 +1,3 @@
 module ActiveModelSerializersBinary
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/test/dummy/app/models/product.rb

@@ -0,0 +1,27 @@
+class Product
+	include ActiveModel::Serializers::Binary
+
+	endianess :big
+	align :dword
+
+	int8 :int8
+	int16 :int16
+	int16le :int16le
+	int16be :int16be
+	int32 :int32
+	int32le :int32le
+	int32be :int32be
+	uint8 :uint8
+	uint16 :uint16
+	uint16le :uint16le
+	uint16be :uint16be
+	uint32 :uint32
+	uint32le :uint32le
+	uint32be :uint32be
+	bitfield :bitfield
+	float32 :float32
+	float64 :float64
+	char :char
+	bool :bool
+	nest :type, coder: Type
+end

data/test/dummy/app/models/type.rb

@@ -0,0 +1,7 @@
+class Type
+	include ActiveModel::Serializers::Binary
+
+	int16 :product_id
+	char :name, count: 1, length: 20
+
+end

data/test/dummy/lib/test_parser.rb

@@ -7,10 +7,28 @@ class String
   end
 end
 
-orig = Producto.new
-orig.silo = 0xFF7F
-orig.nombre = "AAAAAAAAAAAAAAAAAAAA"
-orig.tipo = Tipo.new({name:"BBBBBBBBBBBBBBBBBBBB", producto_id: 0xFF7F})
+orig = Product.new
+
+orig.int8 = 1;
+orig.int16 = 1;
+orig.int16le = 1;
+orig.int16be = 1;
+orig.int32 = 1;
+orig.int32le = 1;
+orig.int32be = 1;
+orig.uint8 = 1;
+orig.uint16 = 1;
+orig.uint16le = 1;
+orig.uint16be = 1;
+orig.uint32 = 1;
+orig.uint32le = 1;
+orig.uint32be = 1;
+orig.bitfield = 1;
+orig.float32 = 1;
+orig.float64 = 1;
+orig.char = "A";
+orig.bool = 1;
+orig.type = Type.new({product_id: 1, name: "ABCDEFGHIJKLMNOPQRST"})
 
 puts 'Datos originales...'
 puts orig.inspect.green
@@ -21,7 +39,7 @@ serial = orig.to_bytes
 puts serial.inspect.yellow
 
 puts 'deserializando...'
-deser = Producto.new.from_bytes serial
+deser = Product.new.from_bytes serial
 puts deser.inspect.green
 
 must_be_equal = (serial <=> deser.to_bytes) === 0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_binary
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - ByS Sistemas de Control
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,8 +128,8 @@ files:
 - test/dummy/app/mailers/.keep
 - test/dummy/app/models/.keep
 - test/dummy/app/models/concerns/.keep
-- test/dummy/app/models/producto.rb
-- test/dummy/app/models/tipo.rb
+- test/dummy/app/models/product.rb
+- test/dummy/app/models/type.rb
 - test/dummy/app/views/layouts/application.html.erb
 - test/dummy/bin/bundle
 - test/dummy/bin/rails
@@ -153,9 +153,6 @@ files:
 - test/dummy/config/locales/en.yml
 - test/dummy/config/routes.rb
 - test/dummy/config/secrets.yml
-- test/dummy/db/migrate/20160608024807_create_productos.rb
-- test/dummy/db/migrate/20170817015810_create_tipos.rb
-- test/dummy/db/schema.rb
 - test/dummy/lib/assets/.keep
 - test/dummy/lib/test_parser.rb
 - test/dummy/log/.keep
@@ -205,8 +202,8 @@ test_files:
 - test/dummy/app/mailers/.keep
 - test/dummy/app/models/.keep
 - test/dummy/app/models/concerns/.keep
-- test/dummy/app/models/producto.rb
-- test/dummy/app/models/tipo.rb
+- test/dummy/app/models/product.rb
+- test/dummy/app/models/type.rb
 - test/dummy/app/views/layouts/application.html.erb
 - test/dummy/bin/bundle
 - test/dummy/bin/rails
@@ -230,9 +227,6 @@ test_files:
 - test/dummy/config/locales/en.yml
 - test/dummy/config/routes.rb
 - test/dummy/config/secrets.yml
-- test/dummy/db/migrate/20160608024807_create_productos.rb
-- test/dummy/db/migrate/20170817015810_create_tipos.rb
-- test/dummy/db/schema.rb
 - test/dummy/lib/assets/.keep
 - test/dummy/lib/test_parser.rb
 - test/dummy/log/.keep

data/test/dummy/app/models/producto.rb

@@ -1,47 +0,0 @@
-# == Schema Information
-#
-# Table name: productos
-#
-#  id              :integer          not null, primary key
-#  uid             :integer
-#  silo            :integer
-#  nombre          :string(255)
-#  total_acumulado :integer
-#  bits1           :boolean
-#  bits2           :boolean
-#  ffloat          :float
-#  variable        :string(255)
-#  created_at      :datetime
-#  updated_at      :datetime
-#
-
-class Producto < ActiveRecord::Base
-	include ActiveModel::Serializers::Binary
-
-	int16 :uid
-	int16 :silo
-	char :nombre, count: 1, length: 20
-	int32 :total_acumulado
-	bool :bits1
-	bool :bits2
-	bool :bits3, virtual: true
-	bool :bits4, virtual: true
-	bool :bits5, virtual: true
-	bool :bits6, virtual: true
-	bool :bits7, virtual: true
-	bool :bits8, virtual: true
-	bool :bits9, virtual: true
-	bool :bits10, virtual: true
-	bool :bits11, virtual: true
-	bool :bits12, virtual: true
-	bool :bits13, virtual: true
-	bool :bits14, virtual: true
-	bool :bits15, virtual: true
-	bool :bits16, virtual: true
-	float32 :ffloat
-	char :variable, count: 1, length: 20 do |field, mode|
-		puts (mode.to_s + ': variable block').blue
-	end
-	int32 :test, count: 10, virtual: true # No existe en la DB
-	nest :tipo, coder: Tipo
-end

data/test/dummy/app/models/tipo.rb

@@ -1,18 +0,0 @@
-# == Schema Information
-#
-# Table name: tipos
-#
-#  id          :integer          not null, primary key
-#  name        :string
-#  producto_id :integer
-#  created_at  :datetime         not null
-#  updated_at  :datetime         not null
-#
-
-class Tipo < ActiveRecord::Base
-	include ActiveModel::Serializers::Binary
-
-	int16 :producto_id
-	char :name, count: 1, length: 20
-
-end

data/test/dummy/db/migrate/20160608024807_create_productos.rb

@@ -1,16 +0,0 @@
-class CreateProductos < ActiveRecord::Migration
-  def change
-    create_table :productos do |t|
-      t.integer :uid
-      t.integer :silo
-      t.string :nombre
-      t.integer :total_acumulado
-      t.boolean :bits1
-      t.boolean :bits2
-      t.float :ffloat
-      t.string :variable
-
-      t.timestamps
-    end
-  end
-end

data/test/dummy/db/migrate/20170817015810_create_tipos.rb

@@ -1,9 +0,0 @@
-class CreateTipos < ActiveRecord::Migration[5.0]
-  def change
-    create_table :tipos do |t|
-      t.string :name
-
-      t.timestamps
-    end
-  end
-end

data/test/dummy/db/schema.rb

@@ -1,36 +0,0 @@
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
-#
-# It's strongly recommended that you check this file into your version control system.
-
-ActiveRecord::Schema.define(version: 20170817015810) do
-
-  create_table "productos", force: :cascade do |t|
-    t.integer  "uid"
-    t.integer  "silo"
-    t.string   "nombre"
-    t.integer  "total_acumulado"
-    t.boolean  "bits1"
-    t.boolean  "bits2"
-    t.float    "ffloat"
-    t.string   "variable"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
-
-  create_table "tipos", force: :cascade do |t|
-    t.string   "name"
-    t.integer  "producto_id"
-    t.datetime "created_at",  null: false
-    t.datetime "updated_at",  null: false
-    t.index ["producto_id"], name: "index_tipos_on_producto_id"
-  end
-
-end