bindata 0.11.0 → 0.11.1

data/spec/deprecated_spec.rb

@@ -7,10 +7,8 @@ require 'bindata'
 describe BinData::SingleValue, "when defining" do
   it "should allow inheriting from deprecated SingleValue" do
     lambda {
-      eval <<-END
-        class SubclassSingleValue < BinData::SingleValue
-        end
-      END
+      class SubclassSingleValue < BinData::SingleValue
+      end
     }.should_not raise_error
   end
 end
@@ -18,10 +16,8 @@ end
 describe BinData::MultiValue, "when defining" do
   it "should allow inheriting from deprecated MultiValue" do
     lambda {
-      eval <<-END
-        class SubclassMultiValue < BinData::MultiValue
-        end
-      END
+      class SubclassMultiValue < BinData::MultiValue
+      end
     }.should_not raise_error
   end
 end

data/spec/int_spec.rb

@@ -138,28 +138,32 @@ share_examples_for "All Integers" do
     end
     (@endian == :little) ? str : str.reverse
   end
+
+  def create_mapping_of_class_to_nbits(endian, signed)
+    base = signed ? "Int" : "Uint"
+    signed_sym = signed ? :signed : :unsigned
+    endian_str = (endian == :little) ? "le" : "be"
+
+    result = {}
+    result[BinData.const_get("#{base}8")] = 1
+    (1 .. 20).each do |nbytes|
+      nbits = nbytes * 8
+      class_name = "#{base}#{nbits}#{endian_str}"
+      BinData::Int.define_class(nbits, endian, signed_sym)
+      result[BinData.const_get(class_name)] = nbytes
+    end
+
+    result
+  end
 end
 
 describe "All signed big endian integers" do
   it_should_behave_like "All Integers"
 
   before(:all) do
-    BinData::Integer.define_class(24, :big, :signed)
-    BinData::Integer.define_class(48, :big, :signed)
-    BinData::Integer.define_class(96, :big, :signed)
     @endian = :big
     @signed = true
-    @ints = {
-      BinData::Int8 => 1,
-      BinData::Int8be => 1,
-      BinData::Int16be => 2,
-      BinData::Int24be => 3,
-      BinData::Int32be => 4,
-      BinData::Int48be => 6,
-      BinData::Int64be => 8,
-      BinData::Int96be => 12,
-      BinData::Int128be => 16,
-    }
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
   end
 end
 
@@ -167,22 +171,9 @@ describe "All unsigned big endian integers" do
   it_should_behave_like "All Integers"
 
   before(:all) do
-    BinData::Integer.define_class(24, :big, :unsigned)
-    BinData::Integer.define_class(48, :big, :unsigned)
-    BinData::Integer.define_class(96, :big, :unsigned)
     @endian = :big
     @signed = false
-    @ints = {
-      BinData::Uint8 => 1,
-      BinData::Uint8be => 1,
-      BinData::Uint16be => 2,
-      BinData::Uint24be => 3,
-      BinData::Uint32be => 4,
-      BinData::Uint48be => 6,
-      BinData::Uint64be => 8,
-      BinData::Uint96be => 12,
-      BinData::Uint128be => 16,
-    }
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
   end
 end
 
@@ -190,22 +181,9 @@ describe "All signed little endian integers" do
   it_should_behave_like "All Integers"
 
   before(:all) do
-    BinData::Integer.define_class(24, :little, :signed)
-    BinData::Integer.define_class(48, :little, :signed)
-    BinData::Integer.define_class(96, :little, :signed)
     @endian = :little
     @signed = true
-    @ints = {
-      BinData::Int8 => 1,
-      BinData::Int8le => 1,
-      BinData::Int16le => 2,
-      BinData::Int24le => 3,
-      BinData::Int32le => 4,
-      BinData::Int48le => 6,
-      BinData::Int64le => 8,
-      BinData::Int96le => 12,
-      BinData::Int128le => 16,
-    }
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
   end
 end
 
@@ -213,41 +191,28 @@ describe "All unsigned little endian integers" do
   it_should_behave_like "All Integers"
 
   before(:all) do
-    BinData::Integer.define_class(24, :little, :unsigned)
-    BinData::Integer.define_class(48, :little, :unsigned)
-    BinData::Integer.define_class(96, :little, :unsigned)
     @endian = :little
     @signed = false
-    @ints = {
-      BinData::Uint8 => 1,
-      BinData::Uint8le => 1,
-      BinData::Uint16le => 2,
-      BinData::Uint24le => 3,
-      BinData::Uint32le => 4,
-      BinData::Uint48le => 6,
-      BinData::Uint64le => 8,
-      BinData::Uint96le => 12,
-      BinData::Uint128le => 16,
-    }
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
   end
 end
 
 describe "Custom defined integers" do
   it "should fail unless bits are a multiple of 8" do
     lambda {
-      BinData::Integer.define_class(7, :little, :unsigned)
+      BinData::Int.define_class(7, :little, :unsigned)
     }.should raise_error
 
     lambda {
-      BinData::Integer.define_class(7, :big, :unsigned)
+      BinData::Int.define_class(7, :big, :unsigned)
     }.should raise_error
 
     lambda {
-      BinData::Integer.define_class(7, :little, :signed)
+      BinData::Int.define_class(7, :little, :signed)
     }.should raise_error
 
     lambda {
-      BinData::Integer.define_class(7, :big, :signed)
+      BinData::Int.define_class(7, :big, :signed)
     }.should raise_error
   end
 end

data/spec/primitive_spec.rb

@@ -4,12 +4,8 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata'
 
 describe BinData::Primitive, "when subclassing" do
-  before(:all) do
-    eval <<-END
-      class SubClassOfPrimitive < BinData::Primitive
-        expose_methods_for_testing
-      end
-    END
+  class SubClassOfPrimitive < BinData::Primitive
+    expose_methods_for_testing
   end
 
   before(:each) do
@@ -25,57 +21,45 @@ end
 describe BinData::Primitive, "when defining" do
   it "should fail on non registered types" do
     lambda {
-      eval <<-END
-        class BadTypePrimitive < BinData::Primitive
-          non_registered_type :a
-        end
-      END
+      class BadTypePrimitive < BinData::Primitive
+        non_registered_type :a
+      end
     }.should raise_error(TypeError)
   end
 
   it "should fail on duplicate names" do
     lambda {
-      eval <<-END
-        class DuplicateNamePrimitive < BinData::Primitive
-          int8 :a
-          int8 :b
-          int8 :a
-        end
-      END
+      class DuplicateNamePrimitive < BinData::Primitive
+        int8 :a
+        int8 :b
+        int8 :a
+      end
     }.should raise_error(SyntaxError)
   end
 
   it "should fail when field name shadows an existing method" do
     lambda {
-      eval <<-END
-        class ExistingNamePrimitive < BinData::Primitive
-          int8 :object_id
-        end
-      END
+      class ExistingNamePrimitive < BinData::Primitive
+        int8 :object_id
+      end
     }.should raise_error(NameError)
   end
 
   it "should fail on unknown endian" do
     lambda {
-      eval <<-END
-        class BadEndianPrimitive < BinData::Primitive
-          endian 'a bad value'
-        end
-      END
+      class BadEndianPrimitive < BinData::Primitive
+        endian 'a bad value'
+      end
     }.should raise_error(ArgumentError)
   end
 end
 
 describe BinData::Primitive do
-  before(:all) do
-    eval <<-END
-      class PrimitiveWithEndian < BinData::Primitive
-        endian :little
-        int16 :a
-        def get; self.a; end
-        def set(v); self.a = v; end
-      end
-    END
+  class PrimitiveWithEndian < BinData::Primitive
+    endian :little
+    int16 :a
+    def get; self.a; end
+    def set(v); self.a = v; end
   end
 
   before(:each) do
@@ -114,14 +98,10 @@ describe BinData::Primitive do
 end
 
 describe BinData::Primitive, "requiring custom parameters" do
-  before(:all) do
-    eval <<-END
-      class PrimitiveWithCustom < BinData::Primitive
-        int8 :a, :initial_value => :iv
-        def get; self.a; end
-        def set(v); self.a = v; end
-      end
-    END
+  class PrimitiveWithCustom < BinData::Primitive
+    int8 :a, :initial_value => :iv
+    def get; self.a; end
+    def set(v); self.a = v; end
   end
 
   it "should pass parameters correctly" do
@@ -131,16 +111,12 @@ describe BinData::Primitive, "requiring custom parameters" do
 end
 
 describe BinData::Primitive, "with custom mandatory parameters" do
-  before(:all) do
-    eval <<-END
-      class MandatoryPrimitive < BinData::Primitive
-        mandatory_parameter :arg1
-
-        uint8 :a, :value => :arg1
-        def get; self.a; end
-        def set(v); self.a = v; end
-      end
-    END
+  class MandatoryPrimitive < BinData::Primitive
+    mandatory_parameter :arg1
+
+    uint8 :a, :value => :arg1
+    def get; self.a; end
+    def set(v); self.a = v; end
   end
 
   it "should raise error if mandatory parameter is not supplied" do
@@ -154,16 +130,12 @@ describe BinData::Primitive, "with custom mandatory parameters" do
 end
 
 describe BinData::Primitive, "with custom default parameters" do
-  before(:all) do
-    eval <<-END
-      class DefaultPrimitive < BinData::Primitive
-        default_parameter :arg1 => 5
-
-        uint8 :a, :value => :arg1
-        def get; self.a; end
-        def set(v); self.a = v; end
-      end
-    END
+  class DefaultPrimitive < BinData::Primitive
+    default_parameter :arg1 => 5
+
+    uint8 :a, :value => :arg1
+    def get; self.a; end
+    def set(v); self.a = v; end
   end
 
   it "should not raise error if default parameter is not supplied" do

data/spec/record_spec.rb

@@ -6,69 +6,55 @@ require 'bindata'
 describe BinData::Record, "when defining" do
   it "should fail on non registered types" do
     lambda {
-      eval <<-END
-        class BadTypeRecord < BinData::Record
-          non_registerd_type :a
-        end
-      END
+      class BadTypeRecord < BinData::Record
+        non_registerd_type :a
+      end
     }.should raise_error(TypeError)
   end
 
   it "should fail on duplicate names" do
     lambda {
-      eval <<-END
-        class DuplicateNameRecord < BinData::Record
-          int8 :a
-          int8 :b
-          int8 :a
-        end
-      END
+      class DuplicateNameRecord < BinData::Record
+        int8 :a
+        int8 :b
+        int8 :a
+      end
     }.should raise_error(SyntaxError)
   end
 
   it "should fail on reserved names" do
     lambda {
-      eval <<-END
-        class ReservedNameRecord < BinData::Record
-          int8 :a
-          int8 :invert # from Hash.instance_methods
-        end
-      END
+      class ReservedNameRecord < BinData::Record
+        int8 :a
+        int8 :invert # from Hash.instance_methods
+      end
     }.should raise_error(NameError)
   end
 
   it "should fail when field name shadows an existing method" do
     lambda {
-      eval <<-END
-        class ExistingNameRecord < BinData::Record
-          int8 :object_id
-        end
-      END
+      class ExistingNameRecord < BinData::Record
+        int8 :object_id
+      end
     }.should raise_error(NameError)
   end
 
   it "should fail on unknown endian" do
     lambda {
-      eval <<-END
-        class BadEndianRecord < BinData::Record
-          endian 'a bad value'
-        end
-      END
+      class BadEndianRecord < BinData::Record
+        endian 'a bad value'
+      end
     }.should raise_error(ArgumentError)
   end
 end
 
 describe BinData::Record, "with hidden fields" do
-  before(:all) do
-    eval <<-END
-      class HiddenRecord < BinData::Record
-        hide :b, 'c'
-        int8 :a
-        int8 'b', :initial_value => 10
-        int8 :c
-        int8 :d, :value => :b
-      end
-    END
+  class HiddenRecord < BinData::Record
+    hide :b, 'c'
+    int8 :a
+    int8 'b', :initial_value => 10
+    int8 :c
+    int8 :d, :value => :b
   end
 
   before(:each) do
@@ -94,13 +80,9 @@ describe BinData::Record, "with hidden fields" do
 end
 
 describe BinData::Record, "with multiple fields" do
-  before(:all) do
-    eval <<-END
-      class MultiFieldRecord < BinData::Record
-        int8 :a
-        int8 :b
-      end
-    END
+  class MultiFieldRecord < BinData::Record
+    int8 :a
+    int8 :b
   end
 
   before(:each) do
@@ -162,24 +144,20 @@ describe BinData::Record, "with multiple fields" do
 end
 
 describe BinData::Record, "with nested structs" do
-  before(:all) do
-    eval <<-END
-      class Inner1Record < BinData::Record
-        int8 :w, :initial_value => 3
-        int8 :x, :value => :the_val
-      end
+  class Inner1Record < BinData::Record
+    int8 :w, :initial_value => 3
+    int8 :x, :value => :the_val
+  end
 
-      class Inner2Record < BinData::Record
-        int8 :y, :value => lambda { parent.b.w }
-        int8 :z
-      end
+  class Inner2Record < BinData::Record
+    int8 :y, :value => lambda { parent.b.w }
+    int8 :z
+  end
 
-      class RecordOuter < BinData::Record
-        int8               :a, :initial_value => 6
-        inner1_record :b, :the_val => :a
-        inner2_record :c
-      end
-    END
+  class RecordOuter < BinData::Record
+    int8               :a, :initial_value => 6
+    inner1_record :b, :the_val => :a
+    inner2_record :c
   end
 
   before(:each) do
@@ -206,19 +184,15 @@ describe BinData::Record, "with nested structs" do
 end
 
 describe BinData::Record, "with an endian defined" do
-  before(:all) do
-    eval <<-END
-      class RecordWithEndian < BinData::Record
-        endian :little
-
-        uint16 :a
-        float  :b
-        array  :c, :type => :int8, :initial_length => 2
-        choice :d, :choices => [ [:uint16], [:uint32] ], :selection => 1
-        struct :e, :fields => [ [:uint16, :f], [:uint32be, :g] ]
-        struct :h, :fields => [ [:struct, :i, {:fields => [[:uint16, :j]]}] ]
-      end
-    END
+  class RecordWithEndian < BinData::Record
+    endian :little
+
+    uint16 :a
+    float  :b
+    array  :c, :type => :int8, :initial_length => 2
+    choice :d, :choices => [ [:uint16], [:uint32] ], :selection => 1
+    struct :e, :fields => [ [:uint16, :f], [:uint32be, :g] ]
+    struct :h, :fields => [ [:struct, :i, {:fields => [[:uint16, :j]]}] ]
   end
 
   before(:each) do
@@ -242,15 +216,11 @@ describe BinData::Record, "with an endian defined" do
 end
 
 describe BinData::Record, "defined recursively" do
-  before(:all) do
-    eval <<-END
-      class RecursiveRecord < BinData::Record
-        endian  :big
-        uint16  :val
-        uint8   :has_nxt, :value => lambda { nxt.clear? ? 0 : 1 }
-        recursive_record :nxt, :onlyif => lambda { has_nxt > 0 }
-      end
-    END
+  class RecursiveRecord < BinData::Record
+    endian  :big
+    uint16  :val
+    uint8   :has_nxt, :value => lambda { nxt.clear? ? 0 : 1 }
+    recursive_record :nxt, :onlyif => lambda { has_nxt > 0 }
   end
 
   it "should be able to be created" do
@@ -282,14 +252,10 @@ describe BinData::Record, "defined recursively" do
 end
 
 describe BinData::Record, "with custom mandatory parameters" do
-  before(:all) do
-    eval <<-END
-      class MandatoryRecord < BinData::Record
-        mandatory_parameter :arg1
+  class MandatoryRecord < BinData::Record
+    mandatory_parameter :arg1
 
-        uint8 :a, :value => :arg1
-      end
-    END
+    uint8 :a, :value => :arg1
   end
 
   it "should raise error if mandatory parameter is not supplied" do
@@ -303,14 +269,10 @@ describe BinData::Record, "with custom mandatory parameters" do
 end
 
 describe BinData::Record, "with custom default parameters" do
-  before(:all) do
-    eval <<-END
-      class DefaultRecord < BinData::Record
-        default_parameter :arg1 => 5
+  class DefaultRecord < BinData::Record
+    default_parameter :arg1 => 5
 
-        uint8 :a, :value => :arg1
-      end
-    END
+    uint8 :a, :value => :arg1
   end
 
   it "should not raise error if default parameter is not supplied" do
@@ -329,14 +291,10 @@ describe BinData::Record, "with custom default parameters" do
 end
 
 describe BinData::Record, "with :onlyif" do
-  before(:all) do
-    eval <<-END
-      class OnlyIfRecord < BinData::Record
-        uint8 :a, :initial_value => 3
-        uint8 :b, :initial_value => 5, :onlyif => lambda { a == 3 }
-        uint8 :c, :initial_value => 7, :onlyif => lambda { a != 3 }
-      end
-    END
+  class OnlyIfRecord < BinData::Record
+    uint8 :a, :initial_value => 3
+    uint8 :b, :initial_value => 5, :onlyif => lambda { a == 3 }
+    uint8 :c, :initial_value => 7, :onlyif => lambda { a != 3 }
   end
 
   before(:each) do