bindata 1.0.0 → 1.1.0

data/ChangeLog

@@ -1,5 +1,12 @@
 = BinData Changelog
 
+== Version 1.1.0 (2009-11-24)
+
+* Allow anonymous fields in Records and Primitives.
+* Add the ability to skip over unused data.
+* Allow Records, Primitives and Wrappers to be derived from.
+* Classes for integers are now defined on demand.
+
 == Version 1.0.0 (2009-09-13)
 
 * Is now compatible with Ruby 1.9

data/README

@@ -48,6 +48,18 @@ Copyright © 2007 - 2009 [Dion Mendel](mailto:dion@lostrealm.com)
 
 ---------------------------------------------------------------------------
 
+# Installation
+
+You can install BinData via rubygems.
+
+    gem install bindata
+
+Alternatively, visit the 
+[download](http://rubyforge.org/frs/?group_id=3252) page and download
+BinData as a tar file.
+
+---------------------------------------------------------------------------
+
 # Overview
 
 BinData declarations are easy to read.  Here's an example.
@@ -248,8 +260,10 @@ one or more fields.
     converted from `CamelCase` to lowercased `underscore_style`.
 
 `field_name`
-:   is the name by which you can access the data.  Use either a
-    `String` or a `Symbol`.
+:   is the name by which you can access the field.  Use either a
+    `String` or a `Symbol`.  If name is nil or the empty string, then
+    this particular field is anonymous.  An anonymous field is still
+    read and written, but will not appear in `#snapshot`.
 
 Each field may have optional *parameters* for how to process the data.
 The parameters are passed as a `Hash` with `Symbols` for keys.
@@ -918,6 +932,34 @@ Examples
 
 # Advanced Topics
 
+## Skipping over unused data
+
+Some binary structures contain data that is irrelevant to your purposes.  
+
+Say you are interested in 50 bytes of data located 10 megabytes into the
+stream.  One way of accessing this useful data is:
+
+    class MyData < BinData::Record
+      string :length => 10 * 1024 * 1024
+      string :data, :length => 50
+    end
+{:ruby}
+
+The advantage of this method is that the irrelevant data is preserved
+when writing the record.  The disadvantage is that even if you don't care
+about preserving this irrelevant data, it still occupies memory.
+
+If you don't need to preserve this data, an alternative is to use
+`skip` instead of `string`.  When reading it will seek over the irrelevant
+data and won't consume space in memory.  When writing it will write
+`:length` number of zero bytes.
+
+    class MyData < BinData::Record
+      skip :length => 10 * 1024 * 1024
+      string :data, :length => 50
+    end
+{:ruby}
+
 ## Wrappers
 
 Sometimes you wish to create a new type that is simply an existing type

data/TODO

@@ -1,6 +1,3 @@
 == Pending refactorings
 
-* Refactor registry into registry and numeric registry
-    update specs accordingly
-
 * Perhaps refactor snapshot -> _snapshot et al

data/lib/bindata.rb

@@ -9,6 +9,7 @@ require 'bindata/int'
 require 'bindata/primitive'
 require 'bindata/record'
 require 'bindata/rest'
+require 'bindata/skip'
 require 'bindata/string'
 require 'bindata/stringz'
 require 'bindata/struct'
@@ -29,5 +30,5 @@ require 'bindata/deprecated'
 #
 # Copyright (c) 2007 - 2009 Dion Mendel.
 module BinData
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/bindata/bits.rb

@@ -8,13 +8,15 @@ module BinData
     def self.define_class(nbits, endian)
       name = "Bit#{nbits}"
       name += "le" if endian == :little
-
-      BinData.module_eval <<-END
-        class #{name} < BinData::BasePrimitive
-          register(self.name, self)
-          BitField.create_methods(self, #{nbits}, :#{endian.to_s})
-        end
-      END
+      unless BinData.const_defined?(name)
+        BinData.module_eval <<-END
+          class #{name} < BinData::BasePrimitive
+            register(self.name, self)
+            BitField.create_methods(self, #{nbits}, :#{endian.to_s})
+          end
+        END
+      end
+      BinData.const_get(name)
     end
 
     def self.create_methods(bit_class, nbits, endian)
@@ -60,9 +62,25 @@ module BinData
     end
   end
 
-  # Create commonly used bit based integers
-  (1 .. 63).each do |nbits|
-    BitField.define_class(nbits, :little)
-    BitField.define_class(nbits, :big)
+  # Create classes on demand
+  class << self
+    alias_method :const_missing_without_bits, :const_missing
+    def const_missing_with_bits(name)
+      name = name.to_s
+      mappings = {
+        /^Bit(\d+)$/ => :big,
+        /^Bit(\d+)le$/ => :little
+      }
+
+      mappings.each_pair do |regex, endian|
+        if regex =~ name
+          nbits = $1.to_i
+          return BitField.define_class(nbits, endian)
+        end
+      end
+
+      const_missing_without_bits(name)
+    end
+    alias_method :const_missing, :const_missing_with_bits
   end
 end

data/lib/bindata/int.rb

@@ -8,17 +8,18 @@ module BinData
     class << self
       def define_class(nbits, endian, signed)
         name = class_name(nbits, endian, signed)
-        return if BinData.const_defined?(name)
-
-        int_type = (signed == :signed) ? 'int' : 'uint'
-        creation_method = "create_#{int_type}_methods"
-
-        BinData.module_eval <<-END
-          class #{name} < BinData::BasePrimitive
-            register(self.name, self)
-            Int.#{creation_method}(self, #{nbits}, :#{endian.to_s})
-          end
-        END
+        unless BinData.const_defined?(name)
+          int_type = (signed == :signed) ? 'int' : 'uint'
+          creation_method = "create_#{int_type}_methods"
+
+          BinData.module_eval <<-END
+            class #{name} < BinData::BasePrimitive
+              register(self.name, self)
+              Int.#{creation_method}(self, #{nbits}, :#{endian.to_s})
+            end
+          END
+        end
+        BinData.const_get(name)
       end
 
       def class_name(nbits, endian, signed)
@@ -182,11 +183,29 @@ module BinData
     Int.create_int_methods(self, 8, :little)
   end
 
-  # Create commonly used integers
-  [8, 16, 32, 64, 128].each do |nbits|
-    Int.define_class(nbits, :little, :unsigned)
-    Int.define_class(nbits, :little, :signed)
-    Int.define_class(nbits, :big, :unsigned)
-    Int.define_class(nbits, :big, :signed)
+  # Create classes on demand
+  class << self
+    alias_method :const_missing_without_int, :const_missing
+    def const_missing_with_int(name)
+      name = name.to_s
+      mappings = {
+        /^Uint(\d+)be$/ => [:big, :unsigned],
+        /^Uint(\d+)le$/ => [:little, :unsigned],
+        /^Int(\d+)be$/ => [:big, :signed],
+        /^Int(\d+)le$/ => [:little, :signed],
+      }
+
+      mappings.each_pair do |regex, args|
+        if regex =~ name
+          nbits = $1.to_i
+          if (nbits % 8).zero?
+            return Int.define_class(nbits, *args)
+          end
+        end
+      end
+
+      const_missing_without_int(name)
+    end
+    alias_method :const_missing, :const_missing_with_int
   end
 end

data/lib/bindata/io.rb

@@ -69,7 +69,10 @@ module BinData
 
     # Seek +n+ bytes from the current position in the io stream.
     def seekbytes(n)
+      reset_read_bits
       @raw_io.seek(n, ::IO::SEEK_CUR)
+    rescue Errno::ESPIPE, Errno::EPIPE
+      skipbytes(n)
     end
 
     # Reads exactly +n+ bytes from +io+.
@@ -78,9 +81,7 @@ module BinData
     #
     # If the data read is too short an IOError is raised.
     def readbytes(n)
-      raise "Internal state error nbits = #{@rnbits}" if @rnbits >= 8
-      @rnbits = 0
-      @rval   = 0
+      reset_read_bits
 
       str = @raw_io.read(n)
       raise EOFError, "End of file reached" if str.nil?
@@ -90,10 +91,7 @@ module BinData
 
     # Reads all remaining bytes from the stream.
     def read_all_bytes
-      raise "Internal state error nbits = #{@rnbits}" if @rnbits >= 8
-      @rnbits = 0
-      @rval   = 0
-
+      reset_read_bits
       @raw_io.read
     end
 
@@ -102,8 +100,7 @@ module BinData
     def readbits(nbits, endian)
       if @rendian != endian
         # don't mix bits of differing endian
-        @rnbits  = 0
-        @rval    = 0
+        reset_read_bits
         @rendian = endian
       end
 
@@ -126,7 +123,6 @@ module BinData
       if @wendian != endian
         # don't mix bits of differing endian
         flushbits
-
         @wendian = endian
       end
 
@@ -164,6 +160,21 @@ module BinData
       @positioning_supported
     end
 
+    def reset_read_bits
+      raise "Internal state error nbits = #{@rnbits}" if @rnbits >= 8
+      @rnbits = 0
+      @rval   = 0
+    end
+
+    def skipbytes(n)
+      # skip over data in 8k blocks
+      while n > 0
+        bytes_to_read = [n, 8192].min
+        @raw_io.read(bytes_to_read)
+        n -= bytes_to_read
+      end
+    end
+
     def read_big_endian_bits(nbits)
       while @rnbits < nbits
         accumulate_big_endian_bits

data/lib/bindata/primitive.rb

@@ -68,7 +68,7 @@ module BinData
       end
 
       def endian(endian = nil)
-        @endian ||= nil
+        @endian ||= default_endian
         if [:little, :big].include?(endian)
           @endian = endian
         elsif endian != nil
@@ -78,9 +78,18 @@ module BinData
         @endian
       end
 
+      def fields #:nodoc:
+        @fields ||= default_fields
+      end
+
       def method_missing(symbol, *args) #:nodoc:
         name, params = args
 
+        if name.is_a?(Hash)
+          params = name
+          name = nil
+        end
+
         type = symbol
         name = name.to_s
         params ||= {}
@@ -99,18 +108,30 @@ module BinData
       #-------------
       private
 
-      def fields
-        unless defined? @fields
-          sanitizer = Sanitizer.new
-          @fields = sanitizer.create_sanitized_fields(endian)
+      def parent_primitive
+        ancestors[1..-1].find { |cls|
+          cls.ancestors[1..-1].include?(BinData::Primitive)
+        }
+      end
+
+      def default_endian
+        prim = parent_primitive
+        prim ? prim.endian : nil
+      end
+
+      def default_fields
+        prim = parent_primitive
+        if prim
+          Sanitizer.new.clone_sanitized_fields(prim.fields)
+        else
+          Sanitizer.new.create_sanitized_fields
         end
-        @fields
       end
 
       def append_field(type, name, params)
         ensure_valid_name(name)
 
-        fields.add_field(type, name, params)
+        fields.add_field(type, name, params, endian)
       rescue UnknownTypeError => err
         raise TypeError, "unknown type '#{err.message}' for #{self}", caller(2)
       end

data/lib/bindata/record.rb

@@ -52,7 +52,7 @@ module BinData
       end
 
       def endian(endian = nil)
-        @endian ||= nil
+        @endian ||= default_endian
         if [:little, :big].include?(endian)
           @endian = endian
         elsif endian != nil
@@ -63,14 +63,23 @@ module BinData
       end
 
       def hide(*args)
-        @hide ||= []
+        @hide ||= default_hide
         @hide.concat(args.collect { |name| name.to_s })
         @hide
       end
 
+      def fields #:nodoc:
+        @fields ||= default_fields
+      end
+
       def method_missing(symbol, *args) #:nodoc:
         name, params = args
 
+        if name.is_a?(Hash)
+          params = name
+          name = nil
+        end
+
         type = symbol
         name = name.to_s
         params ||= {}
@@ -89,18 +98,35 @@ module BinData
       #-------------
       private
 
-      def fields
-        unless defined? @fields
-          sanitizer = Sanitizer.new
-          @fields = sanitizer.create_sanitized_fields(endian)
+      def parent_record
+        ancestors[1..-1].find { |cls|
+          cls.ancestors[1..-1].include?(BinData::Record)
+        }
+      end
+
+      def default_endian
+        rec = parent_record
+        rec ? rec.endian : nil
+      end
+
+      def default_hide
+        rec = parent_record
+        rec ? rec.hide.dup : []
+      end
+
+      def default_fields
+        rec = parent_record
+        if rec
+          Sanitizer.new.clone_sanitized_fields(rec.fields)
+        else
+          Sanitizer.new.create_sanitized_fields
         end
-        @fields
       end
 
       def append_field(type, name, params)
         ensure_valid_name(name)
 
-        fields.add_field(type, name, params)
+        fields.add_field(type, name, params, endian)
       rescue UnknownTypeError => err
         raise TypeError, "unknown type '#{err.message}' for #{self}", caller(2)
       end

data/lib/bindata/registry.rb

@@ -9,6 +9,8 @@ module BinData
     end
 
     def register(name, class_to_register)
+      return if class_to_register.nil?
+
       formatted_name = lookup_key(name)
       warn_if_name_is_already_registered(formatted_name, class_to_register)
 
@@ -17,15 +19,16 @@ module BinData
 
     def lookup(name, endian = nil)
       key = lookup_key(name, endian)
+      try_registering_key(key) unless @registry.has_key?(key)
 
-      @registry[key] || lookup_int(key)
+      @registry[key]
     end
 
     def is_registered?(name, endian = nil)
-      @registry.has_key?(lookup_key(name, endian))
+      lookup(name, endian) != nil
     end
 
-    # Convert camelCase +name+ to underscore style.
+    # Convert CamelCase +name+ to underscore style.
     def underscore_name(name)
       name.to_s.sub(/.*::/, "").
                 gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
@@ -51,29 +54,18 @@ module BinData
       result
     end
 
-    def lookup_int(key)
-      if /^(u?)int(\d+)(le|be)$/ =~ key
-        signed = $1 == "u" ? :unsigned : :signed
-        nbits  = $2.to_i
-        endian = $3 == "le" ? :little : :big
-        if nbits > 0 and (nbits % 8) == 0
-          if BinData.const_defined?(:Int)
-            BinData::Int.define_class(nbits, endian, signed)
-          end
-        end
-      elsif /^bit(\d+)(le)?$/ =~ key
-        nbits  = $1.to_i
-        endian = $2 == "le" ? :little : :big
-        if BinData.const_defined?(:BitField)
-          BinData::BitField.define_class(nbits, endian)
+    def try_registering_key(key)
+      if /^u?int\d+(le|be)$/ =~ key or /^bit\d+(le)?$/ =~ key
+        class_name = key.gsub(/(?:^|_)(.)/) { $1.upcase }
+        begin
+          register(key, BinData::const_get(class_name))
+        rescue NameError
         end
       end
-
-      @registry[key]
     end
 
     def warn_if_name_is_already_registered(name, class_to_register)
-      if $VERBOSE and @registry.has_key?(name)
+      if $VERBOSE and @registry[name] != class_to_register
         prev_class = @registry[name]
         warn "warning: replacing registered class #{prev_class} " +
              "with #{class_to_register}"

data/lib/bindata/sanitize.rb

@@ -149,8 +149,14 @@ module BinData
       SanitizedChoices.new(self, choices)
     end
 
-    def create_sanitized_fields(endian = nil)
-      SanitizedFields.new(self, endian)
+    def create_sanitized_fields
+      SanitizedFields.new(self)
+    end
+
+    def clone_sanitized_fields(fields)
+      new_fields = SanitizedFields.new(self)
+      new_fields.copy_fields(fields)
+      new_fields
     end
 
     def create_sanitized_object_prototype(obj_type, obj_params, endian = nil)
@@ -192,7 +198,7 @@ module BinData
   class SanitizedParameter; end
 
   class SanitizedPrototype < SanitizedParameter
-    def initialize(sanitizer, obj_type, obj_params, endian = nil)
+    def initialize(sanitizer, obj_type, obj_params, endian)
       sanitizer.with_endian(endian) do
         @obj_class = sanitizer.lookup_class(obj_type)
         @obj_params = sanitizer.create_sanitized_params(obj_params, @obj_class)
@@ -206,9 +212,9 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedField < SanitizedParameter
-    def initialize(sanitizer, name, field_type, field_params)
-      @name = name.to_s
-      @prototype = sanitizer.create_sanitized_object_prototype(field_type, field_params)
+    def initialize(sanitizer, name, field_type, field_params, endian)
+      @name = (name != nil and name != "") ? name.to_s : nil
+      @prototype = sanitizer.create_sanitized_object_prototype(field_type, field_params, endian)
     end
     attr_reader :name
 
@@ -219,16 +225,13 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedFields < SanitizedParameter
-    def initialize(sanitizer, endian)
+    def initialize(sanitizer)
       @sanitizer = sanitizer
-      @endian = endian
       @fields = []
     end
 
-    def add_field(type, name, params)
-      @sanitizer.with_endian(@endian) do
-        @fields << SanitizedField.new(@sanitizer, name, type, params)
-      end
+    def add_field(type, name, params, endian)
+      @fields << SanitizedField.new(@sanitizer, name, type, params, endian)
     end
 
     def [](idx)
@@ -238,6 +241,11 @@ module BinData
     def field_names
       @fields.collect { |field| field.name }
     end
+
+    def copy_fields(other)
+      other_fields = other.instance_variable_get(:@fields)
+      @fields.concat(other_fields)
+    end
   end
   #----------------------------------------------------------------------------
 

data/lib/bindata/skip.rb

@@ -0,0 +1,49 @@
+require "bindata/base_primitive"
+
+module BinData
+  # Skip will skip over bytes from the input stream.  If the stream is not
+  # seekable, then the bytes are consumed and discarded.
+  #
+  # When writing, skip will write <tt>:length</tt> number of zero bytes.
+  #
+  #   require 'bindata'
+  #
+  #   class A < BinData::Record
+  #     skip :length => 5
+  #     string :a, :read_length => 5
+  #   end
+  #
+  #   obj = A.read("abcdefghij")
+  #   obj.a #=> "fghij"
+  #
+  # == Parameters
+  #
+  # Skip objects accept all the params that BinData::BasePrimitive
+  # does, as well as the following:
+  #
+  # <tt>:length</tt>:: The number of bytes to skip.
+  #
+  class Skip < BinData::BasePrimitive
+    register(self.name, self)
+
+    mandatory_parameter :length
+
+    #---------------
+    private
+
+    def value_to_binary_string(val)
+      len = eval_parameter(:length)
+      "\000" * len
+    end
+
+    def read_and_return_value(io)
+      len = eval_parameter(:length)
+      io.seekbytes(len)
+      ""
+    end
+
+    def sensible_default
+      ""
+    end
+  end
+end

data/lib/bindata/struct.rb

@@ -28,7 +28,8 @@ module BinData
   #                      params].  Type is a symbol representing a registered
   #                      type.  Name is the name of this field.  Params is an
   #                      optional hash of parameters to pass to this field
-  #                      when instantiating it.
+  #                      when instantiating it.  If name is "" or nil, then
+  #                      that field is anonymous and behaves as a hidden field.
   # <tt>:hide</tt>::     A list of the names of fields that are to be hidden
   #                      from the outside world.  Hidden fields don't appear
   #                      in #snapshot or #field_names but are still accessible
@@ -88,9 +89,9 @@ module BinData
         if params.needs_sanitizing?(:fields)
           fields = params[:fields]
 
-          params[:fields] = sanitizer.create_sanitized_fields(params[:endian])
+          params[:fields] = sanitizer.create_sanitized_fields
           fields.each do |ftype, fname, fparams|
-            params[:fields].add_field(ftype, fname, fparams)
+            params[:fields].add_field(ftype, fname, fparams, params[:endian])
           end
 
           field_names = sanitized_field_names(params[:fields])
@@ -108,7 +109,7 @@ module BinData
       end
 
       def sanitized_field_names(sanitized_fields)
-        sanitized_fields.field_names
+        sanitized_fields.field_names.compact
       end
 
       def hidden_field_names(hidden)
@@ -159,10 +160,10 @@ module BinData
     # in the listing.
     def field_names(include_hidden = false)
       if include_hidden
-        @field_names.dup
+        @field_names.compact
       else
         hidden = get_parameter(:hide) || []
-        @field_names - hidden
+        @field_names.compact - hidden
       end
     end
 

data/lib/bindata/wrapper.rb

@@ -28,7 +28,7 @@ module BinData
       end
 
       def endian(endian = nil)
-        @endian ||= nil
+        @endian ||= default_endian
         if [:little, :big].include?(endian)
           @endian = endian
         elsif endian != nil
@@ -38,17 +38,31 @@ module BinData
         @endian
       end
 
+      def wrapped(*args)
+        @wrapped ||= default_wrapped
+        if args.length == 2
+          type, params = *args
+          ensure_type_exists(type)
+
+          if wrapped != nil
+            raise SyntaxError, "#{self} can only wrap one type", caller(2)
+          end
+          @wrapped = [type, params]
+        end
+        @wrapped
+      end
+
       def method_missing(symbol, *args) #:nodoc:
         type = symbol
         params = args.length == 0 ? {} : args[0]
 
-        set_wrapped(type, params)
+        wrapped(type, params)
       end
 
       def sanitize_parameters!(params, sanitizer) #:nodoc:
-        raise "Nothing to wrap" unless defined? @wrapped
+        raise "Nothing to wrap" if wrapped.nil?
 
-        wrapped_type, wrapped_params = @wrapped
+        wrapped_type, wrapped_params = wrapped
         wrapped_params = wrapped_params.dup
 
         params.move_unknown_parameters_to(wrapped_params)
@@ -59,13 +73,20 @@ module BinData
       #-------------
       private
 
-      def set_wrapped(type, params)
-        ensure_type_exists(type)
+      def parent_wrapper
+        ancestors[1..-1].find { |cls|
+          cls.ancestors[1..-1].include?(BinData::Wrapper)
+        }
+      end
 
-        if defined? @wrapped
-          raise SyntaxError, "#{self} can only wrap one type", caller(2)
-        end
-        @wrapped = [type, params]
+      def default_endian
+        wrap = parent_wrapper
+        wrap ? wrap.endian : nil
+      end
+
+      def default_wrapped
+        wrap = parent_wrapper
+        wrap ? wrap.wrapped : nil
       end
 
       def ensure_type_exists(type)

data/manual.haml

@@ -125,6 +125,11 @@
                       License
                     .acc-section
                       .acc-content
+          %li
+            %a{ :href => "#installation" }
+              Installation
+            .acc-section
+              .acc-content
           %li
             %a{ :href => "#overview" }
               Overview
@@ -247,6 +252,11 @@
             .acc-section
               .acc-content
                 %ul.level2#menu9
+                  %li
+                    %a{ :href => "#skipping_over_unused_data" }
+                      Skipping over unused data
+                    .acc-section
+                      .acc-content
                   %li
                     %a{ :href => "#wrappers" }
                       Wrappers

data/spec/int_spec.rb

@@ -149,7 +149,6 @@ share_examples_for "All Integers" do
     (1 .. 20).each do |nbytes|
       nbits = nbytes * 8
       class_name = "#{base}#{nbits}#{endian_str}"
-      BinData::Int.define_class(nbits, endian, signed_sym)
       result[BinData.const_get(class_name)] = nbytes
     end
 
@@ -200,19 +199,19 @@ end
 describe "Custom defined integers" do
   it "should fail unless bits are a multiple of 8" do
     lambda {
-      BinData::Int.define_class(7, :little, :unsigned)
+      BinData::Uint7le
     }.should raise_error
 
     lambda {
-      BinData::Int.define_class(7, :big, :unsigned)
+      BinData::Uint7be
     }.should raise_error
 
     lambda {
-      BinData::Int.define_class(7, :little, :signed)
+      BinData::Int7le
     }.should raise_error
 
     lambda {
-      BinData::Int.define_class(7, :big, :signed)
+      BinData::Int7be
     }.should raise_error
   end
 end

data/spec/io_spec.rb

@@ -3,6 +3,44 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/io'
 
+describe BinData::IO, "reading from non seekable stream" do
+  before(:each) do
+    @rd, @wr = IO::pipe
+    if fork
+      # parent
+      @wr.close
+      @io = BinData::IO.new(@rd)
+    else
+      # child
+      begin
+        @rd.close
+        @wr.write "a" * 5000
+        @wr.write "b" * 5000
+        @wr.close
+      rescue Exception
+        # ignore it
+      ensure
+        exit!
+      end
+    end
+  end
+
+  after(:each) do
+    @rd.close
+    Process.wait
+  end
+
+  it "should always have an offset of 0" do
+    @io.readbytes(10)
+    @io.offset.should == 0
+  end
+
+  it "should seek" do
+    @io.seekbytes(4999)
+    @io.readbytes(5).should == "abbbb"
+  end
+end
+
 describe BinData::IO do
   it "should wrap strings in StringIO" do
     io = BinData::IO.new("abcd")

data/spec/primitive_spec.rb

@@ -152,3 +152,20 @@ describe BinData::Primitive, "with custom default parameters" do
     obj.value.should == 7
   end
 end
+
+describe BinData::Primitive, "derived classes" do
+  class ParentDerivedPrimitive < BinData::Primitive
+    uint16be :a
+    def get; self.a; end
+    def set(v); self.a = v; end
+  end
+
+  class ChildDerivedPrimitive < ParentDerivedPrimitive
+  end
+
+  it "should derive" do
+    a = ChildDerivedPrimitive.new
+    a.value = 7
+    a.to_binary_s.should == "\000\007"
+  end
+end

data/spec/record_spec.rb

@@ -71,6 +71,34 @@ describe BinData::Record, "when defining" do
   end
 end
 
+describe BinData::Record, "with anonymous fields" do
+  class AnonymousRecord < BinData::Record
+    int8 'a', :initial_value => 10
+    int8 ''
+    int8 :value => :a
+  end
+
+  before(:each) do
+    @obj = AnonymousRecord.new
+  end
+
+  it "should only show non anonymous fields" do
+    @obj.field_names.should == ["a"]
+  end
+
+  it "should not include anonymous fields in snapshot" do
+    @obj.a = 5
+    @obj.snapshot.should == {"a" => 5}
+  end
+
+  it "should write anonymous fields" do
+    str = "\001\002\003"
+    @obj.read(str)
+    @obj.a.clear
+    @obj.to_binary_s.should == "\012\002\012"
+  end
+end
+
 describe BinData::Record, "with hidden fields" do
   class HiddenRecord < BinData::Record
     hide :b, 'c'
@@ -350,3 +378,24 @@ describe BinData::Record, "with :onlyif" do
     @obj.to_binary_s.should == "\x03\x05"
   end
 end
+
+describe BinData::Record, "derived classes" do
+  class ParentDerivedRecord < BinData::Record
+    uint8 :a
+  end
+
+  class ChildDerivedRecord < ParentDerivedRecord
+    uint8 :b
+  end
+
+  it "should not affect parent" do
+    parent = ParentDerivedRecord.new
+    parent.field_names.should == ["a"]
+  end
+
+  it "should inherit fields" do
+    child = ChildDerivedRecord.new
+    child.field_names.should == ["a", "b"]
+  end
+end
+

data/spec/registry_spec.rb

@@ -3,6 +3,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/bits'
 require 'bindata/int'
+require 'bindata/float'
 require 'bindata/registry'
 
 describe BinData::Registry do
@@ -55,54 +56,46 @@ describe BinData::Registry do
   it "should ignore the outer nestings of classes" do
     @r.underscore_name('A::B::C').should == 'c'
   end
+end
 
-=begin
-  it "should lookup integers with endian" do
-    @r.register("Int24be", A)
-    @r.register("Int24le", B)
-    @r.register("Uint24be", C)
-    @r.register("Uint24le", D)
+describe BinData::Registry, "with numerics" do
+  before(:each) do
+    @r = BinData::RegisteredClasses
+  end
 
-    @r.lookup("int24", :big).should == A
-    @r.lookup("int24", :little).should == B
-    @r.lookup("uint24", :big).should == C
-    @r.lookup("uint24", :little).should == D
+  it "should lookup integers with endian" do
+    @r.lookup("int24", :big).to_s.should == "BinData::Int24be"
+    @r.lookup("int24", :little).to_s.should == "BinData::Int24le"
+    @r.lookup("uint24", :big).to_s.should == "BinData::Uint24be"
+    @r.lookup("uint24", :little).to_s.should == "BinData::Uint24le"
   end
 
   it "should not lookup integers without endian" do
-    @r.register("Int24be", A)
-
     @r.lookup("int24").should be_nil
   end
 
-  it "should lookup floats with endian" do
-    @r.register("FloatBe", A)
-    @r.register("FloatLe", B)
-    @r.register("DoubleBe", C)
-    @r.register("DoubleLe", D)
-
-    @r.lookup("float", :big).should == A
-    @r.lookup("float", :little).should == B
-    @r.lookup("double", :big).should == C
-    @r.lookup("double", :little).should == D
+  it "should not lookup non byte based integers" do
+    @r.lookup("int3").should be_nil
+    @r.lookup("int3", :big).should be_nil
+    @r.lookup("int3", :little).should be_nil
   end
 
-  it "should automatically create classes for integers" do
-    BinData.const_defined?(:Uint40be).should be_false
-    @r.lookup("uint40be")
-    BinData.const_defined?(:Uint40be).should be_true
+  it "should lookup floats with endian" do
+    @r.lookup("float", :big).to_s.should == "BinData::FloatBe"
+    @r.lookup("float", :little).to_s.should == "BinData::FloatLe"
+    @r.lookup("double", :big).to_s.should == "BinData::DoubleBe"
+    @r.lookup("double", :little).to_s.should == "BinData::DoubleLe"
   end
 
-  it "should automatically create classes for big endian bits" do
-    BinData.const_defined?(:Bit801).should be_false
-    @r.lookup("bit801")
-    BinData.const_defined?(:Bit801).should be_true
+  it "should lookup bits" do
+    @r.lookup("bit5").to_s.should == "BinData::Bit5"
+    @r.lookup("bit6le").to_s.should == "BinData::Bit6le"
   end
 
-  it "should automatically create classes for little endian bits" do
-    BinData.const_defined?(:Bit802le).should be_false
-    @r.lookup("bit802le")
-    BinData.const_defined?(:Bit802le).should be_true
+  it "should lookup bits by ignoring endian" do
+    @r.lookup("bit2", :big).to_s.should == "BinData::Bit2"
+    @r.lookup("bit3le", :big).to_s.should == "BinData::Bit3le"
+    @r.lookup("bit2", :little).to_s.should == "BinData::Bit2"
+    @r.lookup("bit3le", :little).to_s.should == "BinData::Bit3le"
   end
-=end
 end

data/spec/skip_spec.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require 'bindata/skip'
+
+describe BinData::Skip do
+  before(:each) do
+    @skip = BinData::Skip.new(:length => 5)
+  end
+
+  it "should default to the empty string" do
+    @skip.should == ""
+  end
+
+  it "should skip bytes" do
+    io = StringIO.new("abcdefghij")
+    @skip.read(io)
+    io.pos.should == 5
+  end
+
+  it "should have expected binary representation" do
+    @skip.to_binary_s.should == "\000" * 5
+  end
+
+  it "should have expected binary representation after setting value" do
+    @skip.value = "123"
+    @skip.to_binary_s.should == "\000" * 5
+  end
+
+  it "should have expected binary representation after reading" do
+    io = StringIO.new("abcdefghij")
+    @skip.read(io)
+    @skip.to_binary_s.should == "\000" * 5
+  end
+end

data/spec/struct_spec.rb

@@ -41,6 +41,32 @@ describe BinData::Struct, "when initializing" do
   end
 end
 
+describe BinData::Struct, "with anonymous fields" do
+  before(:each) do
+    @params = { :fields => [
+                   [:int8, :a, {:initial_value => 10}],
+                   [:int8, nil],
+                   [:int8, '', {:value => :a}]] }
+    @obj = BinData::Struct.new(@params)
+  end
+
+  it "should only show non anonymous fields" do
+    @obj.field_names.should == ["a"]
+  end
+
+  it "should not include anonymous fields in snapshot" do
+    @obj.a = 5
+    @obj.snapshot.should == {"a" => 5}
+  end
+
+  it "should write anonymous fields" do
+    str = "\001\002\003"
+    @obj.read(str)
+    @obj.a.clear
+    @obj.to_binary_s.should == "\012\002\012"
+  end
+end
+
 describe BinData::Struct, "with hidden fields" do
   before(:each) do
     @params = { :hide => [:b, 'c'],

data/spec/wrapper_spec.rb

@@ -81,3 +81,17 @@ describe BinData::Wrapper, "inside a struct" do
     obj.should == {'b' => 2}
   end
 end
+
+describe BinData::Wrapper, "derived classes" do
+  class ParentDerivedWrapper < BinData::Wrapper
+    uint32le
+  end
+
+  class ChildDerivedWrapper < ParentDerivedWrapper
+  end
+
+  it "should wrap" do
+    a = ChildDerivedWrapper.new
+    a.num_bytes.should == 4
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bindata
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Dion Mendel
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-13 00:00:00 +08:00
+date: 2009-11-24 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
@@ -22,67 +22,71 @@ extensions: []
 extra_rdoc_files: 
 - NEWS
 files: 
-- INSTALL
-- TODO
-- GPL
-- Rakefile
 - COPYING
-- NEWS
+- INSTALL
 - README
+- NEWS
+- GPL
 - ChangeLog
-- examples/gzip.rb
+- Rakefile
+- TODO
 - examples/ip_address.rb
-- spec/primitive_spec.rb
-- spec/record_spec.rb
-- spec/float_spec.rb
-- spec/int_spec.rb
-- spec/registry_spec.rb
-- spec/lazy_spec.rb
-- spec/deprecated_spec.rb
-- spec/array_spec.rb
-- spec/bits_spec.rb
+- examples/gzip.rb
 - spec/io_spec.rb
-- spec/struct_spec.rb
-- spec/stringz_spec.rb
 - spec/rest_spec.rb
-- spec/base_spec.rb
+- spec/lazy_spec.rb
+- spec/primitive_spec.rb
 - spec/wrapper_spec.rb
+- spec/spec_common.rb
+- spec/registry_spec.rb
+- spec/string_spec.rb
+- spec/stringz_spec.rb
 - spec/choice_spec.rb
 - spec/example.rb
-- spec/system_spec.rb
-- spec/string_spec.rb
-- spec/spec_common.rb
 - spec/base_primitive_spec.rb
-- lib/bindata/array.rb
-- lib/bindata/base_primitive.rb
-- lib/bindata/int.rb
-- lib/bindata/rest.rb
-- lib/bindata/struct.rb
-- lib/bindata/lazy.rb
-- lib/bindata/choice.rb
-- lib/bindata/string.rb
+- spec/bits_spec.rb
+- spec/deprecated_spec.rb
+- spec/base_spec.rb
+- spec/int_spec.rb
+- spec/system_spec.rb
+- spec/record_spec.rb
+- spec/float_spec.rb
+- spec/skip_spec.rb
+- spec/struct_spec.rb
+- spec/array_spec.rb
+- lib/bindata/deprecated.rb
+- lib/bindata/record.rb
 - lib/bindata/float.rb
-- lib/bindata/base.rb
-- lib/bindata/primitive.rb
 - lib/bindata/registry.rb
-- lib/bindata/bits.rb
-- lib/bindata/deprecated.rb
+- lib/bindata/lazy.rb
+- lib/bindata/choice.rb
+- lib/bindata/struct.rb
 - lib/bindata/params.rb
-- lib/bindata/sanitize.rb
+- lib/bindata/base_primitive.rb
+- lib/bindata/bits.rb
 - lib/bindata/trace.rb
+- lib/bindata/wrapper.rb
+- lib/bindata/sanitize.rb
+- lib/bindata/base.rb
+- lib/bindata/skip.rb
+- lib/bindata/rest.rb
+- lib/bindata/string.rb
+- lib/bindata/array.rb
 - lib/bindata/stringz.rb
+- lib/bindata/primitive.rb
+- lib/bindata/int.rb
 - lib/bindata/io.rb
-- lib/bindata/record.rb
-- lib/bindata/wrapper.rb
 - lib/bindata.rb
 - tasks/rdoc.rake
 - tasks/manual.rake
-- tasks/pkg.rake
 - tasks/rspec.rake
+- tasks/pkg.rake
 - setup.rb
 - manual.haml
 has_rdoc: true
 homepage: http://bindata.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -104,9 +108,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: bindata
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A declarative way to read and write binary file formats
 test_files: []