bindata 0.9.2 → 0.9.3

data/lib/bindata/single.rb

@@ -47,11 +47,11 @@ module BinData
   #                           the value just read in.
   class Single < BinData::Base
     # These are the parameters used by this class.
-    optional_parameters :initial_value, :value, :check_value
-    mutually_exclusive_parameters :initial_value, :value
+    bindata_optional_parameters :initial_value, :value, :check_value
+    bindata_mutually_exclusive_parameters :initial_value, :value
 
-    def initialize(params = {}, env = nil)
-      super(params, env)
+    def initialize(params = {}, parent = nil)
+      super(params, parent)
       clear
     end
 

data/lib/bindata/single_value.rb

@@ -67,6 +67,11 @@ module BinData
         register(subclass.name, subclass)
       end
 
+      # Can this data object self reference itself?
+      def recursive?
+        true
+      end
+
       # Returns or sets the endianess of numerics used in this stucture.
       # Endianess is applied to the fields of this structure.
       # Valid values are :little and :big.
@@ -123,28 +128,25 @@ module BinData
         @fields.push([type, name, params])
       end
 
-      # Returns a sanitized +params+ that is of the form expected
-      # by #initialize.
-      def sanitize_parameters(sanitizer, params)
-        params = params.dup
-
-        hash = {}
-        hash[:fields] = self.fields
-        hash[:endian] = self.endian unless self.endian.nil?
+      # Ensures that +params+ is of the form expected by #initialize.
+      def sanitize_parameters!(sanitizer, params)
+        struct_params = {}
+        struct_params[:fields] = self.fields
+        struct_params[:endian] = self.endian unless self.endian.nil?
         
-        params[:struct_params] = hash
+        params[:struct_params] = struct_params
 
         super(sanitizer, params)
       end
     end
 
     # These are the parameters used by this class.
-    mandatory_parameter :struct_params
+    bindata_mandatory_parameter :struct_params
 
-    def initialize(params = {}, env = nil)
-      super(params, env)
+    def initialize(params = {}, parent = nil)
+      super(params, parent)
 
-      @struct = BinData::Struct.new(param(:struct_params), create_env)
+      @struct = BinData::Struct.new(no_eval_param(:struct_params), self)
     end
 
     # Forward method calls to the internal struct.

data/lib/bindata/string.rb

@@ -51,18 +51,15 @@ module BinData
     register(self.name, self)
 
     # These are the parameters used by this class.
-    optional_parameters  :read_length, :length, :trim_value
-    default_parameters   :pad_char => "\0"
-    mutually_exclusive_parameters :read_length, :length
-    mutually_exclusive_parameters :length, :value
+    bindata_optional_parameters :read_length, :length, :trim_value
+    bindata_default_parameters  :pad_char => "\0"
+    bindata_mutually_exclusive_parameters :read_length, :length
+    bindata_mutually_exclusive_parameters :length, :value
 
     class << self
 
-      # Returns a sanitized +params+ that is of the form expected
-      # by #initialize.
-      def sanitize_parameters(sanitizer, params, *args)
-        params = params.dup
-
+      # Ensures that +params+ is of the form expected by #initialize.
+      def sanitize_parameters!(sanitizer, params)
         # warn about deprecated param - remove before releasing 1.0
         if params[:initial_length]
           warn ":initial_length is deprecated. Replacing with :read_length"
@@ -79,7 +76,7 @@ module BinData
           params[:pad_char] = ch
         end
 
-        super(sanitizer, params, *args)
+        super(sanitizer, params)
       end
     end
 
@@ -87,7 +84,9 @@ module BinData
     # trimmed as required.
     def value
       v = val_to_str(_value)
-      v.sub!(/#{eval_param(:pad_char)}*$/, "") if param(:trim_value) == true
+      if no_eval_param(:trim_value) == true
+        v.sub!(/#{eval_param(:pad_char)}*$/, "")
+      end
       v
     end
 

data/lib/bindata/stringz.rb

@@ -31,7 +31,7 @@ module BinData
     register(self.name, self)
 
     # These are the parameters used by this class.
-    optional_parameters :max_length
+    bindata_optional_parameters :max_length
 
     # Overrides value to return the value of this data excluding the trailing
     # zero byte.
@@ -75,24 +75,24 @@ module BinData
     # will not be longer than +max_length+.
     def zero_terminate(str, max_length = nil)
       # str must not be empty
-      str = "\0" if str == ""
+      result = (str == "") ? "\0" : str
 
       # remove anything after the first \0
-      str = str.sub(/([^\0]*\0).*/, '\1')
+      result = result.sub(/([^\0]*\0).*/, '\1')
 
       # trim string to be no longer than max_length including zero byte
       if max_length
         max_length = 1 if max_length < 1
-        str = str[0, max_length]
-        if str.length == max_length and str[-1, 1] != "\0"
-          str[-1, 1] = "\0"
+        result = result[0, max_length]
+        if result.length == max_length and result[-1, 1] != "\0"
+          result[-1, 1] = "\0"
         end
       end
 
       # ensure last byte in the string is a zero byte
-      str << "\0" if str[-1, 1] != "\0"
+      result << "\0" if result[-1, 1] != "\0"
 
-      str
+      result
     end
   end
 end

data/lib/bindata/struct.rb

@@ -44,7 +44,8 @@ module BinData
                 %w{alias and begin break case class def defined do else elsif
                    end ensure false for if in module next nil not or redo
                    rescue retry return self super then true undef unless until
-                   when while yield }).uniq
+                   when while yield} +
+                %w{array element index offset value} ).uniq
 
     # Register this class
     register(self.name, self)
@@ -57,101 +58,20 @@ module BinData
     end
 
     class << self
-      #### DEPRECATION HACK to allow inheriting from BinData::Struct
+      #### DEPRECATION HACK to warn about inheriting from BinData::Struct
       #
       def inherited(subclass) #:nodoc:
         if subclass != MultiValue
           # warn about deprecated method - remove before releasing 1.0
-          warn "warning: inheriting from BinData::Struct in deprecated. Inherit from BinData::MultiValue instead."
-
-          register(subclass.name, subclass)
+          fail "error: inheriting from BinData::Struct has been deprecated. Inherit from BinData::MultiValue instead."
         end
       end
-      def endian(endian = nil)
-        @endian ||= nil
-        if [:little, :big].include?(endian)
-          @endian = endian
-        elsif endian != nil
-          raise ArgumentError, "unknown value for endian '#{endian}'"
-        end
-        @endian
-      end
-      def hide(*args)
-        # note that fields are stored in an instance variable not a class var
-        @hide ||= []
-        args.each do |name|
-          @hide << name.to_s
-        end
-        @hide
-      end
-      def fields
-        @fields || []
-      end
-      def method_missing(symbol, *args)
-        name, params = args
-
-        type = symbol
-        name = name.to_s
-        params ||= {}
-
-        # note that fields are stored in an instance variable not a class var
-        @fields ||= []
-
-        # check that type is known
-        unless Sanitizer.type_exists?(type, endian)
-          raise TypeError, "unknown type '#{type}' for #{self}", caller
-        end
-
-        # check for duplicate names
-        @fields.each do |t, n, p|
-          if n == name
-            raise SyntaxError, "duplicate field '#{name}' in #{self}", caller
-          end
-        end
-
-        # check that name doesn't shadow an existing method
-        if self.instance_methods.include?(name)
-          raise NameError.new("", name),
-                "field '#{name}' shadows an existing method", caller
-        end
-
-        # check that name isn't reserved
-        if self::RESERVED.include?(name)
-          raise NameError.new("", name),
-                "field '#{name}' is a reserved name", caller
-        end
-
-        # remember this field.  These fields will be recalled upon creating
-        # an instance of this class
-        @fields.push([type, name, params])
-      end
-      def deprecated_hack(params)
-        params = params.dup
-
-        # possibly override endian
-        endian = params[:endian] || self.endian
-        params[:endian] = endian unless endian.nil?
-
-        params[:fields] = params[:fields] || self.fields
-        params[:hide] = params[:hide] || self.hide
-
-        params
-      end
       #
       #### DEPRECATION HACK to allow inheriting from BinData::Struct
 
 
-      # Returns a sanitized +params+ that is of the form expected
-      # by #initialize.
-      def sanitize_parameters(sanitizer, params)
-        #### DEPRECATION HACK to allow inheriting from BinData::Struct
-        #
-        params = deprecated_hack(params)
-        #
-        #### DEPRECATION HACK to allow inheriting from BinData::Struct
-
-        params = params.dup
-
+      # Ensures that +params+ is of the form expected by #initialize.
+      def sanitize_parameters!(sanitizer, params)
         # possibly override endian
         endian = params[:endian]
         if endian != nil
@@ -167,68 +87,65 @@ module BinData
             # ensure names of fields are strings and that params is sanitized
             all_fields = params[:fields].collect do |ftype, fname, fparams|
               fname = fname.to_s
-              klass, new_params = sanitizer.sanitize(ftype, fparams)
-              [klass, fname, new_params]
+              klass = sanitizer.lookup_klass(ftype)
+              sanitized_fparams = sanitizer.sanitize_params(klass, fparams)
+              [klass, fname, sanitized_fparams]
             end
             params[:fields] = all_fields
           end
 
-          # collect all hidden names that correspond to a field name
-          hide = []
-          if params.has_key?(:hide)
-            hidden = (params[:hide] || []).collect { |h| h.to_s }
-            all_field_names = params[:fields].collect { |k,n,p| n }
-            hide = hidden & all_field_names
-          end
-          params[:hide] = hide
-        end
-
-        # obtain SanitizedParameters
-        params = super(sanitizer, params)
+          # now params are sanitized, check that parameter names are okay
+          field_names = []
+          instance_methods = self.instance_methods
+          reserved_names = RESERVED
 
-        # now params are sanitized, check that parameter names are okay
+          params[:fields].each do |fklass, fname, fparams|
 
-        field_names = []
-        instance_methods = self.instance_methods
-        reserved_names = RESERVED
+            # check that name doesn't shadow an existing method
+            if instance_methods.include?(fname)
+              raise NameError.new("Rename field '#{fname}' in #{self}, " +
+                                  "as it shadows an existing method.", fname)
+            end
 
-        params[:fields].each do |fklass, fname, fparams|
+            # check that name isn't reserved
+            if reserved_names.include?(fname)
+              raise NameError.new("Rename field '#{fname}' in #{self}, " +
+                                  "as it is a reserved name.", fname)
+            end
 
-          # check that name doesn't shadow an existing method
-          if instance_methods.include?(fname)
-            raise NameError.new("Rename field '#{fname}' in #{self}, " +
-                                "as it shadows an existing method.", fname)
-          end
+            # check for multiple definitions
+            if field_names.include?(fname)
+              raise NameError.new("field '#{fname}' in #{self}, " +
+                                  "is defined multiple times.", fname)
+            end
 
-          # check that name isn't reserved
-          if reserved_names.include?(fname)
-            raise NameError.new("Rename field '#{fname}' in #{self}, " +
-                                "as it is a reserved name.", fname)
+            field_names << fname
           end
 
-          # check for multiple definitions
-          if field_names.include?(fname)
-            raise NameError.new("field '#{fname}' in #{self}, " +
-                                "is defined multiple times.", fname)
+          # collect all hidden names that correspond to a field name
+          hide = []
+          if params.has_key?(:hide)
+            hidden = (params[:hide] || []).collect { |h| h.to_s }
+            all_field_names = params[:fields].collect { |k,n,p| n }
+            hide = hidden & all_field_names
           end
-
-          field_names << fname
+          params[:hide] = hide
         end
 
-        params
+        super(sanitizer, params)
       end
     end
 
     # These are the parameters used by this class.
-    mandatory_parameter :fields
-    optional_parameters :endian, :hide
+    bindata_mandatory_parameter :fields
+    bindata_optional_parameters :endian, :hide
 
     # Creates a new Struct.
-    def initialize(params = {}, env = nil)
-      super(params, env)
+    def initialize(params = {}, parent = nil)
+      super(params, parent)
 
       # extract field names but don't instantiate the fields
-      @field_names = param(:fields).collect { |k, n, p| n }
+      @field_names = no_eval_param(:fields).collect { |k, n, p| n }
       @field_objs  = []
     end
 
@@ -269,7 +186,7 @@ module BinData
     def field_names(include_hidden = false)
       # collect field names
       names = []
-      hidden = param(:hide)
+      hidden = no_eval_param(:hide)
       @field_names.each do |name|
         if include_hidden or not hidden.include?(name)
           names << name
@@ -283,17 +200,6 @@ module BinData
       @field_objs.each { |f| f.done_read unless f.nil? }
     end
 
-    # Returns the data object that stores values for +name+.
-    def find_obj_for_name(name)
-      idx = @field_names.index(name)
-      if idx
-        instantiate_obj(idx)
-        @field_objs[idx]
-      else
-        nil
-      end
-    end
-
     def offset_of(field)
       idx = @field_names.index(field.to_s)
       if idx
@@ -344,16 +250,27 @@ module BinData
     #---------------
     private
 
+    # Returns the data object that stores values for +name+.
+    def find_obj_for_name(name)
+      idx = @field_names.index(name)
+      if idx
+        instantiate_obj(idx)
+        @field_objs[idx].obj
+      else
+        nil
+      end
+    end
+
     # Instantiates all fields.
     def instantiate_all
-      (0...@field_names.length).each { |idx| instantiate_obj(idx) }
+      @field_names.each_with_index { |name, i| instantiate_obj(i) }
     end
 
     # Instantiates the field object at position +idx+.
     def instantiate_obj(idx)
       if @field_objs[idx].nil?
-        fklass, fname, fparams = param(:fields)[idx]
-        @field_objs[idx] = fklass.new(fparams, create_env)
+        fklass, fname, fparams = no_eval_param(:fields)[idx]
+        @field_objs[idx] = fklass.new(fparams, self)
       end
     end
 

data/spec/array_spec.rb

@@ -34,7 +34,7 @@ describe BinData::Array, "with no elements" do
     @data.should_not be_single_value
   end
 
-  it "should return correct length" do
+  it "should return zero length" do
     @data.length.should be_zero
   end
 
@@ -127,7 +127,7 @@ describe BinData::Array, "with several elements" do
     @data.should_not be_empty
   end
 
-  it "should return a nicely formatted array  for inspect" do
+  it "should return a nicely formatted array for inspect" do
     @data.inspect.should == "[1, 2, 3, 4, 5]"
   end
 
@@ -264,6 +264,22 @@ describe BinData::Array, "with :read_until containing +array+ and +index+" do
   end
 end
 
+describe BinData::Array, "with :read_until => :eof" do
+  it "should read records until eof" do
+    obj = BinData::Array.new(:type => :int8, :read_until => :eof)
+    data = "\x01\x02\x03"
+    obj.read(data)
+    obj.snapshot.should == [1, 2, 3]
+  end
+
+  it "should read records until eof, ignoring partial records" do
+    obj = BinData::Array.new(:type => :int16be, :read_until => :eof)
+    data = "\x00\x01\x00\x02\x03"
+    obj.read(data)
+    obj.snapshot.should == [1, 2]
+  end
+end
+
 describe BinData::Array, "of bits" do
   before(:each) do
     @data = BinData::Array.new(:type => :bit1, :initial_length => 15)
@@ -299,3 +315,22 @@ describe BinData::Array, "of bits" do
   end
 end
 
+describe BinData::Array, "nested within an Array" do
+  before(:each) do
+    nested_array_params = { :type => [:int8, { :initial_value => :index }],
+                            :initial_length => lambda { index + 1 } }
+    @data = BinData::Array.new(:type => [:array, nested_array_params],
+                               :initial_length => 3)
+  end
+
+  it "should use correct index" do
+    @data.snapshot.should == [ [0], [0, 1], [0, 1, 2] ]
+  end
+
+  it "should maintain structure when reading" do
+    str = "\x04\x05\x06\x07\x08\x09"
+    @data.read(str)
+    @data.snapshot.should == [ [4], [5, 6], [7, 8, 9] ]
+  end
+end
+