bindata 1.8.2 → 1.8.3

data/ChangeLog.rdoc

@@ -1,5 +1,13 @@
 = BinData Changelog
 
+== Version 1.8.3 (2014-04-16)
+
+* #eval_parameters can now call private methods.  Requested by Ole Rasmussen.
+* Can now determine state of :onlyif fields.  Requested by Ole Rasmussen.
+* Renamed #offset to #abs_offset for clarity.  #offset is now deprecated.
+* Support :byte_align for fields in structs.  Requested by Igor Yamolov.
+* Added bit fields with dynamic length.  Requested by Jacob Dam.
+
 == Version 1.8.2 (2014-02-02)
 
 * Virtual fields can now have values.

data/examples/gzip.rb

@@ -59,7 +59,7 @@ class Gzip
 
   attr_accessor :compressed
   def_delegators :@header, :file_name=, :file_name
-  def_delegators :@header, :comment=, :comment
+  def_delegators :@header, :comment=, :comment, :comment?
   def_delegators :@header, :compression_method
   def_delegators :@footer, :crc32, :uncompressed_size
 
@@ -153,7 +153,7 @@ if __FILE__ == $0
                                                    g.uncompressed_size,
                                                    ratio,
                                                    g.file_name]
-  puts "Comment: #{g.comment}" if g.comment != ""
+  puts "Comment: #{g.comment}" if g.comment?
   puts
 
   puts "Executing gzip -l -v"

data/lib/bindata/base.rb

@@ -233,16 +233,17 @@ module BinData
       end
     end
 
-    # Returns the offset of this object wrt to its most distant ancestor.
-    def offset
+    # Returns the offset (in bytes) of this object with respect to its most
+    # distant ancestor.
+    def abs_offset
       if @parent
-        @parent.offset + @parent.offset_of(self)
+        @parent.abs_offset + @parent.offset_of(self)
       else
         0
       end
     end
 
-    # Returns the offset of this object wrt to its parent.
+    # Returns the offset (in bytes) of this object with respect to its parent.
     def rel_offset
       if @parent
         @parent.offset_of(self)

data/lib/bindata/bits.rb

@@ -6,13 +6,11 @@ module BinData
 
   module BitField #:nodoc: all
     class << self
-      def define_class(nbits, endian, signed = :unsigned)
-        name = ((signed == :signed ) ? "Sbit" : "Bit") + nbits.to_s
-        name << "le" if endian == :little
+      def define_class(name, nbits, endian, signed = :unsigned)
         unless BinData.const_defined?(name)
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
-              BitField.define_methods(self, #{nbits}, :#{endian}, :#{signed})
+              BitField.define_methods(self, #{nbits.inspect}, #{endian.inspect}, #{signed.inspect})
             end
           END
         end
@@ -22,27 +20,34 @@ module BinData
 
       def define_methods(bit_class, nbits, endian, signed)
         bit_class.module_eval <<-END
+          #{create_params_code(nbits)}
+
           def assign(val)
+            #{create_nbits_code(nbits)}
             #{create_clamp_code(nbits, signed)}
             super(val)
           end
 
           def do_write(io)
+            #{create_nbits_code(nbits)}
             val = _value
-            #{create_int2uint_code(nbits) if signed == :signed}
+            #{create_int2uint_code(nbits, signed)}
             io.writebits(val, #{nbits}, :#{endian})
           end
 
           def do_num_bytes
-            #{nbits / 8.0}
+            #{create_nbits_code(nbits)}
+            #{create_do_num_bytes_code(nbits)}
           end
 
           #---------------
           private
 
+
           def read_and_return_value(io)
+            #{create_nbits_code(nbits)}
             val = io.readbits(#{nbits}, :#{endian})
-            #{create_uint2int_code(nbits) if signed == :signed}
+            #{create_uint2int_code(nbits, signed)}
             val
           end
 
@@ -52,7 +57,51 @@ module BinData
         END
       end
 
+      def create_params_code(nbits)
+        if nbits == :nbits
+          "mandatory_parameter :nbits"
+        else
+          ""
+        end
+      end
+
+      def create_nbits_code(nbits)
+        if nbits == :nbits
+          "nbits = eval_parameter(:nbits)"
+        else
+          ""
+        end
+      end
+
+      def create_do_num_bytes_code(nbits)
+        if nbits == :nbits
+          "nbits / 8.0"
+        else
+          nbits / 8.0
+        end
+      end
+
       def create_clamp_code(nbits, signed)
+        if nbits == :nbits
+          create_dynamic_clamp_code(nbits, signed)
+        else
+          create_fixed_clamp_code(nbits, signed)
+        end
+      end
+
+      def create_dynamic_clamp_code(nbits, signed)
+        if signed == :signed
+          max = "max = (1 << (nbits - 1)) - 1"
+          min = "min = -(max + 1)"
+        else
+          max = "max = (1 << nbits) - 1"
+          min = "min = 0"
+        end
+
+        "#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val"
+      end
+
+      def create_fixed_clamp_code(nbits, signed)
         if nbits == 1 and signed == :signed
           raise "signed bitfield must have more than one bit" 
         end
@@ -75,30 +124,50 @@ module BinData
         "val = #{clamp}"
       end
 
-      def create_int2uint_code(nbits)
-        "val = val & #{(1 << nbits) - 1}"
+      def create_int2uint_code(nbits, signed)
+        if signed != :signed
+          ""
+        elsif nbits == :nbits
+          "val &= (1 << nbits) - 1"
+        else
+          "val &= #{(1 << nbits) - 1}"
+        end
       end
 
-      def create_uint2int_code(nbits)
-        "val = val - #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
+      def create_uint2int_code(nbits, signed)
+        if signed != :signed
+          ""
+        elsif nbits == :nbits
+          "val -= (1 << nbits) if (val >= (1 << (nbits - 1)))"
+        else
+          "val -= #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
+        end
       end
     end
   end
 
+  # Create classes for dynamic bitfields
+  {
+    "Bit"    => :big,
+    "BitLe"  => :little,
+    "Sbit"   => [:big, :signed],
+    "SbitLe" => [:little, :signed],
+  }.each_pair { |name, args| BitField.define_class(name, :nbits, *args) }
+
   # Create classes on demand
   module BitFieldFactory
     def const_missing(name)
       mappings = {
-        /^Bit(\d+)$/ => :big,
-        /^Bit(\d+)le$/ => :little,
-        /^Sbit(\d+)$/ => [:big, :signed],
+        /^Bit(\d+)$/    => :big,
+        /^Bit(\d+)le$/  => :little,
+        /^Sbit(\d+)$/   => [:big, :signed],
         /^Sbit(\d+)le$/ => [:little, :signed]
       }
 
       mappings.each_pair do |regex, args|
         if regex =~ name.to_s
           nbits = $1.to_i
-          return BitField.define_class(nbits, *args)
+          return BitField.define_class(name, nbits, *args)
         end
       end
 

data/lib/bindata/buffer.rb

@@ -76,7 +76,7 @@ module BinData
       @type = get_parameter(:type).instantiate(nil, self)
     end
 
-    def clear? #:nodoc:
+    def clear?
       @type.clear?
     end
 

data/lib/bindata/choice.rb

@@ -125,40 +125,24 @@ module BinData
       selection
     end
 
-    def clear? #:nodoc:
-      current_choice.clear?
-    end
-
-    def assign(val)
-      current_choice.assign(val)
-    end
-
-    def snapshot
-      current_choice.snapshot
+    def safe_respond_to?(symbol, include_private = false) #:nodoc:
+      base_respond_to?(symbol, include_private)
     end
 
     def respond_to?(symbol, include_private = false) #:nodoc:
       current_choice.respond_to?(symbol, include_private) || super
     end
 
-    def safe_respond_to?(symbol, include_private = false) #:nodoc:
-      base_respond_to?(symbol, include_private)
-    end
-
     def method_missing(symbol, *args, &block) #:nodoc:
       current_choice.__send__(symbol, *args, &block)
     end
 
-    def do_read(io) #:nodoc:
-      current_choice.do_read(io)
-    end
-
-    def do_write(io) #:nodoc:
-      current_choice.do_write(io)
-    end
-
-    def do_num_bytes #:nodoc:
-      current_choice.do_num_bytes
+    %w(clear? assign snapshot do_read do_write do_num_bytes).each do |m|
+      self.module_eval <<-END
+        def #{m}(*args)
+          current_choice.#{m}(*args)
+        end
+      END
     end
 
     #---------------

data/lib/bindata/deprecated.rb

@@ -20,12 +20,12 @@ module BinData
 
     # Don't override initialize.  If you are defining a new kind of datatype
     # (list, array, choice etc) then put your initialization code in
-    # #initialize_instance.  This is because BinData objects can be initialized
-    # as prototypes and your initialization code may not be called.
+    # #initialize_instance.  BinData objects might be initialized as prototypes
+    # and your initialization code may not be called.
     #
     # If you're subclassing BinData::Record, you are definitely doing the wrong
     # thing.  Read the documentation on how to use BinData.
-    # http://bindata.rubyforge.org/manual.html#records
+    # http://github.com/dmendel/bindata/wiki/Records
     alias_method :initialize_without_warning, :initialize
     def initialize_with_warning(*args)
       owner = method(:initialize).owner
@@ -46,5 +46,11 @@ module BinData
       end
     end
 
+    # #offset has been renamed to #abs_offset.
+    # Eventually #rel_offset will be renamed to #offset.
+    def offset
+      warn "#offset is deprecated in #{debug_name}. Use #abs_offset instead"
+      abs_offset
+    end
   end
 end

data/lib/bindata/int.rb

@@ -6,8 +6,7 @@ module BinData
 
   module Int #:nodoc: all
     class << self
-      def define_class(nbits, endian, signed)
-        name = class_name(nbits, endian, signed)
+      def define_class(name, nbits, endian, signed)
         unless BinData.const_defined?(name)
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
@@ -19,13 +18,6 @@ module BinData
         BinData.const_get(name)
       end
 
-      def class_name(nbits, endian, signed)
-        endian_str = (endian == :big) ? "be" : "le"
-        base = (signed == :signed) ? "Int" : "Uint"
-
-        "#{base}#{nbits}#{endian_str}"
-      end
-
       def define_methods(int_class, nbits, endian, signed)
         raise "nbits must be divisible by 8" unless (nbits % 8).zero?
 
@@ -170,7 +162,7 @@ module BinData
         if regex =~ name.to_s
           nbits = $1.to_i
           if (nbits % 8).zero?
-            return Int.define_class(nbits, *args)
+            return Int.define_class(name, nbits, *args)
           end
         end
       end

data/lib/bindata/io.rb

@@ -190,8 +190,8 @@ module BinData
 
       # Use #seek and #pos on seekable streams
       module SeekableStream
-        # Returns the current offset of the io stream.  The exact value of
-        # the offset when reading bitfields is not defined.
+        # Returns the current offset of the io stream.  Offset will be rounded
+        # up when reading bitfields.
         def offset
           raw_io.pos - @initial_pos
         end
@@ -225,8 +225,8 @@ module BinData
 
       # Manually keep track of offset for unseekable streams.
       module UnSeekableStream
-        # Returns the current offset of the io stream.  The exact value of
-        # the offset when reading bitfields is not defined.
+        # Returns the current offset of the io stream.  Offset will be rounded
+        # up when reading bitfields.
         def offset
           @read_count ||= 0
         end
@@ -284,6 +284,8 @@ module BinData
         @wval    = 0
         @wendian = nil
 
+        @write_count = 0
+
         @bytes_remaining = nil
       end
 
@@ -307,6 +309,12 @@ module BinData
         end
       end
 
+      # Returns the current offset of the io stream.  Offset will be rounded
+      # up when writing bitfields.
+      def offset
+        @write_count + (@wnbits > 0 ? 1 : 0)
+      end
+
       # Writes the given string of bytes to the io stream.
       def writebytes(str)
         flushbits
@@ -394,6 +402,7 @@ module BinData
           @bytes_remaining -= data.size
         end
 
+        @write_count += data.size
         @raw_io.write(data)
       end
 

data/lib/bindata/lazy.rb

@@ -85,7 +85,7 @@ module BinData
 
       if obj_parent.has_parameter?(symbol)
         obj_parent.get_parameter(symbol)
-      elsif obj_parent.safe_respond_to?(symbol)
+      elsif obj_parent.safe_respond_to?(symbol, true)
         obj_parent.__send__(symbol, *args)
       else
         symbol

data/lib/bindata/record.rb

@@ -1,28 +1,10 @@
 require 'bindata/dsl'
-require 'bindata/sanitize'
 require 'bindata/struct'
 
 module BinData
   # A Record is a declarative wrapper around Struct.
   #
-  #    require 'bindata'
-  #
-  #    class SomeDataType < BinData::Record
-  #      hide :a
-  #
-  #      int32le :a
-  #      int16le :b
-  #      struct  :s do
-  #        int8  :x
-  #        int8  :y
-  #        int8  :z
-  #      end
-  #    end
-  #
-  #    obj = SomeDataType.new
-  #    obj.field_names   =># ["b", "s"]
-  #    obj.s.field_names =># ["x", "y", "z"]
-  #
+  # See +Struct+ for more info.
   class Record < BinData::Struct
     include DSLMixin
 

data/lib/bindata/sanitize.rb

@@ -24,6 +24,14 @@ module BinData
       end
     end
 
+    def has_parameter?(param)
+      if @factory
+        @factory.has_parameter?(param)
+      else
+        @obj_params.has_parameter?(param)
+      end
+    end
+
     def instantiate(value = nil, parent = nil)
       @factory ||= @obj_class.new(@obj_params)
 
@@ -48,6 +56,10 @@ module BinData
       @name
     end
 
+    def has_parameter?(param)
+      @prototype.has_parameter?(param)
+    end
+
     def instantiate(value = nil, parent = nil)
       @prototype.instantiate(value, parent)
     end
@@ -83,6 +95,10 @@ module BinData
       @fields.each(&block)
     end
 
+    def each_with_index(&block)
+      @fields.each_with_index(&block)
+    end
+
     def collect(&block)
       @fields.collect(&block)
     end
@@ -103,6 +119,10 @@ module BinData
       @fields.all? { |f| f.name != nil }
     end
 
+    def any_field_has_parameter?(parameter)
+      @fields.any? { |f| f.has_parameter?(parameter) }
+    end
+
     def copy_fields(other)
       @fields.concat(other.fields)
     end

data/lib/bindata/string.rb

@@ -91,13 +91,14 @@ module BinData
 
     def snapshot
       # override to trim padding
-      result = super
-      result = clamp_to_length(result)
+      snap = super
+      snap = clamp_to_length(snap)
 
       if get_parameter(:trim_padding)
-        result = trim_padding(result)
+        trim_padding(snap)
+      else
+        snap
       end
-      result
     end
 
     #---------------

data/lib/bindata/struct.rb

@@ -3,7 +3,7 @@ require 'bindata/base'
 module BinData
 
   class Base
-    optional_parameter :onlyif  # Used by Struct
+    optional_parameter :onlyif, :byte_align  # Used by Struct
   end
 
   # A Struct is an ordered collection of named data objects.
@@ -47,9 +47,11 @@ module BinData
   #
   # Fields may have have extra parameters as listed below:
   #
-  # [<tt>:onlyif</tt>]   Used to indicate a data object is optional.
-  #                      if +false+, this object will not be included in any
-  #                      calls to #read, #write, #num_bytes or #snapshot.
+  # [<tt>:onlyif</tt>]     Used to indicate a data object is optional.
+  #                        if +false+, this object will not be included in any
+  #                        calls to #read, #write, #num_bytes or #snapshot.
+  # [<tt>:byte_align</tt>] This field's rel_offset must be a multiple of
+  #                        <tt>:byte_align</tt>.
   class Struct < BinData::Base
 
     mandatory_parameter :fields
@@ -137,7 +139,9 @@ module BinData
     end
 
     def initialize_shared_instance
-      @field_names = get_parameter(:fields).field_names.freeze
+      fields = get_parameter(:fields)
+      @field_names = fields.field_names.freeze
+      extend ByteAlignPlugin if fields.any_field_has_parameter?(:byte_align)
       super
     end
 
@@ -162,7 +166,7 @@ module BinData
       snapshot = Snapshot.new
       field_names.each do |name|
         obj = find_obj_for_name(name)
-        snapshot[name] = obj.snapshot if include_obj(obj)
+        snapshot[name] = obj.snapshot if include_obj?(obj)
       end
       snapshot
     end
@@ -182,7 +186,7 @@ module BinData
     def respond_to?(symbol, include_private = false) #:nodoc:
       @field_names.include?(base_field_name(symbol)) || super
     end
-
+    
     def method_missing(symbol, *args, &block) #:nodoc:
       obj = find_obj_for_name(symbol)
       if obj
@@ -205,12 +209,12 @@ module BinData
 
     def do_read(io) #:nodoc:
       instantiate_all_objs
-      @field_objs.each { |f| f.do_read(io) if include_obj(f) }
+      @field_objs.each { |f| f.do_read(io) if include_obj?(f) }
     end
 
     def do_write(io) #:nodoc
       instantiate_all_objs
-      @field_objs.each { |f| f.do_write(io) if include_obj(f) }
+      @field_objs.each { |f| f.do_write(io) if include_obj?(f) }
     end
 
     def do_num_bytes #:nodoc:
@@ -242,16 +246,15 @@ module BinData
     #---------------
     private
 
-    def base_field_name(name)
-      name.to_s.chomp("=").to_sym
-    end
-
     def invoke_field(obj, symbol, args)
       name = symbol.to_s
       is_writer = (name[-1, 1] == "=")
+      is_query = (name[-1, 1] == "?")
 
       if is_writer
         obj.assign(*args)
+      elsif is_query
+        include_obj?(obj)
       else
         obj
       end
@@ -271,6 +274,10 @@ module BinData
       end
     end
 
+    def base_field_name(name)
+      name.to_s.sub(/(=|\?)\z/, "").to_sym
+    end
+
     def instantiate_all_objs
       @field_names.each_index { |i| instantiate_obj_at(i) }
     end
@@ -310,19 +317,18 @@ module BinData
     end
 
     def sum_num_bytes_below_index(index)
-      sum = 0
-      (0...index).each do |i|
+      (0...index).inject(0) do |sum, i|
         obj = @field_objs[i]
-        if include_obj(obj)
+        if include_obj?(obj)
           nbytes = obj.do_num_bytes
-          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+          (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+        else
+          sum
         end
       end
-
-      sum
     end
 
-    def include_obj(obj)
+    def include_obj?(obj)
       not obj.has_parameter?(:onlyif) or obj.eval_parameter(:onlyif)
     end
 
@@ -381,4 +387,59 @@ module BinData
       end
     end
   end
+
+  # Align fields to a multiple of :byte_align
+  module ByteAlignPlugin
+    def do_read(io)
+      initial_offset = io.offset
+      instantiate_all_objs
+      @field_objs.each do |f|
+        if include_obj?(f)
+          if align_obj?(f)
+            io.seekbytes(bytes_to_align(f, io.offset - initial_offset))
+          end
+          f.do_read(io)
+        end
+      end
+    end
+
+    def do_write(io)
+      initial_offset = io.offset
+      instantiate_all_objs
+      @field_objs.each do |f|
+        if include_obj?(f)
+          if align_obj?(f)
+            io.writebytes("\x00" * bytes_to_align(f, io.offset - initial_offset))
+          end
+          f.do_write(io)
+        end
+      end
+    end
+
+    def sum_num_bytes_below_index(index)
+      sum = 0
+      (0...@field_objs.length).each do |i|
+        obj = @field_objs[i]
+        if include_obj?(obj)
+          sum = sum.ceil + bytes_to_align(obj, sum.ceil) if align_obj?(obj)
+
+          break if i >= index
+
+          nbytes = obj.do_num_bytes
+          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+        end
+      end
+
+      sum
+    end
+
+    def bytes_to_align(obj, rel_offset)
+      align = obj.eval_parameter(:byte_align)
+      (align - (rel_offset % align)) % align
+    end
+
+    def align_obj?(obj)
+      obj.has_parameter?(:byte_align)
+    end
+  end
 end

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "1.8.2"
+  VERSION = "1.8.3"
 end

data/test/array_test.rb

@@ -168,7 +168,7 @@ describe BinData::Array, "with several elements" do
   end
 
   it "has correct offset" do
-    obj[2].offset.must_equal ExampleSingle.new.num_bytes * 2
+    obj[2].rel_offset.must_equal ExampleSingle.new.num_bytes * 2
   end
 
   it "has correct num_bytes" do
@@ -364,8 +364,8 @@ describe BinData::Array, "of bits" do
   end
 
   it "has correct offset" do
-    obj[7].offset.must_equal 0
-    obj[8].offset.must_equal 1
+    obj[7].rel_offset.must_equal 0
+    obj[8].rel_offset.must_equal 1
   end
 end
 

data/test/bits_test.rb

@@ -5,66 +5,58 @@ require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 module AllBitfields
 
   def test_has_a_sensible_value_of_zero
-    all_classes do |bit_class|
-      bit_class.new.must_equal 0
+    all_objects do |obj, nbits|
+      obj.must_equal 0
     end
   end
 
   def test_avoids_underflow
-    all_classes do |bit_class|
-      obj = bit_class.new
-
+    all_objects do |obj, nbits|
       obj.assign(min_value - 1)
       obj.must_equal min_value
     end
   end
 
   def test_avoids_overflow
-    all_classes do |bit_class|
-      obj = bit_class.new
-
+    all_objects do |obj, nbits|
       obj.assign(max_value + 1)
       obj.must_equal max_value
     end
   end
 
   def test_assign_values
-    all_classes do |bit_class|
+    all_objects do |obj, nbits|
       some_values_within_range.each do |val|
-        obj = bit_class.new
         obj.assign(val)
-
         obj.must_equal val
       end
     end
   end
 
   def test_assign_values_from_other_bit_objects
-    all_classes do |bit_class|
+    all_objects do |obj, nbits|
       some_values_within_range.each do |val|
-        obj = bit_class.new
-        obj.assign(bit_class.new(val))
-
+        obj.assign(obj.new(val))
         obj.must_equal val
       end
     end
   end
 
   def test_symmetrically_read_and_write
-    all_classes do |bit_class|
+    all_objects do |obj, nbits|
       some_values_within_range.each do |val|
-        obj = bit_class.new
         obj.assign(val)
-
-        obj.value_read_from_written.must_equal obj
+        other = obj.new
+        other.read(obj.to_binary_s)
+        other.must_equal obj
       end
     end
   end
 
-  def all_classes(&block)
-    @bits.each_pair do |bit_class, nbits|
+  def all_objects(&block)
+    @bits.each do |obj, nbits|
       @nbits = nbits
-      yield bit_class
+      yield obj, nbits
     end
   end
 
@@ -98,7 +90,7 @@ module AllBitfields
 end
 
 def generate_bit_classes_to_test(endian, signed)
-  bits = {}
+  bits = []
   if signed
     base  = "Sbit"
     start = 2
@@ -107,12 +99,20 @@ def generate_bit_classes_to_test(endian, signed)
     start = 1
   end
 
-  (start .. 50).each do |nbits|
+  (start .. 64).each do |nbits|
     name = "#{base}#{nbits}"
     name << "le" if endian == :little
-    bit_class = BinData.const_get(name)
-    bits[bit_class] = nbits
+    obj = BinData.const_get(name).new
+    bits << [obj, nbits]
+  end
+
+  (start .. 64).each do |nbits|
+    name = "#{base}"
+    name << "Le" if endian == :little
+    obj = BinData.const_get(name).new(:nbits => nbits)
+    bits << [obj, nbits]
   end
+
   bits
 end
 
@@ -125,11 +125,12 @@ describe "Unsigned big endian bitfields" do
   end
 
   it "read big endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b1000_0000].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1 << (nbits - 1)
+      obj.read(str)
+      obj.must_equal 1 << (nbits - 1)
     end
   end
 end
@@ -143,11 +144,12 @@ describe "Signed big endian bitfields" do
   end
 
   it "read big endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0100_0000].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1 << (nbits - 2)
+      obj.read(str)
+      obj.must_equal 1 << (nbits - 2)
     end
   end
 end
@@ -161,11 +163,12 @@ describe "Unsigned little endian bitfields" do
   end
 
   it "read little endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1
+      obj.read(str)
+      obj.must_equal 1
     end
   end
 end
@@ -179,11 +182,12 @@ describe "Signed little endian bitfields" do
   end
 
   it "read little endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1
+      obj.read(str)
+      obj.must_equal 1
     end
   end
 end

data/test/io_test.rb

@@ -152,6 +152,21 @@ describe BinData::IO::Write, "when writing" do
     stream.value.must_equal "abcd"
   end
 
+  it "has #offset" do
+    io.offset.must_equal 0
+
+    io.writebytes("abcd")
+    io.offset.must_equal 4
+
+    io.writebytes("ABCD")
+    io.offset.must_equal 8
+  end
+
+  it "rounds up #offset when writing bits" do
+    io.writebits(123, 9, :little)
+    io.offset.must_equal 2
+  end
+
   it "flushes" do
     io.writebytes("abcd")
     io.flush

data/test/lazy_test.rb

@@ -73,12 +73,16 @@ end
 
 describe BinData::LazyEvaluator, "with one parent" do
   subject {
-    parent_methods = {:m1 => 'Pm1', :com1 => 'PmC', :mm => 3}
+    parent_methods = {:m1 => 'Pm1', :m2 => 'Pm2', :com1 => 'PmC', :mm => 3}
     parent_params  = {:p1 => 'Pp1', :com1 => 'PpC'}
     parent_obj = MockBinDataObject.new(parent_methods, parent_params)
 
-    def parent_obj.echo(a1, a2)
-      [a1, a2]
+    class << parent_obj
+      def echo(a1, a2)
+        [a1, a2]
+      end
+
+      private :m2
     end
 
     methods = {:m1 => 'm1', :com1 => 'mC'}
@@ -118,6 +122,10 @@ describe BinData::LazyEvaluator, "with one parent" do
     lazy_eval(lambda { echo(p1, m1) }).must_equal ['Pp1', 'Pm1']
   end
 
+  it "invokes private methods in the parent" do
+    lazy_eval(lambda { m2 }).must_equal 'Pm2'
+  end
+
   it "resolves parameters in preference to methods in the parent" do
     lazy_eval(lambda { com1 }).must_equal 'PpC'
   end

data/test/record_test.rb

@@ -241,12 +241,12 @@ describe BinData::Record, "with nested structs" do
     obj.c.y.must_equal 3
   end
 
-  it "returns correct offset" do
-    obj.offset.must_equal 0
-    obj.b.offset.must_equal 1
-    obj.b.w.offset.must_equal 1
-    obj.c.offset.must_equal 3
-    obj.c.z.offset.must_equal 4
+  it "returns correct abs_offset" do
+    obj.abs_offset.must_equal 0
+    obj.b.abs_offset.must_equal 1
+    obj.b.w.abs_offset.must_equal 1
+    obj.c.abs_offset.must_equal 3
+    obj.c.z.abs_offset.must_equal 4
   end
 
   it "returns correct rel_offset" do
@@ -476,6 +476,12 @@ describe BinData::Record, "with :onlyif" do
     obj.to_binary_s.must_equal "\x03\x05"
   end
 
+  it "identifies if fields are included" do
+    obj.a?.must_equal true
+    obj.b?.must_equal true
+    obj.c?.must_equal false
+  end
+
   it "reads as lambdaed" do
     obj.read("\x01\x02")
     obj.snapshot.must_equal({"a" => 1, "c" => 2})

data/test/struct_test.rb

@@ -250,11 +250,11 @@ describe BinData::Struct, "with nested structs" do
     obj.c.z.must_equal 0
   end
 
-  it "returns correct offset" do
-    obj.b.offset.must_equal 1
-    obj.b.w.offset.must_equal 1
-    obj.c.offset.must_equal 3
-    obj.c.z.offset.must_equal 4
+  it "returns correct abs_offset" do
+    obj.b.abs_offset.must_equal 1
+    obj.b.w.abs_offset.must_equal 1
+    obj.c.abs_offset.must_equal 3
+    obj.c.z.abs_offset.must_equal 4
   end
 end
 
@@ -313,10 +313,10 @@ describe BinData::Struct, "with bit fields" do
   end
 
   it "has correct offsets" do
-    obj.a.offset.must_equal 0
-    obj.b.offset.must_equal 0
-    obj.c.offset.must_equal 1
-    obj.d.offset.must_equal 2
+    obj.a.rel_offset.must_equal 0
+    obj.b.rel_offset.must_equal 0
+    obj.c.rel_offset.must_equal 1
+    obj.d.rel_offset.must_equal 2
   end
 end
 
@@ -338,6 +338,37 @@ describe BinData::Struct, "with nested endian" do
   end
 end
 
+describe BinData::Struct, "with byte_align" do
+  let(:obj) {
+    params = { :fields => [[:int8, :a],
+                           [:int8, :b, {:byte_align => 5}],
+                           [:bit2, :c],
+                           [:int8, :d, {:byte_align => 3}]] }
+    BinData::Struct.new(params)
+  }
+
+  it "has #num_bytes" do
+    obj.num_bytes.must_equal 10
+  end
+
+  it "reads" do
+    obj.read("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
+    obj.snapshot.must_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 })
+  end
+
+  it "writes" do
+    obj.assign(:a => 1, :b => 2, :c => 3, :d => 4)
+    obj.to_binary_s.must_equal binary("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
+  end
+
+  it "has correct offsets" do
+    obj.a.rel_offset.must_equal 0
+    obj.b.rel_offset.must_equal 5
+    obj.c.rel_offset.must_equal 6
+    obj.d.rel_offset.must_equal 9
+  end
+end
+
 describe BinData::Struct, "with dynamically named types" do
   it "instantiates" do
     dyn = BinData::Struct.new(:name => :my_struct, :fields => [[:int8, :a, {:initial_value => 3}]])

data/test/system_test.rb

@@ -93,7 +93,7 @@ describe BinData::Record, "with choice field" do
 
   it "has correct offset" do
     obj = RecordWithNestedChoiceField.new
-    obj.x.b.offset.must_equal 2
+    obj.x.b.abs_offset.must_equal 2
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bindata
 version: !ruby/object:Gem::Version 
-  hash: 51
+  hash: 49
   prerelease: 
   segments: 
   - 1
   - 8
-  - 2
-  version: 1.8.2
+  - 3
+  version: 1.8.3
 platform: ruby
 authors: 
 - Dion Mendel
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-02-02 00:00:00 +08:00
+date: 2014-04-16 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency