bindata 2.3.3 → 2.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 188ceccd3a9ac4c5e72aec6006b61dae5f71ebf0
-  data.tar.gz: 2f8c6791099daf588f429ab964b6a2d3b1e3bfde
+  metadata.gz: 3a8a6f316e5cf5c69644ea1e3f841ad322c0e02f
+  data.tar.gz: bf847f59e5d21294aa23a8e55b30316259917995
 SHA512:
-  metadata.gz: 76fcb053c1c818b111555dc8d1c46cc84e955c883272a8c23ccc7effafc98591d9892c33640f62354feb94c0613368bd6fd95d542d9d7e3507184b644af5d91f
-  data.tar.gz: 88c93e8224c0734a4e217fb9d41c335fdfc8c3a3b994576ab2403ffed7d8d09d5dfb394857e0457617e671d33110a0ab3873675c858a8b70c187beb32ba9da64
+  metadata.gz: ce1e8ebef76eca71f03e78fd5d0443b489965433848f4d05137cb02b8e6b90db535fa97cd9e1987d93eddeba11cf8c96fd1cbc4cd2f8f83145a88728d1e65a7f
+  data.tar.gz: 49df943ca5a0347649bfd35f2307f17cd4cb0308472c6d8f4341bd65926b9a805b7e0ad75bab3db71d83f4e6803be32a03fe7e996ddb8455d9b3b5952ab79c02

data/ChangeLog.rdoc

@@ -1,5 +1,9 @@
 = BinData Changelog
 
+== Version 2.3.4 (2016-10-17)
+
+* Memoize dynamic methods for primitives.  Thanks to hiroeorz.
+
 == Version 2.3.3 (2016-09-07)
 
 * Fix bug #80.  Thanks to Michael Petter.

data/Rakefile

@@ -10,7 +10,7 @@ task :clobber do
 end
 
 Rake::TestTask.new do |t|
-    t.pattern = "test/**/*_test.rb"
+  t.pattern = "test/**/*_test.rb"
 end
 
-task :default => :test
+task default: :test

data/examples/gzip.rb

@@ -22,33 +22,33 @@ class Gzip < BinData::Record
 
   endian :little
 
-  uint16  :ident,      :asserted_value => 0x8b1f
-  uint8   :compression_method, :initial_value => DEFLATE
-
-  bit3    :freserved,  :asserted_value => 0
-  bit1    :fcomment,   :value => lambda { comment.length > 0 ? 1 : 0 }
-  bit1    :ffile_name, :value => lambda { file_name.length > 0 ? 1 : 0 }
-  bit1    :fextra,     :value => lambda { extra.len > 0 ? 1 : 0 }
-  bit1    :fcrc16,     :value => 0  # see note at end of file
+  uint16  :ident,      asserted_value: 0x8b1f
+  uint8   :compression_method, initial_value: DEFLATE
+
+  bit3    :freserved,  asserted_value: 0
+  bit1    :fcomment,   value: -> { comment.length > 0 ? 1 : 0 }
+  bit1    :ffile_name, value: -> { file_name.length > 0 ? 1 : 0 }
+  bit1    :fextra,     value: -> { extra.len > 0 ? 1 : 0 }
+  bit1    :fcrc16,     value: 0  # see note at end of file
   bit1    :ftext
 
   mtime   :mtime
   uint8   :extra_flags
-  uint8   :os,         :initial_value => 255   # unknown OS
+  uint8   :os,         initial_value: 255   # unknown OS
 
   # The following fields are optional depending on the bits in flags
 
-  struct  :extra,      :onlyif => lambda { fextra.nonzero? } do
-    uint16 :len,  :length => lambda { data.length }
-    string :data, :read_length => :len
+  struct  :extra,      onlyif: -> { fextra.nonzero? } do
+    uint16 :len,  length: -> { data.length }
+    string :data, read_length: :len
   end
-  stringz :file_name,  :onlyif => lambda { ffile_name.nonzero? }
-  stringz :comment,    :onlyif => lambda { fcomment.nonzero? }
-  uint16  :crc16,      :onlyif => lambda { fcrc16.nonzero? }
+  stringz :file_name,  onlyif: -> { ffile_name.nonzero? }
+  stringz :comment,    onlyif: -> { fcomment.nonzero? }
+  uint16  :crc16,      onlyif: -> { fcrc16.nonzero? }
 
   # The length of compressed data must be calculated from the current file offset
   count_bytes_remaining :bytes_remaining
-  string :compressed_data, :read_length => lambda { bytes_remaining - footer.num_bytes }
+  string :compressed_data, read_length: -> { bytes_remaining - footer.num_bytes }
 
   struct :footer do
     uint32 :crc32
@@ -97,14 +97,14 @@ if __FILE__ == $0
   # Output using the same format as gzip -l -v
   puts "method  crc     date  time           compressed        " +
        "uncompressed  ratio uncompressed_name"
-  puts "%5s %08x %6s %5s %19s %19s %5.1f%% %s"  % [comp_meth,
-                                                   g.footer.crc32,
-                                                   g.mtime.strftime('%b %d'),
-                                                   g.mtime.strftime('%H:%M'),
-                                                   g.num_bytes,
-                                                   g.footer.uncompressed_size,
-                                                   ratio,
-                                                   g.file_name]
+  puts "%5s %08x %6s %5s %19s %19s %5.1f%% %s" % [comp_meth,
+                                                  g.footer.crc32,
+                                                  g.mtime.strftime('%b %d'),
+                                                  g.mtime.strftime('%H:%M'),
+                                                  g.num_bytes,
+                                                  g.footer.uncompressed_size,
+                                                  ratio,
+                                                  g.file_name]
   puts "Comment: #{g.comment}" if g.comment?
   puts
 

data/examples/ip_address.rb

@@ -4,15 +4,14 @@ require 'bindata'
 # The underlying binary representation is a sequence of four octets.
 # The human accessible representation is a dotted quad.
 class IPAddr < BinData::Primitive
-  array :octets, :type => :uint8, :initial_length => 4
+  array :octets, type: :uint8, initial_length: 4
 
   def set(val)
-    ints = val.split(/\./).collect { |int| int.to_i }
-    self.octets = ints
+    self.octets = val.split(/\./).map(&:to_i)
   end
 
   def get
-    self.octets.collect { |octet| "%d" % octet }.join(".")
+    self.octets.map(&:to_s).join(".")
   end
 end
 

data/examples/list.rb

@@ -20,15 +20,15 @@ require 'bindata'
 # A first attempt at a declaration would be:
 #
 #     class Atom < BinData::Record
-#       string  :tag, :length => 1, :assert => 'a'
+#       string  :tag, length: 1, assert: 'a'
 #       int32be :val
 #     end
 #
 #     class List < BinData::Record
-#       string  :tag,  :length => 1, :assert => 'l'
-#       int32be :num,  :value => lambda { vals.length }
-#       array   :vals, :initial_length => :num do
-#         choice :selection => ??? do
+#       string  :tag,  length: 1, assert: 'l'
+#       int32be :num,  value: -> { vals.length }
+#       array   :vals, initial_length: :num do
+#         choice selection: ??? do
 #           atom
 #           list
 #         end
@@ -50,18 +50,18 @@ require 'bindata'
 # The declaration then becomes:
 #
 #     class Term < BinData::Record; end  # forward declaration
-#     
+#
 #     class Atom < BinData::Int32be
 #     end
-#     
+#
 #     class List < BinData::Record
-#       int32be :num,  :value => lambda { vals.length }
-#       array   :vals, :type => :term, :initial_length => :num
+#       int32be :num,  value: -> { vals.length }
+#       array   :vals, type: :term, initial_length: :num
 #     end
-#     
+#
 #     class Term < BinData::Record
-#       string :tag, :length => 1
-#       choice :term, :selection => :tag do
+#       string :tag, length: 1
+#       choice :term, selection: :tag do
 #         atom 'a'
 #         list 'l'
 #       end
@@ -81,21 +81,21 @@ class Atom < BinData::Int32be
 end
 
 class List < BinData::Record
-  int32be :num,  :value => lambda { vals.length }
-  array   :vals, :initial_length => :num, :type => :term
+  int32be :num,  value: -> { vals.length }
+  array   :vals, initial_length: :num, type: :term
 
   def decode
-    vals.collect { |v| v.decode }
+    vals.collect(&:decode)
   end
 
   def self.encode(val)
-    List.new(:vals => val.collect { |v| Term.encode(v) })
+    List.new(vals: val.collect { |v| Term.encode(v) })
   end
 end
 
 class Term < BinData::Record
-  string :tag, :length => 1
-  choice :term, :selection => :tag do
+  string :tag, length: 1
+  choice :term, selection: :tag do
     atom 'a'
     list 'l'
   end
@@ -106,9 +106,9 @@ class Term < BinData::Record
 
   def self.encode(val)
     if Fixnum === val
-      Term.new(:tag => 'a', :term => Atom.encode(val))
+      Term.new(tag: 'a', term: Atom.encode(val))
     else
-      Term.new(:tag => 'l', :term => List.encode(val))
+      Term.new(tag: 'l', term: List.encode(val))
     end
   end
 end

data/examples/nbt.rb

@@ -61,8 +61,8 @@ module Nbt
 
   # NBT.txt line 49
   class TagByteArray < BinData::Record
-    int32be :len, :value => lambda { data.length }
-    string  :data, :read_length => :len
+    int32be :len,  value: -> { data.length }
+    string  :data, read_length: :len
 
     def to_formatted_s(indent = 0)
       "[#{len} bytes]"
@@ -71,8 +71,8 @@ module Nbt
 
   # NBT.txt line 53
   class TagString < BinData::Primitive
-    int16be :len, :value => lambda { data.length }
-    string  :data, :read_length => :len
+    int16be :len,  value: -> { data.length }
+    string  :data, read_length: :len
 
     def get
       self.data
@@ -87,7 +87,7 @@ module Nbt
 
   ## Payload is the most important class to understand.
   ## This abstraction allows recursive formats.
-  ## eg. lists can contain lists can contain lists. 
+  ## eg. lists can contain lists can contain lists.
 
   # Forward references used by Payload
   class TagCompound < BinData::Record; end
@@ -111,8 +111,8 @@ module Nbt
   # NBT.txt line 6, 27
   class NamedTag < BinData::Record
     int8 :tag_id
-    tag_string :name,    :onlyif => :not_end_tag?
-    payload    :payload, :onlyif => :not_end_tag?, :selection => :tag_id
+    tag_string :name,    onlyif: :not_end_tag?
+    payload    :payload, onlyif: :not_end_tag?, selection: :tag_id
 
     def not_end_tag?
       tag_id != 0
@@ -127,10 +127,10 @@ module Nbt
 
   # NBT.txt line 57
   class TagList < BinData::Record
-    int8 :tag_id
-    int32be :len, :value => lambda { data.length }
-    array :data, :initial_length => :len do
-      payload :selection => :tag_id
+    int8    :tag_id
+    int32be :len,  value: -> { data.length }
+    array   :data, initial_length: :len do
+      payload selection: :tag_id
     end
 
     def to_formatted_s(indent = 0)
@@ -138,7 +138,7 @@ module Nbt
       tag_type = "TAG_#{TAG_NAMES[tag_id]}"
 
       "#{len} entries of type #{tag_type}\n" +
-      pre + "{\n" + 
+      pre + "{\n" +
         data.collect { |el| "  #{pre}#{tag_type}: #{el.to_formatted_s(indent + 1)}\n" }.join("") +
       pre + "}"
     end
@@ -146,14 +146,14 @@ module Nbt
 
   # NBT.txt line 63
   class TagCompound < BinData::Record
-    array :data, :read_until => lambda { element.tag_id == 0 } do
+    array :data, read_until: -> { element.tag_id == 0 } do
       named_tag
     end
 
     def to_formatted_s(indent = 0)
       pre = "  " * indent
       "#{data.length - 1} entries\n" +
-      pre + "{\n" + 
+      pre + "{\n" +
         data[0..-2].collect { |el| el.to_formatted_s(indent + 1) }.join("") +
       pre + "}"
     end

data/examples/tcp_ip.rb

@@ -11,11 +11,10 @@ require 'bindata'
 
 # Present MAC addresses in a human readable way
 class MacAddr < BinData::Primitive
-  array :octets, :type => :uint8, :initial_length => 6
+  array :octets, type: :uint8, initial_length: 6
 
   def set(val)
-    ints = val.split(/\./).collect { |int| int.to_i }
-    self.octets = ints
+    self.octets = val.split(/\./).collect(&:to_i)
   end
 
   def get
@@ -25,11 +24,10 @@ end
 
 # Present IP addresses in a human readable way
 class IPAddr < BinData::Primitive
-  array :octets, :type => :uint8, :initial_length => 4
+  array :octets, type: :uint8, initial_length: 4
 
   def set(val)
-    ints = val.split(/\./).collect { |int| int.to_i }
-    self.octets = ints
+    self.octets = val.split(/\./).collect(&:to_i)
   end
 
   def get
@@ -57,7 +55,7 @@ class TCP_PDU < BinData::Record
   uint16 :window
   uint16 :checksum
   uint16 :urg_ptr
-  string :options, :read_length => :options_length_in_bytes
+  string :options, read_length: :options_length_in_bytes
   rest   :payload
 
   def options_length_in_bytes
@@ -80,7 +78,7 @@ end
 class IP_PDU < BinData::Record
   endian :big
 
-  bit4   :version, :asserted_value => 4
+  bit4   :version, asserted_value: 4
   bit4   :header_length
   uint8  :tos
   uint16 :total_length
@@ -92,9 +90,9 @@ class IP_PDU < BinData::Record
   uint16 :checksum
   ip_addr :src_addr
   ip_addr :dest_addr
-  string :options, :read_length => :options_length_in_bytes
-  buffer :payload, :length => :payload_length_in_bytes do
-    choice :payload, :selection => :protocol do
+  string :options, read_length: :options_length_in_bytes
+  buffer :payload, length: :payload_length_in_bytes do
+    choice :payload, selection: :protocol do
       tcp_pdu  6
       udp_pdu 17
       rest    :default
@@ -122,7 +120,7 @@ class Ether < BinData::Record
   mac_addr :dst
   mac_addr :src
   uint16   :ether_type
-  choice   :payload, :selection => :ether_type do
+  choice   :payload, selection: :ether_type do
     ip_pdu IPV4
     rest   :default
   end
@@ -155,12 +153,12 @@ class Pcap
       uint32 :linktype
     end
 
-    array :records, :read_until => :eof do
+    array :records, read_until: :eof do
       uint32 :ts_sec
       uint32 :ts_usec
       uint32 :incl_len
       uint32 :orig_len
-      string :data, :length => :incl_len
+      string :data, length: :incl_len
     end
   end
 end

data/lib/bindata/alignment.rb

@@ -37,7 +37,7 @@ module BinData
   #
   #     class MyRecord < BinData::Record
   #       bit4       :preamble
-  #       bit_string :str, :length => 2
+  #       bit_string :str, length: 2
   #     end
   #
   module BitAligned
@@ -46,7 +46,7 @@ module BinData
         @io = io
       end
       def readbytes(n)
-        n.times.inject("") do |bytes, i|
+        n.times.inject("") do |bytes, _|
           bytes << @io.readbits(8, :big).chr
         end
       end

data/lib/bindata/array.rb

@@ -8,22 +8,22 @@ module BinData
   #
   #   data = "\x03\x04\x05\x06\x07\x08\x09"
   #
-  #   obj = BinData::Array.new(:type => :int8, :initial_length => 6)
+  #   obj = BinData::Array.new(type: :int8, initial_length: 6)
   #   obj.read(data) #=> [3, 4, 5, 6, 7, 8]
   #
-  #   obj = BinData::Array.new(:type => :int8,
-  #                            :read_until => lambda { index == 1 })
+  #   obj = BinData::Array.new(type: :int8,
+  #                            read_until: -> { index == 1 })
   #   obj.read(data) #=> [3, 4]
   #
-  #   obj = BinData::Array.new(:type => :int8,
-  #                            :read_until => lambda { element >= 6 })
+  #   obj = BinData::Array.new(type: :int8,
+  #                            read_until: -> { element >= 6 })
   #   obj.read(data) #=> [3, 4, 5, 6]
   #
-  #   obj = BinData::Array.new(:type => :int8,
-  #           :read_until => lambda { array[index] + array[index - 1] == 13 })
+  #   obj = BinData::Array.new(type: :int8,
+  #           read_until: -> { array[index] + array[index - 1] == 13 })
   #   obj.read(data) #=> [3, 4, 5, 6, 7]
   #
-  #   obj = BinData::Array.new(:type => :int8, :read_until => :eof)
+  #   obj = BinData::Array.new(type: :int8, read_until: :eof)
   #   obj.read(data) #=> [3, 4, 5, 6, 7, 8, 9]
   #
   # == Parameters
@@ -76,7 +76,7 @@ module BinData
     end
 
     def clear?
-      @element_list.nil? or elements.all? { |el| el.clear? }
+      @element_list.nil? || elements.all?(&:clear?)
     end
 
     def assign(array)
@@ -86,13 +86,13 @@ module BinData
     end
 
     def snapshot
-      elements.collect { |el| el.snapshot }
+      elements.collect(&:snapshot)
     end
 
     def find_index(obj)
       elements.index(obj)
     end
-    alias_method :index, :find_index
+    alias index find_index
 
     # Returns the first index of +obj+ in self.
     #
@@ -105,7 +105,7 @@ module BinData
       insert(-1, *args)
       self
     end
-    alias_method :<<, :push
+    alias << push
 
     def unshift(*args)
       insert(0, *args)
@@ -125,18 +125,18 @@ module BinData
 
     # Returns the element at +index+.
     def [](arg1, arg2 = nil)
-      if arg1.respond_to?(:to_int) and arg2.nil?
+      if arg1.respond_to?(:to_int) && arg2.nil?
         slice_index(arg1.to_int)
-      elsif arg1.respond_to?(:to_int) and arg2.respond_to?(:to_int)
+      elsif arg1.respond_to?(:to_int) && arg2.respond_to?(:to_int)
         slice_start_length(arg1.to_int, arg2.to_int)
-      elsif arg1.is_a?(Range) and arg2.nil?
+      elsif arg1.is_a?(Range) && arg2.nil?
         slice_range(arg1)
       else
         raise TypeError, "can't convert #{arg1} into Integer" unless arg1.respond_to?(:to_int)
         raise TypeError, "can't convert #{arg2} into Integer" unless arg2.respond_to?(:to_int)
       end
     end
-    alias_method :slice, :[]
+    alias slice []
 
     def slice_index(index)
       extend_array(index)
@@ -168,7 +168,7 @@ module BinData
     # If the array is empty, the first form returns nil, and the second
     # form returns an empty array.
     def first(n = nil)
-      if n.nil? and empty?
+      if n.nil? && empty?
         # explicitly return nil as arrays grow automatically
         nil
       elsif n.nil?
@@ -193,7 +193,7 @@ module BinData
     def length
       elements.length
     end
-    alias_method :size, :length
+    alias size length
 
     def empty?
       length.zero?
@@ -275,7 +275,7 @@ module BinData
 
   class ArrayArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params) #:nodoc:
-      unless params.has_parameter?(:initial_length) or
+      unless params.has_parameter?(:initial_length) ||
                params.has_parameter?(:read_until)
         # ensure one of :initial_length and :read_until exists
         params[:initial_length] = 0
@@ -300,15 +300,14 @@ 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
-
   end
 
-  # Logic for the :read_until => :eof parameter
+  # Logic for the read_until: :eof parameter
   module ReadUntilEOFPlugin
     def do_read(io)
       loop do