bindata 1.8.3 → 2.0.0

data/lib/bindata/bits.rb

@@ -6,11 +6,13 @@ module BinData
 
   module BitField #:nodoc: all
     class << self
-      def define_class(name, nbits, endian, signed = :unsigned)
+      def define_class(nbits, endian, signed = :unsigned)
+        name = ((signed == :signed ) ? "Sbit" : "Bit") + nbits.to_s
+        name << "le" if endian == :little
         unless BinData.const_defined?(name)
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
-              BitField.define_methods(self, #{nbits.inspect}, #{endian.inspect}, #{signed.inspect})
+              BitField.define_methods(self, #{nbits}, :#{endian}, :#{signed})
             end
           END
         end
@@ -20,34 +22,27 @@ module BinData
 
       def define_methods(bit_class, nbits, endian, signed)
         bit_class.module_eval <<-END
-          #{create_params_code(nbits)}
-
           def assign(val)
-            #{create_nbits_code(nbits)}
             #{create_clamp_code(nbits, signed)}
             super(val)
           end
 
           def do_write(io)
-            #{create_nbits_code(nbits)}
             val = _value
-            #{create_int2uint_code(nbits, signed)}
+            #{create_int2uint_code(nbits) if signed == :signed}
             io.writebits(val, #{nbits}, :#{endian})
           end
 
           def do_num_bytes
-            #{create_nbits_code(nbits)}
-            #{create_do_num_bytes_code(nbits)}
+            #{nbits / 8.0}
           end
 
           #---------------
           private
 
-
           def read_and_return_value(io)
-            #{create_nbits_code(nbits)}
             val = io.readbits(#{nbits}, :#{endian})
-            #{create_uint2int_code(nbits, signed)}
+            #{create_uint2int_code(nbits) if signed == :signed}
             val
           end
 
@@ -57,51 +52,7 @@ module BinData
         END
       end
 
-      def create_params_code(nbits)
-        if nbits == :nbits
-          "mandatory_parameter :nbits"
-        else
-          ""
-        end
-      end
-
-      def create_nbits_code(nbits)
-        if nbits == :nbits
-          "nbits = eval_parameter(:nbits)"
-        else
-          ""
-        end
-      end
-
-      def create_do_num_bytes_code(nbits)
-        if nbits == :nbits
-          "nbits / 8.0"
-        else
-          nbits / 8.0
-        end
-      end
-
       def create_clamp_code(nbits, signed)
-        if nbits == :nbits
-          create_dynamic_clamp_code(nbits, signed)
-        else
-          create_fixed_clamp_code(nbits, signed)
-        end
-      end
-
-      def create_dynamic_clamp_code(nbits, signed)
-        if signed == :signed
-          max = "max = (1 << (nbits - 1)) - 1"
-          min = "min = -(max + 1)"
-        else
-          max = "max = (1 << nbits) - 1"
-          min = "min = 0"
-        end
-
-        "#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val"
-      end
-
-      def create_fixed_clamp_code(nbits, signed)
         if nbits == 1 and signed == :signed
           raise "signed bitfield must have more than one bit" 
         end
@@ -124,50 +75,30 @@ module BinData
         "val = #{clamp}"
       end
 
-      def create_int2uint_code(nbits, signed)
-        if signed != :signed
-          ""
-        elsif nbits == :nbits
-          "val &= (1 << nbits) - 1"
-        else
-          "val &= #{(1 << nbits) - 1}"
-        end
+      def create_int2uint_code(nbits)
+        "val = val & #{(1 << nbits) - 1}"
       end
 
-      def create_uint2int_code(nbits, signed)
-        if signed != :signed
-          ""
-        elsif nbits == :nbits
-          "val -= (1 << nbits) if (val >= (1 << (nbits - 1)))"
-        else
-          "val -= #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
-        end
+      def create_uint2int_code(nbits)
+        "val = val - #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
       end
     end
   end
 
-  # Create classes for dynamic bitfields
-  {
-    "Bit"    => :big,
-    "BitLe"  => :little,
-    "Sbit"   => [:big, :signed],
-    "SbitLe" => [:little, :signed],
-  }.each_pair { |name, args| BitField.define_class(name, :nbits, *args) }
-
   # Create classes on demand
   module BitFieldFactory
     def const_missing(name)
       mappings = {
-        /^Bit(\d+)$/    => :big,
-        /^Bit(\d+)le$/  => :little,
-        /^Sbit(\d+)$/   => [:big, :signed],
+        /^Bit(\d+)$/ => :big,
+        /^Bit(\d+)le$/ => :little,
+        /^Sbit(\d+)$/ => [:big, :signed],
         /^Sbit(\d+)le$/ => [:little, :signed]
       }
 
       mappings.each_pair do |regex, args|
         if regex =~ name.to_s
           nbits = $1.to_i
-          return BitField.define_class(name, nbits, *args)
+          return BitField.define_class(nbits, *args)
         end
       end
 

data/lib/bindata/buffer.rb

@@ -76,7 +76,7 @@ module BinData
       @type = get_parameter(:type).instantiate(nil, self)
     end
 
-    def clear?
+    def clear? #:nodoc:
       @type.clear?
     end
 

data/lib/bindata/choice.rb

@@ -125,24 +125,40 @@ module BinData
       selection
     end
 
-    def safe_respond_to?(symbol, include_private = false) #:nodoc:
-      base_respond_to?(symbol, include_private)
+    def clear? #:nodoc:
+      current_choice.clear?
+    end
+
+    def assign(val)
+      current_choice.assign(val)
+    end
+
+    def snapshot
+      current_choice.snapshot
     end
 
     def respond_to?(symbol, include_private = false) #:nodoc:
       current_choice.respond_to?(symbol, include_private) || super
     end
 
+    def safe_respond_to?(symbol, include_private = false) #:nodoc:
+      base_respond_to?(symbol, include_private)
+    end
+
     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|
-      self.module_eval <<-END
-        def #{m}(*args)
-          current_choice.#{m}(*args)
-        end
-      END
+    def do_read(io) #:nodoc:
+      current_choice.do_read(io)
+    end
+
+    def do_write(io) #:nodoc:
+      current_choice.do_write(io)
+    end
+
+    def do_num_bytes #:nodoc:
+      current_choice.do_num_bytes
     end
 
     #---------------

data/lib/bindata/deprecated.rb

@@ -1,31 +1,14 @@
-# Implement Kernel#instance_exec for Ruby 1.8.6 and below
-unless Object.respond_to? :instance_exec
-  module Kernel
-    # Taken from http://eigenclass.org/hiki/instance_exec
-    def instance_exec(*args, &block)
-      mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
-      Object.class_eval{ define_method(mname, &block) }
-      begin
-        ret = send(mname, *args)
-      ensure
-        Object.class_eval{ undef_method(mname) } rescue nil
-      end
-      ret
-    end
-  end
-end
-
 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
-    # and your initialization code may not be called.
+    # #initialize_instance.  This is because BinData objects can be initialized
+    # as prototypes and your initialization code may not be called.
     #
     # If you're subclassing BinData::Record, you are definitely doing the wrong
     # thing.  Read the documentation on how to use BinData.
-    # http://github.com/dmendel/bindata/wiki/Records
+    # http://bindata.rubyforge.org/manual.html#records
     alias_method :initialize_without_warning, :initialize
     def initialize_with_warning(*args)
       owner = method(:initialize).owner
@@ -46,11 +29,5 @@ module BinData
       end
     end
 
-    # #offset has been renamed to #abs_offset.
-    # Eventually #rel_offset will be renamed to #offset.
-    def offset
-      warn "#offset is deprecated in #{debug_name}. Use #abs_offset instead"
-      abs_offset
-    end
   end
 end

data/lib/bindata/int.rb

@@ -6,7 +6,8 @@ module BinData
 
   module Int #:nodoc: all
     class << self
-      def define_class(name, nbits, endian, signed)
+      def define_class(nbits, endian, signed)
+        name = class_name(nbits, endian, signed)
         unless BinData.const_defined?(name)
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
@@ -18,6 +19,13 @@ module BinData
         BinData.const_get(name)
       end
 
+      def class_name(nbits, endian, signed)
+        endian_str = (endian == :big) ? "be" : "le"
+        base = (signed == :signed) ? "Int" : "Uint"
+
+        "#{base}#{nbits}#{endian_str}"
+      end
+
       def define_methods(int_class, nbits, endian, signed)
         raise "nbits must be divisible by 8" unless (nbits % 8).zero?
 
@@ -162,7 +170,7 @@ module BinData
         if regex =~ name.to_s
           nbits = $1.to_i
           if (nbits % 8).zero?
-            return Int.define_class(name, nbits, *args)
+            return Int.define_class(nbits, *args)
           end
         end
       end

data/lib/bindata/io.rb

@@ -6,10 +6,7 @@ module BinData
   module IO
     # Creates a StringIO around +str+.
     def self.create_string_io(str = "")
-      if str.respond_to?(:force_encoding)
-        str = str.dup.force_encoding(Encoding::BINARY)
-      end
-      StringIO.new(str)
+      StringIO.new(str.dup.force_encoding(Encoding::BINARY))
     end
 
     # Create a new IO Read wrapper around +io+.  +io+ must provide #read,
@@ -190,8 +187,8 @@ module BinData
 
       # Use #seek and #pos on seekable streams
       module SeekableStream
-        # Returns the current offset of the io stream.  Offset will be rounded
-        # up when reading bitfields.
+        # Returns the current offset of the io stream.  The exact value of
+        # the offset when reading bitfields is not defined.
         def offset
           raw_io.pos - @initial_pos
         end
@@ -225,8 +222,8 @@ module BinData
 
       # Manually keep track of offset for unseekable streams.
       module UnSeekableStream
-        # Returns the current offset of the io stream.  Offset will be rounded
-        # up when reading bitfields.
+        # Returns the current offset of the io stream.  The exact value of
+        # the offset when reading bitfields is not defined.
         def offset
           @read_count ||= 0
         end
@@ -284,8 +281,6 @@ module BinData
         @wval    = 0
         @wendian = nil
 
-        @write_count = 0
-
         @bytes_remaining = nil
       end
 
@@ -309,12 +304,6 @@ module BinData
         end
       end
 
-      # Returns the current offset of the io stream.  Offset will be rounded
-      # up when writing bitfields.
-      def offset
-        @write_count + (@wnbits > 0 ? 1 : 0)
-      end
-
       # Writes the given string of bytes to the io stream.
       def writebytes(str)
         flushbits
@@ -402,7 +391,6 @@ module BinData
           @bytes_remaining -= data.size
         end
 
-        @write_count += data.size
         @raw_io.write(data)
       end
 

data/lib/bindata/lazy.rb

@@ -85,7 +85,7 @@ module BinData
 
       if obj_parent.has_parameter?(symbol)
         obj_parent.get_parameter(symbol)
-      elsif obj_parent.safe_respond_to?(symbol, true)
+      elsif obj_parent.safe_respond_to?(symbol)
         obj_parent.__send__(symbol, *args)
       else
         symbol

data/lib/bindata/params.rb

@@ -118,7 +118,7 @@ module BinData
       def self.invalid_parameter_names
         unless defined? @invalid_names
           all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
-          allowed_names = ["name", "type", :name, :type] # ruby 1.8 vs 1.9
+          allowed_names = [:name, :type]
           invalid_names = (all_names - allowed_names).uniq
           @invalid_names = Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
         end

data/lib/bindata/record.rb

@@ -1,10 +1,28 @@
 require 'bindata/dsl'
+require 'bindata/sanitize'
 require 'bindata/struct'
 
 module BinData
   # A Record is a declarative wrapper around Struct.
   #
-  # See +Struct+ for more info.
+  #    require 'bindata'
+  #
+  #    class SomeDataType < BinData::Record
+  #      hide :a
+  #
+  #      int32le :a
+  #      int16le :b
+  #      struct  :s do
+  #        int8  :x
+  #        int8  :y
+  #        int8  :z
+  #      end
+  #    end
+  #
+  #    obj = SomeDataType.new
+  #    obj.field_names   =># [:b, :s]
+  #    obj.s.field_names =># [:x, :y, :z]
+  #
   class Record < BinData::Struct
     include DSLMixin
 

data/lib/bindata/sanitize.rb

@@ -24,14 +24,6 @@ module BinData
       end
     end
 
-    def has_parameter?(param)
-      if @factory
-        @factory.has_parameter?(param)
-      else
-        @obj_params.has_parameter?(param)
-      end
-    end
-
     def instantiate(value = nil, parent = nil)
       @factory ||= @obj_class.new(@obj_params)
 
@@ -56,10 +48,6 @@ module BinData
       @name
     end
 
-    def has_parameter?(param)
-      @prototype.has_parameter?(param)
-    end
-
     def instantiate(value = nil, parent = nil)
       @prototype.instantiate(value, parent)
     end
@@ -95,10 +83,6 @@ module BinData
       @fields.each(&block)
     end
 
-    def each_with_index(&block)
-      @fields.each_with_index(&block)
-    end
-
     def collect(&block)
       @fields.collect(&block)
     end
@@ -119,10 +103,6 @@ module BinData
       @fields.all? { |f| f.name != nil }
     end
 
-    def any_field_has_parameter?(parameter)
-      @fields.any? { |f| f.has_parameter?(parameter) }
-    end
-
     def copy_fields(other)
       @fields.concat(other.fields)
     end