bindata 2.5.1 → 3.0.0

data/lib/bindata/registry.rb

@@ -7,36 +7,43 @@ module BinData
   # Numerics (integers and floating point numbers) have an endian property as
   # part of their name (e.g. int32be, float_le).
   #
+  # Classes exist in a namespace that mirrors the Ruby module hierarchy.
+  #
   # Classes can be looked up based on their full name or an abbreviated +name+
   # with +hints+.
   #
-  # There are two hints supported, :endian and :search_prefix.
+  # There are two hints supported, :endian and :search_namespace.
   #
-  #   #lookup("int32", { endian: :big }) will return Int32Be.
+  #   #lookup("", "int32", { endian: :big }) will return Int32Be.
   #
-  #   #lookup("my_type", { search_prefix: :ns }) will return NsMyType.
+  #   #lookup("", "my_type", { search_namespace: :ns }) will return Ns::MyType.
   #
   # Names are stored in under_score_style, not camelCase.
   class Registry
     def initialize
       @registry = {}
+      @backwards_compatible_registry = {}
     end
 
-    def register(name, class_to_register)
-      return if name.nil? || class_to_register.nil?
+    def register(namespace, name, class_to_register)
+      return if namespace.nil? || name.nil? || class_to_register.nil?
 
-      formatted_name = underscore_name(name)
-      warn_if_name_is_already_registered(formatted_name, class_to_register)
+      search = name_with_prefix(name, namespace)
+      warn_if_name_is_already_registered(search, class_to_register)
 
-      @registry[formatted_name] = class_to_register
+      @registry[search] = class_to_register
+      @backwards_compatible_registry[underscore_name(name)] = search
     end
 
-    def unregister(name)
-      @registry.delete(underscore_name(name))
+    def unregister(namespace, name)
+      search = name_with_prefix(name, namespace)
+
+      @registry.delete(search)
+      @backwards_compatible_registry.delete(underscore_name(name))
     end
 
-    def lookup(name, hints = {})
-      search_names(name, hints).each do |search|
+    def lookup(namespace, name, hints = {})
+      search_names(namespace, name, hints).each do |search|
         register_dynamic_class(search)
         if @registry.has_key?(search)
           return @registry[search]
@@ -44,7 +51,7 @@ module BinData
       end
 
       # give the user a hint if the endian keyword is missing
-      search_names(name, hints.merge(endian: :big)).each do |search|
+      search_names(namespace, name, hints.merge(endian: :big)).each do |search|
         register_dynamic_class(search)
         if @registry.has_key?(search)
           raise(UnRegisteredTypeError, "#{name}, do you need to specify endian?")
@@ -58,7 +65,7 @@ module BinData
     def underscore_name(name)
       name
         .to_s
-        .sub(/.*::/, "")
+        .gsub(/::/, "_")
         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
         .tr('-', '_')
@@ -68,24 +75,62 @@ module BinData
     #---------------
     private
 
-    def search_names(name, hints)
-      base = underscore_name(name)
+    def search_names(namespace, name, hints)
+      searches = backwards_compatible_search_names(name, hints)
+      return searches unless searches.empty?
+
       searches = []
 
-      search_prefix = [""] + Array(hints[:search_prefix])
+      # prioritise BinData classes
+      nwp = name_with_prefix(name, "BinData")
+      nwe = name_with_endian(nwp, hints[:endian])
+      searches << nwp
+      searches << nwe if nwe
+
+      ns = underscore_name(namespace)
+      loop do
+        search_prefix = [""] + Array(hints[:search_namespace])
+        search_prefix.each do |prefix|
+          nwp = name_with_prefix(name, name_with_prefix(prefix, ns))
+          nwe = name_with_endian(nwp, hints[:endian])
+
+          searches << nwp
+          searches << nwe if nwe
+        end
+
+        break if ns == ""
+        ns.sub!(/(?:^|_)[^_]*$/, "")
+      end
+
+      searches
+    end
+
+    # The old way of providing namespaces was to prefix the class name.
+    # Here we provide the backward compatibility for existing code.
+    def backwards_compatible_search_names(name, hints)
+      return [] unless hints.has_key?(:search_prefix)
+
+      searches = []
+      search_prefix = Array(hints[:search_prefix])
       search_prefix.each do |prefix|
-        nwp = name_with_prefix(base, prefix)
+        nwp = name_with_prefix(name, prefix)
         nwe = name_with_endian(nwp, hints[:endian])
 
-        searches << nwp
-        searches << nwe if nwe
+        found_search = @backwards_compatible_registry[nwp]
+        searches << found_search if found_search
+
+        if nwe
+          found_search = @backwards_compatible_registry[nwe]
+          searches << found_search if found_search
+        end
       end
 
       searches
     end
 
     def name_with_prefix(name, prefix)
-      prefix = prefix.to_s.chomp('_')
+      name = underscore_name(name)
+      prefix = underscore_name(prefix).chomp('_')
       if prefix == ""
         name
       else
@@ -97,7 +142,7 @@ module BinData
       return nil if endian.nil?
 
       suffix = (endian == :little) ? 'le' : 'be'
-      if /^u?int\d+$/.match?(name)
+      if /^bin_data_u?int\d+$/.match?(name)
         name + suffix
       else
         name + '_' + suffix
@@ -105,8 +150,11 @@ module BinData
     end
 
     def register_dynamic_class(name)
-      if /^u?int\d+(le|be)$/.match?(name) || /^s?bit\d+(le)?$/.match?(name)
-        class_name = name.gsub(/(?:^|_)(.)/) { $1.upcase }
+      return unless /^bin_data_/ =~ name
+
+      if /^bin_data_u?int\d+(le|be)$/.match?(name) || /^bin_data_s?bit\d+(le)?$/.match?(name)
+        base_name = name.sub(/^bin_data_/, "")
+        class_name = base_name.gsub(/(?:^|_)(.)/) { $1.upcase }
         begin
           # call const_get for side effect of creating class
           BinData.const_get(class_name)

data/lib/bindata/sanitize.rb

@@ -6,7 +6,7 @@ module BinData
   class SanitizedParameter; end
 
   class SanitizedPrototype < SanitizedParameter
-    def initialize(obj_type, obj_params, hints)
+    def initialize(obj_type, obj_params, namespace, hints)
       raw_hints = hints.dup
       if raw_hints[:endian].respond_to?(:endian)
         raw_hints[:endian] = raw_hints[:endian].endian
@@ -16,14 +16,14 @@ module BinData
       if BinData::Base === obj_type
         obj_class = obj_type
       else
-        obj_class = RegisteredClasses.lookup(obj_type, raw_hints)
+        obj_class = RegisteredClasses.lookup(namespace, obj_type, raw_hints)
       end
 
       if BinData::Base === obj_class
         @factory = obj_class
       else
         @obj_class  = obj_class
-        @obj_params = SanitizedParameters.new(obj_params, @obj_class, hints)
+        @obj_params = SanitizedParameters.new(obj_params, @obj_class, namespace, hints)
       end
     end
 
@@ -44,9 +44,9 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedField < SanitizedParameter
-    def initialize(name, field_type, field_params, hints)
+    def initialize(name, field_type, field_params, namespace, hints)
       @name      = name
-      @prototype = SanitizedPrototype.new(field_type, field_params, hints)
+      @prototype = SanitizedPrototype.new(field_type, field_params, namespace, hints)
     end
 
     attr_reader :prototype, :name
@@ -68,7 +68,8 @@ module BinData
   class SanitizedFields < SanitizedParameter
     include Enumerable
 
-    def initialize(hints, base_fields = nil)
+    def initialize(namespace, hints, base_fields = nil)
+      @namespace = namespace
       @hints = hints
       @fields =  base_fields ? base_fields.raw_fields : []
     end
@@ -76,7 +77,7 @@ module BinData
     def add_field(type, name, params)
       name = nil if name == ""
 
-      @fields << SanitizedField.new(name, type, params, @hints)
+      @fields << SanitizedField.new(name, type, params, @namespace, @hints)
     end
 
     def raw_fields
@@ -122,14 +123,14 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedChoices < SanitizedParameter
-    def initialize(choices, hints)
+    def initialize(choices, namespace, hints)
       @choices = {}
       choices.each_pair do |key, val|
         if SanitizedParameter === val
           prototype = val
         else
           type, param = val
-          prototype = SanitizedPrototype.new(type, param, hints)
+          prototype = SanitizedPrototype.new(type, param, namespace, hints)
         end
 
         if key == :default
@@ -180,20 +181,30 @@ module BinData
         if SanitizedParameters === parameters
           parameters
         else
-          SanitizedParameters.new(parameters, the_class, {})
+          namespace = parameters[:namespace]
+          unless namespace
+            m = /(.*)::[^:].*/.match(the_class.name)
+            namespace = m ? m[1] : ""
+          end
+          SanitizedParameters.new(parameters, the_class, namespace, {})
         end
       end
     end
 
-    def initialize(parameters, the_class, hints)
+    def initialize(parameters, the_class, namespace, hints)
       parameters.each_pair { |key, value| self[key.to_sym] = value }
 
       @the_class = the_class
+      @namespace = namespace
 
       if hints[:endian]
         self[:endian] ||= hints[:endian]
       end
 
+      if hints[:search_namespace] && !hints[:search_namespace].empty?
+        self[:search_namespace] = Array(self[:search_namespace]).concat(Array(hints[:search_namespace]))
+      end
+
       if hints[:search_prefix] && !hints[:search_prefix].empty?
         self[:search_prefix] = Array(self[:search_prefix]).concat(Array(hints[:search_prefix]))
       end
@@ -211,6 +222,12 @@ module BinData
       false
     end
 
+    def must_have_at_least_one_of(*keys)
+      unless has_at_least_one_of?(*keys)
+        raise ArgumentError, "#{@the_class} requires one of #{keys}"
+      end
+    end
+
     def warn_replacement_parameter(bad_key, suggested_key)
       if has_parameter?(bad_key)
         Kernel.warn ":#{bad_key} is not used with #{@the_class}.  " \
@@ -247,6 +264,10 @@ module BinData
       end
     end
 
+    def merge_dsl_params
+      self.merge!(@the_class.dsl_params)
+    end
+
     def sanitize_object_prototype(key)
       sanitize(key) do |obj_type, obj_params|
         create_sanitized_object_prototype(obj_type, obj_params)
@@ -278,11 +299,15 @@ module BinData
     end
 
     def create_sanitized_params(params, the_class)
-      SanitizedParameters.new(params, the_class, hints)
+      SanitizedParameters.new(params, the_class, @namespace, hints)
     end
 
     def hints
-      { endian: self[:endian], search_prefix: self[:search_prefix] }
+      {
+        endian: self[:endian],
+        search_namespace: self[:search_namespace],
+        search_prefix: self[:search_prefix]
+      }
     end
 
     #---------------
@@ -350,15 +375,15 @@ module BinData
     end
 
     def create_sanitized_choices(choices)
-      SanitizedChoices.new(choices, hints)
+      SanitizedChoices.new(choices, @namespace, hints)
     end
 
     def create_sanitized_fields
-      SanitizedFields.new(hints)
+      SanitizedFields.new(@namespace, hints)
     end
 
     def create_sanitized_object_prototype(obj_type, obj_params)
-      SanitizedPrototype.new(obj_type, obj_params, hints)
+      SanitizedPrototype.new(obj_type, obj_params, @namespace, hints)
     end
   end
   #----------------------------------------------------------------------------

data/lib/bindata/section.rb

@@ -65,8 +65,8 @@ module BinData
       @type.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) # :nodoc:
-      @type.__send__(symbol, *args, &block)
+    def method_missing(symbol, *args, **kwargs, &block) # :nodoc:
+      @type.__send__(symbol, *args, **kwargs, &block)
     end
 
     def do_read(io) # :nodoc:
@@ -90,7 +90,7 @@ module BinData
     include MultiFieldArgSeparator
 
     def sanitize_parameters!(obj_class, params)
-      params.merge!(obj_class.dsl_params)
+      params.merge_dsl_params
       params.sanitize_object_prototype(:type)
     end
   end

data/lib/bindata/skip.rb

@@ -208,13 +208,8 @@ module BinData
 
   class SkipArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params)
-      params.merge!(obj_class.dsl_params)
-
-      unless params.has_at_least_one_of?(:length, :to_abs_offset, :until_valid)
-        raise ArgumentError,
-              "#{obj_class} requires :length, :to_abs_offset or :until_valid"
-      end
-
+      params.merge_dsl_params
+      params.must_have_at_least_one_of(:length, :to_abs_offset, :until_valid)
       params.must_be_integer(:to_abs_offset, :length)
       params.sanitize_object_prototype(:until_valid)
     end

data/lib/bindata/struct.rb

@@ -42,9 +42,9 @@ module BinData
   # <tt>:endian</tt>::   Either :little or :big.  This specifies the default
   #                      endian of any numerics in this struct, or in any
   #                      nested data objects.
-  # <tt>:search_prefix</tt>::  Allows abbreviated type names.  If a type is
-  #                            unrecognised, then each prefix is applied until
-  #                            a match is found.
+  # <tt>:search_namespace</tt>::  Allows namespaced type names.  If a type is
+  #                               unrecognised, then each namespace is searched
+  #                               until a match is found.
   #
   # == Field Parameters
   #
@@ -59,7 +59,8 @@ module BinData
     arg_processor :struct
 
     mandatory_parameter :fields
-    optional_parameters :endian, :search_prefix, :hide
+    optional_parameters :endian, :search_namespace, :search_prefix, :hide
+    mutually_exclusive_parameters :search_namespace, :search_prefix
 
     # These reserved words may not be used as field names
     RESERVED =
@@ -71,7 +72,7 @@ module BinData
             when while yield] +
          %w[array element index value] +
          %w[type initial_length read_until] +
-         %w[fields endian search_prefix hide onlyif byte_align] +
+         %w[fields endian search_namespace search_prefix hide onlyif byte_align] +
          %w[choices selection copy_on_change] +
          %w[read_abs_offset struct_params])
         .collect(&:to_sym)
@@ -292,7 +293,7 @@ module BinData
         key?(symbol) || super
       end
 
-      def method_missing(symbol, *args)
+      def method_missing(symbol, *args, **kwargs)
         key?(symbol) ? self[symbol] : super
       end
     end
@@ -367,6 +368,7 @@ module BinData
   class StructArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params)
       sanitize_endian(params)
+      sanitize_search_namespace(params)
       sanitize_search_prefix(params)
       sanitize_fields(obj_class, params)
       sanitize_hide(params)
@@ -379,6 +381,12 @@ module BinData
       params.sanitize_endian(:endian)
     end
 
+    def sanitize_search_namespace(params)
+      params.sanitize(:search_namespace) do |snamespace|
+        Array(snamespace).collect &:to_s
+      end
+    end
+
     def sanitize_search_prefix(params)
       params.sanitize(:search_prefix) do |sprefix|
         search_prefix = Array(sprefix).collect do |prefix|

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = '2.5.1'
+  VERSION = '3.0.0'
 end

data/lib/bindata.rb

@@ -1,5 +1,5 @@
 # BinData -- Binary data manipulator.
-# Copyright (c) 2007 - 2025 Dion Mendel.
+# Copyright (c) 2007 - 2026 Dion Mendel.
 
 require 'bindata/version'
 require 'bindata/array'
@@ -33,6 +33,6 @@ require 'bindata/warnings'
 #
 # == License
 #
-# BinData is released under the same license as Ruby.
+# BinData is released under the BSD 2-Clause License.
 #
-# Copyright (c) 2007 - 2025 Dion Mendel.
+# Copyright (c) 2007 - 2026 Dion Mendel.

data/test/base_primitive_test.rb

@@ -25,7 +25,7 @@ end
 describe BinData::BasePrimitive do
   it "is not registered" do
     _ {
-      BinData::RegisteredClasses.lookup("BasePrimitive")
+      BinData::RegisteredClasses.lookup("BinData", "BasePrimitive")
     }.must_raise BinData::UnRegisteredTypeError
   end
 end

data/test/primitive_test.rb

@@ -5,7 +5,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 describe BinData::Primitive do
   it "is not registered" do
     _ {
-      BinData::RegisteredClasses.lookup("Primitive")
+      BinData::RegisteredClasses.lookup("BinData", "Primitive")
     }.must_raise BinData::UnRegisteredTypeError
   end
 end

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