bindata 2.3.3 → 2.3.4

data/lib/bindata/skip.rb

@@ -9,8 +9,8 @@ module BinData
   #   require 'bindata'
   #
   #   class A < BinData::Record
-  #     skip :length => 5
-  #     string :a, :read_length => 5
+  #     skip length: 5
+  #     string :a, read_length: 5
   #   end
   #
   #   obj = A.read("abcdefghij")
@@ -18,8 +18,8 @@ module BinData
   #
   #
   #   class B < BinData::Record
-  #     skip :until_valid => [:string, {:read_length => 2, :assert => "ef"} ]
-  #     string :b, :read_length => 5
+  #     skip until_valid: [:string, {read_length: 2, assert: "ef"} ]
+  #     string :b, read_length: 5
   #   end
   #
   #   obj = B.read("abcdefghij")
@@ -42,7 +42,6 @@ module BinData
   #                           <tt>[type_symbol, hash_params]</tt>.
   #
   class Skip < BinData::BasePrimitive
-
     arg_processor :skip
 
     optional_parameters :length, :to_abs_offset, :until_valid
@@ -51,7 +50,7 @@ module BinData
     def initialize_shared_instance
       extend SkipLengthPlugin      if has_parameter?(:length)
       extend SkipToAbsOffsetPlugin if has_parameter?(:to_abs_offset)
-      extend SkipUntilValidPlugin if has_parameter?(:until_valid)
+      extend SkipUntilValidPlugin  if has_parameter?(:until_valid)
       super
     end
 
@@ -84,8 +83,8 @@ module BinData
 
   class SkipArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params)
-      unless params.has_parameter?(:length) or
-             params.has_parameter?(:to_abs_offset) or
+      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"
       end

data/lib/bindata/string.rb

@@ -8,11 +8,11 @@ module BinData
   #
   #   data = "abcdefghij"
   #
-  #   obj = BinData::String.new(:read_length => 5)
+  #   obj = BinData::String.new(read_length: 5)
   #   obj.read(data)
   #   obj #=> "abcde"
   #
-  #   obj = BinData::String.new(:length => 6)
+  #   obj = BinData::String.new(length: 6)
   #   obj.read(data)
   #   obj #=> "abcdef"
   #   obj.assign("abcdefghij")
@@ -20,12 +20,12 @@ module BinData
   #   obj.assign("abcd")
   #   obj #=> "abcd\000\000"
   #
-  #   obj = BinData::String.new(:length => 6, :trim_padding => true)
+  #   obj = BinData::String.new(length: 6, trim_padding: true)
   #   obj.assign("abcd")
   #   obj #=> "abcd"
   #   obj.to_binary_s #=> "abcd\000\000"
   #
-  #   obj = BinData::String.new(:length => 6, :pad_byte => 'A')
+  #   obj = BinData::String.new(length: 6, pad_byte: 'A')
   #   obj.assign("abcd")
   #   obj #=> "abcdAA"
   #   obj.to_binary_s #=> "abcdAA"
@@ -52,13 +52,13 @@ module BinData
     arg_processor :string
 
     optional_parameters :read_length, :length, :trim_padding, :pad_front, :pad_left
-    default_parameters  :pad_byte => "\0"
+    default_parameters  pad_byte: "\0"
     mutually_exclusive_parameters :read_length, :length
     mutually_exclusive_parameters :length, :value
 
     def initialize_shared_instance
       if (has_parameter?(:value) || has_parameter?(:asserted_value)) &&
-          ! has_parameter?(:read_length)
+          !has_parameter?(:read_length)
         extend WarnNoReadLengthPlugin
       end
       super

data/lib/bindata/stringz.rb

@@ -52,7 +52,7 @@ module BinData
       ch = nil
 
       # read until zero byte or we have read in the max number of bytes
-      while ch != "\0" and i != max_length
+      while ch != "\0" && i != max_length
         ch = io.readbytes(1)
         str << ch
         i += 1
@@ -81,14 +81,14 @@ module BinData
       if max_length
         max_length = 1 if max_length < 1
         str.slice!(max_length)
-        if str.length == max_length and str[-1, 1] != "\0"
+        if str.length == max_length && str[-1, 1] != "\0"
           str[-1, 1] = "\0"
         end
       end
     end
 
     def append_zero_byte_if_needed!(str)
-      if str.length == 0 or str[-1, 1] != "\0"
+      if str.length == 0 || str[-1, 1] != "\0"
         str << "\0"
       end
     end

data/lib/bindata/struct.rb

@@ -16,10 +16,10 @@ module BinData
   #      int8  :z
   #    end
   #
-  #    obj = BinData::Struct.new(:hide => :a,
-  #                              :fields => [ [:int32le, :a],
-  #                                           [:int16le, :b],
-  #                                           [:tuple, :s] ])
+  #    obj = BinData::Struct.new(hide: :a,
+  #                              fields: [ [:int32le, :a],
+  #                                        [:int16le, :b],
+  #                                        [:tuple, :s] ])
   #    obj.field_names   =># [:b, :s]
   #
   #
@@ -72,7 +72,7 @@ module BinData
                   %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 { |name| name.to_sym }.
+                  %w{read_abs_offset struct_params}).collect(&:to_sym).
                   uniq.collect { |key| [key, true] }.flatten
                ]
 
@@ -85,7 +85,7 @@ module BinData
     end
 
     def initialize_instance
-      @field_objs  = []
+      @field_objs = []
     end
 
     def clear #:nodoc:
@@ -93,7 +93,7 @@ module BinData
     end
 
     def clear? #:nodoc:
-      @field_objs.all? { |f| f.nil? or f.clear? }
+      @field_objs.all? { |f| f.nil? || f.clear? }
     end
 
     def assign(val)
@@ -159,7 +159,7 @@ module BinData
       end
     end
 
-    def has_key?(key)
+    def key?(key)
       @field_names.index(base_field_name(key))
     end
 
@@ -228,7 +228,7 @@ module BinData
 
       @field_names.compact.each do |name|
         obj = find_obj_for_name(name)
-        if obj and src.has_key?(name)
+        if obj && src.key?(name)
           obj.assign(src[name])
         end
       end
@@ -263,7 +263,7 @@ module BinData
     end
 
     def include_obj?(obj)
-      not obj.has_parameter?(:onlyif) or obj.eval_parameter(:onlyif)
+      !obj.has_parameter?(:onlyif) || obj.eval_parameter(:onlyif)
     end
 
     # A hash that can be accessed via attributes.
@@ -273,7 +273,7 @@ module BinData
       end
 
       def respond_to?(symbol, include_private = false)
-        has_key?(symbol) || super
+        key?(symbol) || super
       end
 
       def method_missing(symbol, *args)
@@ -382,7 +382,7 @@ module BinData
     end
 
     def sanitize_hide(params)
-      if params.needs_sanitizing?(:hide) and params.has_parameter?(:fields)
+      if params.needs_sanitizing?(:hide) && params.has_parameter?(:fields)
         field_names  = sanitized_field_names(params[:fields])
         hfield_names = hidden_field_names(params[:hide])
 
@@ -395,7 +395,7 @@ module BinData
     end
 
     def hidden_field_names(hidden)
-      (hidden || []).collect { |h| h.to_sym }
+      (hidden || []).collect(&:to_sym)
     end
 
     def ensure_field_names_are_valid(obj_class, field_names)
@@ -403,15 +403,15 @@ module BinData
 
       field_names.each do |name|
         if obj_class.method_defined?(name)
-          raise NameError.new("Rename field '#{name}' in #{obj_class}, " +
+          raise NameError.new("Rename field '#{name}' in #{obj_class}, " \
                               "as it shadows an existing method.", name)
         end
         if reserved_names.include?(name)
-          raise NameError.new("Rename field '#{name}' in #{obj_class}, " +
+          raise NameError.new("Rename field '#{name}' in #{obj_class}, " \
                               "as it is a reserved name.", name)
         end
         if field_names.count(name) != 1
-          raise NameError.new("field '#{name}' in #{obj_class}, " +
+          raise NameError.new("field '#{name}' in #{obj_class}, " \
                               "is defined multiple times.", name)
         end
       end

data/lib/bindata/trace.rb

@@ -13,7 +13,7 @@ module BinData
 
     def trace_obj(obj_name, val)
       if val.length > 30
-        val = val.slice(0 .. 30) + "..."
+        val = val.slice(0..30) + "..."
       end
 
       trace "#{obj_name} => #{val}"
@@ -23,20 +23,21 @@ module BinData
   # Turn on trace information when reading a BinData object.
   # If +block+ is given then the tracing only occurs for that block.
   # This is useful for debugging a BinData declaration.
-  def trace_reading(io = STDERR, &block)
+  def trace_reading(io = STDERR)
     @tracer = Tracer.new(io)
-    [BasePrimitive, Choice].each { |traced| traced.turn_on_tracing }
+    [BasePrimitive, Choice].each(&:turn_on_tracing)
+
     if block_given?
       begin
-        block.call
+        yield
       ensure
-        [BasePrimitive, Choice].each { |traced| traced.turn_off_tracing }
+        [BasePrimitive, Choice].each(&:turn_off_tracing)
         @tracer = nil
       end
     end
   end
 
-  def trace_message(&block) #:nodoc:
+  def trace_message #:nodoc:
     yield @tracer if @tracer
   end
 
@@ -60,7 +61,7 @@ module BinData
     end
 
     def trace_value
-      BinData::trace_message do |tracer|
+      BinData.trace_message do |tracer|
         value_string = _value.inspect
         tracer.trace_obj(debug_name, value_string)
       end
@@ -85,7 +86,7 @@ module BinData
     end
 
     def trace_selection
-      BinData::trace_message do |tracer|
+      BinData.trace_message do |tracer|
         selection_string = eval_parameter(:selection).inspect
         tracer.trace_obj("#{debug_name}-selection-", selection_string)
       end

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "2.3.3"
+  VERSION = "2.3.4"
 end

data/lib/bindata/virtual.rb

@@ -8,9 +8,9 @@ module BinData
   #   require 'bindata'
   #
   #   class A < BinData::Record
-  #     string  :a, :read_length => 5
-  #     string  :b, :read_length => 5
-  #     virtual :c, :assert => lambda { a == b }
+  #     string  :a, read_length: 5
+  #     string  :b, read_length: 5
+  #     virtual :c, assert: -> { a == b }
   #   end
   #
   #   obj = A.read("abcdeabcde")

data/lib/bindata/warnings.rb

@@ -1,6 +1,5 @@
 module BinData
   class Base
-
     # Don't override initialize.  If you are defining a new kind of datatype
     # (list, array, choice etc) then put your initialization code in
     # #initialize_instance.  BinData objects might be initialized as prototypes
@@ -21,7 +20,7 @@ module BinData
       end
       initialize_without_warning(*args)
     end
-    alias_method :initialize, :initialize_with_warning
+    alias initialize initialize_with_warning
 
     def initialize_instance(*args)
       unless args.empty?
@@ -29,4 +28,9 @@ module BinData
       end
     end
   end
+
+  class Struct
+    # has_key? is deprecated
+    alias has_key? key?
+  end
 end

data/test/alignment_test.rb

@@ -19,7 +19,7 @@ describe BinData::ResumeByteAlignment do
   end
 
   it "resets write alignment" do
-    obj.assign(:a => 2, :b => 7)
+    obj.assign(a: 2, b: 7)
 
     obj.to_binary_s.must_equal_binary "\x20\x70"
   end
@@ -40,7 +40,7 @@ describe BinData::BitAligned do
 
   class BitAlignedRecord < BinData::Record
     bit4 :preamble
-    bit_string :str, :length => 2
+    bit_string :str, length: 2
     bit4 :afterward
   end
 
@@ -56,11 +56,11 @@ describe BinData::BitAligned do
 
   it "reads as expected" do
     obj.read("\x56\x36\x42")
-    obj.snapshot.must_equal({:preamble => 5, :str => "cd", :afterward => 2})
+    obj.snapshot.must_equal({preamble: 5, str: "cd", afterward: 2})
   end
 
   it "writes as expected" do
-    obj.assign(:preamble => 5, :str => "ab", :afterward => 1)
+    obj.assign(preamble: 5, str: "ab", afterward: 1)
     obj.to_binary_s.must_equal_binary "\x56\x16\x21"
   end
 end

data/test/array_test.rb

@@ -12,49 +12,49 @@ describe BinData::Array, "when instantiating" do
 
   describe "with some but not all mandatory parameters supplied" do
     it "raises an error" do
-      args = {:initial_length => 3}
+      args = {initial_length: 3}
       lambda { BinData::Array.new(args) }.must_raise ArgumentError
     end
   end
 
   it "warns about :length" do
     Kernel.must_warn ":length is not used with BinData::Array.  You probably want to change this to :initial_length" do
-    obj = BinData::Array.new(:type => :uint8, :length => 3)
+    obj = BinData::Array.new(type: :uint8, length: 3)
       obj.read "123"
     end
   end
 
   it "warns about :read_length" do
     Kernel.must_warn ":read_length is not used with BinData::Array.  You probably want to change this to :initial_length" do
-    obj = BinData::Array.new(:type => :uint8, :read_length => 3)
+    obj = BinData::Array.new(type: :uint8, read_length: 3)
       obj.read "123"
     end
   end
 
   it "fails if a given type is unknown" do
-    args = {:type => :does_not_exist, :initial_length => 3}
+    args = {type: :does_not_exist, initial_length: 3}
     lambda { BinData::Array.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails if :initial_length is not an integer" do
-    args = {:type => :uint8, :initial_length => "3"}
+    args = {type: :uint8, initial_length: "3"}
     lambda { BinData::Array.new(args) }.must_raise ArgumentError
   end
 
   it "does not allow both :initial_length and :read_until" do
-    args = {:initial_length => 3, :read_until => lambda { false } }
+    args = {initial_length: 3, read_until: -> { false } }
     lambda { BinData::Array.new(args) }.must_raise ArgumentError
   end
 
   it "accepts BinData::Base as :type" do
-    obj = BinData::Int8.new(:initial_value => 5)
-    array = BinData::Array.new(:type => obj, :initial_length => 1)
+    obj = BinData::Int8.new(initial_value: 5)
+    array = BinData::Array.new(type: obj, initial_length: 1)
     array.must_equal [5]
   end
 end
 
 describe BinData::Array, "with no elements" do
-  let(:obj) { BinData::Array.new(:type => :uint32le) }
+  let(:obj) { BinData::Array.new(type: :uint32le) }
 
   it "initial state" do
     assert obj.clear?
@@ -75,8 +75,8 @@ end
 
 describe BinData::Array, "with several elements" do
   let(:obj) {
-    type = [:uint32le, {:initial_value => lambda { index + 1 }}]
-    BinData::Array.new(:type => type, :initial_length => 5)
+    type = [:uint32le, {initial_value: -> { index + 1 }}]
+    BinData::Array.new(type: type, initial_length: 5)
   }
 
   it "initial state" do
@@ -107,7 +107,7 @@ describe BinData::Array, "with several elements" do
   end
 
   it "assigns a bindata array" do
-    array = BinData::Array.new([4, 5, 6], :type => :uint32le)
+    array = BinData::Array.new([4, 5, 6], type: :uint32le)
     obj.assign(array)
     obj.must_equal [4, 5, 6]
   end
@@ -201,8 +201,8 @@ end
 
 describe BinData::Array, "when accessing elements" do
   let(:obj) {
-    type = [:uint32le, {:initial_value => lambda { index + 1 }}]
-    data = BinData::Array.new(:type => type, :initial_length => 5)
+    type = [:uint32le, {initial_value: -> { index + 1 }}]
+    data = BinData::Array.new(type: type, initial_length: 5)
     data.assign([1, 2, 3, 4, 5])
     data
   }
@@ -273,7 +273,7 @@ describe BinData::Array, "with :read_until" do
   describe "containing +element+" do
     it "reads until the sentinel is reached" do
       read_until = lambda { element == 5 }
-      obj = BinData::Array.new(:type => :int8, :read_until => read_until)
+      obj = BinData::Array.new(type: :int8, read_until: read_until)
 
       obj.read "\x01\x02\x03\x04\x05\x06\x07\x08"
       obj.must_equal [1, 2, 3, 4, 5]
@@ -283,7 +283,7 @@ describe BinData::Array, "with :read_until" do
   describe "containing +array+ and +index+" do
     it "reads until the sentinel is reached" do
       read_until = lambda { index >= 2 and array[index - 2] == 5 }
-      obj = BinData::Array.new(:type => :int8, :read_until => read_until)
+      obj = BinData::Array.new(type: :int8, read_until: read_until)
 
       obj.read "\x01\x02\x03\x04\x05\x06\x07\x08"
       obj.must_equal [1, 2, 3, 4, 5, 6, 7]
@@ -292,22 +292,22 @@ describe BinData::Array, "with :read_until" do
 
   describe ":eof" do
     it "reads records until eof" do
-      obj = BinData::Array.new(:type => :int8, :read_until => :eof)
+      obj = BinData::Array.new(type: :int8, read_until: :eof)
 
       obj.read "\x01\x02\x03"
       obj.must_equal [1, 2, 3]
     end
 
     it "reads records until eof, ignoring partial records" do
-      obj = BinData::Array.new(:type => :int16be, :read_until => :eof)
+      obj = BinData::Array.new(type: :int16be, read_until: :eof)
 
       obj.read "\x00\x01\x00\x02\x03"
       obj.must_equal [1, 2]
     end
 
     it "reports exceptions" do
-      array_type = [:string, {:read_length => lambda { unknown_variable }}]
-      obj = BinData::Array.new(:type => array_type, :read_until => :eof)
+      array_type = [:string, {read_length: -> { unknown_variable }}]
+      obj = BinData::Array.new(type: array_type, read_until: :eof)
       lambda { obj.read "\x00\x01\x00\x02\x03" }.must_raise NoMethodError
     end
   end
@@ -315,10 +315,10 @@ end
 
 describe BinData::Array, "nested within an Array" do
   let(:obj) {
-    nested_array_params = { :type => [:int8, { :initial_value => :index }],
-                            :initial_length => lambda { index + 1 } }
-    BinData::Array.new(:type => [:array, nested_array_params],
-                       :initial_length => 3)
+    nested_array_params = { type: [:int8, { initial_value: :index }],
+                            initial_length: -> { index + 1 } }
+    BinData::Array.new(type: [:array, nested_array_params],
+                       initial_length: 3)
   }
 
   it "#snapshot" do
@@ -334,24 +334,24 @@ end
 describe BinData::Array, "subclassed" do
   class IntArray < BinData::Array
     endian :big
-    default_parameter :initial_element_value => 0
+    default_parameter initial_element_value: 0
 
-    uint16 :initial_value => :initial_element_value
+    uint16 initial_value: :initial_element_value
   end
 
   it "forwards parameters" do
-    obj = IntArray.new(:initial_length => 7)
+    obj = IntArray.new(initial_length: 7)
     obj.length.must_equal 7
   end
 
   it "overrides default parameters" do
-    obj = IntArray.new(:initial_length => 3, :initial_element_value => 5)
+    obj = IntArray.new(initial_length: 3, initial_element_value: 5)
     obj.to_binary_s.must_equal_binary "\x00\x05\x00\x05\x00\x05"
   end
 end
 
 describe BinData::Array, "of bits" do
-  let(:obj) { BinData::Array.new(:type => :bit1, :initial_length => 15) }
+  let(:obj) { BinData::Array.new(type: :bit1, initial_length: 15) }
 
   it "reads" do
     str = [0b0001_0100, 0b1000_1000].pack("CC")