bindata 2.5.0 → 3.0.0

data/test/record_test.rb

@@ -5,7 +5,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 describe BinData::Record do
   it "is not registered" do
     _ {
-      BinData::RegisteredClasses.lookup("Record")
+      BinData::RegisteredClasses.lookup("BinData", "Record")
     }.must_raise BinData::UnRegisteredTypeError
   end
 end
@@ -101,6 +101,15 @@ describe BinData::Record, "when defining with errors" do
     }.must_raise_on_line SyntaxError, 3, "endian must be called before defining fields in BadEndianPosRecord"
   end
 
+  it "fails when search_namespace is after a field" do
+    _ {
+      class BadSearchNamespacePosRecord < BinData::Record
+        string :a
+        search_namespace :ns
+      end
+    }.must_raise_on_line SyntaxError, 3, "search_namespace must be called before defining fields in BadSearchNamespacePosRecord"
+  end
+
   it "fails when search_prefix is after a field" do
     _ {
       class BadSearchPrefixPosRecord < BinData::Record
@@ -396,6 +405,88 @@ describe BinData::Record, "with an endian defined" do
   end
 end
 
+describe BinData::Record, "with namespaces" do
+  module ModA
+    class MyInt < BinData::Int8; end
+    class ARecord < BinData::Record
+      my_int :a
+    end
+  end
+
+  module ModB
+    class BRecord < BinData::Record
+      mod_a_my_int :a
+    end
+  end
+
+  it "looks up with relative name" do
+    obj = ModA::ARecord.new
+    _(obj.a.class.name).must_equal "ModA::MyInt"
+  end
+
+  it "looks up with absolute name" do
+    obj = ModB::BRecord.new
+    _(obj.a.class.name).must_equal "ModA::MyInt"
+  end
+end
+
+describe BinData::Record, "with search_namespace" do
+  module ModA
+    class Snamespace < BinData::Int8; end
+  end
+  module ModB
+    class Snamespace < BinData::Int8; end
+  end
+
+  class RecordWithSearchNamespace < BinData::Record
+    search_namespace :ModA
+    snamespace :f
+  end
+
+  class RecordWithParentSearchNamespace < BinData::Record
+    search_namespace :ModA
+    struct :s do
+      snamespace :f
+    end
+  end
+
+  class RecordWithNestedSearchNamespace < BinData::Record
+    search_namespace :ModA
+    struct :s do
+      search_namespace :x
+      snamespace :f
+    end
+  end
+
+  class RecordWithPrioritisedNestedSearchNamespace < BinData::Record
+    search_namespace :ModB
+    struct :s do
+      search_namespace :ModA
+      snamespace :f
+    end
+  end
+
+  it "uses search_prefix" do
+    obj = RecordWithSearchNamespace.new
+    _(obj.f.class.name).must_equal "ModA::Snamespace"
+  end
+
+  it "uses parent search_prefix" do
+    obj = RecordWithParentSearchNamespace.new
+    _(obj.s.f.class.name).must_equal "ModA::Snamespace"
+  end
+
+  it "uses nested search_prefix" do
+    obj = RecordWithNestedSearchNamespace.new
+    _(obj.s.f.class.name).must_equal "ModA::Snamespace"
+  end
+
+  it "uses prioritised nested search_prefix" do
+    obj = RecordWithPrioritisedNestedSearchNamespace.new
+    _(obj.s.f.class.name).must_equal "ModA::Snamespace"
+  end
+end
+
 describe BinData::Record, "with search_prefix" do
   class ASprefix < BinData::Int8; end
   class BSprefix < BinData::Int8; end
@@ -449,6 +540,29 @@ describe BinData::Record, "with search_prefix" do
   end
 end
 
+describe BinData::Record, "with endian :big_and_little and search_namespace" do
+  module Ns1
+    class BNLIntBe < BinData::Int16be; end
+    class BNLIntLe < BinData::Int16le; end
+  end
+
+  class RecordWithBnLEndianAndSearchNamespace < BinData::Record
+    endian :big_and_little
+    search_namespace :ns1
+     bnl_int :a, value: 1
+  end
+
+  it "creates big endian version" do
+    obj = RecordWithBnLEndianAndSearchNamespaceBe.new
+    _(obj.to_binary_s).must_equal_binary "\x00\x01"
+  end
+
+  it "creates little endian version" do
+    obj = RecordWithBnLEndianAndSearchNamespaceLe.new
+    _(obj.to_binary_s).must_equal_binary "\x01\x00"
+  end
+end
+
 describe BinData::Record, "with endian :big_and_little" do
   class RecordWithBnLEndian < BinData::Record
     endian :big_and_little
@@ -457,7 +571,7 @@ describe BinData::Record, "with endian :big_and_little" do
 
   it "is not registered" do
     _ {
-      BinData::RegisteredClasses.lookup("RecordWithBnLEndian")
+      BinData::RegisteredClasses.lookup("", "RecordWithBnLEndian")
     }.must_raise BinData::UnRegisteredTypeError
   end
 
@@ -515,7 +629,7 @@ describe BinData::Record, "with endian :big_and_little when subclassed" do
 
   it "is not registered" do
     _ {
-      BinData::RegisteredClasses.lookup("BRecordWithBnLEndian")
+      BinData::RegisteredClasses.lookup("", "BRecordWithBnLEndian")
     }.must_raise BinData::UnRegisteredTypeError
   end
 

data/test/registry_test.rb

@@ -7,31 +7,32 @@ describe BinData::Registry do
   B = Class.new
   C = Class.new
   D = Class.new
+  E = Class.new
 
   let(:r) { BinData::Registry.new }
 
   it "lookups registered names" do
-    r.register('ASubClass', A)
-    r.register('AnotherSubClass', B)
+    r.register("", 'ASubClass', A)
+    r.register("", 'AnotherSubClass', B)
 
-    _(r.lookup('ASubClass')).must_equal A
-    _(r.lookup('a_sub_class')).must_equal A
-    _(r.lookup('AnotherSubClass')).must_equal B
-    _(r.lookup('another_sub_class')).must_equal B
+    _(r.lookup("", 'ASubClass')).must_equal A
+    _(r.lookup("", 'a_sub_class')).must_equal A
+    _(r.lookup("", 'AnotherSubClass')).must_equal B
+    _(r.lookup("", 'another_sub_class')).must_equal B
   end
 
   it "does not lookup unregistered names" do
     _ {
-      r.lookup('a_non_existent_sub_class')
+      r.lookup("", 'a_non_existent_sub_class')
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "unregisters names" do
-    r.register('ASubClass', A)
-    r.unregister('ASubClass')
+    r.register("", 'ASubClass', A)
+    r.unregister("", 'ASubClass')
 
     _ {
-      r.lookup('ASubClass')
+      r.lookup("", 'ASubClass')
     }.must_raise BinData::UnRegisteredTypeError
   end
 
@@ -39,10 +40,10 @@ describe BinData::Registry do
     w, $-w = $-w, nil  # disable warning
 
     begin
-      r.register('A', A)
-      r.register('A', B)
+      r.register("", 'A', A)
+      r.register("", 'A', B)
 
-      _(r.lookup('a')).must_equal B
+      _(r.lookup("", 'a')).must_equal B
     ensure
       $-w = w
     end
@@ -55,31 +56,27 @@ describe BinData::Registry do
   it "converts adjacent caps camelCase to underscores" do
     _(r.underscore_name('XYZCamelCase')).must_equal 'xyz_camel_case'
   end
-
-  it "ignores the outer nestings of classes" do
-    _(r.underscore_name('A::B::C')).must_equal 'c'
-  end
 end
 
 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("xx", 'uint24', {endian: :big}).to_s).must_equal "BinData::Uint24be"
+    _(r.lookup("yy", 'uint24', {endian: :little}).to_s).must_equal "BinData::Uint24le"
   end
 
   it "does not lookup integers without endian" do
     _ {
-      r.lookup("int24")
+      r.lookup("", 'int24')
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "provides a nice error message when endian is omitted" do
     begin
-      r.lookup("int24")
+      r.lookup("", 'int24')
     rescue BinData::UnRegisteredTypeError => e
       _(e.message).must_equal "int24, do you need to specify endian?"
     end
@@ -87,41 +84,41 @@ describe BinData::Registry, "with numerics" do
 
   it "does not lookup non byte based integers" do
     _ {
-      r.lookup("int3")
+      r.lookup("", 'int3')
     }.must_raise BinData::UnRegisteredTypeError
     _ {
-      r.lookup("int3", {endian: :big})
+      r.lookup("", 'int3', {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
     _ {
-      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("xx", 'double', {endian: :big}).to_s).must_equal "BinData::DoubleBe"
+    _(r.lookup("yy", 'double', {endian: :little}).to_s).must_equal "BinData::DoubleLe"
   end
 
   it "lookup bits" do
-    _(r.lookup("bit5").to_s).must_equal "BinData::Bit5"
-    _(r.lookup("sbit5").to_s).must_equal "BinData::Sbit5"
-    _(r.lookup("bit6le").to_s).must_equal "BinData::Bit6le"
+    _(r.lookup("", 'bit5').to_s).must_equal "BinData::Bit5"
+    _(r.lookup("", 'sbit5').to_s).must_equal "BinData::Sbit5"
+    _(r.lookup("", 'bit6le').to_s).must_equal "BinData::Bit6le"
   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
 
@@ -129,53 +126,109 @@ describe BinData::Registry, "with endian specific types" do
   let(:r) { BinData::Registry.new }
 
   before do
-    r.register('a_le', A)
-    r.register('b_be', B)
+    r.register("", 'a_le', A)
+    r.register("", 'b_be', B)
   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
     _ {
-      r.lookup('a', {endian: :big})
+      r.lookup("", 'a', {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "lookup prefers exact type" do
-    r.register('c', C)
-    r.register('c_le', D)
+    r.register("", 'c', C)
+    r.register("", 'c_le', D)
+
+    _(r.lookup("", 'c', {endian: :little})).must_equal C
+  end
+end
+
+describe BinData::Registry, "with search_namespace" do
+  let(:r) { BinData::Registry.new }
+
+  before do
+    r.register("", 'a_f', A)
+    r.register("", 'b_f', B)
+  end
+
+  it "lookup single search_namespace" do
+    _(r.lookup("", 'f', {search_namespace: :a})).must_equal A
+  end
+
+  it "lookup single search_namespace with endian" do
+    _(r.lookup("", 'f', {search_namespace: :a, endian: :little})).must_equal A
+  end
 
-    _(r.lookup('c', {endian: :little})).must_equal C
+  it "lookup multiple search_namespace" do
+    _(r.lookup("", 'f', {search_namespace: [:x, :a]})).must_equal A
+  end
+
+  it "lookup first match in search_namespace" do
+    _(r.lookup("", 'f', {search_namespace: [:a, :b]})).must_equal A
   end
 end
 
-describe BinData::Registry, "with search_prefix" do
+describe BinData::Registry, "with namespaces" do
   let(:r) { BinData::Registry.new }
 
   before do
-    r.register('a_f', A)
-    r.register('b_f', B)
+    r.register('ModA::ModB', 'obj1', A)       # ModA::ModB::Obj1
+    r.register('ModA::ModB', 'obj2', B)       # ModA::ModB::Obj2
+    r.register('mod_a_mod_b', 'ns1_obj3', C)  # ModA::ModB::Ns1Obj3
+    r.register('mod_a_mod_c', 'Obj1', D)      # ModA::ModC::Obj1
+    r.register('mod_a_mod_c', 'Obj4', E)      # ModA::ModC::Obj4
+  end
+
+  it "lookups inside the namespace" do
+    _(r.lookup("mod_a_mod_c", 'obj1')).must_equal D
+    _(r.lookup("ModA::ModC", 'obj4')).must_equal E
+  end
+
+  it "doesn't lookup inside a different namespace" do
+    _ {
+      r.lookup("mod_a_mod_c", 'obj2')
+    }.must_raise BinData::UnRegisteredTypeError
+
+    _ {
+      r.lookup("mod_a", 'obj2')
+    }.must_raise BinData::UnRegisteredTypeError
+
+    _ {
+      r.lookup("", 'obj2')
+    }.must_raise BinData::UnRegisteredTypeError
   end
 
-  it "lookup single search_prefix" do
-    _(r.lookup('f', {search_prefix: :a})).must_equal A
+  it "lookups with relative namespace" do
+    _(r.lookup("mod_a_mod_c", 'mod_b_obj1')).must_equal A
+    _(r.lookup("mod_a", 'mod_b_obj1')).must_equal A
   end
 
-  it "lookup single search_prefix with endian" do
-    _(r.lookup('f', {search_prefix: :a, endian: :little})).must_equal A
+  it "lookups with absolute namespace" do
+    _(r.lookup("mod_a_mod_c", 'mod_a_mod_b_obj1')).must_equal A
+    _(r.lookup("", 'mod_a_mod_b_obj1')).must_equal A
   end
 
-  it "lookup multiple search_prefix" do
-    _(r.lookup('f', {search_prefix: [:x, :a]})).must_equal A
+  it "lookups with search_namespace" do
+    _(r.lookup("mod_a_mod_c", 'obj1', {search_namespace: :mod_b})).must_equal D
+    _(r.lookup("mod_a", 'obj1', {search_namespace: :mod_b})).must_equal A
+    _(r.lookup("mod_a_mod_c", 'obj2', {search_namespace: :mod_b})).must_equal B
+    _(r.lookup("mod_a_mod_c", 'obj2', {search_namespace: :mod_a_mod_b})).must_equal B
+    _(r.lookup("", 'obj1', {search_namespace: [:mod_a_mod_b, :mod_a_mod_c]})).must_equal A
+    _(r.lookup("", 'obj1', {search_namespace: [:mod_a_mod_c, :mod_a_mod_b]})).must_equal D
   end
 
-  it "lookup first match in search_prefix" do
-    _(r.lookup('f', {search_prefix: [:a, :b]})).must_equal A
+  it "lookups with old style search_prefix" do
+    _(r.lookup("mod_a_mod_b", 'obj3', {search_prefix: :ns1})).must_equal C
+    _(r.lookup("mod_a_mod_c", 'obj3', {search_prefix: :ns1})).must_equal C
+    _(r.lookup("", 'obj3', {search_prefix: :ns1})).must_equal C
   end
 end

data/test/string_test.rb

@@ -295,6 +295,14 @@ describe BinData::String, "with Ruby 1.9 encodings" do
   end
 end
 
+describe BinData::String, "with Ruby 3.0 keyword arguments" do
+  let(:obj) { BinData::String.new("testing\x92") }
+
+  it "successfully delegates calls with keyword args" do
+    _(obj.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')).must_equal "testing?"
+  end
+end
+
 describe BinData::String, "warnings" do
   it "warns if has :asserted_value but no :length" do
     obj = BinData::String.new(asserted_value: "ABC")

data/test/struct_test.rb

@@ -409,6 +409,66 @@ describe BinData::Struct, "with nested endian" do
   end
 end
 
+describe BinData::Struct, "with a search_namespace" do
+  module ModA
+    class Short < BinData::Uint8; end
+  end
+  module ModB
+    class Short < BinData::Uint8; end
+  end
+
+  it "searches underscore symbol namespaces" do
+    obj = BinData::Struct.new(search_namespace: :mod_a,
+                              fields: [ [:short, :f] ])
+    _(obj.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "searches camelCase symbol namespaces" do
+    obj = BinData::Struct.new(search_namespace: :ModA,
+                              fields: [ [:short, :f] ])
+    _(obj.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "searches string namespaces" do
+    obj = BinData::Struct.new(search_namespace: "ModA",
+                              fields: [ [:short, :f] ])
+    _(obj.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "searches module namespaces" do
+    obj = BinData::Struct.new(search_namespace: ModA,
+                              fields: [ [:short, :f] ])
+    _(obj.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "searches multiple namespaces" do
+    obj = BinData::Struct.new(search_namespace: [:x, :ModA],
+                              fields: [ [:short, :f] ])
+    _(obj.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "uses parent search_namespace" do
+    nested_params = { fields: [[:short, :f]] }
+    obj = BinData::Struct.new(search_namespace: :ModA,
+                              fields: [[:struct, :s, nested_params]])
+    _(obj.s.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "searches parent search_namespace" do
+    nested_params = { search_namespace: :x, fields: [[:short, :f]] }
+    obj = BinData::Struct.new(search_namespace: :ModA,
+                              fields: [[:struct, :s, nested_params]])
+    _(obj.s.f.class.name).must_equal "ModA::Short"
+  end
+
+  it "prioritises nested search_namespace" do
+    nested_params = { search_namespace: :ModA, fields: [[:short, :f]] }
+    obj = BinData::Struct.new(search_namespace: :b,
+                              fields: [[:struct, :s, nested_params]])
+    _(obj.s.f.class.name).must_equal "ModA::Short"
+  end
+end
+
 describe BinData::Struct, "with a search_prefix" do
   class AShort < BinData::Uint8; end
   class BShort < BinData::Uint8; end
@@ -506,10 +566,12 @@ 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, namespace: :ns, fields: [[:int8, :a, {initial_value: 3}]])
 
-    obj = BinData::Struct.new(fields: [[:my_struct, :v]])
+    obj1 = BinData::Struct.new(fields: [[:ns_my_struct, :v]])
+    obj2 = BinData::Struct.new(namespace: :ns, fields: [[:my_struct, :v]])
 
-    _(obj.v.a).must_equal 3
+    _(obj1.v.a).must_equal 3
+    _(obj2.v.a).must_equal 3
   end
 end

data/test/system_test.rb

@@ -490,7 +490,6 @@ describe BinData::Buffer, "with seek_abs" do
   end
 end
 
-
 describe BinData::Record, "buffered readahead" do
   class BufferedReadaheadRecord < BinData::Record
     buffer :a, length: 5 do
@@ -512,3 +511,28 @@ describe BinData::Record, "buffered readahead" do
     _ { BufferedReadaheadRecord.read "123456X890" }.must_raise IOError
   end
 end
+
+describe BinData::Record, "inside modules" do
+  module M
+    class Type1 < BinData::Record
+      int8 :v
+    end
+    class MyRec < BinData::Record
+      type1 :f1
+
+      struct :s1, fields: [ [:type1, :f2] ]
+      struct :s2 do
+        type1 :f3
+      end
+
+      array :arr1, type: :type1, initial_length: 3
+      array :arr2, initial_length: 3 do
+        type1
+      end
+    end
+  end
+
+  it "parses" do
+    M::MyRec.new
+  end
+end

data/test/test_helper.rb

@@ -43,11 +43,15 @@ module Minitest::Assertions
     ex = assert_raises(exp, &block)
     assert_equal(msg, ex.message) if msg
 
-    idx = ex.backtrace.find_index { |bt| /:in `assert_raises_on_line'$/ =~ bt }
+    line_num_regex = /(.*):(\d+)(:in.*)$/
 
-    line_num_regex = /.*:(\d+)(:.*|$)/
-    err_line = line_num_regex.match(ex.backtrace[0])[1].to_i
-    ref_line = line_num_regex.match(ex.backtrace[idx + 2])[1].to_i
+    filename = line_num_regex.match(ex.backtrace[0])[1]
+
+    filtered = ex.backtrace.grep(/^#{Regexp.escape(filename)}/)
+    top = filtered.grep(Regexp.new(Regexp.escape("in <top (required)>")))
+
+    err_line = line_num_regex.match(filtered[0])[2].to_i
+    ref_line = line_num_regex.match(top[0])[2].to_i - 1
 
     assert_equal((err_line - ref_line), line)
   end

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: bindata
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Dion Mendel
-autorequire:
 bindir: bin
 cert_chain: []
 date: 1980-01-01 00:00:00.000000000 Z
@@ -28,16 +27,16 @@ dependencies:
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -59,7 +58,7 @@ description: |
   data is, and BinData works out *how* to read and write data in this
   format.  It is an easier ( and more readable ) alternative to
   ruby's #pack and #unpack methods.
-email: bindata@dm9.info
+email: bindata@dmau.org
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -149,8 +148,8 @@ files:
 homepage: https://github.com/dmendel/bindata
 licenses:
 - BSD-2-Clause
-metadata: {}
-post_install_message:
+metadata:
+  changelog_uri: https://github.com/dmendel/bindata/blob/master/ChangeLog.rdoc
 rdoc_options:
 - "--main"
 - NEWS.rdoc
@@ -167,8 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: A declarative way to read and write binary file formats
 test_files: []