bindata 2.3.3 → 2.3.4

data/test/registry_test.rb

@@ -59,10 +59,10 @@ describe BinData::Registry, "with numerics" do
   let(:r) { BinData::RegisteredClasses }
 
   it "lookup integers with endian" do
-    r.lookup("int24", {:endian => :big}).to_s.must_equal "BinData::Int24be"
-    r.lookup("int24", {:endian => :little}).to_s.must_equal "BinData::Int24le"
-    r.lookup("uint24", {:endian => :big}).to_s.must_equal "BinData::Uint24be"
-    r.lookup("uint24", {:endian => :little}).to_s.must_equal "BinData::Uint24le"
+    r.lookup("int24", {endian: :big}).to_s.must_equal "BinData::Int24be"
+    r.lookup("int24", {endian: :little}).to_s.must_equal "BinData::Int24le"
+    r.lookup("uint24", {endian: :big}).to_s.must_equal "BinData::Uint24be"
+    r.lookup("uint24", {endian: :little}).to_s.must_equal "BinData::Uint24le"
   end
 
   it "does not lookup integers without endian" do
@@ -76,18 +76,18 @@ describe BinData::Registry, "with numerics" do
       r.lookup("int3")
     }.must_raise BinData::UnRegisteredTypeError
     lambda {
-      r.lookup("int3", {:endian => :big})
+      r.lookup("int3", {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
     lambda {
-      r.lookup("int3", {:endian => :little})
+      r.lookup("int3", {endian: :little})
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "lookup floats with endian" do
-    r.lookup("float", {:endian => :big}).to_s.must_equal "BinData::FloatBe"
-    r.lookup("float", {:endian => :little}).to_s.must_equal "BinData::FloatLe"
-    r.lookup("double", {:endian => :big}).to_s.must_equal "BinData::DoubleBe"
-    r.lookup("double", {:endian => :little}).to_s.must_equal "BinData::DoubleLe"
+    r.lookup("float", {endian: :big}).to_s.must_equal "BinData::FloatBe"
+    r.lookup("float", {endian: :little}).to_s.must_equal "BinData::FloatLe"
+    r.lookup("double", {endian: :big}).to_s.must_equal "BinData::DoubleBe"
+    r.lookup("double", {endian: :little}).to_s.must_equal "BinData::DoubleLe"
   end
 
   it "lookup bits" do
@@ -97,17 +97,17 @@ describe BinData::Registry, "with numerics" do
   end
 
   it "lookup bits by ignoring endian" do
-    r.lookup("bit2", {:endian => :big}).to_s.must_equal "BinData::Bit2"
-    r.lookup("bit3le", {:endian => :big}).to_s.must_equal "BinData::Bit3le"
-    r.lookup("bit2", {:endian => :little}).to_s.must_equal "BinData::Bit2"
-    r.lookup("bit3le", {:endian => :little}).to_s.must_equal "BinData::Bit3le"
+    r.lookup("bit2", {endian: :big}).to_s.must_equal "BinData::Bit2"
+    r.lookup("bit3le", {endian: :big}).to_s.must_equal "BinData::Bit3le"
+    r.lookup("bit2", {endian: :little}).to_s.must_equal "BinData::Bit2"
+    r.lookup("bit3le", {endian: :little}).to_s.must_equal "BinData::Bit3le"
   end
 
   it "lookup signed bits by ignoring endian" do
-    r.lookup("sbit2", {:endian => :big}).to_s.must_equal "BinData::Sbit2"
-    r.lookup("sbit3le", {:endian => :big}).to_s.must_equal "BinData::Sbit3le"
-    r.lookup("sbit2", {:endian => :little}).to_s.must_equal "BinData::Sbit2"
-    r.lookup("sbit3le", {:endian => :little}).to_s.must_equal "BinData::Sbit3le"
+    r.lookup("sbit2", {endian: :big}).to_s.must_equal "BinData::Sbit2"
+    r.lookup("sbit3le", {endian: :big}).to_s.must_equal "BinData::Sbit3le"
+    r.lookup("sbit2", {endian: :little}).to_s.must_equal "BinData::Sbit2"
+    r.lookup("sbit3le", {endian: :little}).to_s.must_equal "BinData::Sbit3le"
   end
 end
 
@@ -120,16 +120,16 @@ describe BinData::Registry, "with endian specific types" do
   end
   
   it "lookup little endian types" do
-    r.lookup('a', {:endian => :little}).must_equal A
+    r.lookup('a', {endian: :little}).must_equal A
   end
 
   it "lookup big endian types" do
-    r.lookup('b', {:endian => :big}).must_equal B
+    r.lookup('b', {endian: :big}).must_equal B
   end
 
   it "does not lookup types with non existent endian" do
     lambda {
-      r.lookup('a', {:endian => :big})
+      r.lookup('a', {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
   end
 
@@ -137,7 +137,7 @@ describe BinData::Registry, "with endian specific types" do
     r.register('c', C)
     r.register('c_le', D)
 
-    r.lookup('c', {:endian => :little}).must_equal C
+    r.lookup('c', {endian: :little}).must_equal C
   end
 end
 
@@ -150,18 +150,18 @@ describe BinData::Registry, "with search_prefix" do
   end
 
   it "lookup single search_prefix" do
-    r.lookup('f', {:search_prefix => :a}).must_equal A
+    r.lookup('f', {search_prefix: :a}).must_equal A
   end
 
   it "lookup single search_prefix with endian" do
-    r.lookup('f', {:search_prefix => :a, :endian => :little}).must_equal A
+    r.lookup('f', {search_prefix: :a, endian: :little}).must_equal A
   end
 
   it "lookup multiple search_prefix" do
-    r.lookup('f', {:search_prefix => [:x, :a]}).must_equal A
+    r.lookup('f', {search_prefix: [:x, :a]}).must_equal A
   end
 
   it "lookup first match in search_prefix" do
-    r.lookup('f', {:search_prefix => [:a, :b]}).must_equal A
+    r.lookup('f', {search_prefix: [:a, :b]}).must_equal A
   end
 end

data/test/rest_test.rb

@@ -21,7 +21,7 @@ describe BinData::Rest do
   end
 
   it "accepts BinData::BasePrimitive parameters" do
-    rest = BinData::Rest.new(:assert => "abc")
+    rest = BinData::Rest.new(assert: "abc")
     lambda {
       rest.read("xyz")
     }.must_raise BinData::ValidityError

data/test/skip_test.rb

@@ -12,7 +12,7 @@ describe BinData::Skip, "when instantiating" do
 end
 
 describe BinData::Skip, "with :length" do
-  let(:obj) { BinData::Skip.new(:length => 5) }
+  let(:obj) { BinData::Skip.new(length: 5) }
   let(:io) { StringIO.new("abcdefghij") }
 
   it "initial state" do
@@ -37,28 +37,28 @@ describe BinData::Skip, "with :length" do
 end
 
 describe BinData::Skip, "with :to_abs_offset" do
-  BinData::Struct.new(:fields => [ [:skip, :f, { :to_abs_offset => 5 } ] ])
+  BinData::Struct.new(fields: [ [:skip, :f, { to_abs_offset: 5 } ] ])
 
-  let(:skip_obj) { [:skip, :f, { :to_abs_offset => 5 } ] }
+  let(:skip_obj) { [:skip, :f, { to_abs_offset: 5 } ] }
   let(:io) { StringIO.new("abcdefghij") }
 
   it "reads skipping forward" do
     fields = [ skip_obj ]
-    obj = BinData::Struct.new(:fields => fields)
+    obj = BinData::Struct.new(fields: fields)
     obj.read(io)
     io.pos.must_equal 5
   end
 
   it "reads skipping in place" do
-    fields = [ [:string, :a, { :read_length => 5 }], skip_obj ]
-    obj = BinData::Struct.new(:fields => fields)
+    fields = [ [:string, :a, { read_length: 5 }], skip_obj ]
+    obj = BinData::Struct.new(fields: fields)
     obj.read(io)
     io.pos.must_equal 5
   end
 
   it "does not read skipping backwards" do
-    fields = [ [:string, :a, { :read_length => 10 }], skip_obj ]
-    obj = BinData::Struct.new(:fields => fields)
+    fields = [ [:string, :a, { read_length: 10 }], skip_obj ]
+    obj = BinData::Struct.new(fields: fields)
 
     lambda {
       obj.read(io)
@@ -67,19 +67,19 @@ describe BinData::Skip, "with :to_abs_offset" do
 
   it "writes skipping forward" do
     fields = [ skip_obj ]
-    obj = BinData::Struct.new(:fields => fields)
+    obj = BinData::Struct.new(fields: fields)
     obj.to_binary_s.must_equal "\000\000\000\000\000"
   end
 
   it "reads skipping in place" do
-    fields = [ [:string, :a, { :value => "abcde" }], skip_obj ]
-    obj = BinData::Struct.new(:fields => fields)
+    fields = [ [:string, :a, { value: "abcde" }], skip_obj ]
+    obj = BinData::Struct.new(fields: fields)
     obj.to_binary_s.must_equal "abcde"
   end
 
   it "does not write skipping backwards" do
-    fields = [ [:string, :a, { :value => "abcdefghij" }], skip_obj ]
-    obj = BinData::Struct.new(:fields => fields)
+    fields = [ [:string, :a, { value: "abcdefghij" }], skip_obj ]
+    obj = BinData::Struct.new(fields: fields)
     lambda {
       obj.to_binary_s
     }.must_raise BinData::ValidityError
@@ -90,34 +90,34 @@ describe BinData::Skip, "with :until_valid" do
   let(:io) { StringIO.new("abcdefghij") }
 
   it "skips to valid match" do
-    skip_obj = [:string, { :read_length => 1, :assert => "f" }]
-    fields = [ [:skip, :s, { :until_valid => skip_obj }] ]
-    obj = BinData::Struct.new(:fields => fields)
+    skip_obj = [:string, { read_length: 1, assert: "f" }]
+    fields = [ [:skip, :s, { until_valid: skip_obj }] ]
+    obj = BinData::Struct.new(fields: fields)
     obj.read(io)
     io.pos.must_equal 5
   end
 
   it "doesn't skip when validator doesn't assert" do
-    skip_obj = [:string, { :read_length => 1 }]
-    fields = [ [:skip, :s, { :until_valid => skip_obj }] ]
-    obj = BinData::Struct.new(:fields => fields)
+    skip_obj = [:string, { read_length: 1 }]
+    fields = [ [:skip, :s, { until_valid: skip_obj }] ]
+    obj = BinData::Struct.new(fields: fields)
     obj.read(io)
     io.pos.must_equal 0
   end
 
   it "raises EOFError when no match" do
-    skip_obj = [:string, { :read_length => 1, :assert => "X" }]
-    fields = [ [:skip, :s, { :until_valid => skip_obj }] ]
-    obj = BinData::Struct.new(:fields => fields)
+    skip_obj = [:string, { read_length: 1, assert: "X" }]
+    fields = [ [:skip, :s, { until_valid: skip_obj }] ]
+    obj = BinData::Struct.new(fields: fields)
     lambda {
       obj.read(io)
     }.must_raise EOFError
   end
 
   it "raises IOError when validator reads beyond stream" do
-    skip_obj = [:string, { :read_length => 30 }]
-    fields = [ [:skip, :s, { :until_valid => skip_obj }] ]
-    obj = BinData::Struct.new(:fields => fields)
+    skip_obj = [:string, { read_length: 30 }]
+    fields = [ [:skip, :s, { until_valid: skip_obj }] ]
+    obj = BinData::Struct.new(fields: fields)
     lambda {
       obj.read(io)
     }.must_raise IOError
@@ -125,9 +125,9 @@ describe BinData::Skip, "with :until_valid" do
 
   class DSLSkip < BinData::Record
     skip :s do
-      string :read_length => 1, :assert => "f"
+      string read_length: 1, assert: "f"
     end
-    string :a, :read_length => 1
+    string :a, read_length: 1
   end
 
   it "uses block form" do

data/test/string_test.rb

@@ -4,24 +4,24 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 
 describe BinData::String, "with mutually exclusive parameters" do
   it ":value and :initial_value" do
-    params = {:value => "", :initial_value => ""}
+    params = {value: "", initial_value: ""}
     lambda { BinData::String.new(params) }.must_raise ArgumentError
   end
 
   it ":length and :read_length" do
-    params = {:length => 5, :read_length => 5}
+    params = {length: 5, read_length: 5}
     lambda { BinData::String.new(params) }.must_raise ArgumentError
   end
 
   it ":value and :length" do
-    params = {:value => "", :length => 5}
+    params = {value: "", length: 5}
     lambda { BinData::String.new(params) }.must_raise ArgumentError
   end
 end
 
 describe BinData::String, "when assigning" do
-  let(:small) { BinData::String.new(:length => 3, :pad_byte => "A") }
-  let(:large) { BinData::String.new(:length => 5, :pad_byte => "B") }
+  let(:small) { BinData::String.new(length: 3, pad_byte: "A") }
+  let(:large) { BinData::String.new(length: 5, pad_byte: "B") }
 
   it "copies data from small to large" do
     large.assign(small)
@@ -47,7 +47,7 @@ describe BinData::String do
 end
 
 describe BinData::String, "with :read_length" do
-  let(:obj) { BinData::String.new(:read_length => 5) }
+  let(:obj) { BinData::String.new(read_length: 5) }
 
   specify { obj.num_bytes.must_equal 0 }
   specify { obj.value.must_equal "" }
@@ -68,7 +68,7 @@ describe BinData::String, "with :read_length" do
 end
 
 describe BinData::String, "with :length" do
-  let(:obj) { BinData::String.new(:length => 5) }
+  let(:obj) { BinData::String.new(length: 5) }
 
   specify { obj.num_bytes.must_equal 5 }
   specify { obj.value.must_equal "\0\0\0\0\0" }
@@ -100,7 +100,7 @@ describe BinData::String, "with :length" do
 end
 
 describe BinData::String, "with :read_length and :initial_value" do
-  let(:obj) { BinData::String.new(:read_length => 5, :initial_value => "abcdefghij") }
+  let(:obj) { BinData::String.new(read_length: 5, initial_value: "abcdefghij") }
 
   specify { obj.num_bytes.must_equal 10 }
   specify { obj.value.must_equal "abcdefghij" }
@@ -119,7 +119,7 @@ describe BinData::String, "with :read_length and :initial_value" do
 end
 
 describe BinData::String, "with :read_length and :value" do
-  let(:obj) { BinData::String.new(:read_length => 5, :value => "abcdefghij") }
+  let(:obj) { BinData::String.new(read_length: 5, value: "abcdefghij") }
 
   specify { obj.num_bytes.must_equal 10 }
   specify { obj.value.must_equal "abcdefghij" }
@@ -149,7 +149,7 @@ describe BinData::String, "with :read_length and :value" do
 end
 
 describe BinData::String, "with :length and :initial_value" do
-  let(:obj) { BinData::String.new(:length => 5, :initial_value => "abcdefghij") }
+  let(:obj) { BinData::String.new(length: 5, initial_value: "abcdefghij") }
 
   specify { obj.num_bytes.must_equal 5 }
   specify { obj.value.must_equal "abcde" }
@@ -165,27 +165,27 @@ end
 
 describe BinData::String, "with :pad_byte" do
   it "accepts a numeric value for :pad_byte" do
-    str = BinData::String.new(:length => 5, :pad_byte => 6)
+    str = BinData::String.new(length: 5, pad_byte: 6)
     str.assign("abc")
     str.must_equal "abc\x06\x06"
   end
 
   it "accepts a character for :pad_byte" do
-    str = BinData::String.new(:length => 5, :pad_byte => "R")
+    str = BinData::String.new(length: 5, pad_byte: "R")
     str.assign("abc")
     str.must_equal "abcRR"
   end
 
   it "does not accept a string for :pad_byte" do
-    params = {:length => 5, :pad_byte => "RR"}
+    params = {length: 5, pad_byte: "RR"}
     lambda { BinData::String.new(params) }.must_raise ArgumentError
   end
 end
 
 describe BinData::String, "with :trim_padding" do
   it "set false is the default" do
-    str1 = BinData::String.new(:length => 5)
-    str2 = BinData::String.new(:length => 5, :trim_padding => false)
+    str1 = BinData::String.new(length: 5)
+    str2 = BinData::String.new(length: 5, trim_padding: false)
     str1.assign("abc")
     str2.assign("abc")
     str1.must_equal "abc\0\0"
@@ -193,7 +193,7 @@ describe BinData::String, "with :trim_padding" do
   end
 
   describe "trim padding set" do
-    let(:obj) { BinData::String.new(:pad_byte => 'R', :trim_padding => true) }
+    let(:obj) { BinData::String.new(pad_byte: 'R', trim_padding: true) }
 
     it "trims the value" do
       obj.assign("abcRR")
@@ -219,8 +219,8 @@ end
 
 describe BinData::String, "with :pad_front" do
   it "set false is the default" do
-    str1 = BinData::String.new(:length => 5)
-    str2 = BinData::String.new(:length => 5, :pad_front => false)
+    str1 = BinData::String.new(length: 5)
+    str2 = BinData::String.new(length: 5, pad_front: false)
     str1.assign("abc")
     str2.assign("abc")
     str1.must_equal "abc\0\0"
@@ -228,19 +228,19 @@ describe BinData::String, "with :pad_front" do
   end
 
   it "pads to the front" do
-    str = BinData::String.new(:length => 5, :pad_byte => 'R', :pad_front => true)
+    str = BinData::String.new(length: 5, pad_byte: 'R', pad_front: true)
     str.assign("abc")
     str.must_equal "RRabc"
   end
 
   it "can alternatively be accesses by :pad_left" do
-    str = BinData::String.new(:length => 5, :pad_byte => 'R', :pad_left => true)
+    str = BinData::String.new(length: 5, pad_byte: 'R', pad_left: true)
     str.assign("abc")
     str.must_equal "RRabc"
   end
 
   describe "and :trim_padding" do
-    let(:obj) { BinData::String.new(:length => 5, :pad_byte => 'R', :pad_front => true, :trim_padding => true) }
+    let(:obj) { BinData::String.new(length: 5, pad_byte: 'R', pad_front: true, trim_padding: true) }
 
     it "assigns" do
       obj.assign("abc")
@@ -276,7 +276,7 @@ describe BinData::String, "with Ruby 1.9 encodings" do
   end
 
   it "stores read values as binary" do
-    obj = UTF8String.new(:read_length => binary_str.bytesize)
+    obj = UTF8String.new(read_length: binary_str.bytesize)
     obj.read(binary_str)
 
     obj.to_binary_s.must_equal_binary binary_str
@@ -297,14 +297,14 @@ end
 
 describe BinData::String, "warnings" do
   it "warns if has :asserted_value but no :length" do
-    obj = BinData::String.new(:asserted_value => "ABC")
+    obj = BinData::String.new(asserted_value: "ABC")
     obj.must_warn "obj does not have a :read_length parameter - returning empty string" do
       lambda { obj.read("abcde") }.must_raise BinData::ValidityError
     end
   end
 
   it "warns if has :value but no :read_length" do
-    obj = BinData::String.new(:value => "ABC")
+    obj = BinData::String.new(value: "ABC")
     obj.must_warn "obj does not have a :read_length parameter - returning empty string" do
       obj.read("abcde")
     end

data/test/stringz_test.rb

@@ -74,7 +74,7 @@ describe BinData::Stringz, "when setting the value" do
 end
 
 describe BinData::Stringz, "with max_length" do
-  let(:obj) { BinData::Stringz.new(:max_length => 5) }
+  let(:obj) { BinData::Stringz.new(max_length: 5) }
 
   it "reads less than max_length" do
     io = StringIO.new("abc\0xyz")

data/test/struct_test.rb

@@ -4,14 +4,14 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 
 describe BinData::Struct, "when initializing" do
   it "fails on non registered types" do
-    params = {:fields => [[:non_registered_type, :a]]}
+    params = {fields: [[:non_registered_type, :a]]}
     lambda {
       BinData::Struct.new(params)
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails on duplicate names" do
-    params = {:fields => [[:int8, :a], [:int8, :b], [:int8, :a]]}
+    params = {fields: [[:int8, :a], [:int8, :b], [:int8, :a]]}
     lambda {
       BinData::Struct.new(params)
     }.must_raise NameError
@@ -19,21 +19,21 @@ describe BinData::Struct, "when initializing" do
 
   it "fails on reserved names" do
     # note that #invert is from Hash.instance_methods
-    params = {:fields => [[:int8, :a], [:int8, :invert]]}
+    params = {fields: [[:int8, :a], [:int8, :invert]]}
     lambda {
       BinData::Struct.new(params)
     }.must_raise NameError
   end
 
   it "fails when field name shadows an existing method" do
-    params = {:fields => [[:int8, :object_id]]}
+    params = {fields: [[:int8, :object_id]]}
     lambda {
       BinData::Struct.new(params)
     }.must_raise NameError
   end
 
   it "fails on unknown endian" do
-    params = {:endian => 'bad value', :fields => []}
+    params = {endian: 'bad value', fields: []}
     lambda {
       BinData::Struct.new(params)
     }.must_raise ArgumentError
@@ -42,10 +42,10 @@ end
 
 describe BinData::Struct, "with anonymous fields" do
   let(:obj) {
-    params = { :fields => [
-                            [:int8, :a, {:initial_value => 5}],
+    params = { fields: [
+                            [:int8, :a, {initial_value: 5}],
                             [:int8, nil],
-                            [:int8, '', {:value => :a}]
+                            [:int8, '', {value: :a}]
                           ] }
     BinData::Struct.new(params)
   }
@@ -56,7 +56,7 @@ describe BinData::Struct, "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
@@ -68,12 +68,12 @@ end
 
 describe BinData::Struct, "with hidden fields" do
   let(:obj) {
-    params = { :hide => [:b, :c],
-               :fields => [
+    params = { hide: [:b, :c],
+               fields: [
                    [:int8, :a],
-                   [:int8, 'b', {:initial_value => 5}],
+                   [:int8, 'b', {initial_value: 5}],
                    [:int8, :c],
-                   [:int8, :d, {:value => :b}]] }
+                   [:int8, :d, {value: :b}]] }
     BinData::Struct.new(params)
   }
 
@@ -95,7 +95,7 @@ describe BinData::Struct, "with hidden fields" do
 
   it "does not include hidden fields in snapshot" do
     obj.b = 7
-    obj.snapshot.must_equal({:a => 0, :d => 7})
+    obj.snapshot.must_equal({a: 0, d: 7})
   end
 
   it "detects hidden fields with has_key?" do
@@ -104,8 +104,8 @@ describe BinData::Struct, "with hidden fields" do
 end
 
 describe BinData::Struct, "with multiple fields" do
-  let(:params) { { :fields => [ [:int8, :a], [:int8, :b] ] } }
-  let(:obj) { BinData::Struct.new({:a => 1, :b => 2}, params) }
+  let(:params) { { fields: [ [:int8, :a], [:int8, :b] ] } }
+  let(:obj) { BinData::Struct.new({a: 1, b: 2}, params) }
 
   specify { obj.field_names.must_equal [:a, :b] }
   specify { obj.to_binary_s.must_equal_binary "\x01\x02" }
@@ -165,17 +165,17 @@ describe BinData::Struct, "with multiple fields" do
     assert snap.respond_to?(:a)
     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 "assigns from partial hash" do
-    obj.assign(:a => 3)
+    obj.assign(a: 3)
     obj.a.must_equal 3
     obj.b.must_equal 0
   end
 
   it "assigns from hash" do
-    obj.assign(:a => 3, :b => 4)
+    obj.assign(a: 3, b: 4)
     obj.a.must_equal 3
     obj.b.must_equal 4
   end
@@ -230,16 +230,16 @@ end
 
 describe BinData::Struct, "with nested structs" do
   let(:obj) {
-    inner1 = [ [:int8, :w, {:initial_value => 3}],
-               [:int8, :x, {:value => :the_val}] ]
+    inner1 = [ [:int8, :w, {initial_value: 3}],
+               [:int8, :x, {value: :the_val}] ]
 
-    inner2 = [ [:int8, :y, {:value => lambda { parent.b.w }}],
+    inner2 = [ [:int8, :y, {value: -> { parent.b.w }}],
                [:int8, :z] ]
 
-    params = { :fields => [
-                 [:int8, :a, {:initial_value => 6}],
-                 [:struct, :b, {:fields => inner1, :the_val => :a}],
-                 [:struct, :c, {:fields => inner2}]] }
+    params = { fields: [
+                 [:int8, :a, {initial_value: 6}],
+                 [:struct, :b, {fields: inner1, the_val: :a}],
+                 [:struct, :c, {fields: inner2}]] }
     BinData::Struct.new(params)
   }
 
@@ -269,22 +269,23 @@ end
 
 describe BinData::Struct, "with an endian defined" do
   let(:obj) {
-    BinData::Struct.new(:endian => :little,
-                        :fields => [
-                                     [: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]]}]]}]])
+    BinData::Struct.new(endian: :little,
+                        fields: [
+                                  [: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]]}]]}]
+                                ])
   }
 
   it "uses correct endian" do
@@ -305,8 +306,8 @@ end
 
 describe BinData::Struct, "with bit fields" do
   let(:obj) {
-    params = { :fields => [ [:bit1le, :a], [:bit2le, :b], [:uint8, :c], [:bit1le, :d] ] }
-    BinData::Struct.new({:a => 1, :b => 2, :c => 3, :d => 1}, params)
+    params = { fields: [ [:bit1le, :a], [:bit2le, :b], [:uint8, :c], [:bit1le, :d] ] }
+    BinData::Struct.new({a: 1, b: 2, c: 3, d: 1}, params)
   }
 
   specify { obj.num_bytes.must_equal 3 }
@@ -331,12 +332,12 @@ end
 
 describe BinData::Struct, "with nested endian" do
   it "uses correct endian" do
-    nested_params = { :endian => :little,
-                      :fields => [[:int16, :b], [:int16, :c]] }
-    params = { :endian => :big, 
-               :fields => [[:int16, :a],
-                           [:struct, :s, nested_params],
-                           [:int16, :d]] }
+    nested_params = { endian: :little,
+                      fields: [[:int16, :b], [:int16, :c]] }
+    params = { endian: :big, 
+               fields: [[:int16, :a],
+                        [:struct, :s, nested_params],
+                        [:int16, :d]] }
     obj = BinData::Struct.new(params)
     obj.read("\x00\x01\x02\x00\x03\x00\x00\x04")
 
@@ -352,57 +353,57 @@ describe BinData::Struct, "with a search_prefix" do
   class BShort < BinData::Uint8; end
 
   it "searches symbol prefixes" do
-    obj = BinData::Struct.new(:search_prefix => :a,
-                              :fields => [ [:short, :f] ])
+    obj = BinData::Struct.new(search_prefix: :a,
+                              fields: [ [:short, :f] ])
     obj.f.class.name.must_equal "AShort"
   end
 
   it "searches string prefixes" do
-    obj = BinData::Struct.new(:search_prefix => "a",
-                              :fields => [ [:short, :f] ])
+    obj = BinData::Struct.new(search_prefix: "a",
+                              fields: [ [:short, :f] ])
     obj.f.class.name.must_equal "AShort"
   end
 
   it "searches string prefixes with optional underscore" do
-    obj = BinData::Struct.new(:search_prefix => "a_",
-                              :fields => [ [:short, :f] ])
+    obj = BinData::Struct.new(search_prefix: "a_",
+                              fields: [ [:short, :f] ])
     obj.f.class.name.must_equal "AShort"
   end
 
   it "searches multiple prefixes" do
-    obj = BinData::Struct.new(:search_prefix => [:x, :a],
-                              :fields => [ [:short, :f] ])
+    obj = BinData::Struct.new(search_prefix: [:x, :a],
+                              fields: [ [:short, :f] ])
     obj.f.class.name.must_equal "AShort"
   end
 
   it "uses parent search_prefix" do
-    nested_params = { :fields => [[:short, :f]] }
-    obj = BinData::Struct.new(:search_prefix => :a,
-                              :fields => [[:struct, :s, nested_params]])
+    nested_params = { fields: [[:short, :f]] }
+    obj = BinData::Struct.new(search_prefix: :a,
+                              fields: [[:struct, :s, nested_params]])
     obj.s.f.class.name.must_equal "AShort"
   end
 
   it "searches parent search_prefix" do
-    nested_params = { :search_prefix => :x, :fields => [[:short, :f]] }
-    obj = BinData::Struct.new(:search_prefix => :a,
-                              :fields => [[:struct, :s, nested_params]])
+    nested_params = { search_prefix: :x, fields: [[:short, :f]] }
+    obj = BinData::Struct.new(search_prefix: :a,
+                              fields: [[:struct, :s, nested_params]])
     obj.s.f.class.name.must_equal "AShort"
   end
 
   it "prioritises nested search_prefix" do
-    nested_params = { :search_prefix => :a, :fields => [[:short, :f]] }
-    obj = BinData::Struct.new(:search_prefix => :b,
-                              :fields => [[:struct, :s, nested_params]])
+    nested_params = { search_prefix: :a, fields: [[:short, :f]] }
+    obj = BinData::Struct.new(search_prefix: :b,
+                              fields: [[:struct, :s, nested_params]])
     obj.s.f.class.name.must_equal "AShort"
   end
 end
 
 describe BinData::Struct, "with byte_align" do
   let(:obj) {
-    params = { :fields => [[:int8, :a],
-                           [:int8, :b, :byte_align => 5],
-                           [:bit2, :c],
-                           [:int8, :d, :byte_align => 3]] }
+    params = { fields: [[:int8, :a],
+                        [:int8, :b, byte_align: 5],
+                        [:bit2, :c],
+                        [:int8, :d, byte_align: 3]] }
     BinData::Struct.new(params)
   }
 
@@ -412,11 +413,11 @@ describe BinData::Struct, "with byte_align" do
 
   it "reads" do
     obj.read("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
-    obj.snapshot.must_equal({ :a => 1, :b => 2, :c => 3, :d => 4 })
+    obj.snapshot.must_equal({ a: 1, b: 2, c: 3, d: 4 })
   end
 
   it "writes" do
-    obj.assign(:a => 1, :b => 2, :c => 3, :d => 4)
+    obj.assign(a: 1, b: 2, c: 3, d: 4)
     obj.to_binary_s.must_equal_binary "\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04"
   end
 
@@ -430,9 +431,9 @@ end
 
 describe BinData::Struct, "with dynamically named types" do
   it "instantiates" do
-    _ = BinData::Struct.new(:name => :my_struct, :fields => [[:int8, :a, {:initial_value => 3}]])
+    _ = BinData::Struct.new(name: :my_struct, fields: [[:int8, :a, {initial_value: 3}]])
 
-    obj = BinData::Struct.new(:fields => [[:my_struct, :v]])
+    obj = BinData::Struct.new(fields: [[:my_struct, :v]])
 
     obj.v.a.must_equal 3
   end