bindata 1.8.3 → 2.0.0

data/lib/bindata/string.rb

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

data/lib/bindata/struct.rb

@@ -3,7 +3,7 @@ require 'bindata/base'
 module BinData
 
   class Base
-    optional_parameter :onlyif, :byte_align  # Used by Struct
+    optional_parameter :onlyif  # Used by Struct
   end
 
   # A Struct is an ordered collection of named data objects.
@@ -20,7 +20,7 @@ module BinData
   #                              :fields => [ [:int32le, :a],
   #                                           [:int16le, :b],
   #                                           [:tuple, :s] ])
-  #    obj.field_names   =># ["b", "s"]
+  #    obj.field_names   =># [:b, :s]
   #
   #
   # == Parameters
@@ -47,11 +47,9 @@ 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>:byte_align</tt>] This field's rel_offset must be a multiple of
-  #                        <tt>:byte_align</tt>.
+  # [<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.
   class Struct < BinData::Base
 
     mandatory_parameter :fields
@@ -139,9 +137,7 @@ module BinData
     end
 
     def initialize_shared_instance
-      fields = get_parameter(:fields)
-      @field_names = fields.field_names.freeze
-      extend ByteAlignPlugin if fields.any_field_has_parameter?(:byte_align)
+      @field_names = get_parameter(:fields).field_names.freeze
       super
     end
 
@@ -166,7 +162,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
@@ -180,13 +176,13 @@ module BinData
       else
         hidden = get_parameter(:hide) || []
         @field_names.compact - hidden
-      end.collect { |x| x.to_s }
+      end
     end
 
     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
@@ -209,12 +205,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:
@@ -246,15 +242,16 @@ 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
@@ -274,10 +271,6 @@ 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
@@ -317,65 +310,26 @@ module BinData
     end
 
     def sum_num_bytes_below_index(index)
-      (0...index).inject(0) do |sum, i|
+      sum = 0
+      (0...index).each do |i|
         obj = @field_objs[i]
-        if include_obj?(obj)
+        if include_obj(obj)
           nbytes = obj.do_num_bytes
-          (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
-        else
-          sum
+          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
         end
       end
-    end
 
-    def include_obj?(obj)
-      not obj.has_parameter?(:onlyif) or obj.eval_parameter(:onlyif)
+      sum
     end
 
-    if RUBY_VERSION <= "1.9"
-      module OrderedHash #:nodoc:
-        def keys
-          @order ||= []
-          k = super
-          @order & k
-        end
-
-        def []=(key, value)
-          @order ||= []
-          @order << key
-          super(key, value)
-        end
-
-        def each
-          keys.each do |k|
-            yield [k, self[k]]
-          end
-        end
-
-        def each_pair
-          each do |el|
-            yield *el
-          end
-        end
-      end
+    def include_obj(obj)
+      not obj.has_parameter?(:onlyif) or obj.eval_parameter(:onlyif)
     end
 
     # A hash that can be accessed via attributes.
     class Snapshot < ::Hash #:nodoc:
-      include OrderedHash if RUBY_VERSION <= "1.9"
-
-      def has_key?(key)
-        super(key.to_s)
-      end
-
-      def [](key)
-        super(key.to_s)
-      end
-
       def []=(key, value)
-        if value != nil
-          super(key.to_s, value)
-        end
+        super(key, value) unless value.nil?
       end
 
       def respond_to?(symbol, include_private = false)
@@ -387,59 +341,4 @@ 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.3"
+  VERSION = "2.0.0"
 end

data/test/alignment_test.rb

@@ -52,7 +52,7 @@ describe BinData::BitAligned do
 
   it "reads as expected" do
     obj.read("\x56\x36\x42")
-    obj.snapshot.must_equal({"preamble" => 5, "str" => "cd", "afterward" => 2})
+    obj.snapshot.must_equal({:preamble => 5, :str => "cd", :afterward => 2})
   end
 
   it "writes as expected" do

data/test/array_test.rb

@@ -168,7 +168,7 @@ describe BinData::Array, "with several elements" do
   end
 
   it "has correct offset" do
-    obj[2].rel_offset.must_equal ExampleSingle.new.num_bytes * 2
+    obj[2].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].rel_offset.must_equal 0
-    obj[8].rel_offset.must_equal 1
+    obj[7].offset.must_equal 0
+    obj[8].offset.must_equal 1
   end
 end
 

data/test/bits_test.rb

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