bindata 2.5.1 → 3.0.0

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

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: bindata
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  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
@@ -151,7 +150,6 @@ licenses:
 - BSD-2-Clause
 metadata:
   changelog_uri: https://github.com/dmendel/bindata/blob/master/ChangeLog.rdoc
-post_install_message:
 rdoc_options:
 - "--main"
 - NEWS.rdoc
@@ -168,8 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: A declarative way to read and write binary file formats
 test_files: []