bindata 2.5.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c768f9ce67cbaab54614d38246801939b4bb65ad02be42996b08613ed07aa92
-  data.tar.gz: d0409b0247506c870c314d089a5a9e0b806a1ab8e0c5ed05b2c280d81b9472c1
+  metadata.gz: e50992a28fe499f3fc0c25e376060609a6f89abfa391973296601c3e81692c9f
+  data.tar.gz: 5822008067da279c8e6bb5787a1b720b2a3a563ff60826c543409686ca1a188b
 SHA512:
-  metadata.gz: 65e8e7d1df5b3220dc61aca18e1aef0a026e09191c6a78cf63e7dd5b4c5437fb04f8db688f926c4e4048dba972518b970254236959948681b7335e1a1302bff6
-  data.tar.gz: 195f0a260ec3cbccaa4e2a2e060ae0cc65b9f843a0c17acafb426041bf0a7d3fe0e96a6ff46befa68ed6f4b36fc2655a3a458f138e5ab92c78684347f39abc8e
+  metadata.gz: 1335d582aae17320deefc138b14ef101dbf6b02e8272a30b1c1e9e5eed935678e4fe6c4d7e55f99eb8cf7ab65b3c9f05b2b77bfcc95520a2e6da09455801569a
+  data.tar.gz: 95b9d293bc50ee2c7438bd60488725ab4711f3ef25ab6826c86e4b5937af588fc349ce73984d8b9cfe0919999046c8001b028c03bfcbb5a87918bbf0f16a6d7b

data/ChangeLog.rdoc

@@ -1,5 +1,12 @@
 = BinData Changelog
 
+== Version 3.0.0 (2026-07-13)
+
+* Ruby 2.x now has its own separate branch.
+* Namespacing now uses Ruby modules, rather than prefixes.
+* Added class names to dynamically generated ints and bits.
+* Forward keyword arguments.  Thanks to Simon Coffey.
+
 == Version 2.5.1 (2025-04-11)
 
 * Added changelog link to gemspec. Thanks to Mark Young.

data/LICENSE

@@ -1,6 +1,6 @@
 BSD 2-Clause License
 
-Copyright (c) 2007-2022, Dion Mendel
+Copyright (c) 2007-2026, Dion Mendel
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/NEWS.rdoc

@@ -1,3 +1,54 @@
+= 3.0.0
+
+BinData 3.0.0 requires Ruby 3.0 or greater.  Support for Ruby 2.x is found in
+BinData versions 2.5.1.
+
+This release introduces a new way to handle namespaces.  It uses the Ruby
+module hierarchy instead of the previous flat namespace.  Code using the old
+`:search_prefix` method should still work, but consider migrating to the new
+method.
+
+== 2.5.x
+
+    class Ns1Foo << BinData::Record; end
+    class Ns1Bar << BinData::Record; end
+    class Ns2Foo << BinData::Record; end
+
+    class MyClass < BinData::Record
+      search_prefix ns2
+      foo :a     # resolves to ns2_foo
+      bar :b     # resolves to ns1_bar
+      ns1_foo :c # explicitly  ns1_foo
+    end
+
+== 3.0.0
+
+    module Ns1
+      class Foo << BinData::Record; end
+      class Bar << BinData::Record; end
+    end
+
+    module Ns2
+      class Foo << BinData::Record; end
+    end
+
+    module Ns2
+      class MyClass < BinData::Record
+        foo     :a
+        bar     :b
+        ns1_foo :c
+      end
+    end
+
+    -or-
+
+    class MyClass < BinData::Record
+      search_namespace :ns2
+      foo :a
+      bar :b
+      ns1_foo :c
+    end
+
 = 2.4.15
 
 This software was originally dual licensed under the Ruby license and the
@@ -8,14 +59,14 @@ BSD-2-Clause license.  It is now licensed solely as BSD-2-Clause.
 This release changes the internal API for sanitizing parameters.  This only
 affects those that implement the `#sanitize_parameters` method.
 
-= 2.3.x
+== 2.3.x
 
     if params.needs_sanitizing?(:type)
       el_type, el_params = params[:type]
       params[:type] = params.create_sanitized_object_prototype(el_type, el_params)
     end
 
-= 2.4.0
+== 2.4.0
 
     params.sanitize_object_prototype(:type)
 

data/README.md

@@ -38,7 +38,7 @@ BinData provides a _declarative_ way to read and write structured binary data.
 This means the programmer specifies *what* the format of the binary
 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.
+Ruby's `#pack` and `#unpack` methods.
 
 BinData makes it easy to create new data types. It supports all the common
 primitive datatypes that are found in structured binary data formats. Support

data/bindata.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 2.5.0"
 
   s.add_development_dependency('rake')
-  s.add_development_dependency('minitest', "> 5.0.0")
+  s.add_development_dependency('minitest', "~> 5.0")
   s.add_development_dependency('simplecov')
   s.description = <<-END.gsub(/^ +/, "")
     BinData is a declarative way to read and write binary file formats.

data/lib/bindata/array.rb

@@ -337,7 +337,7 @@ module BinData
       params.warn_replacement_parameter(:read_length, :initial_length)
       params.must_be_integer(:initial_length)
 
-      params.merge!(obj_class.dsl_params)
+      params.merge_dsl_params
       params.sanitize_object_prototype(:type)
     end
   end

data/lib/bindata/base.rb

@@ -44,14 +44,21 @@ module BinData
 
       # Call this method if this class is abstract and not to be used.
       def unregister_self
-        RegisteredClasses.unregister(name)
+        m = /(.*)::([^:].*)/.match(name)
+        namespace = m ? m[1] : ""
+        shortname = m ? m[2] : name
+
+        RegisteredClasses.unregister(namespace, shortname)
       end
 
       # Registers all subclasses of this class for use
       def register_subclasses # :nodoc:
         singleton_class.send(:undef_method, :inherited)
         define_singleton_method(:inherited) do |subclass|
-          RegisteredClasses.register(subclass.name, subclass)
+          m = /(.*)::([^:].*)/.match(subclass.name)
+          namespace = m ? m[1] : ""
+          shortname = m ? m[2] : subclass
+          RegisteredClasses.register(namespace, shortname, subclass)
           register_subclasses
         end
       end

data/lib/bindata/base_primitive.rb

@@ -93,15 +93,15 @@ module BinData
       child.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) # :nodoc:
+    def method_missing(symbol, *args, **kwargs, &block) # :nodoc:
       child = snapshot
       if child.respond_to?(symbol)
         self.class.class_eval <<-END, __FILE__, __LINE__ + 1
-          def #{symbol}(*args, &block)         # def clamp(*args, &block)
-            snapshot.#{symbol}(*args, &block)  #   snapshot.clamp(*args, &block)
-          end                                  # end
+          def #{symbol}(*args, **kwargs, &block)         # def clamp(*args, **kwargs, &block)
+            snapshot.#{symbol}(*args, **kwargs, &block)  #   snapshot.clamp(*args, **kwargs, &block)
+          end                                            # end
         END
-        child.__send__(symbol, *args, &block)
+        child.__send__(symbol, *args, **kwargs, &block)
       else
         super
       end

data/lib/bindata/bits.rb

@@ -12,59 +12,53 @@ module BinData
       def define_class(name, nbits, endian, signed = :unsigned)
         @@mutex.synchronize do
           unless BinData.const_defined?(name)
-            new_class = Class.new(BinData::BasePrimitive)
-            BitField.define_methods(new_class, nbits, endian.to_sym, signed.to_sym)
-            RegisteredClasses.register(name, new_class)
-
-            BinData.const_set(name, new_class)
+            BinData.module_eval <<-END
+              class #{name} < BasePrimitive
+                #{create_params_code(nbits)}
+
+                def assign(val)
+                  #{create_nbits_code(nbits)}
+                  #{create_clamp_code(nbits, signed)}
+                  super(val)
+                end
+
+                def do_write(io)
+                  #{create_nbits_code(nbits)}
+                  val = _value
+                  #{create_int2uint_code(nbits, signed)}
+                  io.writebits(val, #{nbits}, :#{endian})
+                end
+
+                def do_num_bytes
+                  #{create_nbits_code(nbits)}
+                  #{create_do_num_bytes_code(nbits)}
+                end
+
+                def bit_aligned?
+                  true
+                end
+
+                #---------------
+                private
+
+                def read_and_return_value(io)
+                  #{create_nbits_code(nbits)}
+                  val = io.readbits(#{nbits}, :#{endian})
+                  #{create_uint2int_code(nbits, signed)}
+                  val
+                end
+
+                def sensible_default
+                  0
+                end
+              end
+            END
           end
         end
 
         BinData.const_get(name)
       end
 
-      def define_methods(bit_class, nbits, endian, signed)
-        bit_class.module_eval <<-END
-          #{create_params_code(nbits)}
-
-          def assign(val)
-            #{create_nbits_code(nbits)}
-            #{create_clamp_code(nbits, signed)}
-            super(val)
-          end
-
-          def do_write(io)
-            #{create_nbits_code(nbits)}
-            val = _value
-            #{create_int2uint_code(nbits, signed)}
-            io.writebits(val, #{nbits}, :#{endian})
-          end
-
-          def do_num_bytes
-            #{create_nbits_code(nbits)}
-            #{create_do_num_bytes_code(nbits)}
-          end
-
-          def bit_aligned?
-            true
-          end
-
-          #---------------
-          private
-
-          def read_and_return_value(io)
-            #{create_nbits_code(nbits)}
-            val = io.readbits(#{nbits}, :#{endian})
-            #{create_uint2int_code(nbits, signed)}
-            val
-          end
-
-          def sensible_default
-            0
-          end
-        END
-      end
-
       def create_params_code(nbits)
         if nbits == :nbits
           "mandatory_parameter :nbits"

data/lib/bindata/buffer.rb

@@ -84,8 +84,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:
@@ -187,7 +187,7 @@ module BinData
     include MultiFieldArgSeparator
 
     def sanitize_parameters!(obj_class, params)
-      params.merge!(obj_class.dsl_params)
+      params.merge_dsl_params
       params.must_be_integer(:length)
       params.sanitize_object_prototype(:type)
     end

data/lib/bindata/choice.rb

@@ -90,8 +90,8 @@ module BinData
       current_choice.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) # :nodoc:
-      current_choice.__send__(symbol, *args, &block)
+    def method_missing(symbol, *args, **kwargs, &block) # :nodoc:
+      current_choice.__send__(symbol, *args, **kwargs, &block)
     end
 
     %w[clear? assign snapshot do_read do_write do_num_bytes].each do |m|
@@ -123,7 +123,7 @@ module BinData
 
   class ChoiceArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params) # :nodoc:
-      params.merge!(obj_class.dsl_params)
+      params.merge_dsl_params
 
       params.sanitize_choices(:choices) do |choices|
         hash_choices = choices_as_hash(choices)

data/lib/bindata/delayed_io.rb

@@ -87,8 +87,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 abs_offset
@@ -147,7 +147,7 @@ module BinData
     include MultiFieldArgSeparator
 
     def sanitize_parameters!(obj_class, params)
-      params.merge!(obj_class.dsl_params)
+      params.merge_dsl_params
       params.must_be_integer(:read_abs_offset)
       params.sanitize_object_prototype(:type)
     end

data/lib/bindata/dsl.rb

@@ -42,8 +42,8 @@ module BinData
       end
     end
 
-    def method_missing(symbol, *args, &block) # :nodoc:
-      dsl_parser.__send__(symbol, *args, &block)
+    def method_missing(symbol, *args, **kwargs, &block) # :nodoc:
+      dsl_parser.__send__(symbol, *args, **kwargs, &block)
     end
 
     # Assert object is not an array or string.
@@ -67,9 +67,13 @@ module BinData
         @parser_type    = parser_type
         @validator      = DSLFieldValidator.new(the_class, self)
         @endian         = nil
+
+        m = /(.*)::([^:].*)/.match(@the_class.name)
+        @namespace = m ? m[1] : ""
       end
 
       attr_reader :parser_type
+      attr_accessor :namespace
 
       def endian(endian = nil)
         if endian
@@ -80,6 +84,21 @@ module BinData
         @endian
       end
 
+      def search_namespace(*args)
+        @search_namespace ||= parent_attribute(:search_namespace, []).dup
+
+        namespace = args.collect(&:to_sym).compact
+        unless namespace.empty?
+          if fields?
+            dsl_raise SyntaxError, "search_namespace must be called before defining fields"
+          end
+
+          @search_namespace = namespace.concat(@search_namespace)
+        end
+
+        @search_namespace
+      end
+
       def search_prefix(*args)
         @search_prefix ||= parent_attribute(:search_prefix, []).dup
 
@@ -107,7 +126,7 @@ module BinData
       end
 
       def fields
-        @fields ||= SanitizedFields.new(hints, parent_fields)
+        @fields ||= SanitizedFields.new(namespace, hints, parent_fields)
       end
 
       def dsl_params
@@ -115,9 +134,9 @@ module BinData
         send(abilities.at(0), abilities.at(1))
       end
 
-      def method_missing(*args, &block)
+      def method_missing(*args, **kwargs, &block)
         ensure_hints
-        parse_and_append_field(*args, &block)
+        parse_and_append_field(*args, **kwargs, &block)
       end
 
       #-------------
@@ -142,11 +161,12 @@ module BinData
 
       def ensure_hints
         endian
+        search_namespace
         search_prefix
       end
 
       def hints
-        { endian: endian, search_prefix: search_prefix }
+        { endian: endian, search_namespace: search_namespace, search_prefix: search_prefix }
       end
 
       def set_endian(endian)
@@ -179,7 +199,7 @@ module BinData
       end
 
       def parse_and_append_field(*args, &block)
-        parser = DSLFieldParser.new(hints, *args, &block)
+        parser = DSLFieldParser.new(namespace, hints, *args, &block)
         begin
           @validator.validate_field(parser.name)
           append_field(parser.type, parser.name, parser.params)
@@ -239,6 +259,9 @@ module BinData
         if !endian.nil?
           result[:endian] = endian
         end
+        if !search_namespace.empty?
+          result[:search_namespace] = search_namespace
+        end
         if !search_prefix.empty?
           result[:search_prefix] = search_prefix
         end
@@ -324,9 +347,10 @@ module BinData
         def class_with_endian(class_name, endian)
           hints = {
             endian: endian,
+            search_namespace: class_name.dsl_parser.search_namespace,
             search_prefix: class_name.dsl_parser.search_prefix
           }
-          RegisteredClasses.lookup(class_name, hints)
+          RegisteredClasses.lookup("", class_name, hints)
         end
 
         def obj_attribute(obj, attr)
@@ -337,7 +361,8 @@ module BinData
 
     # Extracts the details from a field declaration.
     class DSLFieldParser
-      def initialize(hints, symbol, *args, &block)
+      def initialize(namespace, hints, symbol, *args, &block)
+        @namespace = namespace
         @hints  = hints
         @type   = symbol
         @name   = name_from_field_declaration(args)
@@ -385,7 +410,9 @@ module BinData
 
         if bindata_classes.include?(@type)
           parser = DSLParser.new(bindata_classes[@type], @type)
+          parser.namespace = @namespace
           parser.endian(@hints[:endian])
+          parser.search_namespace(*@hints[:search_namespace])
           parser.search_prefix(*@hints[:search_prefix])
           parser.instance_eval(&block)
 

data/lib/bindata/int.rb

@@ -12,46 +12,38 @@ module BinData
       def define_class(name, nbits, endian, signed)
         @@mutex.synchronize do
           unless BinData.const_defined?(name)
-            new_class = Class.new(BinData::BasePrimitive)
-            Int.define_methods(new_class, nbits, endian.to_sym, signed.to_sym)
-            RegisteredClasses.register(name, new_class)
-
-            BinData.const_set(name, new_class)
-          end
-        end
-
-        BinData.const_get(name)
-      end
-
-      def define_methods(int_class, nbits, endian, signed)
-        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+            BinData.module_eval <<-END
+              class #{name} < BasePrimitive
+                def assign(val)
+                  #{create_clamp_code(nbits, signed)}
+                  super(val)
+                end
 
-        int_class.module_eval <<-END
-          def assign(val)
-            #{create_clamp_code(nbits, signed)}
-            super(val)
-          end
+                def do_num_bytes
+                  #{nbits / 8}
+                end
 
-          def do_num_bytes
-            #{nbits / 8}
-          end
+                #---------------
+                private
 
-          #---------------
-          private
+                def sensible_default
+                  0
+                end
 
-          def sensible_default
-            0
-          end
+                def value_to_binary_string(val)
+                  #{create_clamp_code(nbits, signed)}
+                  #{create_to_binary_s_code(nbits, endian, signed)}
+                end
 
-          def value_to_binary_string(val)
-            #{create_clamp_code(nbits, signed)}
-            #{create_to_binary_s_code(nbits, endian, signed)}
+                def read_and_return_value(io)
+                  #{create_read_code(nbits, endian, signed)}
+                end
+              end
+            END
           end
+        end
 
-          def read_and_return_value(io)
-            #{create_read_code(nbits, endian, signed)}
-          end
-        END
+        BinData.const_get(name)
       end
 
       #-------------
@@ -176,18 +168,12 @@ module BinData
   end
 
 
-  # Unsigned 1 byte integer.
-  class Uint8 < BinData::BasePrimitive
-    Int.define_methods(self, 8, :little, :unsigned)
-  end
-
-  # Signed 1 byte integer.
-  class Int8 < BinData::BasePrimitive
-    Int.define_methods(self, 8, :little, :signed)
-  end
-
   # Create classes on demand
   module IntFactory
+    # 1 byte integers
+    Int.define_class("Uint8", 8, :big, :unsigned)
+    Int.define_class("Int8", 8, :big, :signed)
+
     def const_missing(name)
       mappings = {
         /^Uint(\d+)be$/ => [:big,    :unsigned],

data/lib/bindata/lazy.rb

@@ -62,11 +62,11 @@ module BinData
       raise NoMethodError, "no index found"
     end
 
-    def method_missing(symbol, *args)
+    def method_missing(symbol, *args, **kwargs)
       return @overrides[symbol] if defined?(@overrides) && @overrides.key?(symbol)
 
       if @obj.parent
-        eval_symbol_in_parent_context(symbol, args)
+        eval_symbol_in_parent_context(symbol, args, kwargs)
       else
         super
       end
@@ -75,26 +75,26 @@ module BinData
     #---------------
     private
 
-    def eval_symbol_in_parent_context(symbol, args)
-      result = resolve_symbol_in_parent_context(symbol, args)
-      recursively_eval(result, args)
+    def eval_symbol_in_parent_context(symbol, args, kwargs)
+      result = resolve_symbol_in_parent_context(symbol, args, kwargs)
+      recursively_eval(result, args, kwargs)
     end
 
-    def resolve_symbol_in_parent_context(symbol, args)
+    def resolve_symbol_in_parent_context(symbol, args, kwargs)
       obj_parent = @obj.parent
 
       if obj_parent.has_parameter?(symbol)
         obj_parent.get_parameter(symbol)
       elsif obj_parent.safe_respond_to?(symbol, true)
-        obj_parent.__send__(symbol, *args)
+        obj_parent.__send__(symbol, *args, **kwargs)
       else
         symbol
       end
     end
 
-    def recursively_eval(val, args)
+    def recursively_eval(val, args, kwargs)
       if val.is_a?(Symbol)
-        parent.__send__(val, *args)
+        parent.__send__(val, *args, **kwargs)
       elsif callable?(val)
         parent.instance_exec(&val)
       else

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