bindata 2.3.3 → 2.3.4

data/test/system_test.rb

@@ -4,20 +4,20 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 
 describe "lambdas with index" do
   class NestedLambdaWithIndex < BinData::Record
-    uint8 :a, :value => lambda { index * 10 }
+    uint8 :a, value: -> { index * 10 }
   end
 
   it "uses index of containing array" do
-    arr = BinData::Array.new(:type =>
-                               [:uint8, { :value => lambda { index * 10 } }],
-                             :initial_length => 3)
+    arr = BinData::Array.new(type:
+                               [:uint8, { value: -> { index * 10 } }],
+                             initial_length: 3)
     arr.snapshot.must_equal [0, 10, 20]
   end
 
   it "uses index of nearest containing array" do
-    arr = BinData::Array.new(:type => :nested_lambda_with_index,
-                             :initial_length => 3)
-    arr.snapshot.must_equal [{:a => 0}, {:a => 10}, {:a => 20}]
+    arr = BinData::Array.new(type: :nested_lambda_with_index,
+                             initial_length: 3)
+    arr.snapshot.must_equal [{a: 0}, {a: 10}, {a: 20}]
   end
 
   it "fails if there is no containing array" do
@@ -29,12 +29,12 @@ end
 describe "lambdas with parent" do
   it "accesses immediate parent when no parent is specified" do
     class NestedLambdaWithoutParent < BinData::Record
-      int8 :a, :value => 5
-      int8 :b, :value => lambda { a }
+      int8 :a, value: 5
+      int8 :b, value: -> { a }
     end
 
     class TestLambdaWithoutParent < BinData::Record
-      int8   :a, :value => 3
+      int8   :a, value: 3
       nested_lambda_without_parent :x
     end
 
@@ -44,12 +44,12 @@ describe "lambdas with parent" do
 
   it "accesses parent's parent when parent is specified" do
     class NestedLambdaWithParent < BinData::Record
-      int8 :a, :value => 5
-      int8 :b, :value => lambda { parent.a }
+      int8 :a, value: 5
+      int8 :b, value: -> { parent.a }
     end
 
     class TestLambdaWithParent < BinData::Record
-      int8   :a, :value => 3
+      int8   :a, value: 3
       nested_lambda_with_parent :x
     end
 
@@ -60,20 +60,20 @@ end
 
 describe BinData::Record, "with choice field" do
   class TupleRecord < BinData::Record
-    uint8 :a, :value => 3
-    uint8 :b, :value => 5
+    uint8 :a, value: 3
+    uint8 :b, value: 5
   end
 
   class RecordWithChoiceField < BinData::Record
-    choice :x, :selection => 0 do
+    choice :x, selection: 0 do
       tuple_record
     end
   end
 
   class RecordWithNestedChoiceField < BinData::Record
-    uint8  :sel, :value => 0
-    choice :x, :selection => 0 do
-      choice :selection => :sel do
+    uint8  :sel, value: 0
+    choice :x, selection: 0 do
+      choice selection: :sel do
         tuple_record
       end
     end
@@ -119,7 +119,7 @@ describe BinData::Record, "containing bitfields" do
       bit4 :w
     end
 
-    array  :b, :type => :bit1, :initial_length => 9
+    array  :b, type: :bit1, initial_length: 9
 
     struct :c do
       bit2 :x
@@ -163,32 +163,32 @@ describe "Objects with debug_name" do
   end
 
   it "includes array index" do
-    arr = BinData::Array.new(:type => :uint8, :initial_length => 2)
+    arr = BinData::Array.new(type: :uint8, initial_length: 2)
     arr[2].debug_name.must_equal "obj[2]"
   end
 
   it "includes field name" do
-    s = BinData::Struct.new(:fields => [[:uint8, :a]])
+    s = BinData::Struct.new(fields: [[:uint8, :a]])
     s.a.debug_name.must_equal "obj.a"
   end
 
   it "delegates to choice" do
-    choice_params = {:choices => [:uint8], :selection => 0}
-    s = BinData::Struct.new(:fields => [[:choice, :a, choice_params]])
+    choice_params = {choices: [:uint8], selection: 0}
+    s = BinData::Struct.new(fields: [[:choice, :a, choice_params]])
     s.a.debug_name.must_equal "obj.a"
   end
 
   it "nests" do
-    nested_struct_params = {:fields => [[:uint8, :c]]}
-    struct_params = {:fields => [[:struct, :b, nested_struct_params]]}
-    s = BinData::Struct.new(:fields => [[:struct, :a, struct_params]])
+    nested_struct_params = {fields: [[:uint8, :c]]}
+    struct_params = {fields: [[:struct, :b, nested_struct_params]]}
+    s = BinData::Struct.new(fields: [[:struct, :a, struct_params]])
     s.a.b.c.debug_name.must_equal "obj.a.b.c"
   end
 end
 
 describe "Tracing"  do
   it "should trace arrays" do
-    arr = BinData::Array.new(:type => :int8, :initial_length => 5)
+    arr = BinData::Array.new(type: :int8, initial_length: 5)
 
     io = StringIO.new
     BinData::trace_reading(io) { arr.read("\x01\x02\x03\x04\x05") }
@@ -213,7 +213,7 @@ describe "Tracing"  do
   end
 
   it "traces choice selection" do
-    obj = BinData::Choice.new(:choices => [:int8, :int16be], :selection => 0)
+    obj = BinData::Choice.new(choices: [:int8, :int16be], selection: 0)
 
     io = StringIO.new
     BinData::trace_reading(io) { obj.read("\x01") }
@@ -222,7 +222,7 @@ describe "Tracing"  do
   end
 
   it "trims long trace values" do
-    obj = BinData::String.new(:read_length => 40)
+    obj = BinData::String.new(read_length: 40)
 
     io = StringIO.new
     BinData::trace_reading(io) { obj.read("0000000000111111111122222222223333333333") }
@@ -233,47 +233,47 @@ end
 
 describe "Forward referencing with Primitive" do
   class FRPrimitive < BinData::Record
-    uint8  :len, :value => lambda { data.length }
-    string :data, :read_length => :len
+    uint8  :len, value: -> { data.length }
+    string :data, read_length: :len
   end
 
   let(:obj) { FRPrimitive.new }
 
   it "initialises" do
-    obj.snapshot.must_equal({:len => 0, :data => ""})
+    obj.snapshot.must_equal({len: 0, data: ""})
   end
 
   it "reads" do
     obj.read("\x04test")
-    obj.snapshot.must_equal({:len => 4, :data => "test"})
+    obj.snapshot.must_equal({len: 4, data: "test"})
   end
 
   it "sets value" do
     obj.data = "hello"
-    obj.snapshot.must_equal({:len => 5, :data => "hello"})
+    obj.snapshot.must_equal({len: 5, data: "hello"})
   end
 end
 
 describe "Forward referencing with Array" do
   class FRArray < BinData::Record
-    uint8  :len, :value => lambda { data.length }
-    array :data, :type => :uint8, :initial_length => :len
+    uint8  :len, value: -> { data.length }
+    array :data, type: :uint8, initial_length: :len
   end
 
   let(:obj) { FRArray.new }
 
   it "initialises" do
-    obj.snapshot.must_equal({:len => 0, :data => []})
+    obj.snapshot.must_equal({len: 0, data: []})
   end
 
   it "reads" do
     obj.read("\x04\x01\x02\x03\x04")
-    obj.snapshot.must_equal({:len => 4, :data => [1, 2, 3, 4]})
+    obj.snapshot.must_equal({len: 4, data: [1, 2, 3, 4]})
   end
 
   it "sets value" do
     obj.data = [1, 2, 3]
-    obj.snapshot.must_equal({:len => 3, :data => [1, 2, 3]})
+    obj.snapshot.must_equal({len: 3, data: [1, 2, 3]})
   end
 end
 
@@ -281,13 +281,13 @@ describe "Evaluating custom parameters" do
   class CustomParameterRecord < BinData::Record
     mandatory_parameter :zz
 
-    uint8 :a, :value => :zz
-    uint8 :b, :value => :a
-    uint8 :c, :custom => :b
+    uint8 :a, value: :zz
+    uint8 :b, value: :a
+    uint8 :c, custom: :b
   end
 
   it "recursively evaluates parameter" do
-    obj = CustomParameterRecord.new(:zz => 5)
+    obj = CustomParameterRecord.new(zz: 5)
     obj.c.eval_parameter(:custom).must_equal 5
   end
 end
@@ -299,29 +299,29 @@ describe BinData::Record, "with custom sized integers" do
 
   it "reads as expected" do
     str = "\x00\x00\x00\x00\x05"
-    CustomIntRecord.read(str).snapshot.must_equal({:a => 5})
+    CustomIntRecord.read(str).snapshot.must_equal({a: 5})
   end
 end
 
 describe BinData::Record, "with choice field" do
   class ChoiceFieldRecord < BinData::Record
     int8 :a
-    choice :b, :selection => :a do
-      struct 1, :fields => [[:int8, :v]]
+    choice :b, selection: :a do
+      struct 1, fields: [[:int8, :v]]
     end
   end
 
   it "assigns" do
-    obj = BinData::Array.new(:type => :choice_field_record)
-    data = ChoiceFieldRecord.new(:a => 1, :b => {:v => 3})
+    obj = BinData::Array.new(type: :choice_field_record)
+    data = ChoiceFieldRecord.new(a: 1, b: {v: 3})
     obj.assign([data])
   end
 end
 
 describe BinData::Primitive, "representing a string" do
   class PascalStringPrimitive < BinData::Primitive
-    uint8  :len,  :value => lambda { data.length }
-    string :data, :read_length => :len
+    uint8  :len,  value: -> { data.length }
+    string :data, read_length: :len
 
     def get;   self.data; end
     def set(v) self.data = v; end

data/test/virtual_test.rb

@@ -22,7 +22,7 @@ describe BinData::Virtual do
 
   it "asserts on #read" do
     data = []
-    obj = BinData::Virtual.new(:assert => lambda { data << 1; true })
+    obj = BinData::Virtual.new(assert: -> { data << 1; true })
 
     obj.read ""
     data.must_equal [1]
@@ -30,7 +30,7 @@ describe BinData::Virtual do
 
   it "asserts on #assign" do
     data = []
-    obj = BinData::Virtual.new(:assert => lambda { data << 1; true })
+    obj = BinData::Virtual.new(assert: -> { data << 1; true })
 
     obj.assign("foo")
     data.must_equal [1]
@@ -42,7 +42,7 @@ describe BinData::Virtual do
   end
 
   it "accepts the :value parameter" do
-    obj = BinData::Virtual.new(:value => 3)
+    obj = BinData::Virtual.new(value: 3)
     obj.must_equal 3
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bindata
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.3.4
 platform: ruby
 authors:
 - Dion Mendel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-07 00:00:00.000000000 Z
+date: 2016-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake