bindata 0.9.1 → 0.9.2

data/lib/bindata/choice.rb

@@ -60,7 +60,7 @@ module BinData
 
       # Returns a sanitized +params+ that is of the form expected
       # by #initialize.
-      def sanitize_parameters(params, endian = nil)
+      def sanitize_parameters(sanitizer, params)
         params = params.dup
 
         if params.has_key?(:choices)
@@ -80,12 +80,7 @@ module BinData
 
               # collect sanitized choice values
               type, param = choices[key]
-              klass = lookup(type, endian)
-              if klass.nil?
-                raise TypeError, "unknown type '#{type}' for #{self}"
-              end
-              val = [klass, SanitizedParameters.new(klass, param, endian)]
-              new_choices[key] = val
+              new_choices[key] = sanitizer.sanitize(type, param)
             end
             params[:choices] = new_choices
           when ::Array
@@ -94,11 +89,7 @@ module BinData
                 # allow sparse arrays
                 nil
               else
-                klass = lookup(type, endian)
-                if klass.nil?
-                  raise TypeError, "unknown type '#{type}' for #{self}"
-                end
-                [klass, SanitizedParameters.new(klass, param, endian)]
+                sanitizer.sanitize(type, param)
               end
             end
             params[:choices] = choices
@@ -107,28 +98,7 @@ module BinData
           end
         end
 
-        super(params, endian)
-      end
-
-      # Returns all the possible field names a :choice may have.
-      def all_possible_field_names(sanitized_params)
-        unless SanitizedParameters === sanitized_params
-          raise ArgumentError, "parameters aren't sanitized"
-        end
-
-        choices = sanitized_params[:choices]
-
-        names = []
-        if ::Array === choices
-          choices.each do |cklass, cparams|
-            names.concat(cklass.all_possible_field_names(cparams))
-          end
-        elsif ::Hash === choices
-          choices.values.each do |cklass, cparams|
-            names.concat(cklass.all_possible_field_names(cparams))
-          end
-        end
-        names
+        super(sanitizer, params)
       end
     end
 
@@ -140,15 +110,10 @@ module BinData
       @last_key = nil
     end
 
-    def_delegators :the_choice, :clear, :clear?, :single_value?, :field_names
-    def_delegators :the_choice, :snapshot, :done_read
+    def_delegators :the_choice, :clear, :clear?, :single_value?
+    def_delegators :the_choice, :done_read, :_snapshot
     def_delegators :the_choice, :_do_read, :_do_write, :_do_num_bytes
 
-    # Returns the data object that stores values for +name+.
-    def find_obj_for_name(name)
-      field_names.include?(name) ? the_choice.find_obj_for_name(name) : nil
-    end
-
     # Override to include selected data object.
     def respond_to?(symbol, include_private = false)
       super || the_choice.respond_to?(symbol, include_private)

data/lib/bindata/float.rb

@@ -63,25 +63,25 @@ module BinData
 
 
   # Single precision floating point number in little endian format
-  class FloatLe < Single
+  class FloatLe < BinData::Single
     register(self.name, self)
     Float.create_float_methods(self, true, :little)
   end
 
   # Single precision floating point number in big endian format
-  class FloatBe < Single
+  class FloatBe < BinData::Single
     register(self.name, self)
     Float.create_float_methods(self, true, :big)
   end
 
   # Double precision floating point number in little endian format
-  class DoubleLe < Single
+  class DoubleLe < BinData::Single
     register(self.name, self)
     Float.create_float_methods(self, false, :little)
   end
 
   # Double precision floating point number in big endian format
-  class DoubleBe < Single
+  class DoubleBe < BinData::Single
     register(self.name, self)
     Float.create_float_methods(self, false, :big)
   end

data/lib/bindata/int.rb

@@ -100,85 +100,85 @@ module BinData
 
 
   # Unsigned 1 byte integer.
-  class Uint8 < Single
+  class Uint8 < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 8, :little)
   end
 
   # Unsigned 2 byte little endian integer.
-  class Uint16le < Single
+  class Uint16le < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 16, :little)
   end
 
   # Unsigned 2 byte big endian integer.
-  class Uint16be < Single
+  class Uint16be < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 16, :big)
   end
 
   # Unsigned 4 byte little endian integer.
-  class Uint32le < Single
+  class Uint32le < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 32, :little)
   end
 
   # Unsigned 4 byte big endian integer.
-  class Uint32be < Single
+  class Uint32be < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 32, :big)
   end
 
   # Unsigned 8 byte little endian integer.
-  class Uint64le < Single
+  class Uint64le < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 64, :little)
   end
 
   # Unsigned 8 byte big endian integer.
-  class Uint64be < Single
+  class Uint64be < BinData::Single
     register(self.name, self)
     Integer.create_uint_methods(self, 64, :big)
   end
 
   # Signed 1 byte integer.
-  class Int8 < Single
+  class Int8 < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 8, :little)
   end
 
   # Signed 2 byte little endian integer.
-  class Int16le < Single
+  class Int16le < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 16, :little)
   end
 
   # Signed 2 byte big endian integer.
-  class Int16be < Single
+  class Int16be < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 16, :big)
   end
 
   # Signed 4 byte little endian integer.
-  class Int32le < Single
+  class Int32le < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 32, :little)
   end
 
   # Signed 4 byte big endian integer.
-  class Int32be < Single
+  class Int32be < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 32, :big)
   end
 
   # Signed 8 byte little endian integer.
-  class Int64le < Single
+  class Int64le < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 64, :little)
   end
 
   # Signed 8 byte big endian integer.
-  class Int64be < Single
+  class Int64be < BinData::Single
     register(self.name, self)
     Integer.create_int_methods(self, 64, :big)
   end

data/lib/bindata/multi_value.rb

@@ -16,11 +16,11 @@ module BinData
   #
   #      int32le :a
   #      int16le :b
-  #      tuple   nil
+  #      tuple   :s
   #    end
   #
   #    obj = SomeDataType.new
-  #    obj.field_names   =># ["b", "x", "y", "z"]
+  #    obj.field_names   =># ["b", "s"]
   #
   #
   # == Parameters
@@ -31,10 +31,9 @@ module BinData
   # <tt>:fields</tt>::   An array specifying the fields for this struct.
   #                      Each element of the array is of the form [type, name,
   #                      params].  Type is a symbol representing a registered
-  #                      type.  Name is the name of this field.  Name may be
-  #                      nil as in the example above.  Params is an optional
-  #                      hash of parameters to pass to this field when
-  #                      instantiating it.
+  #                      type.  Name is the name of this field.  Params is an
+  #                      optional hash of parameters to pass to this field
+  #                      when instantiating it.
   # <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
@@ -42,7 +41,7 @@ module BinData
   # <tt>:endian</tt>::   Either :little or :big.  This specifies the default
   #                      endian of any numerics in this struct, or in any
   #                      nested data objects.
-  class MultiValue < Struct
+  class MultiValue < BinData::Struct
 
     class << self
       # Register the names of all subclasses of this class.
@@ -68,16 +67,14 @@ module BinData
       def hide(*args)
         # note that fields are stored in an instance variable not a class var
         @hide ||= []
-        args.each do |name|
-          next if name.nil?
-          @hide << name.to_s
-        end
+        @hide.concat(args.collect { |name| name.to_s })
         @hide
       end
 
-      # Returns all stored fields.  Should only be called by #sanitize_parameters
+      # Returns all stored fields.
+      # Should only be called by #sanitize_parameters
       def fields
-        @fields || []
+        @fields ||= []
       end
 
       # Used to define fields for this structure.
@@ -85,37 +82,34 @@ module BinData
         name, params = args
 
         type = symbol
-        name = (name.nil? or name == "") ? nil : name.to_s
+        name = name.to_s
         params ||= {}
 
         # note that fields are stored in an instance variable not a class var
         @fields ||= []
 
         # check that type is known
-        if lookup(type, endian).nil?
+        unless Sanitizer.type_exists?(type, endian)
           raise TypeError, "unknown type '#{type}' for #{self}", caller
         end
 
-        # check that name is okay
-        if name != nil
-          # check for duplicate names
-          @fields.each do |t, n, p|
-            if n == name
-              raise SyntaxError, "duplicate field '#{name}' in #{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 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 ::Hash.instance_methods.include?(name)
-            raise NameError.new("", name),
-                  "field '#{name}' is a reserved name", 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
@@ -125,19 +119,18 @@ module BinData
 
       # Returns a sanitized +params+ that is of the form expected
       # by #initialize.
-      def sanitize_parameters(params, endian = nil)
+      def sanitize_parameters(sanitizer, params)
         params = params.dup
 
-        # possibly override endian
-        endian = params[:endian] || self.endian || endian
-        unless endian.nil?
-          params[:endian] = endian
-        end
+        endian = params[:endian] || self.endian
+        fields = params[:fields] || self.fields
+        hide   = params[:hide]   || self.hide
 
-        params[:fields] = params[:fields] || self.fields
-        params[:hide] = params[:hide] || self.hide
+        params[:endian] = endian unless endian.nil?
+        params[:fields] = fields
+        params[:hide]   = hide
 
-        super(params, endian)
+        super(sanitizer, params)
       end
     end
   end

data/lib/bindata/rest.rb

@@ -15,7 +15,7 @@ module BinData
   #   obj.a #=> "abcde"
   #   obj.rest #=" "fghij"
   #
-  class Rest < Single
+  class Rest < BinData::Single
 
     # Register this class
     register(self.name, self)

data/lib/bindata/sanitize.rb

@@ -1,6 +1,91 @@
 require 'forwardable'
 
 module BinData
+  class Sanitizer
+    class << self
+      # Sanitize +params+ for +obj+.
+      # Returns sanitized parameters.
+      def sanitize(obj, params)
+        sanitizer = self.new
+        klass, new_params = sanitizer.sanitize(obj.class, params)
+        new_params
+      end
+
+      # Returns true if +type+ is registered.
+      def type_exists?(type, endian = nil)
+        lookup(type, endian) != nil
+      end
+
+      # Returns the class matching a previously registered +name+.
+      def lookup(name, endian)
+        name = name.to_s
+        klass = Registry.instance.lookup(name)
+        if klass.nil? and endian != nil
+          # lookup failed so attempt endian lookup
+          if /^u?int\d{1,3}$/ =~ name
+            new_name = name + ((endian == :little) ? "le" : "be")
+            klass = Registry.instance.lookup(new_name)
+          elsif ["float", "double"].include?(name)
+            new_name = name + ((endian == :little) ? "_le" : "_be")
+            klass = Registry.instance.lookup(new_name)
+          end
+        end
+        klass
+      end
+    end
+
+    # Create a new Sanitizer.
+    def initialize
+      @seen   = []
+      @endian = nil
+    end
+
+    # Executes the given block with +endian+ set as the current endian.
+    def with_endian(endian, &block)
+      if endian != nil
+        saved_endian = @endian
+        @endian = endian
+        yield
+        @endian = saved_endian
+      else
+        yield
+      end
+    end
+
+    # Sanitizes +params+ for +type+.
+    # Returns [klass, sanitized_params]
+    def sanitize(type, params)
+      if Class === type
+        klass = type
+      else
+        klass = self.class.lookup(type, @endian)
+        raise TypeError, "unknown type '#{type}'" if klass.nil?
+      end
+
+      params ||= {}
+      if @seen.include?(klass)
+        # This klass is defined recursively.  Remember the current endian
+        # and delay sanitizing the parameters until later.
+        if @endian != nil and klass.accepted_parameters.include?(:endian) and
+            not params.has_key?(:endian)
+          params = params.dup
+          params[:endian] = @endian
+        end
+      else
+        # subclasses of MultiValue may be defined recursively
+        # TODO: define a class field instead
+        possibly_recursive = (BinData.const_defined?(:MultiValue) and 
+                              klass.ancestors.include?(BinData.const_get(:MultiValue)))
+        @seen.push klass if possibly_recursive
+
+        new_params = klass.sanitize_parameters(self, params)
+        params = SanitizedParameters.new(klass, new_params)
+      end
+
+      [klass, params]
+    end
+  end
+
   # A BinData object accepts arbitrary parameters.  This class ensures that
   # the parameters have been sanitized, and categorizes them according to
   # whether they are BinData::Base.accepted_parameters or are extra.
@@ -8,9 +93,8 @@ module BinData
     extend Forwardable
 
     # Sanitize the given parameters.
-    def initialize(klass, params, *args)
-      params ||= {}
-      @hash = klass.sanitize_parameters(params, *args)
+    def initialize(klass, params)
+      @hash = params
       @accepted_parameters = {}
       @extra_parameters = {}
 
@@ -34,3 +118,4 @@ module BinData
     def_delegators :@hash, :[], :has_key?, :include?, :keys
   end
 end
+