bindata 0.5.0 → 0.5.1

data/ChangeLog

@@ -1,9 +1,10 @@
 = BinData Changelog
 
-== Version THE_NEXT_VERSION
+== Version 0.5.1 (2007-03-21)
 
-Updated documentation.
+* Updated documentation.
+* Struct now raises an error if a field name shadows an existing method.
 
 == Version 0.5.0 (2007-03-14)
 
-Initial public release.
+* Initial public release.

data/README

@@ -50,11 +50,11 @@ The structure of the data in this example is
 
 The BinData declaration matches the english description closely.  Just for
 fun, lets look at how we'd implement this using #pack and #unpack.  Here's
-the writing function, have a go at the reading function.
+the writing code, have a go at the reading code.
 
-  def write_my_fancy_format(io, comment, some_ints)
-    comment = "this is a comment"
-    some_ints = [2, 3, 8, 9, 1, 8]
+  comment = "this is a comment"
+  some_ints = [2, 3, 8, 9, 1, 8]
+  File.open(...) do |io|
     io.write([comment, some_ints.size, *some_ints].pack("Z*CN*"))
   end
 
@@ -67,9 +67,9 @@ fields.
     ...
   end
 
-*type* is the name of a supplied type (e.g. +uint32be+,  +string+) or a
-user defined type.  For user defined types, convert the class name from
-CamelCase to lowercase underscore_style.
+*type* is the name of a supplied type (e.g. <tt>uint32be</tt>,  +string+)
+or a user defined type.  For user defined types, convert the class name
+from CamelCase to lowercase underscore_style.
 
 *field_name* is the name by which you can access the data.  Use either a
 String or a Symbol.  You may specify a name as nil, but this is described

data/TODO

@@ -11,4 +11,3 @@
 
 * Think how offset_of should work.
 
-* Raise error when a struct defines a name of an existing method

data/lib/bindata.rb

@@ -9,5 +9,5 @@ require 'bindata/stringz'
 require 'bindata/struct'
 
 module BinData
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/bindata/struct.rb

@@ -87,6 +87,12 @@ module BinData
           raise SyntaxError, "duplicate field '#{name}' in #{self}", caller
         end
 
+        # check that name doesn't shadow an existing method
+        if self.instance_methods.include?(name)
+          raise NameError.new("", name),
+                "field '#{name}' shadows an existing method", caller
+        end
+
         # remember this field.  These fields will be recalled upon creating
         # an instance of this class
         @fields.push([type, name, params])
@@ -110,6 +116,9 @@ module BinData
       @fields = param(:fields).collect do |type, name, params|
         klass = self.class.lookup(type)
         raise TypeError, "unknown type '#{type}' for #{self}" if klass.nil?
+        if methods.include?(name)
+          raise NameError.new("field '#{name}' shadows an existing method",name)
+        end
         [name, klass.new(params, create_env)]
       end
     end

data/spec/array_spec.rb

@@ -28,20 +28,20 @@ context "An Array with several elements" do
   end
 
   specify "should return a correct snapshot" do
-    @data.snapshot.should == [1, 2, 3, 4, 5]
+    @data.snapshot.should eql([1, 2, 3, 4, 5])
   end
 
   specify "should have correct num elements" do
-    @data.length.should == 5
-    @data.size.should == 5
+    @data.length.should eql(5)
+    @data.size.should eql(5)
   end
 
   specify "should have correct num_bytes" do
-    @data.num_bytes.should == 10
+    @data.num_bytes.should eql(10)
   end
 
   specify "should have correct num_bytes for individual elements" do
-    @data.num_bytes(0).should == 2
+    @data.num_bytes(0).should eql(2)
   end
 
   specify "should have no field_names" do
@@ -50,23 +50,23 @@ context "An Array with several elements" do
 
   specify "should be able to directly access elements" do
     @data[1] = 8
-    @data[1].should == 8
+    @data[1].should eql(8)
   end
 
   specify "should be able to use methods from Enumerable" do
-    @data.select { |x| (x % 2) == 0 }.should == [2, 4]
+    @data.select { |x| (x % 2) == 0 }.should eql([2, 4])
   end
 
   specify "should clear" do
     @data[1] = 8
     @data.clear
-    @data.collect.should == [1, 2, 3, 4, 5]
+    @data.collect.should eql([1, 2, 3, 4, 5])
   end
 
   specify "should clear a single element" do
     @data[1] = 8
     @data.clear(1)
-    @data[1].should == 2
+    @data[1].should eql(2)
   end
 
   specify "should be clear upon creation" do
@@ -92,10 +92,10 @@ context "An Array with several elements" do
 
     @data.clear
     io.rewind
-    @data[1].should == 2
+    @data[1].should eql(2)
 
     @data.read(io)
-    @data[1].should == 8
+    @data[1].should eql(8)
   end
 end
 
@@ -108,7 +108,7 @@ context "An Array containing structs" do
   end
 
   specify "should access elements, not values" do
-    @data[3].a.should == 3
+    @data[3].a.should eql(3)
   end
 
   specify "should not be able to modify elements" do
@@ -116,6 +116,6 @@ context "An Array containing structs" do
   end
 
   specify "should interate over each element" do
-    @data.collect { |s| s.a }.should == [0, 1, 2, 3, 4]
+    @data.collect { |s| s.a }.should eql([0, 1, 2, 3, 4])
   end
 end

data/spec/base_spec.rb

@@ -80,16 +80,16 @@ context "A data object with parameters" do
 
   specify "should evaluate mandatory and optional parameters" do
     obj = WithParam.new(:p1 => 1, :p3 => lambda {1 + 2}, :p4 => 4, :p5 => 5)
-    obj.eval_param(:p1).should == 1
+    obj.eval_param(:p1).should eql(1)
     obj.eval_param(:p2).should_be_nil
-    obj.eval_param(:p3).should == 3
+    obj.eval_param(:p3).should eql(3)
     obj.eval_param(:p4).should_be_nil
     obj.eval_param(:p5).should_be_nil
   end
 
   specify "should be able to access without evaluating" do
     obj = WithParam.new(:p1 => :asym, :p3 => lambda {1 + 2})
-    obj.param(:p1).should == :asym
+    obj.param(:p1).should eql(:asym)
     obj.param(:p2).should_be_nil
     obj.param(:p3).should respond_to(:arity)
   end
@@ -164,17 +164,17 @@ context "A data object with :readwrite => false" do
   specify "should not read" do
     io = StringIO.new("12345678901234567890")
     @obj.read(io)
-    @obj._do_read.should_not == true
+    @obj._do_read.should_not eql(true)
   end
 
   specify "should not write" do
     io = StringIO.new
     @obj.write(io)
-    @obj._do_write.should_not == true
+    @obj._do_write.should_not eql(true)
   end
 
   specify "should have zero num_bytes" do
-    @obj.num_bytes.should == 0
+    @obj.num_bytes.should eql(0)
   end
 end
 

data/spec/choice_spec.rb

@@ -40,15 +40,15 @@ context "A Choice with several choices" do
 
   specify "should be able to select the choice" do
     @env.choose = 0
-    @data.value.should == 3
+    @data.value.should eql(3)
     @env.choose = 1
-    @data.value.should == 5
+    @data.value.should eql(5)
     @env.choose = 2
-    @data.value.should == 0
+    @data.value.should eql(0)
     @env.choose = 3
-    @data.a.should == 0
+    @data.a.should eql(0)
     @env.choose = 4
-    @data.value.should == 7
+    @data.value.should eql(7)
   end
 
   specify "should not be able to select an invalid choice" do
@@ -61,7 +61,7 @@ context "A Choice with several choices" do
   specify "should be able to interact directly with the choice" do
     @env.choose = 0
     @data.value = 17
-    @data.value.should == 17
+    @data.value.should eql(17)
   end
 
   specify "should handle missing methods correctly" do
@@ -77,29 +77,29 @@ context "A Choice with several choices" do
     @data.value = 17
 
     @data.find_obj_for_name("does_not_exist").should be_nil
-    @data.num_bytes.should == 2
+    @data.num_bytes.should eql(2)
     @data.field_names.should be_empty
-    @data.value.should == 17
+    @data.value.should eql(17)
 
     io = StringIO.new
     @data.write(io)
 
     @data.clear
     @data.clear?.should be_true
-    @data.value.should == 5
+    @data.value.should eql(5)
 
     io.rewind
     @data.read(io)
-    @data.value.should == 17
+    @data.value.should eql(17)
 
-    @data.snapshot.should == 17
+    @data.snapshot.should eql(17)
   end
 
   specify "should delegate methods to the selected complex choice" do
     @env.choose = 3
     @data.find_obj_for_name("a").should_not be_nil
-    @data.field_names.should == ["a"]
-    @data.num_bytes.should == 1
+    @data.field_names.should eql(["a"])
+    @data.num_bytes.should eql(1)
   end
 end
 

data/spec/int_spec.rb

@@ -10,7 +10,7 @@ context "All signed integers" do
      BinData::Int16be,
      BinData::Int32le,
      BinData::Int32be].each do |klass|
-      klass.new.value.should == 0
+      klass.new.value.should eql(0)
     end
   end
 
@@ -36,7 +36,7 @@ context "All unsigned integers" do
      BinData::Uint16be,
      BinData::Uint32le,
      BinData::Uint32be].each do |klass|
-      klass.new.value.should == 0
+      klass.new.value.should eql(0)
     end
   end
 
@@ -60,7 +60,7 @@ def test_read_write(klass, val, clamped_val, str)
   # set the data and ensure clamping occurs
   data = klass.new
   data.value = val
-  data.value.should == clamped_val
+  data.value.should eql(clamped_val)
   
   # write the data
   io = StringIO.new
@@ -68,13 +68,13 @@ def test_read_write(klass, val, clamped_val, str)
 
   # check that we write the expected byte pattern
   io.rewind
-  io.read.should == str
+  io.read.should eql(str)
 
   # check that we read in the same data that was written
   io.rewind
   data = klass.new
   data.read(io)
-  data.value.should == clamped_val
+  data.value.should eql(clamped_val)
 end
 
 # return test data for testing unsigned ints

data/spec/lazy_spec.rb

@@ -31,17 +31,17 @@ context "A single environment" do
   end
 
   specify "should evaluate value" do
-    @e1.lazy_eval(lambda { value }).should == 'v1'
+    @e1.lazy_eval(lambda { value }).should eql('v1')
   end
 
   specify "should evaluate index" do
     @e1.index = 7
-    @e1.lazy_eval(lambda { index }).should == 7
+    @e1.lazy_eval(lambda { index }).should eql(7)
   end
 
   specify "should evaluate offset" do
     @e1.offset = 9
-    @e1.lazy_eval(lambda { offset }).should == 9
+    @e1.lazy_eval(lambda { offset }).should eql(9)
   end
 
   specify "should not resolve any unknown fields" do
@@ -53,9 +53,9 @@ context "A single environment" do
   specify "should accept symbols as a shortcut to lambda" do
     @e1.index  = 7
     @e1.offset = 9
-    @e1.lazy_eval(:value).should == 'v1'
-    @e1.lazy_eval(:index).should == 7
-    @e1.lazy_eval(:offset).should == 9
+    @e1.lazy_eval(:value).should eql('v1')
+    @e1.lazy_eval(:index).should eql(7)
+    @e1.lazy_eval(:offset).should eql(9)
   end
 end
 
@@ -74,15 +74,15 @@ context "An environment with one parent" do
   end
 
   specify "should evaluate parent parameter" do
-    @e1.lazy_eval(:p2).should == 'p2'
+    @e1.lazy_eval(:p2).should eql('p2')
   end
 
   specify "should evaluate parent field" do
-    @e1.lazy_eval(:f2).should == 'f2'
+    @e1.lazy_eval(:f2).should eql('f2')
   end
 
   specify "should prefer parent param over parent field" do
-    @e1.lazy_eval(:common).should == 'param2'
+    @e1.lazy_eval(:common).should eql('param2')
   end
 end
 
@@ -109,12 +109,12 @@ context "A nested environment" do
   end
 
   specify "should access parent environments" do
-    @e1.lazy_eval(lambda { parent.p3 }).should == 'p3'
-    @e1.lazy_eval(lambda { parent.parent.p4 }).should == 'p4'
+    @e1.lazy_eval(lambda { parent.p3 }).should eql('p3')
+    @e1.lazy_eval(lambda { parent.parent.p4 }).should eql('p4')
   end
 
   specify "should cascade lambdas" do
-    @e1.lazy_eval(lambda { l2 }).should == 'l4'
-    @e1.lazy_eval(lambda { s2 }).should == 's4'
+    @e1.lazy_eval(lambda { l2 }).should eql('l4')
+    @e1.lazy_eval(lambda { s2 }).should eql('s4')
   end
 end

data/spec/registry_spec.rb

@@ -18,8 +18,8 @@ context "The Registry" do
     @r.register('ASubClass', A)
     @r.register('AnotherSubClass', B)
 
-    @r.lookup('a_sub_class').should == A
-    @r.lookup('another_sub_class').should == B
+    @r.lookup('a_sub_class').should eql(A)
+    @r.lookup('another_sub_class').should eql(B)
   end
 
   specify "should not lookup unregistered names" do
@@ -27,21 +27,21 @@ context "The Registry" do
   end
 
   specify "should convert CamelCase to underscores" do
-    @r.register('CamelCase', A).should == 'camel_case'
+    @r.register('CamelCase', A).should eql('camel_case')
   end
 
   specify "should convert adjacent caps camelCase to underscores" do
-    @r.register('XYZCamelCase', A).should == 'xyz_camel_case'
+    @r.register('XYZCamelCase', A).should eql('xyz_camel_case')
   end
 
   specify "should ignore the outer nestings of classes" do
-    @r.register('A::B::C', A).should == 'c'
+    @r.register('A::B::C', A).should eql('c')
   end
 
   specify "should allow overriding of registered classes" do
     @r.register('A', A)
     @r.register('A', B)
 
-    @r.lookup('a').should == B
+    @r.lookup('a').should eql(B)
   end
 end

data/spec/single_spec.rb

@@ -22,18 +22,18 @@ context "The sample implementation of Single" do
     io.rewind
     data = ConcreteSingle.new
     data.read(io)
-    data.value.should == 42
+    data.value.should eql(42)
   end
 end
 
 context "The class Single" do
   specify "should register subclasses" do
-    BinData::Single.lookup(:concrete_single).should == ConcreteSingle
+    BinData::Single.lookup(:concrete_single).should eql(ConcreteSingle)
   end
 
   specify "should read and return a value" do
     io = StringIO.new([123456].pack("V"))
-    ConcreteSingle.read(io).should == 123456
+    ConcreteSingle.read(io).should eql(123456)
     data = ConcreteSingle.new
   end
 end
@@ -42,7 +42,7 @@ context "A Single object" do
   specify "should conform to rule 1 for returning a value" do
     data = ConcreteSingle.new(:value => 5)
     data.should_not be_in_read
-    data.value.should == 5
+    data.value.should eql(5)
   end
 
   specify "should conform to rule 2 for returning a value" do
@@ -50,33 +50,33 @@ context "A Single object" do
     data = ConcreteSingle.new(:value => 5)
     data.do_read(io)
     data.should be_in_read
-    data.value.should == 42
+    data.value.should eql(42)
   end
 
   specify "should conform to rule 3 for returning a value" do
     data = ConcreteSingle.new(:initial_value => 5)
     data.should be_clear
-    data.value.should == 5
+    data.value.should eql(5)
   end
 
   specify "should conform to rule 4 for returning a value" do
     data = ConcreteSingle.new(:initial_value => 5)
     data.value = 17
     data.should_not be_clear
-    data.value.should == 17
+    data.value.should eql(17)
   end
 
   specify "should conform to rule 5 for returning a value" do
     data = ConcreteSingle.new
     data.should be_clear
-    data.value.should == 0
+    data.value.should eql(0)
   end
 
   specify "should conform to rule 6 for returning a value" do
     data = ConcreteSingle.new
     data.value = 8
     data.should_not be_clear
-    data.value.should == 8
+    data.value.should eql(8)
   end
 end
 
@@ -91,12 +91,12 @@ context "A new Single object" do
   end
 
   specify "should have a sensible value" do
-    @data.value.should == 0
+    @data.value.should eql(0)
   end
 
   specify "should allowing setting and retrieving value" do
     @data.value = 5
-    @data.value.should == 5
+    @data.value.should eql(5)
   end
 
   specify "should be clear" do
@@ -115,7 +115,7 @@ context "A new Single object" do
   end
 
   specify "should return num_bytes" do
-    @data.num_bytes.should == 4
+    @data.num_bytes.should eql(4)
   end
 
   specify "should not contain any field names" do
@@ -124,7 +124,7 @@ context "A new Single object" do
 
   specify "should return a snapshot" do
     @data.value = 5
-    @data.snapshot.should == 5
+    @data.snapshot.should eql(5)
   end
 end
 
@@ -134,24 +134,24 @@ context "A Single with :initial_value" do
   end
 
   specify "should return that initial value before reading or being set" do
-    @data.value.should == 5
+    @data.value.should eql(5)
   end
 
   specify "should forget :initial_value after being set" do
     @data.value = 17
-    @data.value.should_not == 5
+    @data.value.should_not eql(5)
   end
 
   specify "should forget :initial_value after reading" do
     io = StringIO.new([56].pack("V"))
     @data.read(io)
-    @data.value.should_not == 5
+    @data.value.should_not eql(5)
   end
 
   specify "should remember :initial_value after being cleared" do
     @data.value = 17
     @data.clear
-    @data.value.should == 5
+    @data.value.should eql(5)
   end
 end
 
@@ -161,25 +161,25 @@ context "A Single with :value" do
   end
 
   specify "should return that :value" do
-    @data.value.should == 5
+    @data.value.should eql(5)
   end
 
   specify "should change during reading" do
     io = StringIO.new([56].pack("V"))
     @data.do_read(io)
-    @data.value.should == 56
+    @data.value.should eql(56)
     @data.done_read
   end
 
   specify "should not change after reading" do
     io = StringIO.new([56].pack("V"))
     @data.read(io)
-    @data.value.should == 5
+    @data.value.should eql(5)
   end
 
   specify "should not be able to change the value" do
     @data.value = 17
-    @data.value.should == 5
+    @data.value.should eql(5)
   end
 end
 

data/spec/string_spec.rb

@@ -31,29 +31,29 @@ context "A String with :initial_length" do
   end
 
   specify "should set num_bytes" do
-    @str.num_bytes.should == 5
+    @str.num_bytes.should eql(5)
   end
 
   specify "should fill value with pad_char" do
-    @str.value.should == "\0\0\0\0\0"
+    @str.value.should eql("\0\0\0\0\0")
   end
 
   specify "should read :initial_length bytes" do
     io = StringIO.new("abcdefghij")
     @str.read(io)
-    @str.value.should == "abcde"
+    @str.value.should eql("abcde")
   end
 
   specify "should forget :initial_length after value is set" do
     @str.value = "abc"
-    @str.num_bytes.should == 3
+    @str.num_bytes.should eql(3)
   end
 
   specify "should remember :initial_length after value is cleared" do
     @str.value = "abc"
-    @str.num_bytes.should == 3
+    @str.num_bytes.should eql(3)
     @str.clear
-    @str.num_bytes.should == 5
+    @str.num_bytes.should eql(5)
   end
 end
 
@@ -63,37 +63,37 @@ context "A String with :length" do
   end
 
   specify "should set num_bytes" do
-    @str.num_bytes.should == 5
+    @str.num_bytes.should eql(5)
   end
 
   specify "should fill value with pad_char" do
-    @str.value.should == "\0\0\0\0\0"
+    @str.value.should eql("\0\0\0\0\0")
   end
 
   specify "should retain :length after value is set" do
     @str.value = "abcdefghij"
-    @str.num_bytes.should == 5
+    @str.num_bytes.should eql(5)
   end
 
   specify "should read :length bytes" do
     io = StringIO.new("abcdefghij")
     @str.read(io)
-    @str.value.should == "abcde"
+    @str.value.should eql("abcde")
   end
 
   specify "should pad values less than :length" do
     @str.value = "abc"
-    @str.value.should == "abc\0\0"
+    @str.value.should eql("abc\0\0")
   end
 
   specify "should accept values exactly :length" do
     @str.value = "abcde"
-    @str.value.should == "abcde"
+    @str.value.should eql("abcde")
   end
 
   specify "should truncate values greater than :length" do
     @str.value = "abcdefg"
-    @str.value.should == "abcde"
+    @str.value.should eql("abcde")
   end
 end
 
@@ -103,31 +103,31 @@ context "A String with :initial_length and :value" do
   end
 
   specify "should use :initial_length before value is read" do
-    @str.num_bytes.should == 5
-    @str.value.should == "abcde"
+    @str.num_bytes.should eql(5)
+    @str.value.should eql("abcde")
   end
 
   specify "should use :initial_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    io.pos.should == 5
+    io.pos.should eql(5)
    end
 
   specify "should forget :initial_length after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    @str.num_bytes.should == 10
-    @str.value.should == "abcdefghij"
+    @str.num_bytes.should eql(10)
+    @str.value.should eql("abcdefghij")
   end
 
   specify "should return read value before calling done_read" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
 
     @str.do_read(io)
-    @str.value.should == "ABCDE"
+    @str.value.should eql("ABCDE")
 
     @str.done_read
-    @str.value.should == "abcdefghij"
+    @str.value.should eql("abcdefghij")
   end
 end
 
@@ -137,16 +137,16 @@ context "A String with :length and :initial_value" do
   end
 
   specify "should apply :length to :initial_value" do
-    @str.num_bytes.should == 5
-    @str.value.should == "abcde"
+    @str.num_bytes.should eql(5)
+    @str.value.should eql("abcde")
   end
 
   specify "should forget :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    io.pos.should == 5
-    @str.num_bytes.should == 5
-    @str.value.should == "ABCDE"
+    io.pos.should eql(5)
+    @str.num_bytes.should eql(5)
+    @str.value.should eql("ABCDE")
   end
 end
 
@@ -154,13 +154,13 @@ context "A String with :pad_char" do
   specify "should accept a numeric value for :pad_char" do
     @str = BinData::String.new(:length => 5, :pad_char => 6)
     @str.value = "abc"
-    @str.value.should == "abc\x06\x06"
+    @str.value.should eql("abc\x06\x06")
   end
 
   specify "should accept a character for :pad_char" do
     @str = BinData::String.new(:length => 5, :pad_char => "R")
     @str.value = "abc"
-    @str.value.should == "abcRR"
+    @str.value.should eql("abcRR")
   end
 
   specify "should not accept a string for :pad_char" do
@@ -175,31 +175,31 @@ context "A String with :trim_value" do
     str2 = BinData::String.new(:length => 5, :trim_value => false)
     str1.value = "abc"
     str2.value = "abc"
-    str1.value.should == "abc\0\0"
-    str2.value.should == "abc\0\0"
+    str1.value.should eql("abc\0\0")
+    str2.value.should eql("abc\0\0")
   end
 
   specify "should trim the value" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
-    str.value.should == "abc"
+    str.value.should eql("abc")
   end
 
   specify "should not affect num_bytes" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
-    str.num_bytes.should == 5
+    str.num_bytes.should eql(5)
   end
 
   specify "should trim if last char is :pad_char" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
-    str.value.should == "abc"
+    str.value.should eql("abc")
   end
 
   specify "should not trim if value contains :pad_char not at the end" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRRde"
-    str.value.should == "abcRRde"
+    str.value.should eql("abcRRde")
   end
 end

data/spec/stringz_spec.rb

@@ -9,18 +9,18 @@ context "An empty Stringz data object" do
   end
 
   specify "should include the zero byte in num_bytes total" do
-    @str.num_bytes.should == 1
+    @str.num_bytes.should eql(1)
   end
 
   specify "should not append the zero byte terminator to the value" do
-    @str.value.should == ""
+    @str.value.should eql("")
   end
 
   specify "should write the zero byte terminator" do
     io = StringIO.new
     @str.write(io)
     io.rewind
-    io.read.should == "\0"
+    io.read.should eql("\0")
   end
 end
 
@@ -31,18 +31,18 @@ context "A Stringz data object with value set" do
   end
 
   specify "should include the zero byte in num_bytes total" do
-    @str.num_bytes.should == 5
+    @str.num_bytes.should eql(5)
   end
 
   specify "should not append the zero byte terminator to the value" do
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 
   specify "should write the zero byte terminator" do
     io = StringIO.new
     @str.write(io)
     io.rewind
-    io.read.should == "abcd\0"
+    io.read.should eql("abcd\0")
   end
 end
 
@@ -54,15 +54,15 @@ context "Reading with a Stringz data object" do
   specify "should stop at the first zero byte" do
     io = StringIO.new("abcd\0xyz\0")
     @str.read(io)
-    @str.value.should == "abcd"
-    io.read(1).should == "x"
+    @str.value.should eql("abcd")
+    io.read(1).should eql("x")
   end
 
   specify "should handle a zero length string" do
     io = StringIO.new("\0abcd")
     @str.read(io)
-    @str.value.should == ""
-    io.read(1).should == "a"
+    @str.value.should eql("")
+    io.read(1).should eql("a")
   end
 
   specify "should fail if no zero byte is found" do
@@ -78,27 +78,27 @@ context "Setting the value of a Stringz data object" do
 
   specify "should include the zero byte in num_bytes total" do
     @str.value = "abcd"
-    @str.num_bytes.should == 5
+    @str.num_bytes.should eql(5)
   end
 
   specify "should accept empty strings" do
     @str.value = ""
-    @str.value.should == ""
+    @str.value.should eql("")
   end
 
   specify "should accept strings that aren't zero terminated" do
     @str.value = "abcd"
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 
   specify "should accept strings that are zero terminated" do
     @str.value = "abcd\0"
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 
   specify "should accept up to the first zero byte" do
     @str.value = "abcd\0xyz\0"
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 end
 
@@ -110,35 +110,35 @@ context "A Stringz data object with max_length" do
   specify "should read less than max_length" do
     io = StringIO.new("abc\0xyz")
     @str.read(io)
-    @str.value.should == "abc"
+    @str.value.should eql("abc")
   end
 
   specify "should read exactly max_length" do
     io = StringIO.new("abcd\0xyz")
     @str.read(io)
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 
   specify "should read no more than max_length" do
     io = StringIO.new("abcdefg\0xyz")
     @str.read(io)
-    @str.value.should == "abcd"
-    io.read(1).should == "f"
+    @str.value.should eql("abcd")
+    io.read(1).should eql("f")
   end
 
   specify "should accept values less than max_length" do
     @str.value = "abc"
-    @str.value.should == "abc"
+    @str.value.should eql("abc")
   end
 
   specify "should accept values exactly max_length" do
     @str.value = "abcd"
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 
   specify "should trim values greater than max_length" do
     @str.value = "abcde"
-    @str.value.should == "abcd"
+    @str.value.should eql("abcd")
   end
 
   specify "should write values less than max_length" do
@@ -146,7 +146,7 @@ context "A Stringz data object with max_length" do
     @str.value = "abc"
     @str.write(io)
     io.rewind
-    io.read.should == "abc\0"
+    io.read.should eql("abc\0")
   end
 
   specify "should write values exactly max_length" do
@@ -154,6 +154,6 @@ context "A Stringz data object with max_length" do
     @str.value = "abcd"
     @str.write(io)
     io.rewind
-    io.read.should == "abcd\0"
+    io.read.should eql("abcd\0")
   end
 end

data/spec/struct_spec.rb

@@ -23,9 +23,9 @@ context "A Struct with hidden fields" do
   end
 
   specify "should be able to access hidden fields directly" do
-    @obj.b.should == 10
+    @obj.b.should eql(10)
     @obj.c = 15
-    @obj.c.should == 15
+    @obj.c.should eql(15)
 
     @obj.should respond_to?(:b=)
   end
@@ -58,6 +58,20 @@ context "Defining a Struct" do
       END
     }.should raise_error(SyntaxError)
   end
+
+  specify "should fail when field name shadows an existing method" do
+    lambda {
+      eval <<-END
+        class ExistingName < BinData::Struct
+          int8 :object_id
+        end
+      END
+    }.should raise_error(NameError)
+
+    lambda {
+      BinData::Struct.new(:fields => [[:int8, :object_id]])
+    }.should raise_error(NameError)
+  end
 end
 
 context "A Struct with multiple fields" do
@@ -69,9 +83,9 @@ context "A Struct with multiple fields" do
   end
 
   specify "should return num_bytes" do
-    @obj.num_bytes(:a).should == 1
-    @obj.num_bytes(:b).should == 1
-    @obj.num_bytes.should == 2
+    @obj.num_bytes(:a).should eql(1)
+    @obj.num_bytes(:b).should eql(1)
+    @obj.num_bytes.should     eql(2)
   end
 
   specify "should clear" do
@@ -93,21 +107,21 @@ context "A Struct with multiple fields" do
     @obj.write(io)
 
     io.rewind
-    io.read.should == "\x01\x02"
+    io.read.should eql("\x01\x02")
   end
 
   specify "should read ordered" do
     io = StringIO.new "\x03\x04"
     @obj.read(io)
 
-    @obj.a.should == 3
-    @obj.b.should == 4
+    @obj.a.should eql(3)
+    @obj.b.should eql(4)
   end
 
   specify "should return a snapshot" do
     snap = @obj.snapshot
-    snap.a.should == 1
-    snap.b.should == 2
+    snap.a.should eql(1)
+    snap.b.should eql(2)
     snap.should == { "a" => 1, "b" => 2 }
   end
 
@@ -175,16 +189,16 @@ context "A Struct with nested structs" do
   end
 
   specify "should access nested fields" do
-    @obj.a.should == 6
-    @obj.b.w.should == 3
-    @obj.b.x.should == 6
-    @obj.y.should == 3
+    @obj.a.should   eql(6)
+    @obj.b.w.should eql(3)
+    @obj.b.x.should eql(6)
+    @obj.y.should   eql(3)
   end
 
   specify "should return correct offset of" do
-    @obj.offset_of("b").should == 1
-    @obj.offset_of("y").should == 3
-    @obj.offset_of("z").should == 4
+    @obj.offset_of("b").should eql(1)
+    @obj.offset_of("y").should eql(3)
+    @obj.offset_of("z").should eql(4)
   end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: bindata
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
-date: 2007-03-16 00:00:00 +09:00
+  version: 0.5.1
+date: 2007-03-21 00:00:00 +09:00
 summary: A declarative way to read and write binary file formats
 require_paths: 
 - lib