bindata 2.5.0 → 3.0.0

data/lib/bindata/name.rb

@@ -11,16 +11,26 @@ module BinData
   #                    BinData::Struct.new(name: :my_struct, fields: ...)
   #                    array = BinData::Array.new(type: :my_struct)
   #                  </pre></code>
+  # <tt>:namespace</tt>:: The namespace that this object belongs to may be
+  #                       set explicitly.  This is only useful when dynamically
+  #                       generating types.
+  #                       <code><pre>
+  #                         BinData::Struct.new(name: :my_struct, namespace: :ns1, fields: ...)
+  #                         BinData::Struct.new(name: :my_struct, namespace: :ns2, fields: ...)
+  #                         array = BinData::Array.new(namespace: :ns1, type: :my_struct)
+  #                       </pre></code>
   module RegisterNamePlugin
 
     def self.included(base) # :nodoc:
-      # The registered name may be provided explicitly.
-      base.optional_parameter :name
+      # +name+ and +namespace+ may be provided explicitly.
+      base.optional_parameter :name, :namespace
     end
 
     def initialize_shared_instance
       if has_parameter?(:name)
-        RegisteredClasses.register(get_parameter(:name), self)
+        name = get_parameter(:name)
+        namespace = get_parameter(:namespace) || ""
+        RegisteredClasses.register(namespace, name, self)
       end
       super
     end

data/lib/bindata/primitive.rb

@@ -77,9 +77,9 @@ module BinData
       @struct.respond_to?(symbol, include_private) || super
     end
 
-    def method_missing(symbol, *args, &block) # :nodoc:
+    def method_missing(symbol, *args, **kwargs, &block) # :nodoc:
       if @struct.respond_to?(symbol)
-        @struct.__send__(symbol, *args, &block)
+        @struct.__send__(symbol, *args, **kwargs, &block)
       else
         super
       end

data/lib/bindata/record.rb

@@ -17,7 +17,7 @@ module BinData
     include MultiFieldArgSeparator
 
     def sanitize_parameters!(obj_class, params)
-      super(obj_class, params.merge!(obj_class.dsl_params))
+      super(obj_class, params.merge_dsl_params)
     end
   end
 end

data/lib/bindata/registry.rb

@@ -7,50 +7,65 @@ 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 = {})
-      the_class = @registry[normalize_name(name, hints)]
-      if the_class
-        the_class
-      elsif @registry[normalize_name(name, hints.merge(endian: :big))]
-        raise(UnRegisteredTypeError, "#{name}, do you need to specify endian?")
-      else
-        raise(UnRegisteredTypeError, name)
+    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]
+        end
+      end
+
+      # give the user a hint if the endian keyword is missing
+      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?")
+        end
       end
+
+      raise(UnRegisteredTypeError, name)
     end
 
     # Convert CamelCase +name+ to underscore style.
     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('-', '_')
@@ -60,31 +75,62 @@ module BinData
     #---------------
     private
 
-    def normalize_name(name, hints)
-      name = underscore_name(name)
+    def search_names(namespace, name, hints)
+      searches = backwards_compatible_search_names(name, hints)
+      return searches unless searches.empty?
 
-      if !registered?(name)
-        search_prefix = [""] + Array(hints[:search_prefix])
-        search_prefix.each do |prefix|
-          nwp = name_with_prefix(name, prefix)
-          if registered?(nwp)
-            name = nwp
-            break
-          end
+      searches = []
+
+      # 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])
-          if registered?(nwe)
-            name = nwe
-            break
-          end
+
+          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(name, prefix)
+        nwe = name_with_endian(nwp, hints[:endian])
+
+        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
 
-      name
+      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
@@ -93,27 +139,24 @@ module BinData
     end
 
     def name_with_endian(name, endian)
-      return name if endian.nil?
+      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
       end
     end
 
-    def registered?(name)
-      register_dynamic_class(name) unless @registry.key?(name)
-
-      @registry.key?(name)
-    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 effects
+          # call const_get for side effect of creating class
           BinData.const_get(class_name)
         rescue NameError
         end
@@ -124,7 +167,7 @@ module BinData
       prev_class = @registry[name]
       if prev_class && prev_class != class_to_register
         Kernel.warn "warning: replacing registered class #{prev_class} " \
-             "with #{class_to_register}"
+                    "with #{class_to_register}"
       end
     end
   end

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.0'
+  VERSION = '3.0.0'
 end

data/lib/bindata.rb

@@ -1,5 +1,5 @@
 # BinData -- Binary data manipulator.
-# Copyright (c) 2007 - 2018 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 - 2018 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