bindata 2.4.10 → 2.5.0

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,24 +104,29 @@ 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 include_obj?
+      !has_parameter?(:onlyif) || eval_parameter(:onlyif)
+    end
+
     # DelayedIO objects aren't read when #read is called.
     # The reading is delayed until this method is called.
     def read_now!
+      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
@@ -130,8 +135,10 @@ module BinData
     # DelayedIO objects aren't written when #write is called.
     # The writing is delayed until this method is called.
     def write_now!
+      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
@@ -146,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
 

data/lib/bindata/int.rb

@@ -5,7 +5,7 @@ module BinData
   # Defines a number of classes that contain an integer.  The integer
   # is defined by endian, signedness and number of bytes.
 
-  module Int #:nodoc: all
+  module Int # :nodoc: all
     @@mutex = Mutex.new
 
     class << self
@@ -59,16 +59,14 @@ module BinData
 
       def create_clamp_code(nbits, 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
 
-        clamp = "(#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val)"
-
-        "val = #{clamp}"
+        "val = val.clamp(#{min}, #{max})"
       end
 
       def create_read_code(nbits, endian, signed)
@@ -87,7 +85,7 @@ module BinData
           "io.readbytes(1).ord"
         else
           unpack_str   = create_read_unpack_code(nbits, endian, signed)
-          assemble_str = create_read_assemble_code(nbits, endian, signed)
+          assemble_str = create_read_assemble_code(nbits, endian)
 
           "(#{unpack_str} ; #{assemble_str})"
         end
@@ -100,7 +98,7 @@ module BinData
         "ints = io.readbytes(#{nbytes}).unpack('#{pack_directive}')"
       end
 
-      def create_read_assemble_code(nbits, endian, signed)
+      def create_read_assemble_code(nbits, endian)
         nwords = nbits / bits_per_word(nbits)
 
         idx = (0...nwords).to_a
@@ -119,7 +117,7 @@ module BinData
         return "(val & 0xff).chr" if nbits == 8
 
         pack_directive = pack_directive(nbits, endian, signed)
-        words          = val_as_packed_words(nbits, endian, signed)
+        words          = val_as_packed_words(nbits, endian)
         pack_str       = "[#{words}].pack('#{pack_directive}')"
 
         if need_signed_conversion_code?(nbits, signed)
@@ -129,7 +127,7 @@ module BinData
         end
       end
 
-      def val_as_packed_words(nbits, endian, signed)
+      def val_as_packed_words(nbits, endian)
         nwords = nbits / bits_per_word(nbits)
         mask   = (1 << bits_per_word(nbits)) - 1
 
@@ -138,7 +136,7 @@ module BinData
         vals.reverse! if (endian == :big)
 
         vals = vals.collect { |val| "#{val} & #{mask}" }  # TODO: "& mask" is needed to work around jruby bug. Remove this line when fixed.
-        vals.join(",")
+        vals.join(',')
       end
 
       def create_int2uint_code(nbits)
@@ -159,10 +157,10 @@ module BinData
       def pack_directive(nbits, endian, signed)
         nwords = nbits / bits_per_word(nbits)
 
-        directives = { 8 => "C", 16 => "S", 32 => "L", 64 => "Q" }
+        directives = { 8 => 'C', 16 => 'S', 32 => 'L', 64 => 'Q' }
 
         d = directives[bits_per_word(nbits)]
-        d += ((endian == :big) ? ">" : "<") unless d == "C"
+        d += ((endian == :big) ? '>' : '<') unless d == 'C'
 
         if signed == :signed && directives.key?(nbits)
           (d * nwords).downcase
@@ -195,7 +193,7 @@ module BinData
         /^Uint(\d+)be$/ => [:big,    :unsigned],
         /^Uint(\d+)le$/ => [:little, :unsigned],
         /^Int(\d+)be$/  => [:big,    :signed],
-        /^Int(\d+)le$/  => [:little, :signed],
+        /^Int(\d+)le$/  => [:little, :signed]
       }
 
       mappings.each_pair do |regex, args|