active_model_serializers_binary 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8867fc2c627dc2fe2e4e7c064bd1ed5ae721eb89
-  data.tar.gz: b096205753623930ad89c0c9dd4d308f3ff8ef19
+  metadata.gz: 876801a003f61b57070687c4049198f3a7407a21
+  data.tar.gz: e9c677a84305f640f0f77280d01767246da97f9d
 SHA512:
-  metadata.gz: c89aed42e8c94feb10867ee254dec8638e9ecae1ed8b414cef0792ec08e50e000d08dc99c0ea1e0356bbf1efc19b2a086b213efb63d4b69b69b07f8a9b148804
-  data.tar.gz: 7acb69425c7502733109d4200fb255951a93f5354d8cb2d3b6c1662948f521264d470099cab822e472593250aac36eeb4868a34e86a80077988c4c0b30258898
+  metadata.gz: 34ed74da0e671a9be0e153940416150b8550e091d8e5ee10ab8c74caf89c30cbe963dfe62cdb47b3926b13b9cd9e7140d1617473e42d27197f7873e1fa0ba859
+  data.tar.gz: f7e0803f4e919c2c7b2c3d7e32718f0b912aaeff3be7288b86016c26bc21b3dbeb1ff1edc4bea9af6783dcb189d929fcae2ac1a8d961d389e36edd4c89c027d9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_model_serializers_binary (0.1.5)
+    active_model_serializers_binary (0.2.0)
       activemodel (~> 5.0)
 
 GEM

data/lib/active_model_serializers_binary/active_model_serializers_binary.rb

@@ -14,11 +14,16 @@ module ActiveModel
         extend ActiveModel::Naming
 
         class_attribute :attr_config
-        self.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
+        }
 
         def attributes
-          keys = self.attr_config.select{ |k, v| v[:virtual]==true }.keys
-          values = keys.map{ |var| self.instance_variable_get("@#{var}") }
+          keys = self.attr_config.select{ |attr| attr[:virtual]==true }.map{ |attr| attr[:name] }
+          values = keys.map{ |attr| self.instance_variable_get("@#{attr}") }
           (super rescue {}).merge(Hash[keys.zip values])
         end
 
@@ -36,16 +41,16 @@ module ActiveModel
 
       module ClassMethods
         def add_virtual_attributes( instance )
-          self.attr_config.each{ |k, v| add_virtual_attribute(instance, k, v) }
+          self.attr_config.each{ |attr| add_virtual_attribute(instance, attr) }
         end
 
-        def add_virtual_attribute( instance, attr_name, attr_value )
-          attr_name = attr_name.to_s
-          if attr_value[:virtual] == true
+        def add_virtual_attribute( instance, attr )
+          if attr[:virtual] == true
             true
           else
+            attr_name = attr[:name].to_s
             if !instance.respond_to? attr_name
-              attr_value[:virtual] = true
+              attr[:virtual] = true
               attr_accessor attr_name
               true
             else
@@ -56,56 +61,114 @@ module ActiveModel
 
         # 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.merge!(attr_name.to_s => {:coder => coder, :count => count, :length => length, :block => block, :name => attr_name, :virtual => virtual})
+          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.merge!(attr_name.to_s => options.merge({ block: block }))
+          self.attr_config.push(options.merge({:name => attr_name.to_s, block: block }))
+          if options[:virtual]==true
+            attr_accessor attr_name
+          end
         end       
 
         def int8( attr_name, options = {}, &block )
+          options = 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)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Int16}), &block
         end
 
+        def int16le( attr_name, options = {}, &block )
+          int16( attr_name, options.merge({endianess: :little}), &block )
+        end
+
+        def int16be( attr_name, options = {}, &block )
+          int16( attr_name, options.merge({endianess: :big}), &block )
+        end
+
         def int32( attr_name, options = {}, &block )
+          options = serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::Int32}), &block
         end
 
+        def int32le( attr_name, options = {}, &block )
+          int32( attr_name, options.merge({endianess: :little}), &block )
+        end
+
+        def int32be( attr_name, options = {}, &block )
+          int16( attr_name, options.merge({endianess: :big}), &block )
+        end
+
         def uint8( attr_name, options = {}, &block )
+          options = 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)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::UInt16}), &block
         end
 
+        def uint16le( attr_name, options = {}, &block )
+          uint16( attr_name, options.merge({endianess: :little}), &block )
+        end
+
+        def uint16be( attr_name, options = {}, &block )
+          uint16( attr_name, options.merge({endianess: :big}), &block )
+        end
+
         def uint32( attr_name, options = {}, &block )
+          options = serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::UInt32}), &block
         end
 
+        def uint32le( attr_name, options = {}, &block )
+          uint32( attr_name, options.merge({endianess: :little}), &block )
+        end
+
+        def uint32be( attr_name, options = {}, &block )
+          uint32( attr_name, options.merge({endianess: :big}), &block )
+        end       
+
         def bitfield( attr_name, options = {}, &block )
+          options = serialize_options_global.merge(options)
           serialize_attribute_options attr_name, options.merge({coder: DataTypes::BitField}), &block
         end
 
         def float32( attr_name, options = {}, &block )
+          options = 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
         end
 
         def char( attr_name, options = {}, &block )
+          options = 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
         end
 
         def nest( attr_name, options={}, &block )
+          options = 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})
+        end
       end
 
       class Serializer #:nodoc:
@@ -124,12 +187,14 @@ module ActiveModel
           tmp_buffer = [] # Aux Data Buffer
           current_address = start_address*2 + 0.0 # Address in bytes
 
-          @serializable.attr_config.each do |attr_name, attr_options|
+          @serializable.attr_config.each do |attr_options|
+            attr_name = attr_options[:name]
             if attr_options[:type] != :nest
               var = attr_options[:coder].new(attr_options.merge(parent: @serializable))
               var.value = serializable_values[attr_name] rescue nil
             else
-              var = attr_options[:coder].new(serializable_values[attr_name].attributes)
+              var_value = serializable_values[attr_name].attributes rescue nil
+              var = attr_options[:coder].new(var_value)
             end
 
             byte = current_address.floor
@@ -186,7 +251,8 @@ module ActiveModel
 
           current_address = start_address*2 + 0.0 # Dirección en bytes
 
-          @serializable.attr_config.each do |attr, attr_options|
+          @serializable.attr_config.each do |attr_options|
+            attr_name = attr_options[:name]
             byte = current_address.floor
             bit = (current_address.modulo(1)*8).round
 
@@ -222,9 +288,9 @@ module ActiveModel
             end
 
             if attr_options[:type] == :nest
-              serialized_values["#{attr}"] = result_deserialized
+              serialized_values["#{attr_name}"] = result_deserialized
             else
-              serialized_values["#{attr}"] = result_deserialized.count>1 ? result_deserialized : result_deserialized.first
+              serialized_values["#{attr_name}"] = result_deserialized.count>1 ? result_deserialized : result_deserialized.first
             end
             current_address = (byte+bit/8.0)+var.size
           end
@@ -243,7 +309,7 @@ module ActiveModel
 
           current_address = 0.0 # Dirección en bytes
 
-          @serializable.attr_config.each do |attr_name, attr_options|
+          @serializable.attr_config.each do |attr_options|
             var = attr_options[:coder].new(attr_options.merge(parent: @serializable))
 
             byte = current_address.floor
@@ -269,7 +335,6 @@ module ActiveModel
                 end
               end
             end
-
             current_address = (byte+bit/8.0)+var.size
           end
           current_address-start_address
@@ -286,10 +351,7 @@ module ActiveModel
       #   => [98, 111, 98, 0, 0, 0, 0, 0, 0, 0, 22, 0, 1]
       #
       def to_bytes(options = {}, &block)
-        default_options = {
-            :align => true,
-        }
-        options = default_options.deep_merge(options)
+        options = self.serialize_options_global.deep_merge(options)
         if block_given?
             yield self
         end
@@ -341,10 +403,7 @@ module ActiveModel
       # @yield code block to execute after deserialization
       #
       def from_bytes(buffer, options = {}, &block)
-        default_options = {
-            :align => true
-        }
-        options = default_options.deep_merge(options)
+        options = self.serialize_options_global.deep_merge(options)
         retVal = Serializer.new(self, options).load buffer
         
         if block_given?
@@ -361,10 +420,7 @@ module ActiveModel
       end
 
       def size(options = {})
-        default_options = {
-            :align => true
-        }
-        options = default_options.deep_merge(options)
+        options = self.serialize_options_global.deep_merge(options)
         Serializer.new(self, options).size
       end
 

data/lib/active_model_serializers_binary/base_type.rb

@@ -2,7 +2,7 @@ module DataTypes
 
   class BaseType
 
-    attr_accessor :raw_value, :bit_length, :type, :sign, :count, :length, :value, :name, :parent
+    attr_accessor :raw_value, :bit_length, :type, :sign, :count, :length, :value, :name, :parent, :endianess
 
     def initialize(options = {})
       @default_value = options[:default_value].nil? ? 0 : options[:default_value]
@@ -16,6 +16,7 @@ module DataTypes
       @block = options[:block]
       @name = options[:name]
       @parent = options[:parent]
+      @endianess = options[:endianess] || :little
     end
 
     def to_s

data/lib/active_model_serializers_binary/data_types.rb

@@ -1,187 +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 )
-      @raw_value = @value.pack('s<*').unpack('C*')
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('s<*')
-      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 )
-      @raw_value = @value.pack('l<*').unpack('C*')
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('l<*') if !value.nil?
-      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 )
-      @raw_value = @value.pack('S<*').unpack('C*')
-    end
-
-    def load(raw_value) 
-      @raw_value = check_raw_value(raw_value)
-      self.value = @raw_value.pack('C*').unpack('S<*')
-      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 )
-      @raw_value = @value.pack('L<*').unpack('C*')
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('L<*') if !value.nil?
-      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 )
-      @raw_value = @value.pack('e*').unpack('C*')
-    end
-
-    def load(raw_value)
-      self.value = check_raw_value(raw_value).pack('C*').unpack('e*') if !value.nil?
-      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 ).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
 end

data/lib/active_model_serializers_binary/version.rb

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

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

@@ -5,12 +5,12 @@
 #  id              :integer          not null, primary key
 #  uid             :integer
 #  silo            :integer
-#  nombre          :string
+#  nombre          :string(255)
 #  total_acumulado :integer
 #  bits1           :boolean
 #  bits2           :boolean
 #  ffloat          :float
-#  variable        :string
+#  variable        :string(255)
 #  created_at      :datetime
 #  updated_at      :datetime
 #
@@ -18,6 +18,30 @@
 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/lib/test_parser.rb

@@ -8,8 +8,9 @@ class String
 end
 
 orig = Producto.new
+orig.silo = 0xFF7F
 orig.nombre = "AAAAAAAAAAAAAAAAAAAA"
-orig.tipo = Tipo.new({name:"BBBBBBBBBBBBBBBBBBBB", producto_id: 0x55AA})
+orig.tipo = Tipo.new({name:"BBBBBBBBBBBBBBBBBBBB", producto_id: 0xFF7F})
 
 puts 'Datos originales...'
 puts orig.inspect.green

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_binary
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - ByS Sistemas de Control