bindata 2.4.11 → 2.5.1

data/lib/bindata/bits.rb

@@ -5,7 +5,7 @@ module BinData
   # Defines a number of classes that contain a bit based integer.
   # The integer is defined by endian and number of bits.
 
-  module BitField #:nodoc: all
+  module BitField # :nodoc: all
     @@mutex = Mutex.new
 
     class << self
@@ -99,14 +99,14 @@ module BinData
 
       def create_dynamic_clamp_code(signed)
         if signed == :signed
-          max = "max = (1 << (nbits - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (nbits - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          max = "max = (1 << nbits) - 1"
-          min = "min = 0"
+          max = "(1 << nbits) - 1"
+          min = "0"
         end
 
-        "#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val"
+        "val = val.clamp(#{min}, #{max})"
       end
 
       def create_fixed_clamp_code(nbits, signed)
@@ -115,14 +115,14 @@ module BinData
         end
 
         if signed == :signed
-          max = "max = (1 << (#{nbits} - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (#{nbits} - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          min = "min = 0"
-          max = "max = (1 << #{nbits}) - 1"
+          min = "0"
+          max = "(1 << #{nbits}) - 1"
         end
 
-        clamp = "(#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val)"
+        clamp = "(val = val.clamp(#{min}, #{max}))"
 
         if nbits == 1
           # allow single bits to be used as booleans
@@ -156,10 +156,10 @@ module BinData
 
   # Create classes for dynamic bitfields
   {
-    "Bit"    => :big,
-    "BitLe"  => :little,
-    "Sbit"   => [:big, :signed],
-    "SbitLe" => [:little, :signed],
+    'Bit'    => :big,
+    'BitLe'  => :little,
+    'Sbit'   => [:big, :signed],
+    'SbitLe' => [:little, :signed]
   }.each_pair { |name, args| BitField.define_class(name, :nbits, *args) }
 
   # Create classes on demand

data/lib/bindata/buffer.rb

@@ -41,7 +41,7 @@ module BinData
   #       end
   #     end
   #   end
-  #     
+  #
   #
   # == Parameters
   #
@@ -80,29 +80,107 @@ module BinData
       @type.snapshot
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      @type.respond_to?(symbol, include_private) || super
+    def respond_to_missing?(symbol, include_all = false) # :nodoc:
+      @type.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       @type.__send__(symbol, *args, &block)
     end
 
-    def do_read(io) #:nodoc:
-      io.with_buffer(eval_parameter(:length)) do
-        @type.do_read(io)
+    def do_read(io) # :nodoc:
+      buf_len = eval_parameter(:length)
+      io.transform(BufferIO.new(buf_len)) do |transformed_io, _|
+        @type.do_read(transformed_io)
       end
     end
 
-    def do_write(io) #:nodoc:
-      io.with_buffer(eval_parameter(:length)) do
-        @type.do_write(io)
+    def do_write(io) # :nodoc:
+      buf_len = eval_parameter(:length)
+      io.transform(BufferIO.new(buf_len)) do |transformed_io, _|
+        @type.do_write(transformed_io)
       end
     end
 
-    def do_num_bytes #:nodoc:
+    def do_num_bytes # :nodoc:
       eval_parameter(:length)
     end
+
+    # Transforms the IO stream to restrict access inside
+    # a buffer of specified length.
+    class BufferIO < IO::Transform
+      def initialize(length)
+        super()
+        @bytes_remaining = length
+      end
+
+      def before_transform
+        @buf_start = offset
+        @buf_end = @buf_start + @bytes_remaining
+      end
+
+      def num_bytes_remaining
+        [@bytes_remaining, super].min
+      rescue IOError
+        @bytes_remaining
+      end
+
+      def skip(n)
+        nbytes = buffer_limited_n(n)
+        @bytes_remaining -= nbytes
+
+        chain_skip(nbytes)
+      end
+
+      def seek_abs(n)
+        if n < @buf_start || n >= @buf_end
+          raise IOError, "can not seek to abs_offset outside of buffer"
+        end
+
+        @bytes_remaining -= (n - offset)
+        chain_seek_abs(n)
+      end
+
+      def read(n)
+        nbytes = buffer_limited_n(n)
+        @bytes_remaining -= nbytes
+
+        chain_read(nbytes)
+      end
+
+      def write(data)
+        nbytes = buffer_limited_n(data.size)
+        @bytes_remaining -= nbytes
+        if nbytes < data.size
+          data = data[0, nbytes]
+        end
+
+        chain_write(data)
+      end
+
+      def after_read_transform
+        read(nil)
+      end
+
+      def after_write_transform
+        write("\x00" * @bytes_remaining)
+      end
+
+      def buffer_limited_n(n)
+        if n.nil?
+          @bytes_remaining
+        elsif n.positive?
+          limit = @bytes_remaining
+          n > limit ? limit : n
+# uncomment if we decide to allow backwards skipping
+#        elsif n.negative?
+#          limit = @bytes_remaining + @buf_start - @buf_end
+#          n < limit ? limit : n
+        else
+          0
+        end
+      end
+    end
   end
 
   class BufferArgProcessor < BaseArgProcessor

data/lib/bindata/choice.rb

@@ -82,18 +82,19 @@ module BinData
       if selection.nil?
         raise IndexError, ":selection returned nil for #{debug_name}"
       end
+
       selection
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      current_choice.respond_to?(symbol, include_private) || super
+    def respond_to?(symbol, include_all = false) # :nodoc:
+      current_choice.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       current_choice.__send__(symbol, *args, &block)
     end
 
-    %w(clear? assign snapshot do_read do_write do_num_bytes).each do |m|
+    %w[clear? assign snapshot do_read do_write do_num_bytes].each do |m|
       module_eval <<-END
         def #{m}(*args)
           current_choice.#{m}(*args)
@@ -112,14 +113,16 @@ module BinData
     def instantiate_choice(selection)
       prototype = get_parameter(:choices)[selection]
       if prototype.nil?
-        raise IndexError, "selection '#{selection}' does not exist in :choices for #{debug_name}"
+        msg = "selection '#{selection}' does not exist in :choices for #{debug_name}"
+        raise IndexError, msg
       end
+
       prototype.instantiate(nil, self)
     end
   end
 
   class ChoiceArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params) #:nodoc:
+    def sanitize_parameters!(obj_class, params) # :nodoc:
       params.merge!(obj_class.dsl_params)
 
       params.sanitize_choices(:choices) do |choices|

data/lib/bindata/count_bytes_remaining.rb

@@ -1,4 +1,4 @@
-require "bindata/base_primitive"
+require 'bindata/base_primitive'
 
 module BinData
   # Counts the number of bytes remaining in the input stream from the current

data/lib/bindata/delayed_io.rb

@@ -83,11 +83,11 @@ module BinData
       @type.num_bytes
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      @type.respond_to?(symbol, include_private) || super
+    def respond_to_missing?(symbol, include_all = false) # :nodoc:
+      @type.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       @type.__send__(symbol, *args, &block)
     end
 
@@ -104,31 +104,20 @@ module BinData
       abs_offset
     end
 
-    def do_read(io) #:nodoc:
+    def do_read(io) # :nodoc:
       @read_io = io
     end
 
-    def do_write(io) #:nodoc:
+    def do_write(io) # :nodoc:
       @write_io = io
     end
 
-    def do_num_bytes #:nodoc:
+    def do_num_bytes # :nodoc:
       0
     end
 
-    def eval_parameter_with_delayed_io(key, overrides = nil)
-      result = eval_parameter_without_delayed_io(key, overrides)
-
-      # Delay processing :onlyif until we do the actual read/write
-      result = true if key == :onlyif && ! result
-
-      result
-    end
-    alias_method :eval_parameter_without_delayed_io, :eval_parameter
-    alias_method :eval_parameter, :eval_parameter_with_delayed_io
-
     def include_obj?
-      ! has_parameter?(:onlyif) || eval_parameter_without_delayed_io(:onlyif)
+      !has_parameter?(:onlyif) || eval_parameter(:onlyif)
     end
 
     # DelayedIO objects aren't read when #read is called.
@@ -137,7 +126,7 @@ module BinData
       return unless include_obj?
       raise IOError, "read from where?" unless @read_io
 
-      @read_io.seekbytes(abs_offset - @read_io.offset)
+      @read_io.seek_to_abs_offset(abs_offset)
       start_read do
         @type.do_read(@read_io)
       end
@@ -149,7 +138,7 @@ module BinData
       return unless include_obj?
       raise IOError, "write to where?" unless @write_io
 
-      @write_io.seekbytes(abs_offset - @write_io.offset)
+      @write_io.seek_to_abs_offset(abs_offset)
       @type.do_write(@write_io)
     end
   end
@@ -164,15 +153,16 @@ module BinData
     end
   end
 
-  # Add +auto_call_delayed_io+ keyword to BinData::Base.
   class Base
+    # Add +auto_call_delayed_io+ keyword to BinData::Base.
     class << self
       # The +auto_call_delayed_io+ keyword sets a data object tree to perform
       # multi pass I/O automatically.
       def auto_call_delayed_io
+        include AutoCallDelayedIO
+
         return if DelayedIO.method_defined? :initialize_instance_without_record_io
 
-        include AutoCallDelayedIO
         DelayedIO.send(:alias_method, :initialize_instance_without_record_io, :initialize_instance)
         DelayedIO.send(:define_method, :initialize_instance) do
           if @parent && !defined? @delayed_io_recorded

data/lib/bindata/dsl.rb

@@ -42,7 +42,7 @@ module BinData
       end
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       dsl_parser.__send__(symbol, *args, &block)
     end
 
@@ -131,7 +131,8 @@ module BinData
           choice:     [:to_choice_params, :choices,     [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]],
           delayed_io: [:to_object_params, :type,        [:multiple_fields, :optional_fieldnames, :hidden_fields]],
           primitive:  [:to_struct_params, :struct,      [:multiple_fields, :optional_fieldnames]],
-          skip:       [:to_object_params, :until_valid, [:multiple_fields, :optional_fieldnames]],
+          section:    [:to_object_params, :type,        [:multiple_fields, :optional_fieldnames]],
+          skip:       [:to_object_params, :until_valid, [:multiple_fields, :optional_fieldnames]]
         }
       end
 
@@ -182,21 +183,21 @@ module BinData
         begin
           @validator.validate_field(parser.name)
           append_field(parser.type, parser.name, parser.params)
-        rescue Exception => err
-          dsl_raise err.class, err.message
+        rescue Exception => e
+          dsl_raise e.class, e.message
         end
       end
 
       def append_field(type, name, params)
         fields.add_field(type, name, params)
-      rescue BinData::UnRegisteredTypeError => err
-        raise TypeError, "unknown type '#{err.message}'"
+      rescue BinData::UnRegisteredTypeError => e
+        raise TypeError, "unknown type '#{e.message}'"
       end
 
       def parent_attribute(attr, default = nil)
         parent = @the_class.superclass
         parser = parent.respond_to?(:dsl_parser) ? parent.dsl_parser : nil
-        if parser && parser.respond_to?(attr)
+        if parser&.respond_to?(attr)
           parser.send(attr)
         else
           default
@@ -205,7 +206,7 @@ module BinData
 
       def dsl_raise(exception, msg)
         backtrace = caller
-        backtrace.shift while %r{bindata/dsl.rb} =~ backtrace.first
+        backtrace.shift while %r{bindata/dsl.rb}.match?(backtrace.first)
 
         raise exception, "#{msg} in #{@the_class}", backtrace
       end
@@ -215,9 +216,9 @@ module BinData
         when 0
           {}
         when 1
-          {key => fields[0].prototype}
+          { key => fields[0].prototype }
         else
-          {key=> [:struct, to_struct_params]}
+          { key => [:struct, to_struct_params] }
         end
       end
 
@@ -225,16 +226,16 @@ module BinData
         if fields.empty?
           {}
         elsif fields.all_field_names_blank?
-          {key => fields.collect(&:prototype)}
+          { key => fields.collect(&:prototype) }
         else
           choices = {}
           fields.each { |f| choices[f.name] = f.prototype }
-          {key => choices}
+          { key => choices }
         end
       end
 
-      def to_struct_params(*unused)
-        result = {fields: fields}
+      def to_struct_params(*_)
+        result = { fields: fields }
         if !endian.nil?
           result[:endian] = endian
         end
@@ -274,7 +275,7 @@ module BinData
         def override_new_in_class(bnl_class)
           endian_classes = {
             big:    class_with_endian(bnl_class, :big),
-            little: class_with_endian(bnl_class, :little),
+            little: class_with_endian(bnl_class, :little)
           }
           bnl_class.define_singleton_method(:new) do |*args|
             if self == bnl_class
@@ -290,7 +291,7 @@ module BinData
         def delegate_field_creation(bnl_class)
           endian_classes = {
             big:    class_with_endian(bnl_class, :big),
-            little: class_with_endian(bnl_class, :little),
+            little: class_with_endian(bnl_class, :little)
           }
 
           parser = bnl_class.dsl_parser
@@ -302,28 +303,28 @@ module BinData
 
         def fixup_subclass_hierarchy(bnl_class)
           parent = bnl_class.superclass
-          if obj_attribute(parent, :endian) == :big_and_little
-            be_subclass = class_with_endian(bnl_class, :big)
-            be_parent   = class_with_endian(parent, :big)
-            be_fields   = obj_attribute(be_parent, :fields)
+          return if obj_attribute(parent, :endian) != :big_and_little
 
-            le_subclass = class_with_endian(bnl_class, :little)
-            le_parent   = class_with_endian(parent, :little)
-            le_fields   = obj_attribute(le_parent, :fields)
+          be_subclass = class_with_endian(bnl_class, :big)
+          be_parent   = class_with_endian(parent, :big)
+          be_fields   = obj_attribute(be_parent, :fields)
 
-            be_subclass.dsl_parser.define_singleton_method(:parent_fields) do
-              be_fields
-            end
-            le_subclass.dsl_parser.define_singleton_method(:parent_fields) do
-              le_fields
-            end
+          le_subclass = class_with_endian(bnl_class, :little)
+          le_parent   = class_with_endian(parent, :little)
+          le_fields   = obj_attribute(le_parent, :fields)
+
+          be_subclass.dsl_parser.define_singleton_method(:parent_fields) do
+            be_fields
+          end
+          le_subclass.dsl_parser.define_singleton_method(:parent_fields) do
+            le_fields
           end
         end
 
         def class_with_endian(class_name, endian)
           hints = {
             endian: endian,
-            search_prefix: class_name.dsl_parser.search_prefix,
+            search_prefix: class_name.dsl_parser.search_prefix
           }
           RegisteredClasses.lookup(class_name, hints)
         end
@@ -377,8 +378,9 @@ module BinData
           buffer:     BinData::Buffer,
           choice:     BinData::Choice,
           delayed_io: BinData::DelayedIO,
+          section:    BinData::Section,
           skip:       BinData::Skip,
-          struct:     BinData::Struct,
+          struct:     BinData::Struct
         }
 
         if bindata_classes.include?(@type)
@@ -420,7 +422,7 @@ module BinData
       def ensure_valid_name(name)
         if name && !option?(:fieldnames_are_values)
           if malformed_name?(name)
-            raise NameError.new("", name), "field '#{name}' is an illegal fieldname"
+            raise SyntaxError, "field '#{name}' is an illegal fieldname"
           end
 
           if duplicate_name?(name)
@@ -428,11 +430,11 @@ module BinData
           end
 
           if name_shadows_method?(name)
-            raise NameError.new("", name), "field '#{name}' shadows an existing method"
+            raise SyntaxError, "field '#{name}' shadows an existing method"
           end
 
           if name_is_reserved?(name)
-            raise NameError.new("", name), "field '#{name}' is a reserved name"
+            raise SyntaxError, "field '#{name}' is a reserved name"
           end
         end
       end
@@ -457,7 +459,7 @@ module BinData
       end
 
       def malformed_name?(name)
-        /^[a-z_]\w*$/ !~ name.to_s
+        !/^[a-z_]\w*$/.match?(name.to_s)
       end
 
       def duplicate_name?(name)

data/lib/bindata/float.rb

@@ -4,7 +4,7 @@ module BinData
   # Defines a number of classes that contain a floating point number.
   # The float is defined by precision and endian.
 
-  module FloatingPoint #:nodoc: all
+  module FloatingPoint # :nodoc: all
     class << self
       PRECISION = {
         single: 4,
@@ -15,7 +15,7 @@ module BinData
         [:single, :little] => 'e',
         [:single, :big]    => 'g',
         [:double, :little] => 'E',
-        [:double, :big]    => 'G',
+        [:double, :big]    => 'G'
       }
 
       def define_methods(float_class, precision, endian)
@@ -49,7 +49,7 @@ module BinData
         nbytes = PRECISION[precision]
         unpack = PACK_CODE[[precision, endian]]
 
-        "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
+        "io.readbytes(#{nbytes}).unpack1('#{unpack}')"
       end
 
       def create_to_binary_s_code(precision, endian)

data/lib/bindata/framework.rb

@@ -1,14 +1,13 @@
 module BinData
   # Error raised when unexpected results occur when reading data from IO.
-  class ValidityError < StandardError ; end
+  class ValidityError < StandardError; end
 
   # All methods provided by the framework are to be implemented or overridden 
   # by subclasses of BinData::Base.
   module Framework
     # Initializes the state of the object.  All instance variables that
     # are used by the object must be initialized here.
-    def initialize_instance
-    end
+    def initialize_instance; end
 
     # Initialises state that is shared by objects with the same parameters.
     #
@@ -16,8 +15,7 @@ module BinData
     # variables set here, and changes to the singleton class will be shared
     # between all objects that are initialized with the same parameters.
     # This method is called only once for a particular set of parameters.
-    def initialize_shared_instance
-    end
+    def initialize_shared_instance; end
 
     # Returns true if the object has not been changed since creation.
     def clear?
@@ -37,13 +35,13 @@ module BinData
 
     # Returns the debug name of +child+.  This only needs to be implemented
     # by objects that contain child objects.
-    def debug_name_of(child) #:nodoc:
+    def debug_name_of(child) # :nodoc:
       debug_name
     end
 
     # Returns the offset of +child+.  This only needs to be implemented
     # by objects that contain child objects.
-    def offset_of(child) #:nodoc:
+    def offset_of(child) # :nodoc:
       0
     end
 
@@ -53,17 +51,17 @@ module BinData
     end
 
     # Reads the data for this data object from +io+.
-    def do_read(io) #:nodoc:
+    def do_read(io) # :nodoc:
       raise NotImplementedError
     end
 
     # Writes the value for this data to +io+.
-    def do_write(io) #:nodoc:
+    def do_write(io) # :nodoc:
       raise NotImplementedError
     end
 
     # Returns the number of bytes it will take to write this data.
-    def do_num_bytes #:nodoc:
+    def do_num_bytes # :nodoc:
       raise NotImplementedError
     end