bindata 0.6.0 → 0.7.0

data/spec/base_spec.rb

@@ -3,25 +3,25 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/base'
 
-context "A data object with mandatory option" do
-  context_setup do
+describe "A data object with mandatory option" do
+  before(:all) do
     eval <<-END
       class Mandatory < BinData::Base
         mandatory_parameter :p1
       end
     END
   end
-  specify "should ensure that those options are present" do
+  it "should ensure that those options are present" do
     lambda { Mandatory.new(:p1 => "a") }.should_not raise_error
   end
 
-  specify "should fail when those options are not present" do
+  it "should fail when those options are not present" do
     lambda { Mandatory.new(:p2 => "a") }.should raise_error(ArgumentError)
   end
 end
 
-context "A data object with mutually exclusive options" do
-  context_setup do
+describe "A data object with mutually exclusive options" do
+  before(:all) do
     eval <<-END
       class MutexParam < BinData::Base
         optional_parameters :p1, :p2
@@ -33,22 +33,22 @@ context "A data object with mutually exclusive options" do
     END
   end
 
-  specify "should not fail when neither of those options is present" do
+  it "should not fail when neither of those options is present" do
     lambda { MutexParam.new }.should_not raise_error
   end
 
-  specify "should not fail when only one of those options is present" do
+  it "should not fail when only one of those options is present" do
     lambda { MutexParam.new(:p1 => "a") }.should_not raise_error
     lambda { MutexParam.new(:p2 => "a") }.should_not raise_error
   end
 
-  specify "should fail when both those options are present" do
+  it "should fail when both those options are present" do
     lambda { MutexParam.new(:p1 => "a", :p2 => "b") }.should raise_error(ArgumentError)
   end
 end
 
-context "A data object with parameters" do
-  context_setup do
+describe "A data object with parameters" do
+  before(:all) do
     eval <<-END
       class WithParam < BinData::Base
         mandatory_parameter :p1
@@ -58,18 +58,18 @@ context "A data object with parameters" do
     END
   end
 
-  specify "should not allow nil parameters" do
+  it "should not allow nil parameters" do
     lambda { WithParam.new(:p1 => 1, :p2 => nil) }.should raise_error(ArgumentError)
   end
 
-  specify "should identify extra parameters" do
+  it "should identify extra parameters" do
     env = mock("env")
     env.should_receive(:params=).with(:p4 => 4, :p5 => 5)
     env.should_receive(:data_object=)
     obj = WithParam.new({:p1 => 1, :p3 => 3, :p4 => 4, :p5 => 5}, env)
   end
 
-  specify "should only recall mandatory and optional parameters" do
+  it "should only recall mandatory and optional parameters" do
     obj = WithParam.new(:p1 => 1, :p3 => 3, :p4 => 4, :p5 => 5)
     obj.should     have_param(:p1)
     obj.should_not have_param(:p2)
@@ -78,25 +78,25 @@ context "A data object with parameters" do
     obj.should_not have_param(:p5)
   end
 
-  specify "should evaluate mandatory and optional parameters" do
+  it "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 eql(1)
-    obj.eval_param(:p2).should_be_nil
+    obj.eval_param(:p2).should be_nil
     obj.eval_param(:p3).should eql(3)
-    obj.eval_param(:p4).should_be_nil
-    obj.eval_param(:p5).should_be_nil
+    obj.eval_param(:p4).should be_nil
+    obj.eval_param(:p5).should be_nil
   end
 
-  specify "should be able to access without evaluating" do
+  it "should be able to access without evaluating" do
     obj = WithParam.new(:p1 => :asym, :p3 => lambda {1 + 2})
     obj.param(:p1).should eql(:asym)
-    obj.param(:p2).should_be_nil
+    obj.param(:p2).should be_nil
     obj.param(:p3).should respond_to(:arity)
   end
 end
 
-context "A data object with :check_offset" do
-  context_setup do
+describe "A data object with :check_offset" do
+  before(:all) do
     eval <<-END
       class TenByteOffset < BinData::Base
         def do_read(io)
@@ -111,28 +111,28 @@ context "A data object with :check_offset" do
     END
   end
 
-  specify "should fail if offset is incorrect" do
+  it "should fail if offset is incorrect" do
     io = StringIO.new("12345678901234567890")
     io.seek(2)
     obj = TenByteOffset.new(:check_offset => 8)
     lambda { obj.read(io) }.should raise_error(BinData::ValidityError)
   end
 
-  specify "should succeed if offset is correct" do
+  it "should succeed if offset is correct" do
     io = StringIO.new("12345678901234567890")
     io.seek(3)
     obj = TenByteOffset.new(:check_offset => 10)
     lambda { obj.read(io) }.should_not raise_error
   end
 
-  specify "should fail if :check_offset fails" do
+  it "should fail if :check_offset fails" do
     io = StringIO.new("12345678901234567890")
     io.seek(4)
     obj = TenByteOffset.new(:check_offset => lambda { offset == 11 } )
     lambda { obj.read(io) }.should raise_error(BinData::ValidityError)
   end
 
-  specify "should succeed if :check_offset succeeds" do
+  it "should succeed if :check_offset succeeds" do
     io = StringIO.new("12345678901234567890")
     io.seek(5)
     obj = TenByteOffset.new(:check_offset => lambda { offset == 10 } )
@@ -140,8 +140,8 @@ context "A data object with :check_offset" do
   end
 end
 
-context "A data object with :readwrite => false" do
-  context_setup do
+describe "A data object with :readwrite => false" do
+  before(:all) do
     eval <<-END
       class NoIO < BinData::Base
         def _do_read(io)
@@ -161,25 +161,25 @@ context "A data object with :readwrite => false" do
     @obj = NoIO.new :readwrite => false
   end
 
-  specify "should not read" do
+  it "should not read" do
     io = StringIO.new("12345678901234567890")
     @obj.read(io)
     @obj._do_read.should_not eql(true)
   end
 
-  specify "should not write" do
+  it "should not write" do
     io = StringIO.new
     @obj.write(io)
     @obj._do_write.should_not eql(true)
   end
 
-  specify "should have zero num_bytes" do
+  it "should have zero num_bytes" do
     @obj.num_bytes.should eql(0)
   end
 end
 
-context "A data object defining a value method" do
-  context_setup do
+describe "A data object defining a value method" do
+  before(:all) do
     eval <<-END
       class SingleValueObject < BinData::Base
         def value; end
@@ -187,7 +187,7 @@ context "A data object defining a value method" do
     END
   end
 
-  specify "should be a single value object" do
+  it "should be a single value object" do
     obj = SingleValueObject.new
     obj.should be_a_single_value
   end

data/spec/choice_spec.rb

@@ -6,8 +6,8 @@ require 'bindata/int'
 require 'bindata/lazy'
 require 'bindata/struct'
 
-context "Instantiating a Choice" do
-  specify "should ensure mandatory parameters are supplied" do
+describe "Instantiating a Choice" do
+  it "should ensure mandatory parameters are supplied" do
     args = {}
     lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
     args = {:selection => 1}
@@ -16,14 +16,14 @@ context "Instantiating a Choice" do
     lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
   end
 
-  specify "should fail if a given type is unknown" 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)
   end
 end
 
-context "A Choice with several choices" do
-  setup do
+describe "A Choice with several choices" do
+  before(:each) do
     # allow specifications to select the choice
     @env = BinData::LazyEvalEnv.new
     @env.class.class_eval { attr_accessor :choose }
@@ -38,7 +38,7 @@ context "A Choice with several choices" do
                                 @env)
   end
 
-  specify "should be able to select the choice" do
+  it "should be able to select the choice" do
     @env.choose = 0
     @data.value.should eql(3)
     @env.choose = 1
@@ -51,20 +51,20 @@ context "A Choice with several choices" do
     @data.value.should eql(7)
   end
 
-  specify "should not be able to select an invalid choice" do
+  it "should not be able to select an invalid choice" do
     @env.choose = -1
     lambda { @data.value }.should raise_error(IndexError)
     @env.choose = 5
     lambda { @data.value }.should raise_error(IndexError)
   end
 
-  specify "should be able to interact directly with the choice" do
+  it "should be able to interact directly with the choice" do
     @env.choose = 0
     @data.value = 17
     @data.value.should eql(17)
   end
 
-  specify "should handle missing methods correctly" do
+  it "should handle missing methods correctly" do
     @env.choose = 0
 
     @data.should respond_to(:value)
@@ -72,7 +72,7 @@ context "A Choice with several choices" do
     lambda { @data.does_not_exist }.should raise_error(NoMethodError)
   end
 
-  specify "should delegate methods to the selected single choice" do
+  it "should delegate methods to the selected single choice" do
     @env.choose = 1
     @data.value = 17
 
@@ -95,7 +95,7 @@ context "A Choice with several choices" do
     @data.snapshot.should eql(17)
   end
 
-  specify "should delegate methods to the selected complex choice" do
+  it "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 eql(["a"])

data/spec/float_spec.rb

@@ -3,22 +3,22 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/float'
 
-context "A FloatLe" do
-  setup do
+describe "A FloatLe" do
+  before(:each) do
     @obj = BinData::FloatLe.new
     @obj.value = Math::PI
 
     @io = StringIO.new
   end
 
-  specify "should write the expected value" do
+  it "should write the expected value" do
     @obj.write(@io)
     @io.rewind
 
     @io.read.should == [Math::PI].pack('e')
   end
 
-  specify "should read the same value as written" do
+  it "should read the same value as written" do
     @obj.write(@io)
     @io.rewind
 
@@ -28,22 +28,22 @@ context "A FloatLe" do
   end
 end
 
-context "A FloatBe" do
-  setup do
+describe "A FloatBe" do
+  before(:each) do
     @obj = BinData::FloatBe.new
     @obj.value = Math::PI
 
     @io = StringIO.new
   end
 
-  specify "should write the expected value" do
+  it "should write the expected value" do
     @obj.write(@io)
     @io.rewind
 
     @io.read.should == [Math::PI].pack('g')
   end
 
-  specify "should read the same value as written" do
+  it "should read the same value as written" do
     @obj.write(@io)
     @io.rewind
 
@@ -53,22 +53,22 @@ context "A FloatBe" do
   end
 end
 
-context "A DoubleLe" do
-  setup do
+describe "A DoubleLe" do
+  before(:each) do
     @obj = BinData::DoubleLe.new
     @obj.value = Math::PI
 
     @io = StringIO.new
   end
 
-  specify "should write the expected value" do
+  it "should write the expected value" do
     @obj.write(@io)
     @io.rewind
 
     @io.read.should == [Math::PI].pack('E')
   end
 
-  specify "should read the same value as written" do
+  it "should read the same value as written" do
     @obj.write(@io)
     @io.rewind
 
@@ -79,22 +79,22 @@ context "A DoubleLe" do
 end
 
 
-context "A DoubleBe" do
-  setup do
+describe "A DoubleBe" do
+  before(:each) do
     @obj = BinData::DoubleBe.new
     @obj.value = Math::PI
 
     @io = StringIO.new
   end
 
-  specify "should write the expected value" do
+  it "should write the expected value" do
     @obj.write(@io)
     @io.rewind
 
     @io.read.should == [Math::PI].pack('G')
   end
 
-  specify "should read the same value as written" do
+  it "should read the same value as written" do
     @obj.write(@io)
     @io.rewind
 

data/spec/int_spec.rb

@@ -3,8 +3,8 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/int'
 
-context "All signed integers" do
-  specify "should have a sensible value of zero" do
+describe "All signed integers" do
+  it "should have a sensible value of zero" do
     [BinData::Int8,
      BinData::Int16le,
      BinData::Int16be,
@@ -16,7 +16,7 @@ context "All signed integers" do
     end
   end
 
-  specify "should pass these tests" do
+  it "should pass these tests" do
     [
       [1, true,  BinData::Int8],
       [2, false, BinData::Int16le],
@@ -33,8 +33,8 @@ context "All signed integers" do
   end
 end
 
-context "All unsigned integers" do
-  specify "should have a sensible value of zero" do
+describe "All unsigned integers" do
+  it "should have a sensible value of zero" do
     [BinData::Uint8,
      BinData::Uint16le,
      BinData::Uint16be,
@@ -46,7 +46,7 @@ context "All unsigned integers" do
     end
   end
 
-  specify "should pass these tests" do
+  it "should pass these tests" do
     [
       [1, true,  BinData::Uint8],
       [2, false, BinData::Uint16le],

data/spec/lazy_spec.rb

@@ -3,65 +3,52 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/lazy'
 
-# A mock data object that can substitute for BinData::Simple or BinData::Struct
+# A mock data object with customizable fields.
 class MockDataObject
-  def initialize(value = nil, fields = {})
-    @value = value
-    @fields = fields
-  end
-  attr_accessor :value
-
-  def field_names
-    @fields.keys.collect { |k| k.to_s }
-  end
-  def respond_to?(symbol, include_private = false)
-    field_names.include?(symbol.id2name) ? true : super
-  end
-  def method_missing(symbol, *args)
-    @fields[symbol] || super
+  def initialize(fields = {})
+    fields.each do |k,v|
+      self.class.send(:define_method, k.to_sym) { v }
+    end
   end
 end
 
-context "A single environment" do
-  setup do
-    @do1 = MockDataObject.new('v1', :f1 => 'f1')
+describe "A single environment" do
+  before(:each) do
+    @do1 = MockDataObject.new(:f1 => 'f1')
     @e1 = BinData::LazyEvalEnv.new
     @e1.data_object = @do1
-    @e1.params = {:p1 => 'p1'}
+    @e1.add_variable(:v1, 'v1')
   end
 
-  specify "should evaluate value" do
-    @e1.lazy_eval(lambda { value }).should eql('v1')
+  it "should accept symbols as a shortcut to lambda" do
+    @e1.lazy_eval(lambda { o1 }, :o1 => 'o1').should eql('o1')
+    @e1.lazy_eval(lambda { v1 }).should eql('v1')
+    @e1.lazy_eval(:o1, :o1 => 'o1').should eql('o1')
+    @e1.lazy_eval(:v1).should eql('v1')
   end
 
-  specify "should evaluate index" do
-    @e1.index = 7
-    @e1.lazy_eval(lambda { index }).should eql(7)
+  it "should evaluate overrides" do
+    @e1.lazy_eval(:o1, :o1 => 'o1').should eql('o1')
   end
 
-  specify "should evaluate offset" do
-    @e1.offset = 9
-    @e1.lazy_eval(lambda { offset }).should eql(9)
+  it "should evaluate variables" do
+    @e1.lazy_eval(:v1).should eql('v1')
   end
 
-  specify "should not resolve any unknown fields" do
-    lambda { @e1.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
-    lambda { @e1.lazy_eval(lambda { p1 }) }.should raise_error(NameError)
-    lambda { @e1.lazy_eval(lambda { f1 }) }.should raise_error(NameError)
+  it "should prioritise overrides over variables" do
+    @e1.lazy_eval(:v1, :v1 => 'o1').should eql('o1')
   end
 
-  specify "should accept symbols as a shortcut to lambda" do
-    @e1.index  = 7
-    @e1.offset = 9
-    @e1.lazy_eval(:value).should eql('v1')
-    @e1.lazy_eval(:index).should eql(7)
-    @e1.lazy_eval(:offset).should eql(9)
+  it "should not resolve any unknown fields" do
+    lambda { @e1.lazy_eval(:unknown) }.should raise_error(NameError)
+    lambda { @e1.lazy_eval(:p1) }.should raise_error(NameError)
+    lambda { @e1.lazy_eval(:f1) }.should raise_error(NameError)
   end
 end
 
-context "An environment with one parent" do
-  setup do
-    @do2 = MockDataObject.new(nil, :f2 => 'f2', :common => 'field2')
+describe "An environment with one parent" do
+  before(:each) do
+    @do2 = MockDataObject.new(:f2 => 'f2', :common1 => 'f2', :common2 => 'f2')
     @do1 = MockDataObject.new
 
     @e2 = BinData::LazyEvalEnv.new
@@ -70,28 +57,35 @@ context "An environment with one parent" do
     @e2.data_object = @do2
     @e1.data_object = @do1
 
-    @e2.params = {:p2 => 'p2', :l2 => lambda { 'l2' }, :common => 'param2'}
+    @e1.add_variable(:common2, 'v1')
+
+    @e2.params = {:p2 => 'p2', :common1 => 'p2', :common2 => 'p2'}
+    @e2.add_variable(:common2, 'v2')
   end
 
-  specify "should evaluate parent parameter" do
+  it "should evaluate parent parameter" do
     @e1.lazy_eval(:p2).should eql('p2')
   end
 
-  specify "should evaluate parent field" do
+  it "should evaluate parent field" do
     @e1.lazy_eval(:f2).should eql('f2')
   end
 
-  specify "should prefer parent param over parent field" do
-    @e1.lazy_eval(:common).should eql('param2')
+  it "should prefer parent param over parent field" do
+    @e1.lazy_eval(:common1).should eql('p2')
+  end
+
+  it "should prefer variable over parent param" do
+    @e1.lazy_eval(:common2).should eql('v1')
   end
 end
 
-context "A nested environment" do
-  setup do
-    @do4 = MockDataObject.new(nil, :f4 => 'f4')
-    @do3 = MockDataObject.new(nil, :f3 => 'f3')
-    @do2 = MockDataObject.new(nil, :f2 => 'f2')
-    @do1 = MockDataObject.new(nil, :f1 => 'f1')
+describe "A nested environment" do
+  before(:each) do
+    @do4 = MockDataObject.new(:f4 => 'f4')
+    @do3 = MockDataObject.new(:f3 => 'f3')
+    @do2 = MockDataObject.new(:f2 => 'f2', :fs2 => :s3)
+    @do1 = MockDataObject.new(:f1 => 'f1')
 
     @e4 = BinData::LazyEvalEnv.new
     @e3 = BinData::LazyEvalEnv.new(@e4)
@@ -104,17 +98,27 @@ context "A nested environment" do
     @e1.data_object = @do1
 
     @e4.params = {:p4 => 'p4', :s4 => 's4', :l4 => 'l4'}
-    @e3.params = {:p3 => 'p3', :s3 => :s4, :l3 => lambda { l4 }}
+    @e3.params = {:p3 => 'p3', :s3 => :s4, :s4 => 'xx', :l3 => lambda { l4 }}
     @e2.params = {:p2 => 'p2', :s2 => :s3, :l2 => lambda { l3 }}
+
+    @e2.add_variable(:v2, 'v2')
   end
 
-  specify "should access parent environments" do
+  it "should access parent environments" do
     @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
+  it "should cascade lambdas" do
     @e1.lazy_eval(lambda { l2 }).should eql('l4')
     @e1.lazy_eval(lambda { s2 }).should eql('s4')
   end
+
+  it "should access parent environments by cascading" do
+    @e1.lazy_eval(lambda { p3 }).should eql('p3')
+    @e1.lazy_eval(lambda { p4 }).should eql('p4')
+    @e1.lazy_eval(lambda { v2 }).should eql('v2')
+    @e1.lazy_eval(lambda { s3 }).should eql('s4')
+    @e1.lazy_eval(lambda { fs2 }).should eql('s4')
+  end
 end