bindata 0.11.0 → 0.11.1

data/lib/bindata.rb

@@ -21,5 +21,5 @@ require 'bindata/deprecated'
 # A declarative way to read and write structured binary data.
 # 
 module BinData
-  VERSION = "0.11.0"
+  VERSION = "0.11.1"
 end

data/lib/bindata/array.rb

@@ -95,7 +95,7 @@ module BinData
     end
 
     def find_index(obj)
-      elements.find_index(obj)
+      elements.index(obj)
     end
     alias_method :index, :find_index
 
@@ -103,7 +103,7 @@ module BinData
     #
     # Uses equal? for the comparator.
     def find_index_of(obj)
-      elements.find_index { |el| el.equal?(obj) }
+      elements.index { |el| el.equal?(obj) }
     end
 
     def push(*args)
@@ -222,7 +222,7 @@ module BinData
       index = find_index_of(child)
       sum = sum_num_bytes_below_index(index)
 
-      child_offset = (::Integer === child.do_num_bytes) ? sum.ceil : sum.floor
+      child_offset = child.do_num_bytes.is_a?(Integer) ? sum.ceil : sum.floor
 
       offset + child_offset
     end
@@ -337,7 +337,7 @@ module BinData
       sum = 0
       (0...index).each do |i|
         nbytes = elements[i].do_num_bytes
-        sum = ((::Integer === nbytes) ? sum.ceil : sum) + nbytes
+        sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
       end
 
       sum

data/lib/bindata/choice.rb

@@ -92,7 +92,7 @@ module BinData
         if choices.has_key?(nil)
           raise ArgumentError, ":choices hash may not have nil key"
         end
-        if choices.keys.detect { |key| Symbol === key }
+        if choices.keys.detect { |key| key.is_a?(Symbol) }
           raise ArgumentError, ":choices hash may not have symbols for keys"
         end
       end

data/lib/bindata/deprecated.rb

@@ -139,8 +139,8 @@ module BinData
 
     alias_method :orig_offset_of, :offset_of
     def offset_of(child)
-      if child.class == ::String
-        fail "error: 'offset_of(\"fieldname\")' is deprecated.  Use 'fieldname.offset' instead"
+      if child.is_a?(::String) or child.is_a?(Symbol)
+        fail "error: 'offset_of(#{child.inspect})' is deprecated.  Use '#{child.to_s}.offset' instead"
       end
       orig_offset_of(child)
     end

data/lib/bindata/float.rb

@@ -7,10 +7,10 @@ module BinData
   module FloatingPoint #:nodoc: all
     def self.create_float_methods(float_class, precision, endian)
       read = create_read_code(precision, endian)
-      to_s = create_to_s_code(precision, endian)
+      to_binary_s = create_to_binary_s_code(precision, endian)
       nbytes = (precision == :single) ? 4 : 8
 
-      define_methods(float_class, nbytes, read, to_s)
+      define_methods(float_class, nbytes, read, to_binary_s)
     end
 
     def self.create_read_code(precision, endian)
@@ -25,7 +25,7 @@ module BinData
       "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
     end
 
-    def self.create_to_s_code(precision, endian)
+    def self.create_to_binary_s_code(precision, endian)
       if precision == :single
         pack = (endian == :little) ? 'e' : 'g'
       else # double_precision
@@ -35,7 +35,7 @@ module BinData
       "[val].pack('#{pack}')"
     end
 
-    def self.define_methods(float_class, nbytes, read, to_s)
+    def self.define_methods(float_class, nbytes, read, to_binary_s)
       float_class.module_eval <<-END
         def _do_num_bytes(ignored)
           #{nbytes}
@@ -49,7 +49,7 @@ module BinData
         end
 
         def value_to_binary_string(val)
-          #{to_s}
+          #{to_binary_s}
         end
 
         def read_and_return_value(io)

data/lib/bindata/int.rb

@@ -4,49 +4,58 @@ module BinData
   # Defines a number of classes that contain an integer.  The integer
   # is defined by endian, signedness and number of bytes.
 
-  module Integer #:nodoc: all
+  module Int #:nodoc: all
     class << self
       def define_class(nbits, endian, signed)
-        endian_str = (endian == :big) ? "be" : "le"
-        if signed == :signed
-          name = "Int#{nbits}#{endian_str}"
-          creation_method = "create_int_methods"
-        else
-          name = "Uint#{nbits}#{endian_str}"
-          creation_method = "create_uint_methods"
-        end
+        name = class_name(nbits, endian, signed)
+        return if BinData.const_defined?(name)
+
+        int_type = (signed == :signed) ? 'int' : 'uint'
+        creation_method = "create_#{int_type}_methods"
 
         BinData.module_eval <<-END
           class #{name} < BinData::BasePrimitive
             register(self.name, self)
-            Integer.#{creation_method}(self, #{nbits}, :#{endian.to_s})
+            Int.#{creation_method}(self, #{nbits}, :#{endian.to_s})
           end
         END
       end
 
+      def class_name(nbits, endian, signed)
+        endian_str = (endian == :big) ? "be" : "le"
+        base = (signed == :signed) ? "Int" : "Uint"
+
+        "#{base}#{nbits}#{endian_str}"
+      end
+
       def create_uint_methods(int_class, nbits, endian)
+        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+
         min = 0
         max = (1 << nbits) - 1
 
         clamp = create_clamp_code(min, max)
         read = create_read_code(nbits, endian)
-        to_s = create_to_s_code(nbits, endian)
+        to_binary_s = create_to_binary_s_code(nbits, endian)
 
-        define_methods(int_class, nbits / 8, clamp, read, to_s)
+        define_methods(int_class, nbits / 8, clamp, read, to_binary_s)
       end
 
       def create_int_methods(int_class, nbits, endian)
+        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+
         max = (1 << (nbits - 1)) - 1
         min = -(max + 1)
 
         clamp = create_clamp_code(min, max)
         read = create_read_code(nbits, endian)
-        to_s = create_to_s_code(nbits, endian)
+        to_binary_s = create_to_binary_s_code(nbits, endian)
 
         int2uint = create_int2uint_code(nbits)
         uint2int = create_uint2int_code(nbits)
 
-        define_methods(int_class, nbits / 8, clamp, read, to_s, int2uint, uint2int)
+        define_methods(int_class, nbits / 8, clamp, read, to_binary_s,
+                         int2uint, uint2int)
       end
 
       def create_clamp_code(min, max)
@@ -65,8 +74,6 @@ module BinData
       end
 
       def create_read_code(nbits, endian)
-        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
-
         # determine "word" size and unpack directive
         if (nbits % 32).zero?
           bytes_per_word = 4
@@ -97,9 +104,7 @@ module BinData
         "(#{unpack_str}; #{assemble_str})"
       end
 
-      def create_to_s_code(nbits, endian)
-        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
-
+      def create_to_binary_s_code(nbits, endian)
         # special case 8bit integers for speed
         return "val.chr" if nbits == 8
 
@@ -130,8 +135,8 @@ module BinData
         "#{array_str}.pack('#{d * nwords}')"
       end
 
-      def define_methods(int_class, nbytes, clamp, read, to_s,
-                              int2uint = nil, uint2int = nil)
+      def define_methods(int_class, nbytes, clamp, read, to_binary_s,
+                           int2uint = nil, uint2int = nil)
         int_class.module_eval <<-END
           #---------------
           private
@@ -152,7 +157,7 @@ module BinData
           def value_to_binary_string(val)
             #{clamp}
             #{int2uint unless int2uint.nil?}
-            #{to_s}
+            #{to_binary_s}
           end
 
           def read_and_return_value(io)
@@ -168,20 +173,20 @@ module BinData
   # Unsigned 1 byte integer.
   class Uint8 < BinData::BasePrimitive
     register(self.name, self)
-    Integer.create_uint_methods(self, 8, :little)
+    Int.create_uint_methods(self, 8, :little)
   end
 
   # Signed 1 byte integer.
   class Int8 < BinData::BasePrimitive
     register(self.name, self)
-    Integer.create_int_methods(self, 8, :little)
+    Int.create_int_methods(self, 8, :little)
   end
 
   # Create commonly used integers
   [8, 16, 32, 64, 128].each do |nbits|
-    Integer.define_class(nbits, :little, :unsigned)
-    Integer.define_class(nbits, :little, :signed)
-    Integer.define_class(nbits, :big, :unsigned)
-    Integer.define_class(nbits, :big, :signed)
+    Int.define_class(nbits, :little, :unsigned)
+    Int.define_class(nbits, :little, :signed)
+    Int.define_class(nbits, :big, :unsigned)
+    Int.define_class(nbits, :big, :signed)
   end
 end

data/lib/bindata/registry.rb

@@ -57,8 +57,8 @@ module BinData
         nbits  = $2.to_i
         endian = $3 == "le" ? :little : :big
         if nbits > 0 and (nbits % 8) == 0
-          if BinData.const_defined?(:Integer)
-            BinData::Integer.define_class(nbits, endian, signed)
+          if BinData.const_defined?(:Int)
+            BinData::Int.define_class(nbits, endian, signed)
           end
         end
       elsif /^bit(\d+)(le)?$/ =~ key

data/lib/bindata/sanitize.rb

@@ -58,6 +58,7 @@ module BinData
       unless @all_sanitized
         unused_keys = @parameters.keys - @the_class.accepted_parameters.all
         unused_keys.each do |param|
+          next if param == :onlyif
           dest[param] = @parameters.delete(param)
         end
       end

data/lib/bindata/struct.rb

@@ -188,7 +188,7 @@ module BinData
     def offset_of(child)
       instantiate_all_objs
       sum = sum_num_bytes_below_index(find_index_of(child))
-      child_offset = (::Integer === child.do_num_bytes) ? sum.ceil : sum.floor
+      child_offset = child.do_num_bytes.is_a?(Integer) ? sum.ceil : sum.floor
 
       offset + child_offset
     end
@@ -208,12 +208,12 @@ module BinData
     end
 
     def find_index_of(obj)
-      @field_objs.find_index { |el| el.equal?(obj) }
+      @field_objs.index { |el| el.equal?(obj) }
     end
 
     def find_obj_for_name(name)
       field_name = name.to_s.chomp("=")
-      index = @field_names.find_index(field_name)
+      index = @field_names.index(field_name)
       if index
         instantiate_obj_at(index)
         @field_objs[index]
@@ -297,7 +297,7 @@ module BinData
         obj = @field_objs[i]
         if include_obj(obj)
           nbytes = obj.do_num_bytes
-          sum = ((::Integer === nbytes) ? sum.ceil : sum) + nbytes
+          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
         end
       end
 

data/spec/array_spec.rb

@@ -158,7 +158,7 @@ describe BinData::Array, "with several elements" do
   it "should clear" do
     @data[1] = 8
     @data.clear
-    @data.collect.should == [1, 2, 3, 4, 5]
+    @data.should == [1, 2, 3, 4, 5]
   end
 
   it "should clear a single element" do

data/spec/base_primitive_spec.rb

@@ -13,16 +13,12 @@ class ExampleSingle
 end
 
 describe BinData::BasePrimitive, "when subclassing" do
-  before(:all) do
-    eval <<-END
-      class SubClassOfSingle < BinData::BasePrimitive
-        expose_methods_for_testing
-      end
-    END
+  class SubClassOfBasePrimitive < BinData::BasePrimitive
+    expose_methods_for_testing
   end
 
   before(:each) do
-    @obj = SubClassOfSingle.new
+    @obj = SubClassOfBasePrimitive.new
   end
 
   it "should raise errors on unimplemented methods" do

data/spec/base_spec.rb

@@ -30,12 +30,8 @@ class MockBaseStub < BaseStub
 end
 
 describe BinData::Base, "when subclassing" do
-  before(:all) do
-    eval <<-END
-      class SubClassOfBase < BinData::Base
-        expose_methods_for_testing
-      end
-    END
+  class SubClassOfBase < BinData::Base
+    expose_methods_for_testing
   end
 
   before(:each) do
@@ -63,11 +59,9 @@ describe BinData::Base, "with parameters" do
 
   it "should raise error if parameter name is invalid" do
     lambda {
-      eval <<-END
-        class InvalidParameterNameBase < BinData::Base
-          optional_parameter :eval # i.e. Kernel#eval
-        end
-      END
+      class InvalidParameterNameBase < BinData::Base
+        optional_parameter :eval # i.e. Kernel#eval
+      end
     }.should raise_error(NameError)
   end
 
@@ -79,13 +73,9 @@ describe BinData::Base, "with parameters" do
 end
 
 describe BinData::Base, "with mandatory parameters" do
-  before(:all) do
-    eval <<-END
-      class MandatoryBase < BaseStub
-        mandatory_parameter :p1
-        mandatory_parameter :p2
-      end
-    END
+  class MandatoryBase < BaseStub
+    mandatory_parameter :p1
+    mandatory_parameter :p2
   end
 
   it "should ensure that all mandatory parameters are present" do
@@ -104,12 +94,8 @@ describe BinData::Base, "with mandatory parameters" do
 end
 
 describe BinData::Base, "with default parameters" do
-  before(:all) do
-    eval <<-END
-      class DefaultBase < BaseStub
-        default_parameter :p1 => "a"
-      end
-    END
+  class DefaultBase < BaseStub
+    default_parameter :p1 => "a"
   end
 
   it "should use default parameters when not specified" do
@@ -126,13 +112,9 @@ describe BinData::Base, "with default parameters" do
 end
 
 describe BinData::Base, "with mutually exclusive parameters" do
-  before(:all) do
-    eval <<-END
-      class MutexParamBase < BaseStub
-        optional_parameters :p1, :p2
-        mutually_exclusive_parameters :p1, :p2
-      end
-    END
+  class MutexParamBase < BaseStub
+    optional_parameters :p1, :p2
+    mutually_exclusive_parameters :p1, :p2
   end
 
   it "should not fail when neither of those parameters are present" do
@@ -150,14 +132,10 @@ describe BinData::Base, "with mutually exclusive parameters" do
 end
 
 describe BinData::Base, "with multiple parameters" do
-  before(:all) do
-    eval <<-END
-      class WithParamBase < BaseStub
-        mandatory_parameter :p1
-        optional_parameter  :p2
-        default_parameter   :p3 => 3
-      end
-    END
+  class WithParamBase < BaseStub
+    mandatory_parameter :p1
+    optional_parameter  :p2
+    default_parameter   :p3 => 3
   end
 
   it "should identify internally accepted parameters" do
@@ -220,16 +198,12 @@ describe BinData::Base, "with multiple parameters" do
 end
 
 describe BinData::Base, "with :check_offset" do
-  before(:all) do
-    eval <<-END
-      class TenByteOffsetBase < BaseStub
-        def do_read(io)
-          # advance the io position before checking offset
-          io.seekbytes(10)
-          super(io)
-        end
-      end
-    END
+  class TenByteOffsetBase < BaseStub
+    def do_read(io)
+      # advance the io position before checking offset
+      io.seekbytes(10)
+      super(io)
+    end
   end
 
   before(:each) do
@@ -262,16 +236,12 @@ describe BinData::Base, "with :check_offset" do
 end
 
 describe BinData::Base, "with :adjust_offset" do
-  before(:all) do
-    eval <<-END
-      class TenByteAdjustingOffsetBase < BaseStub
-        def do_read(io)
-          # advance the io position before checking offset
-          io.seekbytes(10)
-          super(io)
-        end
-      end
-    END
+  class TenByteAdjustingOffsetBase < BaseStub
+    def do_read(io)
+      # advance the io position before checking offset
+      io.seekbytes(10)
+      super(io)
+    end
   end
 
   before(:each) do