bindata 2.3.5 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa6f6792c33e83b12b474d4e1b6a6b057fdd4425
-  data.tar.gz: 347099da9214708c8799fef5e2aa1d8d6dc6a0bf
+  metadata.gz: 273d7545be91c481736500d0acc038741cce9327
+  data.tar.gz: 50326341e03e5bb741d78d7025470576e9389b34
 SHA512:
-  metadata.gz: d9da79f0e12fdf4854db54801f3233b79ab5c3f30850e9d64bdcb27bcb7d937527a7e700d16fdf7abd2ebf9cd1caf1a72ef37488d989e1ead8406ba540327981
-  data.tar.gz: a6f7fb484a15d030d277c723ba023f76308e4b87d36b73a28385de25705dc9776408323380eabbc087cd339b2738d2f0a5a3132ee0827c639c6cf150a7e9fe53
+  metadata.gz: ede91bae71b3e11e97d95e586fbaa215b4b3c09aa32cab067f9dfde861687c0a421c8b59654e5e4bd3661e5562b221010af71b3e5b66bcf5d3fcbc9a77003265
+  data.tar.gz: 043a8490cc4c132ff909562084e4e1b4de46bd1ae892f14e8b2c981a981052ada21eb3d2d3a615e381dd58a898e6f11ebf3b5095da010a083185cd2e0b19b77c

data/ChangeLog.rdoc

@@ -1,5 +1,10 @@
 = BinData Changelog
 
+== Version 2.4.0 (2017-04-09)
+
+* Reworked internal sanitizing API.
+* Fix bit-based integers inside buffers.  Reported by Claudius Coenen.
+
 == Version 2.3.5 (2017-01-19)
 
 * Enforce Integer#nbits > 0.  Reported by Keenan Tims.

data/NEWS.rdoc

@@ -1,3 +1,19 @@
+= 2.4.0
+
+This release changes the internal API for sanitizing parameters.  This only
+affects those that implement the `#sanitize_parameters` method.
+
+= 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
+
+    params.sanitize_object_prototype(:type)
+
 = 2.3.0
 
 This release adds I/O features.

data/lib/bindata/array.rb

@@ -275,9 +275,8 @@ module BinData
 
   class ArrayArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params) #:nodoc:
-      unless params.has_parameter?(:initial_length) ||
-               params.has_parameter?(:read_until)
-        # ensure one of :initial_length and :read_until exists
+      # ensure one of :initial_length and :read_until exists
+      unless params.has_at_least_one_of?(:initial_length, :read_until)
         params[:initial_length] = 0
       end
 
@@ -286,11 +285,7 @@ module BinData
       params.must_be_integer(:initial_length)
 
       params.merge!(obj_class.dsl_params)
-
-      if params.needs_sanitizing?(:type)
-        el_type, el_params = params[:type]
-        params[:type] = params.create_sanitized_object_prototype(el_type, el_params)
-      end
+      params.sanitize_object_prototype(:type)
     end
   end
 
@@ -300,8 +295,7 @@ module BinData
       loop do
         element = append_new_element
         element.do_read(io)
-        variables = { index: self.length - 1, element: self.last,
-                      array: self }
+        variables = { index: self.length - 1, element: self.last, array: self }
         break if eval_parameter(:read_until, variables)
       end
     end

data/lib/bindata/base_primitive.rb

@@ -73,12 +73,13 @@ module BinData
       raise ArgumentError, "can't set a nil value for #{debug_name}" if val.nil?
 
       raw_val = val.respond_to?(:snapshot) ? val.snapshot : val
-      @value = begin
-                 raw_val.dup
-               rescue TypeError
-                 # can't dup Fixnums
-                 raw_val
-               end
+      @value =
+        begin
+          raw_val.dup
+        rescue TypeError
+          # can't dup Fixnums
+          raw_val
+        end
     end
 
     def snapshot
@@ -101,9 +102,10 @@ module BinData
     def method_missing(symbol, *args, &block) #:nodoc:
       child = snapshot
       if child.respond_to?(symbol)
-        self.class.class_eval "def #{symbol}(*args, &block);" \
-                              "  snapshot.#{symbol}(*args, &block);" \
-                              "end"
+        self.class.class_eval \
+          "def #{symbol}(*args, &block);" \
+          "  snapshot.#{symbol}(*args, &block);" \
+          "end"
         child.__send__(symbol, *args, &block)
       else
         super
@@ -179,13 +181,14 @@ module BinData
         current_value = snapshot
         expected = eval_parameter(:assert, value: current_value)
 
-        msg = if !expected
-                "value '#{current_value}' not as expected"
-              elsif expected != true && current_value != expected
-                "value is '#{current_value}' but expected '#{expected}'"
-              else
-                nil
-              end
+        msg =
+          if !expected
+            "value '#{current_value}' not as expected"
+          elsif expected != true && current_value != expected
+            "value is '#{current_value}' but expected '#{expected}'"
+          else
+            nil
+          end
 
         raise ValidityError, "#{msg} for #{debug_name}" if msg
       end

data/lib/bindata/bits.rb

@@ -10,7 +10,8 @@ module BinData
         unless BinData.const_defined?(name)
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
-              BitField.define_methods(self, #{nbits.inspect}, #{endian.inspect}, #{signed.inspect})
+              # nbits is either an integer or the symbol `:nbits`
+              BitField.define_methods(self, #{nbits.inspect}, :#{endian}, :#{signed})
             end
           END
         end

data/lib/bindata/buffer.rb

@@ -110,13 +110,8 @@ module BinData
 
     def sanitize_parameters!(obj_class, params)
       params.merge!(obj_class.dsl_params)
-
       params.must_be_integer(:length)
-
-      if params.needs_sanitizing?(:type)
-        el_type, el_params = params[:type]
-        params[:type] = params.create_sanitized_object_prototype(el_type, el_params)
-      end
+      params.sanitize_object_prototype(:type)
     end
   end
 end

data/lib/bindata/choice.rb

@@ -122,10 +122,10 @@ module BinData
     def sanitize_parameters!(obj_class, params) #:nodoc:
       params.merge!(obj_class.dsl_params)
 
-      if params.needs_sanitizing?(:choices)
-        choices = choices_as_hash(params[:choices])
-        ensure_valid_keys(choices)
-        params[:choices] = params.create_sanitized_choices(choices)
+      params.sanitize_choices(:choices) do |choices|
+        hash_choices = choices_as_hash(choices)
+        ensure_valid_keys(hash_choices)
+        hash_choices
       end
     end
 

data/lib/bindata/delayed_io.rb

@@ -141,13 +141,8 @@ module BinData
 
     def sanitize_parameters!(obj_class, params)
       params.merge!(obj_class.dsl_params)
-
       params.must_be_integer(:read_abs_offset)
-
-      if params.needs_sanitizing?(:type)
-        el_type, el_params = params[:type]
-        params[:type] = params.create_sanitized_object_prototype(el_type, el_params)
-      end
+      params.sanitize_object_prototype(:type)
     end
   end
 
@@ -157,10 +152,9 @@ module BinData
       # 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

@@ -107,11 +107,7 @@ module BinData
       end
 
       def fields
-        @fields ||= begin
-          SanitizedFields.new(hints).tap do |san_fields|
-            san_fields.copy_fields(parent_fields) if parent_fields
-          end
-        end
+        @fields ||= SanitizedFields.new(hints, parent_fields)
       end
 
       def dsl_params

data/lib/bindata/io.rb

@@ -273,11 +273,7 @@ module BinData
       # If the data read is too short an IOError is raised.
       def readbytes(n)
         reset_read_bits
-
-        str = read(n)
-        raise EOFError, "End of file reached" if str.nil?
-        raise IOError, "data truncated" if str.size < n
-        str
+        read(n)
       end
 
       # Reads all remaining bytes from the stream.
@@ -313,7 +309,12 @@ module BinData
       private
 
       def read(n = nil)
-        read_raw(buffer_limited_n(n))
+        str = read_raw(buffer_limited_n(n))
+        if n
+          raise EOFError, "End of file reached" if str.nil?
+          raise IOError, "data truncated" if str.size < n
+        end
+        str
       end
 
       def read_big_endian_bits(nbits)
@@ -329,10 +330,7 @@ module BinData
       end
 
       def accumulate_big_endian_bits
-        byte = read(1)
-        raise EOFError, "End of file reached" if byte.nil?
-        byte = byte.unpack('C').at(0) & 0xff
-
+        byte = read(1).unpack('C').at(0) & 0xff
         @rval = (@rval << 8) | byte
         @rnbits += 8
       end
@@ -350,10 +348,7 @@ module BinData
       end
 
       def accumulate_little_endian_bits
-        byte = read(1)
-        raise EOFError, "End of file reached" if byte.nil?
-        byte = byte.unpack('C').at(0) & 0xff
-
+        byte = read(1).unpack('C').at(0) & 0xff
         @rval = @rval | (byte << @rnbits)
         @rnbits += 8
       end

data/lib/bindata/registry.rb

@@ -43,11 +43,13 @@ module BinData
 
     # Convert CamelCase +name+ to underscore style.
     def underscore_name(name)
-      name.to_s.sub(/.*::/, "").
-                gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-                gsub(/([a-z\d])([A-Z])/, '\1_\2').
-                tr("-", "_").
-                downcase
+      name.
+        to_s.
+        sub(/.*::/, "").
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        tr("-", "_").
+        downcase
     end
 
     #---------------

data/lib/bindata/sanitize.rb

@@ -72,11 +72,14 @@ module BinData
   class SanitizedFields < SanitizedParameter
     include Enumerable
 
-    def initialize(hints)
-      @fields = []
-      @hints  = hints
+    def initialize(hints, base_fields = nil)
+      @hints = hints
+      if base_fields
+        @fields = base_fields.raw_fields
+      else
+        @fields = []
+      end
     end
-    attr_reader :fields
 
     def add_field(type, name, params)
       name = nil if name == ""
@@ -84,6 +87,10 @@ module BinData
       @fields << SanitizedField.new(name, type, params, @hints)
     end
 
+    def raw_fields
+      @fields.dup
+    end
+
     def [](idx)
       @fields[idx]
     end
@@ -119,10 +126,6 @@ module BinData
     def any_field_has_parameter?(parameter)
       @fields.any? { |f| f.has_parameter?(parameter) }
     end
-
-    def copy_fields(other)
-      @fields.concat(other.fields)
-    end
   end
   #----------------------------------------------------------------------------
 
@@ -209,10 +212,12 @@ module BinData
 
     alias_method :has_parameter?, :key?
 
-    def needs_sanitizing?(key)
-      parameter = self[key]
+    def has_at_least_one_of?(*keys)
+      keys.each do |key|
+        return true if has_parameter?(key)
+      end
 
-      parameter && !parameter.is_a?(SanitizedParameter)
+      false
     end
 
     def warn_replacement_parameter(bad_key, suggested_key)
@@ -245,36 +250,46 @@ module BinData
       end
     end
 
-    def hints
-      { endian: self[:endian], search_prefix: self[:search_prefix] }
+    def rename_parameter(old_key, new_key)
+      if has_parameter?(old_key)
+        self[new_key] = delete(old_key)
+      end
     end
 
-    def create_sanitized_endian(endian)
-      if endian == :big
-        BIG_ENDIAN
-      elsif endian == :little
-        LITTLE_ENDIAN
-      elsif endian == :big_and_little
-        raise ArgumentError, "endian: :big or endian: :little is required"
-      else
-        raise ArgumentError, "unknown value for endian '#{endian}'"
+    def sanitize_object_prototype(key)
+      sanitize(key) { |obj_type, obj_params| create_sanitized_object_prototype(obj_type, obj_params) }
+    end
+
+    def sanitize_fields(key, &block)
+      sanitize(key) do |fields|
+        sanitized_fields = create_sanitized_fields
+        yield(fields, sanitized_fields)
+        sanitized_fields
       end
     end
 
-    def create_sanitized_params(params, the_class)
-      SanitizedParameters.new(params, the_class, hints)
+    def sanitize_choices(key, &block)
+      sanitize(key) do |obj|
+        create_sanitized_choices(yield(obj))
+      end
     end
 
-    def create_sanitized_choices(choices)
-      SanitizedChoices.new(choices, hints)
+    def sanitize_endian(key)
+      sanitize(key) { |endian| create_sanitized_endian(endian) }
     end
 
-    def create_sanitized_fields
-      SanitizedFields.new(hints)
+    def sanitize(key, &block)
+      if needs_sanitizing?(key)
+        self[key] = yield(self[key])
+      end
     end
 
-    def create_sanitized_object_prototype(obj_type, obj_params)
-      SanitizedPrototype.new(obj_type, obj_params, hints)
+    def create_sanitized_params(params, the_class)
+      SanitizedParameters.new(params, the_class, hints)
+    end
+
+    def hints
+      { endian: self[:endian], search_prefix: self[:search_prefix] }
     end
 
     #---------------
@@ -290,6 +305,12 @@ module BinData
       ensure_mutual_exclusion_of_parameters
     end
 
+    def needs_sanitizing?(key)
+      parameter = self[key]
+
+      parameter && !parameter.is_a?(SanitizedParameter)
+    end
+
     def ensure_no_nil_values
       each do |key, value|
         if value.nil?
@@ -324,6 +345,30 @@ module BinData
         end
       end
     end
+
+    def create_sanitized_endian(endian)
+      if endian == :big
+        BIG_ENDIAN
+      elsif endian == :little
+        LITTLE_ENDIAN
+      elsif endian == :big_and_little
+        raise ArgumentError, "endian: :big or endian: :little is required"
+      else
+        raise ArgumentError, "unknown value for endian '#{endian}'"
+      end
+    end
+
+    def create_sanitized_choices(choices)
+      SanitizedChoices.new(choices, hints)
+    end
+
+    def create_sanitized_fields
+      SanitizedFields.new(hints)
+    end
+
+    def create_sanitized_object_prototype(obj_type, obj_params)
+      SanitizedPrototype.new(obj_type, obj_params, hints)
+    end
   end
   #----------------------------------------------------------------------------
 end

data/lib/bindata/skip.rb

@@ -83,17 +83,12 @@ module BinData
 
   class SkipArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params)
-      unless params.has_parameter?(:length) ||
-             params.has_parameter?(:to_abs_offset) ||
-             params.has_parameter?(:until_valid)
-        raise ArgumentError, "#{obj_class} requires either :length, :to_abs_offset or :until_valid"
+      unless params.has_at_least_one_of?(:length, :to_abs_offset, :until_valid)
+        raise ArgumentError,
+          "#{obj_class} requires either :length, :to_abs_offset or :until_valid"
       end
       params.must_be_integer(:to_abs_offset, :length)
-
-      if params.needs_sanitizing?(:until_valid)
-        el_type, el_params = params[:until_valid]
-        params[:until_valid] = params.create_sanitized_object_prototype(el_type, el_params)
-      end
+      params.sanitize_object_prototype(:until_valid)
     end
   end
 

data/lib/bindata/string.rb

@@ -127,15 +127,8 @@ module BinData
     def sanitize_parameters!(obj_class, params)
       params.warn_replacement_parameter(:initial_length, :read_length)
       params.must_be_integer(:read_length, :length)
-
-      if params.has_parameter?(:pad_left)
-        params[:pad_front] = params.delete(:pad_left)
-      end
-
-      if params.has_parameter?(:pad_byte)
-        byte = params[:pad_byte]
-        params[:pad_byte] = sanitized_pad_byte(byte)
-      end
+      params.rename_parameter(:pad_left, :pad_front)
+      params.sanitize(:pad_byte) { |byte| sanitized_pad_byte(byte) }
     end
 
     #-------------

data/lib/bindata/struct.rb

@@ -62,19 +62,20 @@ module BinData
     optional_parameters :endian, :search_prefix, :hide
 
     # These reserved words may not be used as field names
-    RESERVED = Hash[*
-                 (Hash.instance_methods +
-                  %w{alias and begin break case class def defined do else elsif
-                     end ensure false for if in module next nil not or redo
-                     rescue retry return self super then true undef unless until
-                     when while yield} +
-                  %w{array element index value} +
-                  %w{type initial_length read_until} +
-                  %w{fields endian search_prefix hide only_if byte_align} +
-                  %w{choices selection copy_on_change} +
-                  %w{read_abs_offset struct_params}).collect(&:to_sym).
-                  uniq.collect { |key| [key, true] }.flatten
-               ]
+    RESERVED =
+      Hash[*
+        (Hash.instance_methods +
+         %w{alias and begin break case class def defined do else elsif
+            end ensure false for if in module next nil not or redo
+            rescue retry return self super then true undef unless until
+            when while yield} +
+         %w{array element index value} +
+         %w{type initial_length read_until} +
+         %w{fields endian search_prefix hide only_if byte_align} +
+         %w{choices selection copy_on_change} +
+         %w{read_abs_offset struct_params}).collect(&:to_sym).
+         uniq.collect { |key| [key, true] }.flatten
+      ]
 
     def initialize_shared_instance
       fields = get_parameter(:fields)
@@ -349,44 +350,38 @@ module BinData
     private
 
     def sanitize_endian(params)
-      if params.needs_sanitizing?(:endian)
-        endian = params.create_sanitized_endian(params[:endian])
-        params[:endian] = endian
-      end
+      params.sanitize_endian(:endian)
     end
 
     def sanitize_search_prefix(params)
-      if params.needs_sanitizing?(:search_prefix)
+      params.sanitize(:search_prefix) do |sprefix|
         search_prefix = []
-        Array(params[:search_prefix]).each do |prefix|
+        Array(sprefix).each do |prefix|
           prefix = prefix.to_s.chomp("_")
           search_prefix << prefix if prefix != ""
         end
 
-        params[:search_prefix] = search_prefix
+        search_prefix
       end
     end
 
     def sanitize_fields(obj_class, params)
-      if params.needs_sanitizing?(:fields)
-        fields = params[:fields]
-
-        params[:fields] = params.create_sanitized_fields
+      params.sanitize_fields(:fields) do |fields, sanitized_fields|
         fields.each do |ftype, fname, fparams|
-          params[:fields].add_field(ftype, fname, fparams)
+          sanitized_fields.add_field(ftype, fname, fparams)
         end
 
-        field_names = sanitized_field_names(params[:fields])
+        field_names = sanitized_field_names(sanitized_fields)
         ensure_field_names_are_valid(obj_class, field_names)
       end
     end
 
     def sanitize_hide(params)
-      if params.needs_sanitizing?(:hide) && params.has_parameter?(:fields)
+      params.sanitize(:hide) do |hidden|
         field_names  = sanitized_field_names(params[:fields])
-        hfield_names = hidden_field_names(params[:hide])
+        hfield_names = hidden_field_names(hidden)
 
-        params[:hide] = (hfield_names & field_names)
+        hfield_names & field_names
       end
     end
 

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "2.3.5"
+  VERSION = "2.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bindata
 version: !ruby/object:Gem::Version
-  version: 2.3.5
+  version: 2.4.0
 platform: ruby
 authors:
 - Dion Mendel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-19 00:00:00.000000000 Z
+date: 2017-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -163,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: bindata
-rubygems_version: 2.4.5
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: A declarative way to read and write binary file formats