bindata 2.3.3 → 2.3.4

data/lib/bindata/float.rb

@@ -6,6 +6,18 @@ module BinData
 
   module FloatingPoint #:nodoc: all
     class << self
+      PRECISION = {
+        single: 4,
+        double: 8,
+      }
+
+      PACK_CODE = {
+        [:single, :little] => 'e',
+        [:single, :big]    => 'g',
+        [:double, :little] => 'E',
+        [:double, :big]    => 'G',
+      }
+
       def define_methods(float_class, precision, endian)
         float_class.module_eval <<-END
           def do_num_bytes
@@ -30,27 +42,18 @@ module BinData
       end
 
       def create_num_bytes_code(precision)
-        (precision == :single) ? 4 : 8
+        PRECISION[precision]
       end
 
       def create_read_code(precision, endian)
-        if precision == :single
-          unpack = (endian == :little) ? 'e' : 'g'
-          nbytes = 4
-        else # double_precision
-          unpack = (endian == :little) ? 'E' : 'G'
-          nbytes = 8
-        end
+        nbytes = PRECISION[precision]
+        unpack = PACK_CODE[[precision, endian]]
 
         "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
       end
 
       def create_to_binary_s_code(precision, endian)
-        if precision == :single
-          pack = (endian == :little) ? 'e' : 'g'
-        else # double_precision
-          pack = (endian == :little) ? 'E' : 'G'
-        end
+        pack = PACK_CODE[[precision, endian]]
 
         "[val].pack('#{pack}')"
       end

data/lib/bindata/int.rb

@@ -96,10 +96,10 @@ module BinData
       def create_read_assemble_code(nbits, endian, signed)
         nwords = nbits / bits_per_word(nbits)
 
-        idx = (0 ... nwords).to_a
-        idx.reverse! if (endian == :big)
+        idx = (0...nwords).to_a
+        idx.reverse! if endian == :big
 
-        parts = (0 ... nwords).collect do |i|
+        parts = (0...nwords).collect do |i|
                   "(ints.at(#{idx[i]}) << #{bits_per_word(nbits) * i})"
                 end
         parts[0].sub!(/ << 0\b/, "")  # Remove " << 0" for optimisation
@@ -126,7 +126,7 @@ module BinData
         nwords = nbits / bits_per_word(nbits)
         mask   = (1 << bits_per_word(nbits)) - 1
 
-        vals = (0 ... nwords).collect { |i| "val >> #{bits_per_word(nbits) * i}" }
+        vals = (0...nwords).collect { |i| "val >> #{bits_per_word(nbits) * i}" }
         vals[0].sub!(/ >> 0\b/, "")  # Remove " >> 0" for optimisation
         vals.reverse! if (endian == :big)
 
@@ -157,7 +157,7 @@ module BinData
         d = directives[bits_per_word(nbits)]
         d << ((endian == :big) ? ">" : "<") unless d == "C"
 
-        if signed == :signed and directives.has_key?(nbits)
+        if signed == :signed && directives.key?(nbits)
           (d * nwords).downcase
         else
           d * nwords
@@ -165,7 +165,7 @@ module BinData
       end
 
       def need_signed_conversion_code?(nbits, signed)
-        signed == :signed and not [64, 32, 16].include?(nbits)
+        signed == :signed && ![64, 32, 16].include?(nbits)
       end
     end
   end

data/lib/bindata/io.rb

@@ -39,9 +39,9 @@ module BinData
 
       def buffer_limited_n(n)
         if @buffer_end_points
-          if n.nil? or n > 0
+          if n.nil? || n > 0
             max = @buffer_end_points[1] - offset
-            n = max if n.nil? or n > max
+            n = max if n.nil? || n > max
           else
             min = @buffer_end_points[0] - offset
             n = min if n < min
@@ -51,7 +51,7 @@ module BinData
         n
       end
 
-      def with_buffer_common(n, &block)
+      def with_buffer_common(n)
         prev = @buffer_end_points
         if prev
           avail = prev[1] - offset
@@ -59,7 +59,7 @@ module BinData
         end
         @buffer_end_points = [offset, offset + n]
         begin
-          block.call(*@buffer_end_points)
+          yield(*@buffer_end_points)
         ensure
           @buffer_end_points = prev
         end
@@ -87,10 +87,10 @@ module BinData
 
         # All io calls in +block+ are rolled back after this
         # method completes.
-        def with_readahead(&block)
+        def with_readahead
           mark = @raw_io.pos
           begin
-            block.call
+            yield
           ensure
             @raw_io.seek(mark, ::IO::SEEK_SET)
           end
@@ -133,7 +133,7 @@ module BinData
 
         # All io calls in +block+ are rolled back after this
         # method completes.
-        def with_readahead(&block)
+        def with_readahead
           mark = @offset
           @read_data = ""
           @in_readahead = true
@@ -144,7 +144,7 @@ module BinData
           end
 
           begin
-            block.call
+            yield
           ensure
             @offset = mark
             @in_readahead = false
@@ -167,12 +167,12 @@ module BinData
         def read_raw_with_readahead(n)
           data = ""
 
-          if @read_data.length > 0 and not @in_readahead
+          unless @read_data.empty? || @in_readahead
             bytes_to_consume = [n, @read_data.length].min
             data << @read_data.slice!(0, bytes_to_consume)
             n -= bytes_to_consume
 
-            if @read_data.length == 0
+            if @read_data.empty?
               class << self
                 alias_method :read_raw, :read_raw_without_readahead
               end
@@ -247,9 +247,9 @@ module BinData
 
       # Sets a buffer of +n+ bytes on the io stream.  Any reading or seeking
       # calls inside the +block+ will be contained within this buffer.
-      def with_buffer(n, &block)
+      def with_buffer(n)
         with_buffer_common(n) do
-          block.call
+          yield
           read
         end
       end
@@ -384,9 +384,9 @@ module BinData
       # +block+ will be contained within this buffer.  If less than +n+ bytes
       # are written inside the block, the remainder will be padded with '\0'
       # bytes.
-      def with_buffer(n, &block)
-        with_buffer_common(n) do |buf_start, buf_end|
-          block.call
+      def with_buffer(n)
+        with_buffer_common(n) do |_buf_start, buf_end|
+          yield
           write("\0" * (buf_end - offset))
         end
       end
@@ -435,7 +435,7 @@ module BinData
           writebits(0, 8 - @wnbits, @wendian)
         end
       end
-      alias_method :flush, :flushbits
+      alias flush flushbits
 
       #---------------
       private

data/lib/bindata/lazy.rb

@@ -3,7 +3,7 @@ module BinData
   # lambdas in the context of this data object.  These lambdas
   # are those that are passed to data objects as parameters, e.g.:
   #
-  #    BinData::String.new(:value => lambda { %w{a test message}.join(" ") })
+  #    BinData::String.new(value: -> { %w(a test message).join(" ") })
   #
   # As a shortcut, :foo is the equivalent of lambda { foo }.
   #
@@ -48,7 +48,7 @@ module BinData
     # Returns the index of this data object inside it's nearest container
     # array.
     def index
-      return @overrides[:index] if defined? @overrides and @overrides.has_key?(:index)
+      return @overrides[:index] if defined?(@overrides) && @overrides.key?(:index)
 
       child = @obj
       parent = @obj.parent
@@ -63,7 +63,7 @@ module BinData
     end
 
     def method_missing(symbol, *args)
-      return @overrides[symbol] if defined? @overrides and @overrides.has_key?(symbol)
+      return @overrides[symbol] if defined?(@overrides) && @overrides.key?(symbol)
 
       if @obj.parent
         eval_symbol_in_parent_context(symbol, args)

data/lib/bindata/name.rb

@@ -8,8 +8,8 @@ module BinData
   #                  set explicitly.  This is only useful when dynamically
   #                  generating types.
   #                  <code><pre>
-  #                    BinData::Struct.new(:name => :my_struct, :fields => ...)
-  #                    array = BinData::Array.new(:type => :my_struct)
+  #                    BinData::Struct.new(name: :my_struct, fields: ...)
+  #                    array = BinData::Array.new(type: :my_struct)
   #                  </pre></code>
   module RegisterNamePlugin
 

data/lib/bindata/offset.rb

@@ -48,11 +48,11 @@ module BinData
 
       def check_offset(io)
         actual_offset = io.offset
-        expected = eval_parameter(:check_offset, :offset => actual_offset)
+        expected = eval_parameter(:check_offset, offset: actual_offset)
 
-        if not expected
+        if !expected
           raise ValidityError, "offset not as expected for #{debug_name}"
-        elsif actual_offset != expected and expected != true
+        elsif actual_offset != expected && expected != true
           raise ValidityError,
                 "offset is '#{actual_offset}' but " +
                 "expected '#{expected}' for #{debug_name}"

data/lib/bindata/params.rb

@@ -23,17 +23,16 @@ module BinData
       accepted_parameters.mutually_exclusive(*args)
     end
 
-    alias_method :mandatory_parameter, :mandatory_parameters
-    alias_method :optional_parameter, :optional_parameters
-    alias_method :default_parameter, :default_parameters
+    alias mandatory_parameter mandatory_parameters
+    alias optional_parameter  optional_parameters
+    alias default_parameter   default_parameters
 
     def accepted_parameters #:nodoc:
-      unless defined? @accepted_parameters
+      @accepted_parameters ||= begin
         ancestor_params = superclass.respond_to?(:accepted_parameters) ?
                             superclass.accepted_parameters : nil
-        @accepted_parameters = AcceptedParameters.new(ancestor_params)
+        AcceptedParameters.new(ancestor_params)
       end
-      @accepted_parameters
     end
 
     # BinData objects accept parameters when initializing.  AcceptedParameters
@@ -55,7 +54,7 @@ module BinData
       end
 
       def mandatory(*args)
-        if not args.empty?
+        unless args.empty?
           @mandatory.concat(to_syms(args))
           @mandatory.uniq!
         end
@@ -63,7 +62,7 @@ module BinData
       end
 
       def optional(*args)
-        if not args.empty?
+        unless args.empty?
           @optional.concat(to_syms(args))
           @optional.uniq!
         end
@@ -82,7 +81,7 @@ module BinData
 
       def mutually_exclusive(*args)
         arg1 = args.shift
-        while not args.empty?
+        until args.empty?
           args.each do |arg2|
             @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
             @mutually_exclusive.uniq!
@@ -100,7 +99,7 @@ module BinData
       private
 
       def to_syms(args)
-        syms = args.collect { |el| el.to_sym }
+        syms = args.collect(&:to_sym)
         ensure_valid_names(syms)
         syms
       end
@@ -109,22 +108,21 @@ module BinData
         invalid_names = self.class.invalid_parameter_names
         names.each do |name|
           if invalid_names.include?(name)
-            raise NameError.new("Rename parameter '#{name}' " +
+            raise NameError.new("Rename parameter '#{name}' " \
                                 "as it shadows an existing method.", name)
           end
         end
       end
 
       def self.invalid_parameter_names
-        unless defined? @invalid_names
+        @invalid_names ||= begin
           all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
           allowed_names = [:name, :type]
           invalid_names = (all_names - allowed_names).uniq
-          @invalid_names = Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
+
+          Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
         end
-        @invalid_names
       end
     end
   end
 end
-

data/lib/bindata/primitive.rb

@@ -14,8 +14,8 @@ module BinData
   #    require 'bindata'
   #
   #    class PascalString < BinData::Primitive
-  #      uint8  :len,  :value => lambda { data.length }
-  #      string :data, :read_length => :len
+  #      uint8  :len,  value: -> { data.length }
+  #      string :data, read_length: :len
   #
   #      def get
   #        self.data
@@ -26,7 +26,7 @@ module BinData
   #      end
   #    end
   #
-  #    ps = PascalString.new(:initial_value => "hello")
+  #    ps = PascalString.new(initial_value: "hello")
   #    ps.to_binary_s #=> "\005hello"
   #    ps.read("\003abcde")
   #    ps #=> "abc"

data/lib/bindata/registry.rb

@@ -44,8 +44,8 @@ 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').
+                gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+                gsub(/([a-z\d])([A-Z])/, '\1_\2').
                 tr("-", "_").
                 downcase
     end
@@ -56,17 +56,17 @@ module BinData
     def normalize_name(name, hints)
       name = underscore_name(name)
 
-      if not is_registered?(name)
+      if !registered?(name)
         search_prefix = [""].concat(Array(hints[:search_prefix]))
         search_prefix.each do |prefix|
           nwp = name_with_prefix(name, prefix)
-          if is_registered?(nwp)
+          if registered?(nwp)
             name = nwp
             break
           end
 
           nwe = name_with_endian(nwp, hints[:endian])
-          if is_registered?(nwe)
+          if registered?(nwe)
             name = nwe
             break
           end
@@ -96,17 +96,17 @@ module BinData
       end
     end
 
-    def is_registered?(name)
-      register_dynamic_class(name) unless @registry.has_key?(name)
+    def registered?(name)
+      register_dynamic_class(name) unless @registry.key?(name)
 
-      @registry.has_key?(name)
+      @registry.key?(name)
     end
 
     def register_dynamic_class(name)
-      if /^u?int\d+(le|be)$/ =~ name or /^s?bit\d+(le)?$/ =~ name
+      if /^u?int\d+(le|be)$/ =~ name || /^s?bit\d+(le)?$/ =~ name
         class_name = name.gsub(/(?:^|_)(.)/) { $1.upcase }
         begin
-          BinData::const_get(class_name)
+          BinData.const_get(class_name)
         rescue NameError
         end
       end
@@ -114,8 +114,8 @@ module BinData
 
     def warn_if_name_is_already_registered(name, class_to_register)
       prev_class = @registry[name]
-      if $VERBOSE and prev_class and prev_class != class_to_register
-        warn "warning: replacing registered class #{prev_class} " +
+      if $VERBOSE && prev_class && prev_class != class_to_register
+        warn "warning: replacing registered class #{prev_class} " \
              "with #{class_to_register}"
       end
     end

data/lib/bindata/rest.rb

@@ -7,7 +7,7 @@ module BinData
   #   require 'bindata'
   #
   #   class A < BinData::Record
-  #     string :a, :read_length => 5
+  #     string :a, read_length: 5
   #     rest   :rest
   #   end
   #
@@ -16,7 +16,6 @@ module BinData
   #   obj.rest #=" "fghij"
   #
   class Rest < BinData::BasePrimitive
-
     #---------------
     private
 

data/lib/bindata/sanitize.rb

@@ -101,15 +101,15 @@ module BinData
     end
 
     def field_names
-      @fields.collect { |field| field.name_as_sym }
+      @fields.collect(&:name_as_sym)
     end
 
-    def has_field_name?(name)
+    def field_name?(name)
       @fields.detect { |f| f.name_as_sym == name.to_sym }
     end
 
     def all_field_names_blank?
-      @fields.all? { |f| f.name == nil }
+      @fields.all? { |f| f.name.nil? }
     end
 
     def no_field_names_blank?
@@ -200,25 +200,25 @@ module BinData
         self[:endian] ||= hints[:endian]
       end
 
-      if hints[:search_prefix] and not hints[:search_prefix].empty?
+      if hints[:search_prefix] && !hints[:search_prefix].empty?
         self[:search_prefix] = Array(self[:search_prefix]).concat(Array(hints[:search_prefix]))
       end
 
       sanitize!
     end
 
-    alias_method :has_parameter?, :has_key?
+    alias_method :has_parameter?, :key?
 
     def needs_sanitizing?(key)
       parameter = self[key]
 
-      parameter and not parameter.is_a?(SanitizedParameter)
+      parameter && !parameter.is_a?(SanitizedParameter)
     end
 
     def warn_replacement_parameter(bad_key, suggested_key)
       if has_parameter?(bad_key)
-        Kernel.warn ":#{bad_key} is not used with #{@the_class}.  " +
-        "You probably want to change this to :#{suggested_key}"
+        Kernel.warn ":#{bad_key} is not used with #{@the_class}.  " \
+                    "You probably want to change this to :#{suggested_key}"
       end
     end
 
@@ -226,7 +226,7 @@ module BinData
 #      val = delete(old_key)
 #      if val
 #        self[new_key] = val
-#        Kernel.warn ":#{old_key} has been renamed to :#{new_key} in #{@the_class}.  " +
+#        Kernel.warn ":#{old_key} has been renamed to :#{new_key} in #{@the_class}.  " \
 #        "Using :#{old_key} is now deprecated and will be removed in the future"
 #      end
 #    end
@@ -235,10 +235,10 @@ module BinData
       keys.each do |key|
         if has_parameter?(key)
           parameter = self[key]
-          unless Symbol === parameter or
-                 parameter.respond_to? :arity or
-                 parameter.respond_to? :to_int
-            raise ArgumentError, "parameter '#{key}' in #{@the_class} must " +
+          unless Symbol === parameter ||
+                 parameter.respond_to?(:arity) ||
+                 parameter.respond_to?(:to_int)
+            raise ArgumentError, "parameter '#{key}' in #{@the_class} must " \
                                  "evaluate to an integer, got #{parameter.class}"
           end
         end
@@ -246,7 +246,7 @@ module BinData
     end
 
     def hints
-      { :endian => self[:endian], :search_prefix => self[:search_prefix] }
+      { endian: self[:endian], search_prefix: self[:search_prefix] }
     end
 
     def create_sanitized_endian(endian)
@@ -255,7 +255,7 @@ module BinData
       elsif endian == :little
         LITTLE_ENDIAN
       elsif endian == :big_and_little
-        raise ArgumentError, ":endian => :big or :endian => :little is required"
+        raise ArgumentError, "endian: :big or endian: :little is required"
       else
         raise ArgumentError, "unknown value for endian '#{endian}'"
       end
@@ -318,13 +318,12 @@ module BinData
       return if length < 2
 
       @the_class.mutually_exclusive_parameters.each do |key1, key2|
-        if has_parameter?(key1) and has_parameter?(key2)
-          raise ArgumentError, "params '#{key1}' and '#{key2}' " +
+        if has_parameter?(key1) && has_parameter?(key2)
+          raise ArgumentError, "params '#{key1}' and '#{key2}' " \
                                "are mutually exclusive in #{@the_class}"
         end
       end
     end
   end
   #----------------------------------------------------------------------------
-
 end