bindata 0.10.0 → 0.11.0

data/lib/bindata/deprecated.rb

@@ -0,0 +1,148 @@
+module BinData
+  class Base
+    def single_value?
+      warn "#single_value? is deprecated.  It should no longer be needed"
+      false
+    end
+  end
+
+  class SingleValue < Primitive
+    class << self
+      def inherited(subclass) #:nodoc:
+        warn "BinData::SingleValue is deprecated.  Replacing with BinData::Primitive"
+        super
+      end
+    end
+  end
+
+  class MultiValue < Record
+    class << self
+      def inherited(subclass) #:nodoc:
+        warn "BinData::MultiValue is deprecated.  Replacing with BinData::Record"
+        super
+      end
+    end
+  end
+
+  class Registry
+    def Registry.instance #:nodoc:
+      warn "'Registry.instance' is deprecated.  Replacing with 'RegisteredClasses'"
+      RegisteredClasses
+    end
+  end
+
+  class Array
+    alias_method :orig_clear?, :clear?
+    def clear?(index = nil) #:nodoc:
+      if index.nil?
+        orig_clear?
+      elsif index < elements.length
+        warn "'obj.clear?(n)' is deprecated.  Replacing with 'obj[n].clear?'"
+        elements[index].clear?
+      else
+        true
+      end
+    end
+
+    alias_method :orig_clear, :clear
+    def clear(index = nil) #:nodoc:
+      if index.nil?
+        orig_clear
+      elsif index < elements.length
+        warn "'obj.clear(n)' is deprecated.  Replacing with 'obj[n].clear'"
+        elements[index].clear
+      end
+    end
+
+    alias_method :orig__do_num_bytes, :_do_num_bytes
+    def _do_num_bytes(index) #:nodoc:
+      if index.nil?
+        orig__do_num_bytes(nil)
+      elsif index < elements.length
+        warn "'obj.num_bytes(n)' is deprecated.  Replacing with 'obj[n].num_bytes'"
+        elements[index].do_num_bytes
+      else
+        0
+      end
+    end
+
+    def append(value = nil) #:nodoc:
+      warn "#append is deprecated, use push or slice instead"
+      if value.nil?
+        slice(length)
+      else
+        push(value)
+      end
+      self.last
+    end
+  end
+
+  class String < BinData::BasePrimitive
+    class << self
+      def deprecate!(params, old_key, new_key) #:nodoc:
+        if params.has_parameter?(old_key)
+          warn ":#{old_key} is deprecated. Replacing with :#{new_key}"
+          params[new_key] = params.delete(old_key)
+        end
+      end
+
+      alias_method :orig_sanitize_parameters!, :sanitize_parameters!
+      def sanitize_parameters!(params, sanitizer) #:nodoc:
+        deprecate!(params, :trim_value, :trim_padding)
+        orig_sanitize_parameters!(params, sanitizer)
+      end
+    end
+  end
+
+
+  class Struct < BinData::Base
+    class << self
+      def inherited(subclass) #:nodoc:
+        if subclass != Record
+          fail "error: inheriting from BinData::Struct has been deprecated. Inherit from BinData::Record instead."
+        end
+      end
+    end
+
+    alias_method :orig_clear, :clear
+    def clear(name = nil) #:nodoc:
+      if name.nil?
+        orig_clear
+      else
+        warn "'obj.clear(name)' is deprecated.  Replacing with 'obj.name.clear'"
+        obj = find_obj_for_name(name)
+        obj.clear unless obj.nil?
+      end
+    end
+
+    alias_method :orig_clear?, :clear?
+    def clear?(name = nil) #:nodoc:
+      if name.nil?
+        orig_clear?
+      else
+        warn "'obj.clear?(name)' is deprecated.  Replacing with 'obj.name.clear?'"
+        obj = find_obj_for_name(name)
+        obj.nil? ? true : obj.clear?
+      end
+    end
+
+    alias_method :orig__do_num_bytes, :_do_num_bytes
+    def _do_num_bytes(name) #:nodoc:
+      if name.nil?
+        orig__do_num_bytes(nil)
+      else
+        warn "'obj.num_bytes(name)' is deprecated.  Replacing with 'obj.name.num_bytes'"
+        obj = find_obj_for_name(name)
+        obj.nil? ? 0 : obj.do_num_bytes
+      end
+    end
+
+    alias_method :orig_offset_of, :offset_of
+    def offset_of(child)
+      if child.class == ::String
+        fail "error: 'offset_of(\"fieldname\")' is deprecated.  Use 'fieldname.offset' instead"
+      end
+      orig_offset_of(child)
+    end
+  end
+end

data/lib/bindata/lazy.rb

@@ -71,12 +71,10 @@ module BinData
     def index
       return @overrides[:index] if @overrides.has_key?(:index)
 
-      bindata_array_class = BinData.const_defined?("Array") ? 
-                              BinData.const_get("Array") : nil
       child = @obj
       parent = @obj.parent
       while parent
-        if parent.class == bindata_array_class
+        if parent.respond_to?(:find_index_of)
           return parent.find_index_of(child)
         end
         child = parent

data/lib/bindata/params.rb

@@ -1,79 +1,23 @@
+require 'bindata/lazy'
+
 module BinData
   # BinData objects accept parameters when initializing.  AcceptedParameters
   # allow a BinData class to declaratively identify accepted parameters as
   # mandatory, optional, default or mutually exclusive.
   class AcceptedParameters
-    class << self
-      def define_all_accessors(obj_class, param_name)
-        all_accessors = [:mandatory, :optional, :default, :mutually_exclusive]
-        all_accessors.each do |accessor|
-          define_accessor(obj_class, param_name, accessor)
-        end
-      end
-
-      def define_accessors(obj_class, param_name, *accessors)
-        accessors.each do |accessor|
-          define_accessor(obj_class, param_name, accessor)
-        end
-      end
-
-      def get(obj_class, param_name)
-        obj_class.__send__(internal_storage_method_name(param_name))
-      end
-
-      #-------------
-      private
-
-      def define_accessor(obj_class, param_name, accessor)
-        singular_name = accessor_method_name(accessor)
-        plural_name = singular_name + "s"
-        internal_storage_method = internal_storage_method_name(param_name)
-
-        ensure_parameter_storage_exists(obj_class, internal_storage_method)
-
-        obj_class.class_eval <<-END
-          def #{singular_name}(*args)
-            #{internal_storage_method}.#{accessor}(*args)
-          end
-          alias_method :#{plural_name}, :#{singular_name}
-        END
-      end
-
-      def accessor_method_name(accessor)
-        "#{accessor}_parameter"
-      end
-
-      def internal_storage_method_name(param_name)
-        "_bindata_accepted_parameters_#{param_name}"
-      end
-
-      def ensure_parameter_storage_exists(obj_class, method_name)
-        return if obj_class.instance_methods.include?(method_name)
-
-        iv = "@#{method_name}"
-        obj_class.class_eval <<-END
-          def #{method_name}
-            unless defined? #{iv}
-              ancestor = ancestors[1..-1].find { |a| a.instance_variable_defined?(:#{iv}) }
-              ancestor_params = ancestor.nil? ? nil : ancestor.instance_variable_get(:#{iv})
-              #{iv} = AcceptedParameters.new(ancestor_params)
-            end
-            #{iv}
-          end
-        END
-      end
-    end
 
     def initialize(ancestor_params = nil)
       @mandatory = ancestor_params ? ancestor_params.mandatory : []
-      @optional = ancestor_params ? ancestor_params.optional : []
-      @default = ancestor_params ? ancestor_params.default : Hash.new
-      @mutually_exclusive = ancestor_params ? ancestor_params.mutually_exclusive : []
+      @optional  = ancestor_params ? ancestor_params.optional  : []
+      @default   = ancestor_params ? ancestor_params.default   : Hash.new
+      @mutually_exclusive = ancestor_params ?
+                                     ancestor_params.mutually_exclusive : []
     end
 
     def mandatory(*args)
       if not args.empty?
-        @mandatory.concat(args.collect { |a| a.to_sym })
+        ensure_valid_names(args)
+        @mandatory.concat(args.collect { |arg| arg.to_sym })
         @mandatory.uniq!
       end
       @mandatory.dup
@@ -81,7 +25,8 @@ module BinData
 
     def optional(*args)
       if not args.empty?
-        @optional.concat(args.collect { |a| a.to_sym })
+        ensure_valid_names(args)
+        @optional.concat(args.collect { |arg| arg.to_sym })
         @optional.uniq!
       end
       @optional.dup
@@ -89,8 +34,9 @@ module BinData
 
     def default(args = {})
       if not args.empty?
-        args.each_pair do |k,v|
-          @default[k.to_sym] = v
+        ensure_valid_names(args.keys)
+        args.each_pair do |param, value|
+          @default[param.to_sym] = value
         end
       end
       @default.dup
@@ -109,34 +55,17 @@ module BinData
       (@mandatory + @optional + @default.keys).uniq
     end
 
-    def sanitize_parameters!(sanitizer, params)
-      merge_default_parameters!(params)
-      ensure_mandatory_parameters_exist(params)
-      ensure_mutual_exclusion_of_parameters(params)
-    end
-
     #---------------
     private
 
-    def merge_default_parameters!(params)
-      @default.each do |k,v|
-        params[k] = v unless params.has_key?(k)
-      end
-    end
-
-    def ensure_mandatory_parameters_exist(params)
-      @mandatory.each do |prm|
-        unless params.has_key?(prm)
-          raise ArgumentError, "parameter ':#{prm}' must be specified"
-        end
-      end
-    end
-
-    def ensure_mutual_exclusion_of_parameters(params)
-      @mutually_exclusive.each do |param1, param2|
-        if params.has_key?(param1) and params.has_key?(param2)
-          raise ArgumentError, "params ':#{param1}' and ':#{param2}' " +
-                               "are mutually exclusive"
+    def ensure_valid_names(names)
+      invalid_names = LazyEvaluator.instance_methods(true) +
+                        Kernel.methods - ["type"]
+      names.each do |name|
+        name = name.to_s
+        if invalid_names.include?(name)
+          raise NameError.new("Rename parameter '#{name}' " +
+                              "as it shadows an existing method.", name)
         end
       end
     end

data/lib/bindata/primitive.rb

@@ -1,5 +1,4 @@
 require 'bindata/base_primitive'
-require 'bindata/registry'
 require 'bindata/struct'
 
 module BinData
@@ -68,11 +67,6 @@ module BinData
         register(subclass.name, subclass)
       end
 
-      def recursive?
-        # A Primitive can possibly self reference itself.
-        true
-      end
-
       def endian(endian = nil)
         @endian ||= nil
         if [:little, :big].include?(endian)
@@ -90,50 +84,45 @@ module BinData
         name = name.to_s
         params ||= {}
 
-        ensure_type_exists(type)
-        ensure_valid_name(name) unless name.nil?
-
         append_field(type, name, params)
       end
 
-      def sanitize_parameters!(sanitizer, params)
+      def sanitize_parameters!(params, sanitizer)
         struct_params = {}
         struct_params[:fields] = fields
         struct_params[:endian] = endian unless endian.nil?
         
         params[:struct_params] = struct_params
-
-        super(sanitizer, params)
       end
 
       #-------------
       private
 
-      def ensure_type_exists(type)
-        unless RegisteredClasses.is_registered?(type, endian)
-          raise TypeError, "unknown type '#{type}' for #{self}", caller(2)
+      def fields
+        unless defined? @fields
+          sanitizer = Sanitizer.new
+          @fields = sanitizer.create_sanitized_fields(endian)
         end
+        @fields
+      end
+
+      def append_field(type, name, params)
+        ensure_valid_name(name)
+
+        fields.add_field(type, name, params)
+      rescue TypeError
+        raise TypeError, "unknown type '#{type}' for #{self}", caller(2)
       end
 
       def ensure_valid_name(name)
-        fields.each do |t, n, p|
-          if n == name
-            raise SyntaxError, "duplicate field '#{name}' in #{self}", caller(4)
-          end
+        if fields.field_names.include?(name)
+          raise SyntaxError, "duplicate field '#{name}' in #{self}", caller(3)
         end
         if self.instance_methods.include?(name)
           raise NameError.new("", name),
-                "field '#{name}' shadows an existing method", caller(2)
+                "field '#{name}' shadows an existing method", caller(3)
         end
       end
-
-      def append_field(type, name, params)
-        fields.push([type, name, params])
-      end
-
-      def fields
-        @fields ||= []
-      end
     end
 
     mandatory_parameter :struct_params
@@ -145,11 +134,7 @@ module BinData
     end
 
     def method_missing(symbol, *args, &block)
-      if @struct.respond_to?(symbol)
-        @struct.__send__(symbol, *args, &block)
-      else
-        super
-      end
+      @struct.__send__(symbol, *args, &block)
     end
 
     def debug_name_of(child)
@@ -194,13 +179,4 @@ module BinData
     # To be implemented by subclasses
     ###########################################################################
   end
-
-  class SingleValue < Primitive
-    class << self
-      def inherited(subclass) #:nodoc:
-        warn "BinData::BasePrimitiveValue is deprecated.  Replacing with BinData::Primitive"
-        super
-      end
-    end
-  end
 end

data/lib/bindata/record.rb

@@ -1,4 +1,4 @@
-require 'bindata/registry'
+require 'bindata/sanitize'
 require 'bindata/struct'
 
 module BinData
@@ -51,11 +51,6 @@ module BinData
         register(subclass.name, subclass)
       end
 
-      def recursive?
-        # A Record can self reference itself.
-        true
-      end
-
       def endian(endian = nil)
         @endian ||= nil
         if [:little, :big].include?(endian)
@@ -79,75 +74,49 @@ module BinData
         name = name.to_s
         params ||= {}
 
-        ensure_type_exists(type)
-        ensure_valid_name(name)
-
         append_field(type, name, params)
       end
 
-      def sanitize_parameters!(sanitizer, params)
-        merge_endian!(params)
-        merge_fields!(params)
-        merge_hide!(params)
+      def sanitize_parameters!(params, sanitizer)
+        params[:fields] = fields
+        params[:endian] = endian unless endian.nil?
+        params[:hide]   = hide   unless hide.empty?
 
-        super(sanitizer, params)
+        super(params, sanitizer)
       end
 
       #-------------
       private
 
-      def ensure_type_exists(type)
-        unless RegisteredClasses.is_registered?(type, endian)
-          raise TypeError, "unknown type '#{type}' for #{self}", caller(2)
+      def fields
+        unless defined? @fields
+          sanitizer = Sanitizer.new
+          @fields = sanitizer.create_sanitized_fields(endian)
         end
+        @fields
+      end
+
+      def append_field(type, name, params)
+        ensure_valid_name(name)
+
+        fields.add_field(type, name, params)
+      rescue TypeError
+        raise TypeError, "unknown type '#{type}' for #{self}", caller(2)
       end
 
       def ensure_valid_name(name)
-        @fields ||= []
-        @fields.each do |t, n, p|
-          if n == name
-            raise SyntaxError, "duplicate field '#{name}' in #{self}", caller(4)
-          end
+        if fields.field_names.include?(name)
+          raise SyntaxError, "duplicate field '#{name}' in #{self}", caller(3)
         end
         if self.instance_methods.include?(name)
           raise NameError.new("", name),
-                "field '#{name}' shadows an existing method", caller(2)
+                "field '#{name}' shadows an existing method", caller(3)
         end
         if self::RESERVED.include?(name)
           raise NameError.new("", name),
-                "field '#{name}' is a reserved name", caller(2)
+                "field '#{name}' is a reserved name", caller(3)
         end
       end
-
-      def append_field(type, name, params)
-        @fields ||= []
-        @fields.push([type, name, params])
-      end
-
-      def merge_endian!(params)
-        endian = params[:endian] || self.endian
-        params[:endian] = endian unless endian.nil?
-      end
-
-      def merge_fields!(params)
-        @fields ||= []
-        fields = params[:fields] || @fields || []
-        params[:fields] = fields
-      end
-
-      def merge_hide!(params)
-        hide = params[:hide] || self.hide
-        params[:hide] = hide
-      end
-    end
-  end
-
-  class MultiValue < Record
-    class << self
-      def inherited(subclass) #:nodoc:
-        warn "BinData::MultiValue is deprecated.  Replacing with BinData::Record"
-        super
-      end
     end
   end
 end