bindata 2.3.3 → 2.3.4

data/test/lazy_test.rb

@@ -35,8 +35,8 @@ end
 
 describe BinData::LazyEvaluator, "with no parents" do
   subject {
-    methods = {:m1 => 'm1', :com => 'mC'}
-    params  = {:p1 => 'p1', :com => 'pC'}
+    methods = {m1: 'm1', com: 'mC'}
+    params  = {p1: 'p1', com: 'pC'}
     MockBinDataObject.new(methods, params)
   }
 
@@ -53,7 +53,7 @@ describe BinData::LazyEvaluator, "with no parents" do
   end
 
   it "evaluates overrides" do
-    lazy_eval(lambda { o1 }, :o1 => 'o1').must_equal 'o1'
+    lazy_eval(lambda { o1 }, o1: 'o1').must_equal 'o1'
   end
 
   it "does not resolve any unknown methods" do
@@ -73,8 +73,8 @@ end
 
 describe BinData::LazyEvaluator, "with one parent" do
   subject {
-    parent_methods = {:m1 => 'Pm1', :m2 => 'Pm2', :com1 => 'PmC', :mm => 3}
-    parent_params  = {:p1 => 'Pp1', :com1 => 'PpC'}
+    parent_methods = {m1: 'Pm1', m2: 'Pm2', com1: 'PmC', mm: 3}
+    parent_params  = {p1: 'Pp1', com1: 'PpC'}
     parent_obj = MockBinDataObject.new(parent_methods, parent_params)
 
     class << parent_obj
@@ -85,8 +85,8 @@ describe BinData::LazyEvaluator, "with one parent" do
       private :m2
     end
 
-    methods = {:m1 => 'm1', :com1 => 'mC'}
-    params  = {:p1 => 'p1', :com1 => 'pC'}
+    methods = {m1: 'm1', com1: 'mC'}
+    params  = {p1: 'p1', com1: 'pC'}
     MockBinDataObject.new(methods, params, parent_obj)
   }
 
@@ -99,11 +99,11 @@ describe BinData::LazyEvaluator, "with one parent" do
   end
 
   it "evaluates overrides before params" do
-    lazy_eval(lambda { p1 }, :p1 => 'o1').must_equal 'o1'
+    lazy_eval(lambda { p1 }, p1: 'o1').must_equal 'o1'
   end
 
   it "evaluates overrides before methods" do
-    lazy_eval(lambda { m1 }, :m1 => 'o1').must_equal 'o1'
+    lazy_eval(lambda { m1 }, m1: 'o1').must_equal 'o1'
   end
 
   it "does not resolve any unknown methods" do
@@ -141,8 +141,8 @@ end
 
 describe BinData::LazyEvaluator, "with nested parents" do
   subject {
-    pparent_methods = {:m1 => 'PPm1', :m2 => 'PPm2', :com1 => 'PPmC'}
-    pparent_params  = {:p1 => 'PPp1', :p2 => 'PPp2', :com1 => 'PPpC'}
+    pparent_methods = {m1: 'PPm1', m2: 'PPm2', com1: 'PPmC'}
+    pparent_params  = {p1: 'PPp1', p2: 'PPp2', com1: 'PPpC'}
     pparent_obj = MockBinDataObject.new(pparent_methods, pparent_params)
 
     def pparent_obj.echo(arg)
@@ -153,16 +153,16 @@ describe BinData::LazyEvaluator, "with nested parents" do
       ["PP2", arg]
     end
 
-    parent_methods = {:m1 => 'Pm1', :com1 => 'PmC', :sym1 => :m2, :sym2 => lambda { m2 }}
-    parent_params  = {:p1 => 'Pp1', :com1 => 'PpC'}
+    parent_methods = {m1: 'Pm1', com1: 'PmC', sym1: :m2, sym2: -> { m2 }}
+    parent_params  = {p1: 'Pp1', com1: 'PpC'}
     parent_obj = MockBinDataObject.new(parent_methods, parent_params, pparent_obj)
 
     def parent_obj.echo(arg)
       ["P", arg]
     end
 
-    methods = {:m1 => 'm1', :com1 => 'mC'}
-    params  = {:p1 => 'p1', :com1 => 'pC'}
+    methods = {m1: 'm1', com1: 'mC'}
+    params  = {p1: 'p1', com1: 'pC'}
     MockBinDataObject.new(methods, params, parent_obj)
   }
 
@@ -198,7 +198,7 @@ describe BinData::LazyEvaluator, "with nested parents" do
   end
 
   it "invokes methods in the parent's parent" do
-    lazy_eval(lambda { parent.echo(m1) }, { :m1 => 'o1'}).must_equal ['PP', 'o1']
+    lazy_eval(lambda { parent.echo(m1) }, { m1: 'o1'}).must_equal ['PP', 'o1']
   end
 
   it "invokes methods in the parent's parent" do

data/test/offset_test.rb

@@ -44,50 +44,50 @@ describe BinData::Base, "offsets" do
   describe "with :check_offset" do
     it "fails when offset is incorrect" do
       io.seek(2)
-      obj = TenByteOffsetBase.create(:check_offset => 10 - 4)
+      obj = TenByteOffsetBase.create(check_offset: 10 - 4)
       lambda { obj.read(io) }.must_raise BinData::ValidityError
     end
 
     it "succeeds when offset is correct" do
       io.seek(3)
-      obj = TenByteOffsetBase.create(:check_offset => 10)
+      obj = TenByteOffsetBase.create(check_offset: 10)
       obj.read(io).snapshot.must_equal data[3 + 10, 3]
     end
 
     it "fails when :check_offset fails" do
       io.seek(4)
-      obj = TenByteOffsetBase.create(:check_offset => lambda { offset == 10 + 1 } )
+      obj = TenByteOffsetBase.create(check_offset: -> { offset == 10 + 1 } )
       lambda { obj.read(io) }.must_raise BinData::ValidityError
     end
 
     it "succeeds when :check_offset succeeds" do
       io.seek(5)
-      obj = TenByteOffsetBase.create(:check_offset => lambda { offset == 10 } )
+      obj = TenByteOffsetBase.create(check_offset: -> { offset == 10 } )
       obj.read(io).snapshot.must_equal data[5 + 10, 3]
     end
   end
 
   describe "with :adjust_offset" do
     it "is mutually exclusive with :check_offset" do
-      params = { :check_offset => 8, :adjust_offset => 8 }
+      params = { check_offset: 8, adjust_offset: 8 }
       lambda { TenByteOffsetBase.create(params) }.must_raise ArgumentError
     end
 
     it "adjust offset when incorrect" do
       io.seek(2)
-      obj = TenByteOffsetBase.create(:adjust_offset => 13)
+      obj = TenByteOffsetBase.create(adjust_offset: 13)
       obj.read(io).snapshot.must_equal data[2 + 13, 3]
     end
 
     it "succeeds when offset is correct" do
       io.seek(3)
-      obj = TenByteOffsetBase.create(:adjust_offset => 10)
+      obj = TenByteOffsetBase.create(adjust_offset: 10)
       obj.read(io).snapshot.must_equal data[3 + 10, 3]
     end
 
     it "fails if cannot adjust offset" do
       io.seek(4)
-      obj = TenByteOffsetBase.create(:adjust_offset => -5)
+      obj = TenByteOffsetBase.create(adjust_offset: -5)
       lambda { obj.read(io) }.must_raise BinData::ValidityError
     end
   end

data/test/params_test.rb

@@ -13,13 +13,13 @@ describe BinData::Base, "parameters" do
   end
 
   it "fails when parameter has nil value" do
-    lambda { BinData::Base.new(:a => nil) }.must_raise ArgumentError
+    lambda { BinData::Base.new(a: nil) }.must_raise ArgumentError
   end
 end
 
 describe BinData::Base, "#has_parameter?" do
   it "true for existing parameters" do
-    obj = BinData::Base.new(:a => 3)
+    obj = BinData::Base.new(a: 3)
     assert obj.has_parameter?(:a)
   end
 
@@ -31,7 +31,7 @@ end
 
 describe BinData::Base, "#get_parameter" do
   it "retrieves parameter values" do
-    obj = BinData::Base.new(:a => 3)
+    obj = BinData::Base.new(a: 3)
     obj.get_parameter(:a).must_equal 3
   end
 
@@ -46,14 +46,14 @@ describe BinData::Base, "#get_parameter" do
   end
 
   it "wont eval parameters" do
-    obj = BinData::Base.new(:a => lambda { 3 })
+    obj = BinData::Base.new(a: -> { 3 })
     assert_kind_of Proc, obj.get_parameter(:a)
   end
 end
 
 describe BinData::Base, "#eval_parameter" do
   it "evals the parameter" do
-    obj = BinData::Base.new(:a => lambda { 3 })
+    obj = BinData::Base.new(a: -> { 3 })
     obj.eval_parameter(:a).must_equal 3
   end
 
@@ -70,7 +70,7 @@ describe BinData::Base, ".mandatory_parameters" do
   end
 
   it "fails when not all mandatory parameters are present" do
-    params = {:p1 => "a", :xx => "b" }
+    params = {p1: "a", xx: "b" }
     lambda { MandatoryBase.new(params) }.must_raise ArgumentError
   end
 
@@ -81,7 +81,7 @@ end
 
 describe BinData::Base, ".default_parameters" do
   class DefaultBase < BinData::Base
-    default_parameter :p1 => "a"
+    default_parameter p1: "a"
   end
 
   it "uses default parameters when not specified" do
@@ -90,7 +90,7 @@ describe BinData::Base, ".default_parameters" do
   end
 
   it "can override default parameters" do
-    obj = DefaultBase.new(:p1 => "b")
+    obj = DefaultBase.new(p1: "b")
     obj.eval_parameter(:p1).must_equal "b"
   end
 end
@@ -102,9 +102,9 @@ describe BinData::Base, ".mutually_exclusive_parameters" do
   end
 
   it "fails when any two of those parameters are present" do
-    lambda { MutexParamBase.new(:p1 => "a", :p2 => "b") }.must_raise ArgumentError
-    lambda { MutexParamBase.new(:p1 => "a", :p3 => "c") }.must_raise ArgumentError
-    lambda { MutexParamBase.new(:p2 => "b", :p3 => "c") }.must_raise ArgumentError
+    lambda { MutexParamBase.new(p1: "a", p2: "b") }.must_raise ArgumentError
+    lambda { MutexParamBase.new(p1: "a", p3: "c") }.must_raise ArgumentError
+    lambda { MutexParamBase.new(p2: "b", p3: "c") }.must_raise ArgumentError
   end
 end
 

data/test/primitive_test.rb

@@ -85,7 +85,7 @@ describe BinData::Primitive do
   end
 
   it "accepts standard parameters" do
-    obj = PrimitiveWithEndian.new(:initial_value => 2)
+    obj = PrimitiveWithEndian.new(initial_value: 2)
     obj.to_binary_s.must_equal_binary "\x02\x00"
   end
 
@@ -100,7 +100,7 @@ describe BinData::Primitive do
   end
 
   it "uses read value whilst reading" do
-    obj = PrimitiveWithEndian.new(:value => 2)
+    obj = PrimitiveWithEndian.new(value: 2)
     obj.read "\x05\x00"
     obj.must_equal 2
 
@@ -117,13 +117,13 @@ end
 
 describe BinData::Primitive, "requiring custom parameters" do
   class PrimitiveWithCustom < BinData::Primitive
-    int8 :a, :initial_value => :iv
+    int8 :a, initial_value: :iv
     def get; self.a; end
     def set(v); self.a = v; end
   end
 
   it "passes parameters correctly" do
-    obj = PrimitiveWithCustom.new(:iv => 5)
+    obj = PrimitiveWithCustom.new(iv: 5)
     obj.must_equal 5
   end
 end
@@ -132,7 +132,7 @@ describe BinData::Primitive, "with custom mandatory parameters" do
   class MandatoryPrimitive < BinData::Primitive
     mandatory_parameter :arg1
 
-    uint8 :a, :value => :arg1
+    uint8 :a, value: :arg1
     def get; self.a; end
     def set(v); self.a = v; end
   end
@@ -142,16 +142,16 @@ describe BinData::Primitive, "with custom mandatory parameters" do
   end
 
   it "uses mandatory parameter" do
-    obj = MandatoryPrimitive.new(:arg1 => 5)
+    obj = MandatoryPrimitive.new(arg1: 5)
     obj.must_equal 5
   end
 end
 
 describe BinData::Primitive, "with custom default parameters" do
   class DefaultPrimitive < BinData::Primitive
-    default_parameter :arg1 => 5
+    default_parameter arg1: 5
 
-    uint8 :a, :value => :arg1
+    uint8 :a, value: :arg1
     def get; self.a; end
     def set(v); self.a = v; end
   end
@@ -162,7 +162,7 @@ describe BinData::Primitive, "with custom default parameters" do
   end
 
   it "overrides default parameter" do
-    obj = DefaultPrimitive.new(:arg1 => 7)
+    obj = DefaultPrimitive.new(arg1: 7)
     obj.must_equal 7
   end
 end
@@ -175,11 +175,11 @@ describe BinData::Primitive, "subclassed with default parameter" do
   end
 
   class ChildDerivedPrimitive < ParentDerivedPrimitive
-    default_parameter :initial_value => 5
+    default_parameter initial_value: 5
   end
 
   it "overrides initial_value" do
-    a = ChildDerivedPrimitive.new(:initial_value => 7)
+    a = ChildDerivedPrimitive.new(initial_value: 7)
     a.to_binary_s.must_equal_binary "\000\007"
   end
 

data/test/record_test.rb

@@ -22,7 +22,7 @@ describe BinData::Record, "when defining with errors" do
   it "gives correct error message for non registered nested types" do
     lambda {
       class BadNestedTypeRecord < BinData::Record
-        array :a, :type => :non_registered_type
+        array :a, type: :non_registered_type
       end
     }.must_raise_on_line TypeError, 2, "unknown type 'non_registered_type' in BadNestedTypeRecord"
   end
@@ -113,11 +113,11 @@ end
 
 describe BinData::Record, "with anonymous fields" do
   class AnonymousRecord < BinData::Record
-    int8 'a', :initial_value => 10
+    int8 'a', initial_value: 10
     int8 ''
     int8 nil
     int8
-    int8 :value => :a
+    int8 value: :a
   end
 
   let(:obj) { AnonymousRecord.new }
@@ -128,7 +128,7 @@ describe BinData::Record, "with anonymous fields" do
 
   it "does not include anonymous fields in snapshot" do
     obj.a = 5
-    obj.snapshot.must_equal({:a => 5})
+    obj.snapshot.must_equal({a: 5})
   end
 
   it "writes anonymous fields" do
@@ -143,9 +143,9 @@ describe BinData::Record, "with hidden fields" do
   class HiddenRecord < BinData::Record
     hide :b, :c
     int8 :a
-    int8 'b', :initial_value => 10
+    int8 'b', initial_value: 10
     int8 :c
-    int8 :d, :value => :b
+    int8 :d, value: :b
   end
 
   let(:obj) { HiddenRecord.new }
@@ -164,7 +164,7 @@ describe BinData::Record, "with hidden fields" do
 
   it "does not include hidden fields in snapshot" do
     obj.b = 5
-    obj.snapshot.must_equal({:a => 0, :d => 5})
+    obj.snapshot.must_equal({a: 0, d: 5})
   end
 end
 
@@ -174,7 +174,7 @@ describe BinData::Record, "with multiple fields" do
     int8 :b
   end
 
-  let(:obj) { MultiFieldRecord.new(:a => 1, :b => 2) }
+  let(:obj) { MultiFieldRecord.new(a: 1, b: 2) }
 
   it "returns num_bytes" do
     obj.a.num_bytes.must_equal 1
@@ -216,7 +216,7 @@ describe BinData::Record, "with multiple fields" do
     snap = obj.snapshot
     snap.a.must_equal 1
     snap.b.must_equal 2
-    snap.must_equal({ :a => 1, :b => 2 })
+    snap.must_equal({ a: 1, b: 2 })
   end
 
   it "returns field_names" do
@@ -230,14 +230,14 @@ end
 
 describe BinData::Record, "with nested structs" do
   class NestedStructRecord < BinData::Record
-    int8   :a, :initial_value => 6
-    struct :b, :the_val => :a do
+    int8   :a, initial_value: 6
+    struct :b, the_val: :a do
       hide :w
-      int8 :w, :initial_value => 3
-      int8 :x, :value => :the_val
+      int8 :w, initial_value: 3
+      int8 :x, value: :the_val
     end
     struct :c do
-      int8 :y, :value => lambda { b.w }
+      int8 :y, value: -> { b.w }
       int8 :z
     end
   end
@@ -276,7 +276,7 @@ describe BinData::Record, "with nested structs" do
   end
 
   it "assigns nested fields" do
-    obj.assign(:a => 2, :b => {:w => 4})
+    obj.assign(a: 2, b: {w: 4})
     obj.a.must_equal   2
     obj.b.w.must_equal 4
     obj.b.x.must_equal 2
@@ -286,15 +286,15 @@ end
 
 describe BinData::Record, "with nested array of primitives" do
   class NestedPrimitiveArrayRecord < BinData::Record
-    array :a, :initial_length => 3 do
-      uint8 :value => lambda { index }
+    array :a, initial_length: 3 do
+      uint8 value: -> { index }
     end
   end
 
   let(:obj) { NestedPrimitiveArrayRecord.new }
 
   it "uses block as :type" do
-    obj.snapshot.must_equal({:a => [0, 1, 2]})
+    obj.snapshot.must_equal({a: [0, 1, 2]})
   end
 end
 
@@ -310,15 +310,15 @@ describe BinData::Record, "with nested array of structs" do
 
   it "uses block as struct for :type" do
     obj.a[0].b = 2
-    obj.snapshot.must_equal({:a => [{:b => 2, :c => 0}]})
+    obj.snapshot.must_equal({a: [{b: 2, c: 0}]})
   end
 end
 
 describe BinData::Record, "with nested choice with implied keys" do
   class NestedChoiceWithImpliedKeysRecord < BinData::Record
-    choice :a, :selection => 1 do
-      uint8 :value => 1
-      uint8 :value => 2
+    choice :a, selection: 1 do
+      uint8 value: 1
+      uint8 value: 2
     end
   end
 
@@ -329,9 +329,9 @@ end
 
 describe BinData::Record, "with nested choice with explicit keys" do
   class NestedChoiceWithKeysRecord < BinData::Record
-    choice :a, :selection => 5 do
-      uint8 3, :value => 1
-      uint8 5, :value => 2
+    choice :a, selection: 5 do
+      uint8 3, value: 1
+      uint8 5, value: 2
     end
   end
 
@@ -342,9 +342,9 @@ end
 
 describe BinData::Record, "with nested choice with names" do
   class NestedChoiceWithNamesRecord < BinData::Record
-    choice :a, :selection => "b" do
-      uint8 "b", :value => 1
-      uint8 "c", :value => 2
+    choice :a, selection: "b" do
+      uint8 "b", value: 1
+      uint8 "c", value: 2
     end
   end
 
@@ -359,10 +359,10 @@ describe BinData::Record, "with an endian defined" do
 
     uint16 :a
     float  :b
-    array  :c, :initial_length => 2 do
+    array  :c, initial_length: 2 do
       int8
     end
-    choice :d, :selection => 1 do
+    choice :d, selection: 1 do
       uint16
       uint32
     end
@@ -452,7 +452,7 @@ end
 describe BinData::Record, "with endian :big_and_little" do
   class RecordWithBnLEndian < BinData::Record
     endian :big_and_little
-    int16 :a, :value => 1
+    int16 :a, value: 1
   end
 
   it "is not registered" do
@@ -478,7 +478,7 @@ describe BinData::Record, "with endian :big_and_little" do
   end
 
   it "accepts :endian as argument" do
-    obj = RecordWithBnLEndian.new(:endian => :little)
+    obj = RecordWithBnLEndian.new(endian: :little)
     obj.to_binary_s.must_equal_binary "\x01\x00"
   end
 end
@@ -490,7 +490,7 @@ describe BinData::Record, "with endian :big_and_little and search_prefix" do
   class RecordWithBnLEndianAndSearchPrefix < BinData::Record
     endian :big_and_little
     search_prefix :ns
-     bnl_int :a, :value => 1
+     bnl_int :a, value: 1
   end
 
   it "creates big endian version" do
@@ -507,10 +507,10 @@ end
 describe BinData::Record, "with endian :big_and_little when subclassed" do
   class ARecordWithBnLEndian < BinData::Record
     endian :big_and_little
-    int16 :a, :value => 1
+    int16 :a, value: 1
   end
   class BRecordWithBnLEndian < ARecordWithBnLEndian
-    int16 :b, :value => 2
+    int16 :b, value: 2
   end
 
   it "is not registered" do
@@ -536,7 +536,7 @@ describe BinData::Record, "with endian :big_and_little when subclassed" do
   end
 
   it "accepts :endian as argument" do
-    obj = BRecordWithBnLEndian.new(:endian => :little)
+    obj = BRecordWithBnLEndian.new(endian: :little)
     obj.to_binary_s.must_equal_binary "\x01\x00\x02\x00"
   end
 end
@@ -545,8 +545,8 @@ describe BinData::Record, "defined recursively" do
   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 }
+    uint8   :has_nxt, value: -> { nxt.clear? ? 0 : 1 }
+    recursive_record :nxt, onlyif: -> { has_nxt > 0 }
   end
 
   it "can be created" do
@@ -581,7 +581,7 @@ describe BinData::Record, "with custom mandatory parameters" do
   class MandatoryRecord < BinData::Record
     mandatory_parameter :arg1
 
-    uint8 :a, :value => :arg1
+    uint8 :a, value: :arg1
   end
 
   it "raises error if mandatory parameter is not supplied" do
@@ -589,16 +589,16 @@ describe BinData::Record, "with custom mandatory parameters" do
   end
 
   it "uses mandatory parameter" do
-    obj = MandatoryRecord.new(:arg1 => 5)
+    obj = MandatoryRecord.new(arg1: 5)
     obj.a.must_equal 5
   end
 end
 
 describe BinData::Record, "with custom default parameters" do
   class DefaultRecord < BinData::Record
-    default_parameter :arg1 => 5
+    default_parameter arg1: 5
 
-    uint8 :a, :value => :arg1
+    uint8 :a, value: :arg1
     uint8 :b
   end
 
@@ -608,17 +608,17 @@ describe BinData::Record, "with custom default parameters" do
   end
 
   it "overrides default parameter" do
-    obj = DefaultRecord.new(:arg1 => 7)
+    obj = DefaultRecord.new(arg1: 7)
     obj.a.must_equal 7
   end
 
   it "accepts values" do
-    obj = DefaultRecord.new(:b => 2)
+    obj = DefaultRecord.new(b: 2)
     obj.b.must_equal 2
   end
 
   it "accepts values and parameters" do
-    obj = DefaultRecord.new({:b => 2}, :arg1 => 3)
+    obj = DefaultRecord.new({b: 2}, arg1: 3)
     obj.a.must_equal 3
     obj.b.must_equal 2
   end
@@ -626,16 +626,16 @@ end
 
 describe BinData::Record, "with :onlyif" do
   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 }
+    uint8 :a, initial_value: 3
+    uint8 :b, initial_value: 5, onlyif: -> { a == 3 }
+    uint8 :c, initial_value: 7, onlyif: -> { a != 3 }
   end
 
   let(:obj) { OnlyIfRecord.new }
 
   it "initial state" do
     obj.num_bytes.must_equal 2
-    obj.snapshot.must_equal({:a => 3, :b => 5})
+    obj.snapshot.must_equal({a: 3, b: 5})
     obj.to_binary_s.must_equal_binary "\x03\x05"
   end
 
@@ -647,7 +647,7 @@ describe BinData::Record, "with :onlyif" do
 
   it "reads as lambdaed" do
     obj.read("\x01\x02")
-    obj.snapshot.must_equal({:a => 1, :c => 2})
+    obj.snapshot.must_equal({a: 1, c: 2})
   end
 end