active_model_serializers_binary 0.0.10 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6b15a22af56d99e5309303d942972061b28f5f7
-  data.tar.gz: 34fe1c2c45fec1ab4e4d02bba3c4a7a3fb3d9ed4
+  metadata.gz: 2f3830d0d3a2a18ae95bb47c427e1af2ea6d2d86
+  data.tar.gz: 546aff445bb2ec63c9734955c762f3a87029b4b3
 SHA512:
-  metadata.gz: ba001a7dc0310b82190fcb392dfe2d8748139bc5753705e1f136fb1eeec5c1ba8a96b3bf70ea776bfdb623025f9a14c71641a25b7957618d1c3200f285bfe0b3
-  data.tar.gz: 0ca34aff960f7de5470af3c63bd1ac0a98af8b0e141c33bcb8764421f9e182094e580efc3e83644b51eac749c7dd4980d5fbc04f189abafc7ea13b511a17a68f
+  metadata.gz: 92274b86db2b91c5085e29e659279428d0221b1bd3bcfd4c9f650de4d32db55800887e22919261fea282960ac87efed344844da28a3955386848ece83e2c4509
+  data.tar.gz: 272721accba6bd385c4b1c967afd42af2a155e132c4c807d69752bb4673e05cbb6d72da8f64cf0f3767cbbfc0e5ea9797c12db564d655fed3d29436b944976de

data/.gitignore

@@ -6,3 +6,4 @@ test/dummy/db/*.sqlite3-journal
 test/dummy/log/*.log
 test/dummy/tmp/
 test/dummy/.sass-cache
+*.gem

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_model_serializers_binary (0.0.9)
+    active_model_serializers_binary (0.0.12)
       activemodel (~> 4.1)
 
 GEM

data/README.md

@@ -1,4 +1,6 @@
-# README #
+# Active model serializers binary #
+
+[![Gem Version](https://badge.fury.io/rb/active_model_serializers_binary.svg)](https://badge.fury.io/rb/active_model_serializers_binary)
 
 Serializador/Deserializador de bytes en Ruby
 

data/lib/active_model_serializers_binary/active_model_serializers_binary.rb

@@ -15,11 +15,59 @@ module ActiveModel
 
         class_attribute :attr_config
         self.attr_config = {}
+
+        def initialize
+          super
+          self.attr_config.each do |key, options|
+            options[:parent] = self
+          end
+        end
       end
 
       module ClassMethods
-        def serialize_options(attr_name, coder, count=1, length=1)
-          self.attr_config.merge!(attr_name.to_s => {:coder => coder, :count => count, :length => length})
+        # todo: agrupar parametros en hash (rompe la compatibilidad hacia atras)
+        def serialize_options(attr_name, coder, count=1, length=1, &block )
+          self.attr_config.merge!(attr_name.to_s => {:coder => coder, :count => count, :length => length, :block => block, :name => attr_name})
+        end
+
+        def int8( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::Int8, options[:count], options[:length], &block
+        end
+
+        def int16( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::Int16, options[:count], options[:length], &block
+        end
+
+        def int32( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::Int32, options[:count], options[:length], &block
+        end
+
+        def uint8( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::UInt8, options[:count], options[:length], &block
+        end
+
+        def uint16( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::UInt16, options[:count], options[:length], &block
+        end
+
+        def uint32( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::UInt32, options[:count], options[:length], &block
+        end
+
+        def bitfield( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::BitField, options[:count], options[:length], &block
+        end
+
+        def float32( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::Float32, options[:count], options[:length], &block
+        end
+
+        def char( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::Char, options[:count], options[:length], &block
+        end
+
+        def bool( attr_name, options = {}, &block )
+          serialize_options attr_name, DataTypes::Bool, options[:count], options[:length], &block
         end
       end
 
@@ -39,8 +87,8 @@ module ActiveModel
           tmp_buffer = [] # Buffer temporal en bytes
           current_address = start_address*2 + 0.0 # Dirección en bytes
 
-          @serializable.attr_config.each do |key, value|
-            var = value[:coder].new(value[:count], value[:length])
+          @serializable.attr_config.each do |key, options|
+            var = options[:coder].new(options)
             # Busca el valor del atributo y si no existe devuelve nil
             var.value = serializable_values[key] rescue nil
 
@@ -50,20 +98,28 @@ module ActiveModel
             tmp_buffer = var.dump
 
             if @options[:align]
-              # 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
+              if !var.type.in? [:bitfield, :bool]
+                # 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
 
             # Si los datos ocupan mas de un byte concatena los arrays
-            if var.bit_length >= 8 and @options[:align]
+            if !var.type.in? [:bitfield, :bool] and @options[:align]
               buffer.insert(byte, tmp_buffer).flatten!
             else # En caso de ser bits
               tmp_buffer.flatten!
@@ -90,23 +146,31 @@ module ActiveModel
 
           current_address = start_address*2 + 0.0 # Dirección en bytes
 
-          @serializable.attr_config.each do |key, value|
-            #puts "#{key} - #{value}"
+          @serializable.attr_config.each do |key, options|
+            #puts "#{key} - #{options}"
             byte = current_address.floor
             bit = (current_address.modulo(1)*8).round
 
-            var = value[:coder].new(value[:count], value[:length]) #creo objeto del tipo de dato pasado
+            var = options[:coder].new(options) #creo objeto del tipo de dato pasado
 
             if @options[:align]
-              # 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
+              if !var.type.in? [:bitfield, :bool]
+                # 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
 
@@ -114,7 +178,7 @@ module ActiveModel
             if var.bit_length >= 8 and @options[:align]
               result_deserialized=var.load(buffer.slice(byte, var.size))
             else # En caso de ser bits
-              tmp_buffer = buffer.slice(byte, var.size.ceil)
+              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*'))
             end
             # puts result_deserialized.inspect
@@ -138,47 +202,29 @@ module ActiveModel
 
       end #close class serializer
 
-      # Returns XML representing the model. Configuration can be
+      # Returns a binary array representing the model. Configuration can be
       # passed through +options+.
       #
-      # Without any +options+, the returned XML string will include all the
-      # model's attributes.
-      #
-      #   user = User.find(1)
-      #   user.to_xml
+      #   person = Person.find(1)
+      #   person.to_bytes
       #
-      #   <?xml version="1.0" encoding="UTF-8"?>
-      #   <user>
-      #     <id type="integer">1</id>
-      #     <name>David</name>
-      #     <age type="integer">16</age>
-      #     <created-at type="dateTime">2011-01-30T22:29:23Z</created-at>
-      #   </user>
+      #   => [98, 111, 98, 0, 0, 0, 0, 0, 0, 0, 22, 0, 1]
       #
-      # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the
-      # attributes included, and work similar to the +attributes+ method.
-      #
-      # To include the result of some method calls on the model use <tt>:methods</tt>.
-      #
-      # To include associations use <tt>:include</tt>.
-      #
-      # For further documentation, see <tt>ActiveRecord::Serialization#to_xml</tt>
       def to_bytes(options = {}, &block)
         default_options = {
             :align => true,
-            :block => block
         }
         options = default_options.deep_merge(options)
-        if !options[:block].blank?
-            instance_exec(self, &options[:block])
+        if block_given?
+            yield self
         end
         Serializer.new(self, options).dump
       end
 
-      # Sets the model +attributes+ from an XML string. Returns +self+.
+      # Sets the model +attributes+ from an Binary string. Returns +self+.
       #
       #   class Person
-      #     include ActiveModel::Serializers::Xml
+      #     include ActiveModel::Serializers::Binary
       #
       #     attr_accessor :name, :age, :awesome
       #
@@ -191,24 +237,35 @@ module ActiveModel
       #     def attributes
       #       instance_values
       #     end
+      #
+      #     char :name, count: 1, length: 10
+      #     int16 :age
+      #     bool :awesome
       #   end
       #
-      #   xml = { name: 'bob', age: 22, awesome:true }.to_xml
+      #   bytes = [98, 111, 98, 0, 0, 0, 0, 0, 0, 0, 22, 0, 1]
       #   person = Person.new
-      #   person.from_xml(xml) # => #<Person:0x007fec5e3b3c40 @age=22, @awesome=true, @name="bob">
-      #   person.name          # => "bob"
-      #   person.age           # => 22
-      #   person.awesome       # => true
+      #   person.from_bytes(bytes) do |p|
+      #     p.name.upcase!
+      #   end
+      #   => #<Person:0x007fec5e3b3c40 @age=22, @awesome=true, @name="bob">
+      #
+      # @param [Array] buffer byte array with model data to deserialize
+      # @param [Hash] options deserealization options
+      #
+      # @return [Object] Deserialized object
+      # 
+      # @yield code block to execute after deserialization
+      #
       def from_bytes(buffer, options = {}, &block)
         default_options = {
-            :align => true,
-            :block => block
+            :align => true
         }
         options = default_options.deep_merge(options)
         retVal = Serializer.new(self, options).load buffer
         
-        if !options[:block].blank?
-            instance_exec(self, &options[:block])
+        if block_given?
+          yield self
         end
         retVal
       end

data/lib/active_model_serializers_binary/base_type.rb

@@ -0,0 +1,136 @@
+module DataTypes
+
+  class Type
+
+    attr_accessor :raw_value, :bit_length, :type, :sign, :count, :length, :value, :name, :parent
+
+    def initialize(options = {})
+      @default_value = options[:default_value] || 0
+      @raw_value = nil
+      @bit_length = options[:bit_length]        # Cantidad de bits del tipo de dato
+      @type = type
+      @sign = options[:sign]                    # :signed / :unsigned
+      @count = options[:count] || 1             # Cantidad de elementos del array
+      @length = options[:length]  || 1          # En char y bitfield especifica la longitud del campo. Ignorado para el resto de los tipos
+      @value = check_value( @default_value )
+      @block = options[:block]
+      @name = options[:name]
+      @parent = options[:parent]
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def type
+      self.class.to_s.split('::').last.downcase.to_sym
+    end
+
+    # Return size of object in bytes
+    def size
+      ((@bit_length*@length*@count)/8.0).ceil
+    end
+
+    def check( value, options = {} )
+      type = options[:type]
+      count = options[:count]
+      length = options[:length]
+      bit_length = options[:bit_length]
+      sign = options[:sign]
+      default_value = options[:default_value]
+
+      value = Array(value) # Se asegura de que sea un array
+      value = value[0...count]  # Corta el array según la cantidad de elementos especificados en la declaración
+      # Lo convierte al tipo especificado
+      value.map! do |v|
+        if v.nil?
+          default_value
+        else
+          case type
+            when :float32
+              v.to_f
+            when :char
+              v.to_s[0...length]
+            when :bool
+              (v.in? [0, false]) ? false : true
+            else
+              v.to_i
+          end
+        end
+      end
+
+      trim(value, bit_length, sign) # Se asegura de que los valores esten dentro de los rangos permitidos pra el tipo de dato declarado
+      value.fill(default_value, value.length...count) # Completa los elementos faltantes del array con default_value
+    end
+
+    def check_value(value)
+      check(value, {
+        :type => @type,
+        :count => @count,
+        :length => @length,
+        :bit_length => @bit_length,
+        :sign => @sign,
+        :default_value => @default_value,
+        })
+    end
+
+    # Los datos siempre vienen en bytes
+    def check_raw_value(value)
+      check(value, {
+        :type => :uint8,
+        :count => size,
+        :length => 1,
+        :bit_length => 8,
+        :sign => :unsigned,
+        :default_value => 0,
+        })
+    end
+
+    def trim(value, bit_length, sign)
+      # Recorta los valores según el bit_length
+      value.map! do |v|
+        if sign == :signed
+          [-2**(bit_length-1),[v.to_i,2**(bit_length-1)-1].min].max
+        elsif sign == :unsigned
+          [0,[v.to_i,2**(bit_length)-1].min].max
+        else
+          v
+        end
+      end
+    end
+
+    def value=(value)
+      @value = check_value(value)
+    end
+
+
+    #
+    # Se ejecuta antes de serializar los datos
+    #
+    # @param [Object] value valor del objeto a serializar original
+    #
+    # @return [Array] nuevo valor del objeto a serializar
+    # 
+    def before_dump(value)
+      self.value = value if !value.nil?
+      if !@block.nil?
+        value = @parent.instance_exec( self, :dump, &@block )
+        self.value = value if !value.nil?
+      end
+    end
+
+    #
+    # Se ejecuta después de deserializar los datos. @value contiene los datos deserializados
+    #
+    #
+    # @return [Array] Array con los datos deserializados
+    # 
+    def after_load
+      if !@block.nil?
+        value = @parent.instance_exec( self, :load, &@block )
+        self.value = value if !value.nil?
+      end
+      @value
+    end
+  end
+end

data/lib/active_model_serializers_binary/data_types.rb

@@ -1,218 +1,187 @@
+require_relative 'base_type.rb'
+
 module DataTypes
-  class Type
-    attr_accessor :value, :bit_length
 
-    def initialize(bit_length=nil, sign=nil, count=1, length=1)
-      @bit_length = bit_length
-      @sign = sign
-      @count = count
-      @length = length
-      @default_value = 0
+  class Int8 < Type
+    def initialize(options = {})
+      super options.merge :bit_length => 8, :sign => :signed
     end
 
-    def to_s
-      @value.to_s
+    def dump(value=nil)
+      before_dump( value )
+      @raw_value = @value
     end
 
-    # Return size of object in bytes
-    def size
-      (@bit_length*@length*@count)/8.0
+    def load(raw_value)
+      self.value = check_raw_value(raw_value)
+      after_load
     end
+  end
 
-    def check_value(value)
-      if value.nil?
-        value=@value
-      else
-        value=(value.is_a? Array) ? value : [value]
-      end
-
-      value.map!{|v| v.nil? ? @default_value : v}
-      value.map! do |v|
-          case @default_value.class.name
-            when "Float"
-              v.to_f
-            when "String"
-              v.to_s[0...@length]
-            else
-              v.to_i
-          end
-      end
-
-      value=value[0...@count]
-      value.fill(@default_value, value.length...@count)
+  class Int16 < Type
+    def initialize(options = {})
+      super options.merge :bit_length => 16, :sign => :signed
     end
 
-    def value=(value)
-      value = check_value(value)
+    def dump(value=nil)
+      before_dump( value )
+      @raw_value = @value.pack('v*').unpack('C*')
+    end
 
-      # Recorta los valores según el bit_length
-      value.map! do |v|
-        (@sign == :signed)?[-2**(@bit_length-1),[v.to_i,2**(@bit_length-1)-1].min].max :
-            ((@sign == :unsigned)? [0,[v.to_i,2**(@bit_length)-1].min].max : v )
-      end
-      @value=value
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('v*')
+      after_load
     end
   end
 
-  class Int8 < Type
-    def initialize(count=1, length=1)
-      super 8, :signed, count
-      self.value = @default_value
+  class Int32 < Type
+    def initialize(options = {})
+      super options.merge :bit_length => 32, :sign => :signed
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      @value
+      before_dump( value )
+      @raw_value = @value.pack('V*').unpack('C*')
     end
 
-    def load(value)
-      self.value = value if !value.nil?
-      @value
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('V*') if !value.nil?
+      after_load
     end
   end
 
-  class Int16 < Type
-    def initialize(count=1, length=1)
-      super 16, :signed, count
-      self.value = @default_value
+  class UInt16 < Type
+    def initialize(options = {})
+      super options.merge :bit_length => 16, :sign => :unsigned
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      @value.pack('v*').unpack('C*')
+      before_dump( value )
+      @raw_value = @value.pack('v*').unpack('C*')
     end
 
-    def load(value)
-      self.value = value.pack('C*').unpack('v*') if !value.nil?
-      @value
+    def load(raw_value)
+      @raw_value = check_raw_value(raw_value)
+      self.value = @raw_value.pack('C*').unpack('v*')
+      after_load
     end
   end
 
-  class Int32 < Type
-    def initialize(count=1, length=1)
-      super 32, :signed, count
-      self.value = @default_value
+  class UInt32 < Type
+    def initialize(options = {})
+      super options.merge :bit_length => 32, :sign => :unsigned
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      @value.pack('V*').unpack('C*')
+      before_dump( value )
+      @raw_value = @value.pack('l*').unpack('C*')
     end
 
-    def load(value)
-      self.value = value.pack('C*').unpack('V*') if !value.nil?
-      @value
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('l*') if !value.nil?
+      after_load
     end
   end
 
-  class UInt16 < Type
-    def initialize(count=1, length=1)
-      super 16, :unsigned, count
-      self.value = @default_value
+  class UInt8 < Type
+    def initialize(options = {})
+      super options.merge :bit_length => 8, :sign => :unsigned
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      @value.pack('v*').unpack('C*')
+      before_dump( value )
+      @raw_value = @value
     end
 
-    def load(value)
-      self.value = value.pack('C*').unpack('v*') if !value.nil?
-      @value
+    def load(raw_value)
+      self.value = check_raw_value(raw_value)
+      after_load
     end
   end
 
-  class UInt32 < Type
-    def initialize(count=1, length=1)
-      super 32, :unsigned, count
-      self.value = @default_value
+  class BitField < Type
+    def initialize(options = {})
+      length = 32 if length > 32
+      super options.merge :bit_length => length, :sign => :unsigned
     end
 
-    def dump(value=nil)
-      self.value = value if !value.nil?
-      @value.pack('l*').unpack('C*')
-    end
-
-    def load(value)
-      self.value = value.pack('C*').unpack('l*') if !value.nil?
-      @value
+    def format
+      if bit_length <= 8 # 8 bits
+        'C*'
+      elsif bit_length <= 16 # 16 bits
+        'v*'
+      else # 32 bits
+        'l*'
+      end
     end
-  end
 
-  class UInt8 < Type
-    def initialize(count=1, length=1)
-      super 8, :unsigned, count
-      self.value = @default_value
+    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)
-      self.value = value if !value.nil?
-      @value
+      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(value)
-      self.value = value if !value.nil?
-      @value
+    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 < Type
-    def initialize(count=1, length=1)
-      super 8, nil, count, length
-      @default_value = "\x0"
-      self.value = @default_value
-    end
-
-    #@todo: corregir lo de abajo:
-    def self.serialize(value)
-      var = Char.new
-      var.value = value
-      var.serialize
+    def initialize(options = {})
+      super options.merge :bit_length => 8, :sign => nil, :default_value => "\x0"
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      @value.map{|v| v.ljust(@length, @default_value).slice(0,@length).unpack('C*')}
+      before_dump( value )
+      @raw_value = @value.map{|v| v.ljust(@length, @default_value).slice(0,@length).unpack('C*')}
     end
 
-    def load(value)
-      self.value = value.pack('C*').unpack("Z#{@length}") if !value.nil?
-      @value
+    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 < Type
-    def initialize(count=1, length=1)
-      super 1, :unsigned, count
-      self.value = 0
+    def initialize(options = {})
+      super options.merge :bit_length => 1, :default_value => false
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      [@value.join].pack('b*').unpack('C*')
+      before_dump( value )
+      @raw_value = Array(@value.map{|v| v ? 1 : 0}.join).pack('b*').unpack('C*')
     end
 
-    def load(value)
-      self.value = value.pack('C*').unpack('b*').first.slice(0,size*8).split('').map(&:to_i) if !value.nil?
-      @value
+    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 < Type
-    def initialize(count=1, length=1)
-      super 32, nil, count
-      @default_value = 0.0
-      self.value = @default_value
+    def initialize(options = {})
+      super options.merge :bit_length => 32, :sign => nil, :default_value => 0.0
     end
 
     def dump(value=nil)
-      self.value = value if !value.nil?
-      @value.pack('e*').unpack('C*')
+      before_dump( value )
+      @raw_value = @value.pack('e*').unpack('C*')
     end
 
-    def load(value)
-      self.value = value.pack('C*').unpack('e*') if !value.nil?
-      @value
+    def load(raw_value)
+      self.value = check_raw_value(raw_value).pack('C*').unpack('e*') if !value.nil?
+      after_load
     end
   end
 end

data/lib/active_model_serializers_binary/version.rb

@@ -1,3 +1,3 @@
 module ActiveModelSerializersBinary
-  VERSION = "0.0.10"
+  VERSION = "0.0.13"
 end

data/test/dummy/lib/test_parser.rb

@@ -16,6 +16,12 @@ class Producto
     	instance_values
     end
 
+	def attributes=(hash)
+		hash.each do |key, value|
+			instance_variable_set("@#{key}", value)
+		end
+	end
+
 	# def metodo
 	# 	self.instance_variable_get("@variable")
 	# end
@@ -24,49 +30,44 @@ class Producto
 	# 	self.instance_variable_set("@variable", value)
 	# end
 
-	# Formato atributo, Coder, Count, Length
-	serialize_options :id, Int16
-	serialize_options :silo, Int16
-	serialize_options :nombre, Char,1, 20
-	serialize_options :total_acumulado, Int32
-	serialize_options :bits1, Bool, 1
-	serialize_options :bits2, Bool, 1
-	serialize_options :total_acumulado_1, Int32
-	serialize_options :float, Float32
-	serialize_options :variable, Char, 1, 20
-
-	def initialize
-	 	@start_address = 0
-	 	@id = 1
-	 	@silo = 0
-	 	@nombre = "MAIZ"
-	 	@total_acumulado = 50
-	 	@bits1 = 1
-	 	@bits2 = 1
-	 	@total_acumulado_1 = 20
-	 	@float= 1.2345678
-	 	@variable = '012345678901234567890123456789'
+	int16 :id
+	int16 :silo
+	char :nombre, count: 1, length: 20
+	int32 :total_acumulado
+	bool :bits1
+	bool :bits2
+	int32 :total_acumulado_1
+	float32 :float
+	char :variable, count: 1, length: 20 do |field, mode|
+		puts (mode.to_s + ': variable block').blue
 	end
 end
 
+
 orig = Producto.new
+orig.start_address = 0
+orig.id = 1
+orig.silo = 0
+orig.nombre = "MAIZ"
+orig.total_acumulado = 50
+orig.bits1 = 1
+orig.bits2 = 1
+orig.total_acumulado_1 = 20
+orig.float= 1.2345678
+orig.variable = '012345678901234567890123456789'
 
 puts 'Datos originales...'
 puts orig.inspect.green
 
 puts 'serializando...'
 serial = orig.to_bytes do |b|
-	puts '@variable original: ', b.variable
-	b.variable = b.variable.map {|c| (c.ord+10).chr}
-	puts '@variable modificada: ', b.variable
+	puts 'to_bytes block'.blue
 end
 
 puts serial.inspect.yellow
 
 puts 'deserializando...'
 deser = Producto.new.from_bytes serial do |b|
-	puts 'datos leidos: ', b.variable
-	b.variable = b.variable.map {|c| (c.ord-10).chr}
-	puts 'datos modificados: ', b.variable
+	puts 'from_bytes block'.blue
 end
 puts deser.inspect.green

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_binary
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.13
 platform: ruby
 authors:
 - ByS Sistemas de Control
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-25 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -237,6 +237,7 @@ files:
 - active_model_serializers_binary.gemspec
 - lib/active_model_serializers_binary.rb
 - lib/active_model_serializers_binary/active_model_serializers_binary.rb
+- lib/active_model_serializers_binary/base_type.rb
 - lib/active_model_serializers_binary/data_types.rb
 - lib/active_model_serializers_binary/version.rb
 - lib/tasks/active_model_serializers_binary_tasks.rake