bindata 0.11.1 → 1.0.0

data/spec/array_spec.rb

@@ -15,7 +15,7 @@ describe BinData::Array, "when instantiating" do
 
   it "should fail if a given type is unknown" do
     args = {:type => :does_not_exist, :initial_length => 3}
-    lambda { BinData::Array.new(args) }.should raise_error(TypeError)
+    lambda { BinData::Array.new(args) }.should raise_error(BinData::UnknownTypeError)
   end
 
   it "should not allow both :initial_length and :read_until" do

data/spec/base_primitive_spec.rb

@@ -36,10 +36,10 @@ describe BinData::BasePrimitive do
   end
 
   it "should conform to rule 2 for returning a value" do
-    io = StringIO.new([42].pack("V"))
+    io = BinData::IO.new([42].pack("V"))
     data = ExampleSingle.new(:value => 5)
     data.expose_methods_for_testing
-    data.do_read(BinData::IO.new(io))
+    data.do_read(io)
     data.should be_in_read
     data.value.should == 42
   end
@@ -218,14 +218,14 @@ describe BinData::BasePrimitive, "with :value" do
   end
 
   it "should change during reading" do
-    io = StringIO.new([56].pack("V"))
-    @data.do_read(BinData::IO.new(io))
+    io = BinData::IO.new([56].pack("V"))
+    @data.do_read(io)
     @data.value.should == 56
     @data.done_read
   end
 
   it "should not change after reading" do
-    io = StringIO.new([56].pack("V"))
+    io = BinData::IO.new([56].pack("V"))
     @data.read(io)
     @data.value.should == 5
   end
@@ -238,7 +238,7 @@ end
 
 describe BinData::BasePrimitive, "with :check_value" do
   before(:each) do
-    @io = StringIO.new([34].pack("V"))
+    @io = BinData::IO.new([34].pack("V"))
   end
 
   it "should succeed when check_value is non boolean and correct" do

data/spec/base_spec.rb

@@ -10,7 +10,7 @@ class BaseStub < BinData::Base
   def _do_read(io) end
   def _done_read; end
   def _do_write(io) end
-  def _do_num_bytes(x) end
+  def _do_num_bytes; end
   def _assign(x); end
   def _snapshot; end
 
@@ -24,7 +24,7 @@ class MockBaseStub < BaseStub
   def _do_read(io)     mock._do_read(io); end
   def _done_read;      mock._done_read; end
   def _do_write(io)    mock._do_write(io); end
-  def _do_num_bytes(x) mock._do_num_bytes(x) end
+  def _do_num_bytes;   mock._do_num_bytes; end
   def _assign(x);      mock._assign(x); end
   def _snapshot;       mock._snapshot; end
 end
@@ -42,12 +42,10 @@ describe BinData::Base, "when subclassing" do
     lambda { @obj.clear }.should raise_error(NotImplementedError)
     lambda { @obj.clear? }.should raise_error(NotImplementedError)
     lambda { @obj.assign(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.debug_name_of(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.offset_of(nil) }.should raise_error(NotImplementedError)
     lambda { @obj._do_read(nil) }.should raise_error(NotImplementedError)
     lambda { @obj._done_read }.should raise_error(NotImplementedError)
     lambda { @obj._do_write(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj._do_num_bytes(nil) }.should raise_error(NotImplementedError)
+    lambda { @obj._do_num_bytes }.should raise_error(NotImplementedError)
     lambda { @obj._snapshot }.should raise_error(NotImplementedError)
   end
 end
@@ -168,27 +166,6 @@ describe BinData::Base, "with multiple parameters" do
     lambda { WithParamBase.new(:p1 => 1, :p2 => nil) }.should raise_error(ArgumentError)
   end
 
-=begin
-# TODO: how should we evaluate internal parameters? think about this
-  it "should only recall mandatory, default and optional parameters" do
-    obj = WithParamBase.new(:p1 => 1, :p3 => 3, :p4 => 4, :p5 => 5)
-    obj.should     have_param(:p1)
-    obj.should_not have_param(:p2)
-    obj.should     have_param(:p3)
-    obj.should_not have_param(:p4)
-    obj.should_not have_param(:p5)
-  end
-
-  it "should evaluate mandatory, default and optional parameters" do
-    obj = WithParamBase.new(:p1 => 1, :p3 => lambda {1 + 2}, :p4 => 4, :p5 => 5)
-    obj.eval_parameter(:p1).should == 1
-    obj.eval_parameter(:p2).should be_nil
-    obj.eval_parameter(:p3).should == 3
-    obj.eval_parameter(:p4).should be_nil
-    obj.eval_parameter(:p5).should be_nil
-  end
-=end
-
   it "should be able to access without evaluating" do
     obj = WithParamBase.new(:p1 => :asym, :p3 => lambda {1 + 2})
     obj.get_parameter(:p1).should == :asym
@@ -207,7 +184,7 @@ describe BinData::Base, "with :check_offset" do
   end
 
   before(:each) do
-    @io = StringIO.new("12345678901234567890")
+    @io = BinData::IO.create_string_io("12345678901234567890")
   end
 
   it "should fail if offset is incorrect" do
@@ -245,7 +222,7 @@ describe BinData::Base, "with :adjust_offset" do
   end
 
   before(:each) do
-    @io = StringIO.new("12345678901234567890")
+    @io = BinData::IO.create_string_io("12345678901234567890")
   end
 
   it "should be mutually exclusive with :check_offset" do
@@ -317,7 +294,7 @@ describe BinData::Base, "as black box" do
     end
 
     obj = WriteToSBase.new
-    io = StringIO.new
+    io = BinData::IO.create_string_io
     obj.write(io)
     io.rewind
     written = io.read

data/spec/choice_spec.rb

@@ -20,12 +20,12 @@ describe BinData::Choice, "when instantiating" do
 
   it "should fail if a given type is unknown" do
     args = {:choices => [:does_not_exist], :selection => 0}
-    lambda { BinData::Choice.new(args) }.should raise_error(TypeError)
+    lambda { BinData::Choice.new(args) }.should raise_error(BinData::UnknownTypeError)
   end
 
   it "should fail if a given type is unknown" do
     args = {:choices => {0 => :does_not_exist}, :selection => 0}
-    lambda { BinData::Choice.new(args) }.should raise_error(TypeError)
+    lambda { BinData::Choice.new(args) }.should raise_error(BinData::UnknownTypeError)
   end
 
   it "should fail if :choices Hash has a symbol as key" do

data/spec/deprecated_spec.rb

@@ -5,88 +5,19 @@ require File.expand_path(File.join(File.dirname(__FILE__), "example"))
 require 'bindata'
 
 describe BinData::SingleValue, "when defining" do
-  it "should allow inheriting from deprecated SingleValue" do
+  it "should fail when inheriting from deprecated SingleValue" do
     lambda {
       class SubclassSingleValue < BinData::SingleValue
       end
-    }.should_not raise_error
+    }.should raise_error
   end
 end
 
 describe BinData::MultiValue, "when defining" do
-  it "should allow inheriting from deprecated MultiValue" do
+  it "should fail inheriting from deprecated MultiValue" do
     lambda {
       class SubclassMultiValue < BinData::MultiValue
       end
-    }.should_not raise_error
-  end
-end
-
-describe BinData::Array, "with several elements" do
-  before(:each) do
-    type = [:example_single, {:initial_value => lambda { index + 1 }}]
-    @data = BinData::Array.new(:type => type, :initial_length => 5)
-  end
-
-  it "should clear a single element" do
-    @data[1] = 8
-    @data.clear(1)
-    @data[1].should == 2
-  end
-
-  it "should test clear status of individual elements" do
-    @data[1] = 8
-    @data.clear?(0).should be_true
-    @data.clear?(1).should be_false
-  end
-
-  it "should have correct num_bytes for individual elements" do
-    @data.num_bytes(0).should == ExampleSingle.new.num_bytes
-  end
-
-  it "should not extend on clear" do
-    @data.clear(9)
-    @data.length.should == 5
-  end
-
-  it "should not extend on clear?" do
-    @data.clear?(9).should be_true
-    @data.length.should == 5
-  end
-
-  it "should not extend on num_bytes" do
-    @data.num_bytes(9).should == 0
-    @data.length.should == 5
-  end
-end
-
-describe BinData::String, "with deprecated parameters" do
-  it "should substitude :trim_padding for :trim_value" do
-    obj = BinData::String.new(:trim_value => true)
-    obj.value = "abc\0"
-    obj.value.should == "abc"
-  end
-end
-
-describe BinData::Struct, "with multiple fields" do
-  before(:each) do
-    @params = { :fields => [ [:int8, :a], [:int8, :b] ] }
-    @obj = BinData::Struct.new(@params)
-    @obj.a = 1
-    @obj.b = 2
-  end
-
-  it "should return num_bytes" do
-    @obj.num_bytes(:a).should == 1
-    @obj.num_bytes(:b).should == 1
-    @obj.num_bytes.should     == 2
-  end
-
-  it "should clear individual elements" do
-    @obj.a = 6
-    @obj.b = 7
-    @obj.clear(:a)
-    @obj.should be_clear(:a)
-    @obj.should_not be_clear(:b)
+    }.should raise_error
   end
 end

data/spec/io_spec.rb

@@ -172,7 +172,7 @@ end
 
 class BitWriterHelper
   def initialize
-    @stringio = StringIO.new
+    @stringio = BinData::IO.create_string_io
     @io = BinData::IO.new(@stringio)
   end
 

data/spec/record_spec.rb

@@ -3,48 +3,71 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata'
 
+def capture_exception(exception_type, &block)
+  block.call
+rescue Exception => err
+  err.class.should == exception_type
+  return err
+else
+  lambda {}.should raise_error(exception_type)
+end
+
 describe BinData::Record, "when defining" do
   it "should fail on non registered types" do
-    lambda {
+    err = capture_exception(TypeError) {
       class BadTypeRecord < BinData::Record
-        non_registerd_type :a
+        non_registered_type :a
       end
-    }.should raise_error(TypeError)
+    }
+    err.message.should == "unknown type 'non_registered_type' for #{BadTypeRecord}"
+  end
+
+  it "should give correct error message for non registered nested types" do
+    err = capture_exception(TypeError) {
+      class BadNestedTypeRecord < BinData::Record
+        array :a, :type => :non_registered_type
+      end
+    }
+    err.message.should == "unknown type 'non_registered_type' for #{BadNestedTypeRecord}"
   end
 
   it "should fail on duplicate names" do
-    lambda {
+    err = capture_exception(SyntaxError) {
       class DuplicateNameRecord < BinData::Record
         int8 :a
         int8 :b
         int8 :a
       end
-    }.should raise_error(SyntaxError)
+    }
+    err.message.should == "duplicate field 'a' in #{DuplicateNameRecord}"
   end
 
   it "should fail on reserved names" do
-    lambda {
+    err = capture_exception(NameError) {
       class ReservedNameRecord < BinData::Record
         int8 :a
         int8 :invert # from Hash.instance_methods
       end
-    }.should raise_error(NameError)
+    }
+    err.message.should == "field 'invert' is a reserved name in #{ReservedNameRecord}"
   end
 
   it "should fail when field name shadows an existing method" do
-    lambda {
+    err = capture_exception(NameError) {
       class ExistingNameRecord < BinData::Record
         int8 :object_id
       end
-    }.should raise_error(NameError)
+    }
+    err.message.should == "field 'object_id' shadows an existing method in #{ExistingNameRecord}"
   end
 
   it "should fail on unknown endian" do
-    lambda {
+    err = capture_exception(ArgumentError) {
       class BadEndianRecord < BinData::Record
         endian 'a bad value'
       end
-    }.should raise_error(ArgumentError)
+    }
+    err.message.should == "unknown value for endian 'a bad value' in #{BadEndianRecord}"
   end
 end
 
@@ -176,11 +199,20 @@ describe BinData::Record, "with nested structs" do
   end
 
   it "should return correct offset" do
+    @obj.offset.should == 0
     @obj.b.offset.should == 1
     @obj.b.w.offset.should == 1
     @obj.c.offset.should == 3
     @obj.c.z.offset.should == 4
   end
+
+  it "should return correct rel_offset" do
+    @obj.rel_offset.should == 0
+    @obj.b.rel_offset.should == 1
+    @obj.b.w.rel_offset.should == 0
+    @obj.c.rel_offset.should == 3
+    @obj.c.z.rel_offset.should == 1
+  end
 end
 
 describe BinData::Record, "with an endian defined" do

data/spec/struct_spec.rb

@@ -8,7 +8,7 @@ describe BinData::Struct, "when initializing" do
     params = {:fields => [[:non_registered_type, :a]]}
     lambda {
       BinData::Struct.new(params)
-    }.should raise_error(TypeError)
+    }.should raise_error(BinData::UnknownTypeError)
   end
 
   it "should fail on duplicate names" do

data/tasks/manual.rake

@@ -0,0 +1,36 @@
+load_failed = false
+
+begin
+  require 'haml'
+rescue LoadError
+  puts "Haml must be installed to build documentation"
+  load_failed = true
+end
+
+begin
+  require 'maruku'
+rescue LoadError
+  puts "Maruku must be installed to build documentation"
+  load_failed = true
+end
+
+begin
+  require 'syntax'
+rescue LoadError
+  puts "Syntax must be installed to build documentation"
+  load_failed = true
+end
+
+unless load_failed
+  file "manual.html" => ["README", "manual.haml"] do |t|
+    require 'haml/exec'
+
+    opts = Haml::Exec::Haml.new(["manual.haml", "manual.html"])
+    opts.parse!
+  end
+
+  CLOBBER.include("manual.html")
+
+  desc "Build the reference manual"
+  task :manual => "manual.html"
+end

data/tasks/pkg.rake

@@ -13,8 +13,8 @@ begin
     s.rubyforge_project = 'bindata'
     s.require_path = 'lib'
     s.has_rdoc = true
-    s.extra_rdoc_files = ['README']
-    s.rdoc_options << '--main' << 'README'
+    s.extra_rdoc_files = ['NEWS']
+    s.rdoc_options << '--main' << 'NEWS'
     s.files = PKG_FILES
   end
 

data/tasks/rdoc.rake

@@ -1,8 +1,8 @@
 require 'rake/rdoctask'
 
 Rake::RDocTask.new() do |rdoc|
-  rdoc.main = "README"
-  rdoc.rdoc_files.include("README", "NEWS")
+  rdoc.main = "NEWS"
+  rdoc.rdoc_files.include("NEWS")
   rdoc.rdoc_files.include("lib/**/*.rb")
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bindata
 version: !ruby/object:Gem::Version 
-  version: 0.11.1
+  version: 1.0.0
 platform: ruby
 authors: 
 - Dion Mendel
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-29 00:00:00 +08:00
+date: 2009-09-13 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
@@ -20,10 +20,9 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README
+- NEWS
 files: 
 - INSTALL
-- TUTORIAL
 - TODO
 - GPL
 - Rakefile
@@ -32,6 +31,7 @@ files:
 - README
 - ChangeLog
 - examples/gzip.rb
+- examples/ip_address.rb
 - spec/primitive_spec.rb
 - spec/record_spec.rb
 - spec/float_spec.rb
@@ -76,15 +76,17 @@ files:
 - lib/bindata/wrapper.rb
 - lib/bindata.rb
 - tasks/rdoc.rake
+- tasks/manual.rake
 - tasks/pkg.rake
 - tasks/rspec.rake
 - setup.rb
+- manual.haml
 has_rdoc: true
 homepage: http://bindata.rubyforge.org
 post_install_message: 
 rdoc_options: 
 - --main
-- README
+- NEWS
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement