bindata 2.3.3 → 2.3.4

data/test/base_primitive_test.rb

@@ -102,7 +102,7 @@ describe BinData::BasePrimitive, "after initialisation" do
   let(:obj) { ExampleSingle.new }
 
   it "does not allow both :initial_value and :value" do
-    params = {:initial_value => 1, :value => 2}
+    params = {initial_value: 1, value: 2}
     lambda { ExampleSingle.new(params) }.must_raise ArgumentError
   end
 
@@ -141,7 +141,7 @@ describe BinData::BasePrimitive, "after initialisation" do
 end
 
 describe BinData::BasePrimitive, "with :initial_value" do
-  let(:obj) { ExampleSingle.new(:initial_value => 5) }
+  let(:obj) { ExampleSingle.new(initial_value: 5) }
 
   it "initial state" do
     obj.value.must_equal 5
@@ -165,7 +165,7 @@ describe BinData::BasePrimitive, "with :initial_value" do
 end
 
 describe BinData::BasePrimitive, "with :value" do
-  let(:obj) { ExampleSingle.new(:value => 5) }
+  let(:obj) { ExampleSingle.new(value: 5) }
   let(:io)  { ExampleSingle.io_with_value(56) }
 
   it "initial state" do
@@ -195,45 +195,45 @@ describe BinData::BasePrimitive, "asserting value" do
 
   describe ":assert is non boolean" do
     it "asserts sensible value" do
-      data = ExampleSingle.new(:assert => 0)
+      data = ExampleSingle.new(assert: 0)
       data.assert!
       data.value.must_equal 0
     end
 
     it "succeeds when assert is correct" do
-      data = ExampleSingle.new(:assert => 12)
+      data = ExampleSingle.new(assert: 12)
       data.read(io)
       data.value.must_equal 12
     end
 
     it "fails when assert is incorrect" do
-      data = ExampleSingle.new(:assert => lambda { 99 })
+      data = ExampleSingle.new(assert: -> { 99 })
       lambda { data.read(io) }.must_raise BinData::ValidityError
     end
   end
 
   describe ":assert is boolean" do
     it "succeeds when assert is true" do
-      data = ExampleSingle.new(:assert => lambda { value < 20 })
+      data = ExampleSingle.new(assert: -> { value < 20 })
       data.read(io)
       data.value.must_equal 12
     end
 
     it "fails when assert is false" do
-      data = ExampleSingle.new(:assert => lambda { value > 20 })
+      data = ExampleSingle.new(assert: -> { value > 20 })
       lambda { data.read(io) }.must_raise BinData::ValidityError
     end
   end
 
   describe "assigning with :assert" do
     it "succeeds when assert is correct" do
-      data = ExampleSingle.new(:assert => 12)
+      data = ExampleSingle.new(assert: 12)
       data.assign(12)
       data.value.must_equal 12
     end
 
     it "fails when assert is incorrect" do
-      data = ExampleSingle.new(:assert => 12)
+      data = ExampleSingle.new(assert: 12)
       lambda { data.assign(99) }.must_raise BinData::ValidityError
     end
   end
@@ -241,19 +241,19 @@ end
 
 describe BinData::BasePrimitive, ":asserted_value" do
   it "has :value" do
-    data = ExampleSingle.new(:asserted_value => lambda { 12 })
+    data = ExampleSingle.new(asserted_value: -> { 12 })
     data.value.must_equal 12
   end
 
   describe "assigning with :assert" do
     it "succeeds when assert is correct" do
-      data = ExampleSingle.new(:asserted_value => lambda { 12 })
+      data = ExampleSingle.new(asserted_value: -> { 12 })
       data.assign(12)
       data.value.must_equal 12
     end
 
     it "fails when assert is incorrect" do
-      data = ExampleSingle.new(:asserted_value => lambda { 12 })
+      data = ExampleSingle.new(asserted_value: -> { 12 })
       lambda { data.assign(99) }.must_raise BinData::ValidityError
     end
   end
@@ -261,13 +261,13 @@ end
 
 describe BinData::BasePrimitive do
   it "conforms to rule 1 for returning a value" do
-    data = ExampleSingle.new(:value => 5)
+    data = ExampleSingle.new(value: 5)
     data.must_equal 5
   end
 
   it "conforms to rule 2 for returning a value" do
     io = ExampleSingle.io_with_value(42)
-    data = ExampleSingle.new(:value => 5)
+    data = ExampleSingle.new(value: 5)
     data.read(io)
 
     data.stub :reading?, true do
@@ -276,13 +276,13 @@ describe BinData::BasePrimitive do
   end
 
   it "conforms to rule 3 for returning a value" do
-    data = ExampleSingle.new(:initial_value => 5)
+    data = ExampleSingle.new(initial_value: 5)
     assert data.clear?
     data.must_equal 5
   end
 
   it "conforms to rule 4 for returning a value" do
-    data = ExampleSingle.new(:initial_value => 5)
+    data = ExampleSingle.new(initial_value: 5)
     data.assign(17)
     refute data.clear?
     data.must_equal 17

data/test/base_test.rb

@@ -61,12 +61,12 @@ describe BinData::Base, "ArgExtractor" do
   it "parses parameters" do
     par = BinData::Base.new
     data = [
-      [[3                ],  3,   [],   nil],
-      [[3,            par],  3,   [],   par],
-      [[   {:a => 1}     ],  nil, [:a], nil],
-      [[   {:a => 1}, par],  nil, [:a], par],
-      [[3, {:a => 1}     ],  3,   [:a], nil],
-      [[3, {:a => 1}, par],  3,   [:a], par],
+      [[3             ],  3,   [],   nil],
+      [[3,         par],  3,   [],   par],
+      [[   {a: 1}     ],  nil, [:a], nil],
+      [[   {a: 1}, par],  nil, [:a], par],
+      [[3, {a: 1}     ],  3,   [:a], nil],
+      [[3, {a: 1}, par],  3,   [:a], par],
     ]
 
     data.each do |el|

data/test/bits_test.rb

@@ -109,7 +109,7 @@ def generate_bit_classes_to_test(endian, signed)
   (start .. 64).each do |nbits|
     name = "#{base}"
     name << "Le" if endian == :little
-    obj = BinData.const_get(name).new(:nbits => nbits)
+    obj = BinData.const_get(name).new(nbits: nbits)
     bits << [obj, nbits]
   end
 

data/test/buffer_test.rb

@@ -12,19 +12,19 @@ describe BinData::Buffer, "when instantiating" do
 
   describe "with some but not all mandatory parameters supplied" do
     it "raises an error" do
-      args = {:length => 3}
+      args = {length: 3}
       lambda { BinData::Buffer.new(args) }.must_raise ArgumentError
     end
   end
 
   it "fails if a given type is unknown" do
-    args = {:type => :does_not_exist, :length => 3}
+    args = {type: :does_not_exist, length: 3}
     lambda { BinData::Buffer.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "accepts BinData::Base as :type" do
-    obj = BinData::Int8.new(:initial_value => 5)
-    array = BinData::Buffer.new(:type => obj, :length => 3)
+    obj = BinData::Int8.new(initial_value: 5)
+    array = BinData::Buffer.new(type: obj, length: 3)
     array.must_equal 5
   end
 end
@@ -32,7 +32,7 @@ end
 describe BinData::Buffer, "subclassed with a single type" do
   class IntBuffer < BinData::Buffer
     endian :big
-    default_parameter :length => 5
+    default_parameter length: 5
 
     uint16
   end
@@ -68,14 +68,14 @@ end
 describe BinData::Buffer, "subclassed with multiple types" do
   class TupleBuffer < BinData::Buffer
     endian :big
-    default_parameter :length => 5
+    default_parameter length: 5
 
     uint16 :a
     uint16 :b
   end
 
   it "behaves as type" do
-    obj = TupleBuffer.new(:a => 1, :b => 2)
+    obj = TupleBuffer.new(a: 1, b: 2)
     obj.a.must_equal 1
     obj.b.must_equal 2
   end
@@ -97,7 +97,7 @@ describe BinData::Buffer, "subclassed with multiple types" do
   end
 
   it "writes data" do
-    obj = TupleBuffer.new(:a => 1, :b => 2)
+    obj = TupleBuffer.new(a: 1, b: 2)
     obj.to_binary_s.must_equal_binary "\000\001\000\002\000"
   end
 end
@@ -106,11 +106,11 @@ describe BinData::Buffer, "inside a Record" do
   class BufferRecord < BinData::Record
     endian :little
 
-    uint16 :buffer_length, :value => lambda { 2 * list.length + 1 }
-    buffer :list, :length => :buffer_length do
-      array :type => :int16, :read_until => :eof
+    uint16 :buffer_length, value: -> { 2 * list.length + 1 }
+    buffer :list, length: :buffer_length do
+      array type: :int16, read_until: :eof
     end
-    string :footer, :read_length => 2, :asserted_value => "ZZ"
+    string :footer, read_length: 2, asserted_value: "ZZ"
   end
 
   it "reads" do
@@ -119,22 +119,22 @@ describe BinData::Buffer, "inside a Record" do
   end
 
   it "writes" do
-    obj = BufferRecord.new(:list => [1, 2, 3, 4, 5])
+    obj = BufferRecord.new(list: [1, 2, 3, 4, 5])
     obj.to_binary_s.must_equal_binary "\013\000\001\000\002\000\003\000\004\000\005\000\000ZZ"
   end
 end
 
 describe BinData::Buffer, "nested buffers" do
   class NestedBufferRecord < BinData::Record
-    buffer :a, :length => 10 do
-      buffer :aa, :length => 5 do
-        string :read_length => 5
+    buffer :a, length: 10 do
+      buffer :aa, length: 5 do
+        string read_length: 5
       end
-      buffer :bb, :length => 20 do
-        string :read_length => 5
+      buffer :bb, length: 20 do
+        string read_length: 5
       end
     end
-    string :b, :read_length => 5
+    string :b, read_length: 5
   end
 
   it "restricts large nested buffer" do

data/test/choice_test.rb

@@ -17,7 +17,7 @@ end
 
 def create_choice(choices, options = {})
   chooser = Chooser.new
-  params = {:choices => choices, :selection => lambda { chooser.choice } }.merge(options)
+  params = {choices: choices, selection: -> { chooser.choice } }.merge(options)
   choice = BinData::Choice.new(params)
   choice.set_chooser(chooser)
   choice
@@ -28,30 +28,30 @@ describe BinData::Choice, "when instantiating" do
     args = {}
     lambda { BinData::Choice.new(args) }.must_raise ArgumentError
 
-    args = {:selection => 1}
+    args = {selection: 1}
     lambda { BinData::Choice.new(args) }.must_raise ArgumentError
 
-    args = {:choices => []}
+    args = {choices: []}
     lambda { BinData::Choice.new(args) }.must_raise ArgumentError
   end
 
   it "fails when a given type is unknown" do
-    args = {:choices => [:does_not_exist], :selection => 0}
+    args = {choices: [:does_not_exist], selection: 0}
     lambda { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails when a given type is unknown" do
-    args = {:choices => {0 => :does_not_exist}, :selection => 0}
+    args = {choices: {0 => :does_not_exist}, selection: 0}
     lambda { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails when :choices Hash has a symbol as key" do
-    args = {:choices => {:a => :uint8}, :selection => 0}
+    args = {choices: {a: :uint8}, selection: 0}
     lambda { BinData::Choice.new(args) }.must_raise ArgumentError
   end
 
   it "fails when :choices Hash has a nil key" do
-    args = {:choices => {nil => :uint8}, :selection => 0}
+    args = {choices: {nil => :uint8}, selection: 0}
     lambda { BinData::Choice.new(args) }.must_raise ArgumentError
   end
 end
@@ -112,9 +112,9 @@ describe BinData::Choice, "with sparse choices array" do
 
   let(:obj) {
     choices = [nil, nil, nil,
-               [:uint8, {:value => 30}], nil,
-               [:uint8, {:value => 50}], nil,
-               [:uint8, {:value => 70}]]
+               [:uint8, {value: 30}], nil,
+               [:uint8, {value: 50}], nil,
+               [:uint8, {value: 70}]]
     create_choice(choices)
   }
 end
@@ -123,9 +123,9 @@ describe BinData::Choice, "with choices hash" do
   include ChoiceInitializedWithArrayOrHash
 
   let(:obj) {
-    choices = {3 => [:uint8, {:value => 30}],
-               5 => [:uint8, {:value => 50}],
-               7 => [:uint8, {:value => 70}]}
+    choices = {3 => [:uint8, {value: 30}],
+               5 => [:uint8, {value: 50}],
+               7 => [:uint8, {value: 70}]}
     create_choice(choices)
   }
 end
@@ -202,7 +202,7 @@ end
 describe BinData::Choice, "with copy_on_change => true" do
   let(:obj) {
     choices = {3 => :uint8, 5 => :uint8, 7 => :uint8}
-    create_choice(choices, :copy_on_change => true)
+    create_choice(choices, copy_on_change: true)
   }
 
   it "copies value when changing selection" do
@@ -215,15 +215,15 @@ describe BinData::Choice, "with copy_on_change => true" do
 end
 
 describe BinData::Choice, "with :default" do
-  let(:choices) { { "a" => :int8, :default => :int16be } }
+  let(:choices) { { "a" => :int8, default: :int16be } }
 
   it "selects for existing case" do
-    obj = BinData::Choice.new(:selection => "a", :choices => choices)
+    obj = BinData::Choice.new(selection: "a", choices: choices)
     obj.num_bytes.must_equal 1
   end
 
   it "selects for default case" do
-    obj = BinData::Choice.new(:selection => "other", :choices => choices)
+    obj = BinData::Choice.new(selection: "other", choices: choices)
     obj.num_bytes.must_equal 2
   end
 end
@@ -231,7 +231,7 @@ end
 describe BinData::Choice, "subclassed with default parameters" do
   class DerivedChoice < BinData::Choice
     endian :big
-    default_parameter :selection => 'a'
+    default_parameter selection: 'a'
 
     uint16 'a'
     uint32 'b'
@@ -244,12 +244,12 @@ describe BinData::Choice, "subclassed with default parameters" do
   end
 
   it "overides default parameter" do
-    obj = DerivedChoice.new(:selection => 'b')
+    obj = DerivedChoice.new(selection: 'b')
     obj.num_bytes.must_equal 4
   end
 
   it "selects default selection" do
-    obj = DerivedChoice.new(:selection => 'z')
+    obj = DerivedChoice.new(selection: 'z')
     obj.num_bytes.must_equal 8
   end
 end

data/test/count_bytes_remaining_test.rb

@@ -33,7 +33,7 @@ describe BinData::CountBytesRemaining do
   end
 
   it "accepts BinData::BasePrimitive parameters" do
-    count = BinData::CountBytesRemaining.new(:assert => 2)
+    count = BinData::CountBytesRemaining.new(assert: 2)
     lambda {
       count.read("xyz")
     }.must_raise BinData::ValidityError

data/test/delayed_io_test.rb

@@ -12,19 +12,19 @@ describe BinData::DelayedIO, "when instantiating" do
 
   describe "with some but not all mandatory parameters supplied" do
     it "raises an error" do
-      args = {:read_abs_offset => 3}
+      args = {read_abs_offset: 3}
       lambda { BinData::DelayedIO.new(args) }.must_raise ArgumentError
     end
   end
 
   it "fails if a given type is unknown" do
-    args = {:type => :does_not_exist, :length => 3}
+    args = {type: :does_not_exist, length: 3}
     lambda { BinData::DelayedIO.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "accepts BinData::Base as :type" do
-    obj = BinData::Int8.new(:initial_value => 5)
-    array = BinData::DelayedIO.new(:type => obj, :read_abs_offset => 3)
+    obj = BinData::Int8.new(initial_value: 5)
+    array = BinData::DelayedIO.new(type: obj, read_abs_offset: 3)
     array.must_equal 5
   end
 end
@@ -32,7 +32,7 @@ end
 describe BinData::DelayedIO, "subclassed with a single type" do
   class IntDelayedIO < BinData::DelayedIO
     endian :big
-    default_parameter :read_abs_offset => 5
+    default_parameter read_abs_offset: 5
 
     uint16
   end
@@ -120,27 +120,27 @@ end
 describe BinData::DelayedIO, "subclassed with multiple types" do
   class StringDelayedIO < BinData::DelayedIO
     endian :big
-    default_parameter :read_abs_offset => 5
+    default_parameter read_abs_offset: 5
 
-    uint16 :len, :value => lambda { str.length }
-    string :str, :read_length => :len
+    uint16 :len, value: -> { str.length }
+    string :str, read_length: :len
   end
 
   it "behaves as type" do
-    obj = StringDelayedIO.new(:str => "hello")
-    obj.snapshot.must_equal({:len => 5, :str => "hello"})
+    obj = StringDelayedIO.new(str: "hello")
+    obj.snapshot.must_equal({len: 5, str: "hello"})
   end
 
   it "reads explicitly" do
     obj = StringDelayedIO.read "\001\002\003\004\005\000\003abc\013"
     obj.read_now!
 
-    obj.snapshot.must_equal({:len => 3, :str => "abc"})
+    obj.snapshot.must_equal({len: 3, str: "abc"})
   end
 
   it "writes explicitly" do
     io = StringIO.new "\001\002\003\004\005\006\007\010\011\012\013\014\015"
-    obj = StringDelayedIO.new(:str => "hello")
+    obj = StringDelayedIO.new(str: "hello")
     obj.write(io)
     obj.write_now!
     io.value.must_equal "\001\002\003\004\005\000\005hello\015"
@@ -151,19 +151,19 @@ describe BinData::DelayedIO, "inside a Record" do
   class DelayedIORecord < BinData::Record
     endian :little
 
-    uint16 :str_length, :value => lambda { str.length }
-    delayed_io :str, :read_abs_offset => 4 do
-      string :read_length => :str_length
+    uint16 :str_length, value: -> { str.length }
+    delayed_io :str, read_abs_offset: 4 do
+      string read_length: :str_length
     end
-    delayed_io :my_int, :read_abs_offset => 2 do
-      uint16 :initial_value => 7
+    delayed_io :my_int, read_abs_offset: 2 do
+      uint16 initial_value: 7
     end
   end
 
   it "reads" do
     obj = DelayedIORecord.read "\x05\x00\x03\x0012345"
     obj.num_bytes.must_equal 2
-    obj.snapshot.must_equal({:str_length => 0, :str => "", :my_int => 7})
+    obj.snapshot.must_equal({str_length: 0, str: "", my_int: 7})
   end
 
   it "reads explicitly" do
@@ -171,11 +171,11 @@ describe BinData::DelayedIO, "inside a Record" do
     obj.str.read_now!
     obj.my_int.read_now!
     obj.num_bytes.must_equal 2
-    obj.snapshot.must_equal({:str_length => 5, :str => "12345", :my_int => 3})
+    obj.snapshot.must_equal({str_length: 5, str: "12345", my_int: 3})
   end
 
   it "writes" do
-    obj = DelayedIORecord.new(:str => "abc", :my_int => 2)
+    obj = DelayedIORecord.new(str: "abc", my_int: 2)
     io = StringIO.new
     obj.write(io)
     obj.str.write_now!
@@ -188,36 +188,36 @@ describe BinData::DelayedIO, "with auto_call" do
   class AutoCallDelayedIORecord < BinData::Record
     auto_call_delayed_io
     uint8 :a
-    delayed_io :b, :read_abs_offset => 1 do
+    delayed_io :b, read_abs_offset: 1 do
       uint8
     end
   end
 
   it "class reads" do
     obj = AutoCallDelayedIORecord.read "\x01\x02"
-    obj.snapshot.must_equal({:a => 1, :b => 2})
+    obj.snapshot.must_equal({a: 1, b: 2})
   end
 
   it "reads" do
     obj = AutoCallDelayedIORecord.new
     obj.read "\x01\x02"
-    obj.snapshot.must_equal({:a => 1, :b => 2})
+    obj.snapshot.must_equal({a: 1, b: 2})
   end
 
   it "writes" do
-    obj = AutoCallDelayedIORecord.new(:a => 1, :b => 2)
+    obj = AutoCallDelayedIORecord.new(a: 1, b: 2)
     io = StringIO.new
     obj.write(io)
     io.value.must_equal "\x01\x02"
   end
 
   it "to_binary_s" do
-    obj = AutoCallDelayedIORecord.new(:a => 1, :b => 2)
+    obj = AutoCallDelayedIORecord.new(a: 1, b: 2)
     obj.to_binary_s.must_equal_binary "\x01\x02"
   end
 
   it "num_bytes" do
-    obj = AutoCallDelayedIORecord.new(:a => 1, :b => 2)
+    obj = AutoCallDelayedIORecord.new(a: 1, b: 2)
     obj.num_bytes.must_equal 2
   end
 end