doodle 0.1.7 → 0.1.8

data/History.txt

@@ -1,3 +1,41 @@
+== 0.1.8 / 2008-05-13
+- Features:
+  - now applies instance level conversions (class level #from) to
+    attribute values, e.g.
+
+      class Name < String
+        include Doodle::Core
+        from String do |s|
+          Name.new(s)
+        end
+      end
+
+      class Person < Doodle
+        has Name
+      end
+
+      person = Person 'Arthur'
+      person.name.class         # => Name
+
+  - better error reporting
+  - kind can now take an array of classes or modules to match against,
+  - e.g.
+
+      has :name, :kind => [String, Symbol]
+
+    - kind with no args now returns an array of kinds (possibly empty)
+
+- Bug fixes:
+  - #has with class param was not enforcing :kind constraint
+  - moved more methods into DoodleInfo. You should now access metadata
+    via:
+    - obj.doodle.attributes
+    - obj.doodle.conversions
+    - obj.doodle.validations
+    - obj.doodle.parent
+    - obj.doodle.class_attributes
+  - collectors initializing too late when defined at class level
+
 == 0.1.7 / 2008-05-10
 - Features
   - #has now accepts class constant in name position and generates name

data/lib/doodle.rb

@@ -62,6 +62,18 @@ class Doodle
       def const_resolve(constant)
         constant.to_s.split(/::/).reject{|x| x.empty?}.inject(Object) { |prev, this| prev.const_get(this) }
       end
+      # convert keys to symbols - updates target hash
+      def symbolize_keys!(hash)
+        hash.keys.each do |key|
+          sym_key = key.respond_to?(:to_sym) ? key.to_sym : key
+          hash[sym_key] = hash.delete(key)
+        end
+        hash
+      end
+      # convert keys to symbols
+      def symbolize_keys(hash)
+        symbolize_keys(hash.dup)
+      end
     end
   end
   
@@ -91,12 +103,12 @@ class Doodle
   end
 
   # provides more direct access to the singleton class and a way to
-  # treat Modules and Classes equally in a meta context
+  # treat singletons, Modules and Classes equally in a meta context
   module SelfClass
     # return the 'singleton class' of an object, optionally executing
     # a block argument in the (module/class) context of that object
     def singleton_class(&block)
-      sc = (class << self; self; end)
+      sc = class << self; self; end
       sc.module_eval(&block) if block_given?
       sc
     end
@@ -224,8 +236,8 @@ class Doodle
     def collect_inherited(message)
       result = []
       parents.each do |klass|
-        if klass.respond_to?(message)
-          result.unshift(*klass.__send__(message))
+        if klass.respond_to?(:doodle) && klass.doodle.respond_to?(message)
+          result.unshift(*klass.doodle.__send__(message))
         else
           break
         end
@@ -237,33 +249,34 @@ class Doodle
       if tf
         collect_inherited(method).inject(OrderedHash.new){ |hash, item|
           hash.merge(OrderedHash[*item])
-        }.merge(@this.__send__(method))
+        }.merge(@this.doodle.__send__(method))
       else
-        @this.__send__(method)
+        @this.doodle.__send__(method)
       end
     end
-
+    
     # returns array of Attributes
     # - if tf == true, returns all inherited attributes
     # - if tf == false, returns only those attributes defined in the current object/class
     def attributes(tf = true)
-      results = handle_inherited_hash(tf, :doodle_local_attributes)
+      results = handle_inherited_hash(tf, :local_attributes)
       # if an instance, include the singleton_class attributes
       if !@this.kind_of?(Class) && @this.singleton_class.doodle.respond_to?(:attributes)
-        results = results.merge(@this.singleton_class.doodle_attributes)
+        results = results.merge(@this.singleton_class.doodle.attributes)
       end
       results
     end
 
+    # return class level attributes
     def class_attributes
       attrs = OrderedHash.new
       if @this.kind_of?(Class)
         attrs = collect_inherited(:class_attributes).inject(OrderedHash.new){ |hash, item|
           hash.merge(OrderedHash[*item])
-        }.merge(@this.singleton_class.respond_to?(:doodle_attributes) ? @this.singleton_class.doodle_attributes : { })
+        }.merge(@this.singleton_class.doodle.respond_to?(:attributes) ? @this.singleton_class.doodle.attributes : { })
         attrs
       else
-        @this.class.class_attributes
+        @this.class.doodle.class_attributes
       end
     end
 
@@ -275,7 +288,7 @@ class Doodle
         # by name and kind respectively, so only the most recent
         # applies
         
-        local_validations + collect_inherited(:doodle_local_validations)
+        local_validations + collect_inherited(:local_validations)
       else
         local_validations
       end
@@ -295,7 +308,108 @@ class Doodle
     # - if tf == true, returns all inherited conversions
     # - if tf == false, returns only those conversions defined in the current object/class
     def conversions(tf = true)
-      handle_inherited_hash(tf, :doodle_local_conversions)
+      handle_inherited_hash(tf, :local_conversions)
+    end
+
+    # fixme: move
+    def initial_values(tf = true)
+      attributes(tf).select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)|
+        #p [:initial_values, a.name]
+        hash[n] = case a.init
+                  when NilClass, TrueClass, FalseClass, Fixnum, Float, Bignum
+                    # uncloneable values
+                    #p [:initial_values, :special, a.name, a.init]
+                    a.init
+                  when DeferredBlock
+                    #p [:initial_values, self, DeferredBlock, a.name]
+                    begin
+                      @this.instance_eval(&a.init.block)
+                    rescue Object => e
+                      #p [:exception_in_deferred_block, e]
+                      raise
+                    end
+                  else
+                    #p [:initial_values, :clone, a.name]
+                    begin
+                      a.init.clone
+                    rescue Exception => e
+                      warn "tried to clone #{a.init.class} in :init option"
+                      #p [:initial_values, :exception, a.name, e]
+                      a.init
+                    end
+                  end
+        hash
+      }
+    end
+    
+    # turn off validation, execute block, then set validation to same
+    # state as it was before +defer_validation+ was called - can be nested
+    # fixme: move
+    def defer_validation(&block)
+      old_validation = self.validation_on
+      self.validation_on = false
+      v = nil
+      begin
+        v = @this.instance_eval(&block)
+      ensure
+        self.validation_on = old_validation
+      end
+      @this.validate!(false)
+      v
+    end
+
+    # helper function to initialize from hash - this is safe to use
+    # after initialization (validate! is called if this method is
+    # called after initialization) 
+    def initialize_from_hash(*args)
+      #!p [:doodle_initialize_from_hash, :args, *args]
+      defer_validation do
+        # hash initializer
+        # separate into array of hashes of form [{:k1 => v1}, {:k2 => v2}] and positional args 
+        key_values, args = args.partition{ |x| x.kind_of?(Hash)}
+        #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :key_values, key_values, :args, args] }
+        #!p [self.class, :doodle_initialize_from_hash, :key_values, key_values, :args, args]
+
+        # set up initial values with ~clones~ of specified values (so not shared between instances)
+        #init_values = initial_values
+        #!p [:init_values, init_values]
+        
+        # match up positional args with attribute names (from arg_order) using idiom to create hash from array of assocs
+        #arg_keywords = init_values.merge(Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))])
+        arg_keywords = Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))]
+        #!p [self.class, :doodle_initialize_from_hash, :arg_keywords, arg_keywords]
+
+        # merge all hash args into one
+        key_values = key_values.inject(arg_keywords) { |hash, item|
+          #!p [self.class, :doodle_initialize_from_hash, :merge, hash, item]
+          hash.merge(item)
+        }
+        #!p [self.class, :doodle_initialize_from_hash, :key_values2, key_values]
+
+        # convert keys to symbols (note not recursively - only first level == doodle keywords)
+        Doodle::Utils.symbolize_keys!(key_values)
+        #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :key_values2, key_values, :args2, args] }
+        #!p [self.class, :doodle_initialize_from_hash, :key_values3, key_values]
+        
+        # create attributes
+        key_values.keys.each do |key|
+          #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :setting, key, key_values[key]] }
+          #p [self.class, :doodle_initialize_from_hash, :setting, key, key_values[key]]
+          if respond_to?(key)
+            __send__(key, key_values[key])
+          else
+            # raise error if not defined
+            __doodle__.handle_error key, Doodle::UnknownAttributeError, "unknown attribute '#{key}' #{key_values[key].inspect}", (caller)
+          end
+        end
+        # do init_values after user supplied values so init blocks can depend on user supplied values
+        #p [:getting_init_values, instance_variables]
+        __doodle__.initial_values.each do |key, value|
+          if !key_values.key?(key) && respond_to?(key)
+            __send__(key, value)
+          end
+        end
+      end
     end
     
   end
@@ -382,62 +496,6 @@ class Doodle
       end
     end
 
-    # deprecated methods
-    def doodle_collect_inherited(message)
-      __doodle__.collect_inherited(message)
-    end
-    def doodle_parents
-      __doodle__.parents
-    end
-    
-    # return attributes defined in instance
-    def doodle_local_attributes
-      __doodle__.local_attributes
-    end
-    protected :doodle_local_attributes
-
-    # returns array of Attributes
-    # - if tf == true, returns all inherited attributes
-    # - if tf == false, returns only those attributes defined in the current object/class
-    def doodle_attributes(tf = true)
-      __doodle__.attributes(tf)
-    end
-
-    # return attributes for class
-    def class_attributes
-      __doodle__.class_attributes
-    end
-
-    # the set of conversions defined in the current class (i.e. without inheritance)
-    # deprecated
-    def doodle_local_conversions
-      __doodle__.local_conversions
-    end
-    protected :doodle_local_conversions
-
-    # returns hash of conversions
-    # - if tf == true, returns all inherited conversions
-    # - if tf == false, returns only those conversions defined in the current object/class
-    # deprecated
-    def doodle_conversions(tf = true)
-      __doodle__.conversions(tf)
-    end
-
-    # the set of validations defined in the current class (i.e. without inheritance)
-    # deprecated
-    def doodle_local_validations
-      __doodle__.local_validations
-    end
-    protected :doodle_local_validations
-
-    # returns array of Validations
-    # - if tf == true, returns all inherited validations
-    # - if tf == false, returns only those validations defined in the current object/class
-    # deprecated
-    def doodle_validations(tf = true)
-      __doodle__.validations(tf)
-    end
-
     # either get an attribute value (if no args given) or set it
     # (using args and/or block)
     # fixme: move
@@ -485,7 +543,7 @@ class Doodle
           v
         else
           # This is an internal error (i.e. shouldn't happen)
-          __doodle__.handle_error name, NoDefaultError, "'#{name}' has no default defined", [caller[-1]]
+          __doodle__.handle_error name, NoDefaultError, "'#{name}' has no default defined", (caller)
         end
       end
     end
@@ -519,6 +577,7 @@ class Doodle
     # if block passed, define a conversion from class
     # if no args, apply conversion to arguments
     def from(*args, &block)
+      #p [:from, self, args]
       if block_given?
         # set the rule for each arg given
         args.each do |arg|
@@ -541,10 +600,16 @@ class Doodle
 
     # add a validation that attribute must be of class <= kind
     def kind(*args, &block)
+      @kind ||= []
       if args.size > 0
+        @kind = [args].flatten
         # todo[figure out how to handle kind being specified twice?]
-        @kind = args.first
-        __doodle__.local_validations << (Validation.new("be #{@kind}") { |x| x.class <= @kind })
+        if @kind.size > 2
+          kind_text = "a kind of #{ @kind[0..-2].map{ |x| x.to_s }.join(', ') } or #{@kind[-1].to_s}" # => 
+        else
+          kind_text = "a kind of #{@kind.to_s}"
+        end
+        __doodle__.local_validations << (Validation.new(kind_text) { |x| @kind.any? { |klass| x.kind_of?(klass) } })
       else
         @kind
       end
@@ -553,7 +618,7 @@ class Doodle
     # convert a value according to conversion rules
     # fixme: move
     def convert(owner, *args)
-      #!p [:convert, 1, owner, args]
+      #!p [:convert, 1, owner, args, __doodle__.conversions]
       begin
         args = args.map do |value|
           #!p [:convert, 2, value]
@@ -564,27 +629,46 @@ class Doodle
           else
             #!p [:convert, 5, value]
             # try to find nearest ancestor
-            ancestors = value.class.ancestors
-            #!p [:convert, 6, ancestors]
-            matches = ancestors & __doodle__.conversions.keys
+            this_ancestors = value.class.ancestors
+            #!p [:convert, 6, this_ancestors]
+            matches = this_ancestors & __doodle__.conversions.keys
             #!p [:convert, 7, matches]
-            indexed_matches = matches.map{ |x| ancestors.index(x)}
+            indexed_matches = matches.map{ |x| this_ancestors.index(x)}
             #!p [:convert, 8, indexed_matches]
             if indexed_matches.size > 0
               #!p [:convert, 9]
-              converter_class = ancestors[indexed_matches.min]
+              converter_class = this_ancestors[indexed_matches.min]
               #!p [:convert, 10, converter_class]
               if converter = __doodle__.conversions[converter_class]
                 #!p [:convert, 11, converter]
                 value = converter[*args]
                 #!p [:convert, 12, value]
               end
+            else
+              #!p [:convert, 13, :kind, kind, name, value] 
+              mappable_kinds = kind.select{ |x| x <= Doodle::Core }
+              #!p [:convert, 13.1, :kind, kind, mappable_kinds] 
+              if mappable_kinds.size > 0
+                mappable_kinds.each do |mappable_kind|
+                  #!p [:convert, 14, :kind_is_a_doodle, value.class, mappable_kind, mappable_kind.doodle.conversions, args] 
+                  if converter = mappable_kind.doodle.conversions[value.class]
+                    #!p [:convert, 15, value, mappable_kind, args] 
+                    value = converter[*args]
+                    break
+                  else
+                    #!p [:convert, 16, :no_conversion_for, value.class] 
+                  end
+                end
+              else
+                #!p [:convert, 17, :kind_has_no_conversions]
+              end
             end
           end
+          #!p [:convert, 18, value]
           value
         end
       rescue Exception => e
-        owner.__doodle__.handle_error name, ConversionError, "#{owner.kind_of?(Class) ? owner : owner.class} - #{e.to_s}", [caller[-1]]
+        owner.__doodle__.handle_error name, ConversionError, "#{e.message}", (caller)
       end
       if args.size > 1
         args
@@ -597,15 +681,20 @@ class Doodle
     # fixme: move
     def validate(owner, *args)
       ##DBG: Doodle::Debug.d { [:validate, self, :owner, owner, :args, args ] }
-      #!p [:validate, :before_conversion, args]
-      value = convert(owner, *args)
-      #!p [:validate, :after_conversion, args, :becomes, value]
+      #!p [:validate, 1, args]
+      begin
+        value = convert(owner, *args)
+      rescue Exception => e
+        owner.__doodle__.handle_error name, ConversionError, "#{owner.kind_of?(Class) ? owner : owner.class}.#{ name } - #{e.message}", (caller)
+      end
+      #!p [:validate, 2, args, :becomes, value]
       __doodle__.validations.each do |v|
         ##DBG: Doodle::Debug.d { [:validate, self, v, args, value] }
         if !v.block[value]
-          owner.__doodle__.handle_error name, ValidationError, "#{owner.kind_of?(Class) ? owner : owner.class}.#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", [caller[-1]]
+          owner.__doodle__.handle_error name, ValidationError, "#{owner.kind_of?(Class) ? owner : owner.class}.#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", (caller)
         end
       end
+      #!p [:validate, 3, value]
       value
     end
 
@@ -670,50 +759,18 @@ class Doodle
         begin
           args = args.uniq
           args.each do |x|
-            __doodle__.handle_error :arg_order, ArgumentError, "#{x} not a Symbol", [caller[-1]] if !(x.class <= Symbol)
-            __doodle__.handle_error :arg_order, NameError, "#{x} not an attribute name", [caller[-1]] if !doodle_attributes.keys.include?(x)
+            __doodle__.handle_error :arg_order, ArgumentError, "#{x} not a Symbol", (caller) if !(x.class <= Symbol)
+            __doodle__.handle_error :arg_order, NameError, "#{x} not an attribute name", (caller) if !doodle.attributes.keys.include?(x)
           end
           __doodle__.arg_order = args
         rescue Exception => e
-          __doodle__.handle_error :arg_order, InvalidOrderError, e.to_s, [caller[-1]]
+          __doodle__.handle_error :arg_order, InvalidOrderError, e.to_s, (caller)
         end
       else
         __doodle__.arg_order + (__doodle__.attributes.keys - __doodle__.arg_order)
       end
     end
 
-    # fixme: move
-    def get_init_values(tf = true)
-      __doodle__.attributes(tf).select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)|
-        #p [:get_init_values, a.name]
-        hash[n] = case a.init
-                  when NilClass, TrueClass, FalseClass, Fixnum, Float, Bignum
-                    # uncloneable values
-                    #p [:get_init_values, :special, a.name, a.init]
-                    a.init
-                  when DeferredBlock
-                    #p [:get_init_values, self, DeferredBlock, a.name]
-                    begin
-                      instance_eval(&a.init.block)
-                    rescue Object => e
-                      #p [:exception_in_deferred_block, e]
-                      raise
-                    end
-                  else
-                    #p [:get_init_values, :clone, a.name]
-                    begin
-                      a.init.clone
-                    rescue Exception => e
-                      warn "tried to clone #{a.init.class} in :init option"
-                      #p [:get_init_values, :exception, a.name, e]
-                      a.init
-                    end
-                  end
-        hash
-      }
-    end
-    private :get_init_values
-
     # return true if instance variable +name+ defined
     # fixme: move
     def ivar_defined?(name)
@@ -734,7 +791,7 @@ class Doodle
           ##DBG: Doodle::Debug.d { [:validate!, "using class_attributes", class_attributes] }
         else
           attribs = __doodle__.attributes
-          ##DBG: Doodle::Debug.d { [:validate!, "using instance_attributes", doodle_attributes] }
+          ##DBG: Doodle::Debug.d { [:validate!, "using instance_attributes", doodle.attributes] }
         end
         attribs.each do |name, att|
           ivar_name = "@#{att.name}"
@@ -750,7 +807,7 @@ class Doodle
             ##DBG: Doodle::Debug.d { [:validate!, :optional, name ]}
             break
           elsif self.class != Class
-            __doodle__.handle_error name, Doodle::ValidationError, "#{self} missing required attribute '#{name}'", [caller[-1]]
+            __doodle__.handle_error name, Doodle::ValidationError, "#{self} missing required attribute '#{name}'", (caller)
           end
         end
         
@@ -761,10 +818,10 @@ class Doodle
           ##DBG: Doodle::Debug.d { [:validate!, self, v ] }
           begin
             if !instance_eval(&v.block)
-              __doodle__.handle_error self, ValidationError, "#{ self.class } must #{ v.message }", [caller[-1]]
+              __doodle__.handle_error self, ValidationError, "#{ self.class } must #{ v.message }", (caller)
             end
           rescue Exception => e
-            __doodle__.handle_error self, ValidationError, e.to_s, [caller[-1]]
+            __doodle__.handle_error self, ValidationError, e.to_s, (caller)
           end
         end
       end
@@ -772,90 +829,6 @@ class Doodle
       self
     end
 
-    # turn off validation, execute block, then set validation to same
-    # state as it was before +defer_validation+ was called - can be nested
-    # fixme: move
-    def defer_validation(&block)
-      old_validation = __doodle__.validation_on
-      __doodle__.validation_on = false
-      v = nil
-      begin
-        v = instance_eval(&block)
-      ensure
-        __doodle__.validation_on = old_validation
-      end
-      validate!(false)
-      v
-    end
-
-    # helper function to initialize from hash - this is safe to use
-    # after initialization (validate! is called if this method is
-    # called after initialization)
-    # fixme?
-    def doodle_initialize_from_hash(*args)
-      #!p [:doodle_initialize_from_hash, :args, *args]
-      defer_validation do
-        # hash initializer
-        # separate into array of hashes of form [{:k1 => v1}, {:k2 => v2}] and positional args 
-        key_values, args = args.partition{ |x| x.kind_of?(Hash)}
-        #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :key_values, key_values, :args, args] }
-        #!p [self.class, :doodle_initialize_from_hash, :key_values, key_values, :args, args]
-
-        # set up initial values with ~clones~ of specified values (so not shared between instances)
-        #init_values = get_init_values
-        #!p [:init_values, init_values]
-        
-        # match up positional args with attribute names (from arg_order) using idiom to create hash from array of assocs
-        #arg_keywords = init_values.merge(Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))])
-        arg_keywords = Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))]
-        #!p [self.class, :doodle_initialize_from_hash, :arg_keywords, arg_keywords]
-
-        # merge all hash args into one
-        key_values = key_values.inject(arg_keywords) { |hash, item|
-          #!p [self.class, :doodle_initialize_from_hash, :merge, hash, item]
-          hash.merge(item)
-        }
-        #!p [self.class, :doodle_initialize_from_hash, :key_values2, key_values]
-
-        # convert keys to symbols (note not recursively - only first level == doodle keywords)
-        key_values.keys.each do |k|
-          sym_key = k.respond_to?(:to_sym) ? k.to_sym : k
-          key_values[sym_key] = key_values.delete(k)
-        end
-
-        #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :key_values2, key_values, :args2, args] }
-        #!p [self.class, :doodle_initialize_from_hash, :key_values3, key_values]
-        
-        # create attributes
-        key_values.keys.each do |key|
-          #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :setting, key, key_values[key]] }
-          #p [self.class, :doodle_initialize_from_hash, :setting, key, key_values[key]]
-          if respond_to?(key)
-            __send__(key, key_values[key])
-          else
-            # raise error if not defined
-            __doodle__.handle_error key, Doodle::UnknownAttributeError, "unknown attribute '#{key}' #{key_values[key].inspect}", [caller[-1]]
-          end
-        end
-        # do init_values after user supplied values so init blocks can depend on user supplied values
-        #p [:getting_init_values, instance_variables]
-        init_values = get_init_values
-        init_values.each do |key, value|
-          if !key_values.key?(key) && respond_to?(key)
-            __send__(key, value)
-          end
-        end
-      end
-    end
-    #private :doodle_initialize_from_hash
-
-    # return containing object (set during initialization)
-    # (named doodle_parent to avoid clash with ActiveSupport)
-    # fixme: move
-    def doodle_parent
-      __doodle__.parent
-    end
-
     # object can be initialized from a mixture of positional arguments,
     # hash of keyword value pairs and a block which is instance_eval'd
     def initialize(*args, &block)
@@ -866,8 +839,8 @@ class Doodle
       __doodle__.validation_on = true
       __doodle__.parent = Doodle.context[-1]
       Doodle.context.push(self)
-      defer_validation do
-        doodle_initialize_from_hash(*args)
+      __doodle__.defer_validation do
+        doodle.initialize_from_hash(*args)
         instance_eval(&block) if block_given?
       end
       Doodle.context.pop
@@ -980,11 +953,14 @@ class Doodle
         params = key_values.inject(params){ |acc, item| acc.merge(item)}
         #DBG: Doodle::Debug.d { [:has, self, self.class, params] }
         if !params.key?(:name)
-          __doodle__.handle_error name, ArgumentError, "#{self.class} must have a name", [caller[-1]]
+          __doodle__.handle_error name, ArgumentError, "#{self.class} must have a name", (caller)
+          params[:name] = :__ERROR_missing_name__
         else
-          name = params[:name].to_sym
+          # ensure that :name is a symbol
+          params[:name] = params[:name].to_sym
         end
-        __doodle__.handle_error name, ArgumentError, "#{self.class} has too many arguments", [caller[-1]] if positional_args.size > 0
+        name = params[:name]
+        __doodle__.handle_error name, ArgumentError, "#{self.class} has too many arguments", (caller) if positional_args.size > 0
         
         if collector = params.delete(:collect)
           if !params.key?(:using)
@@ -1014,6 +990,7 @@ class Doodle
           params[:collector_name] = collector_name
         end
         params[:doodle_owner] = owner
+        #p [:params, owner, params]
         params
       end
     end
@@ -1121,11 +1098,13 @@ class Doodle
     def define_collection
       if collector_class.nil?
         doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                   junk = #{name} if !#{name} # force initialization for classes
                    args.unshift(block) if block_given?
                    #{name}.<<(*args);
                  end", __FILE__, __LINE__)
       else
         doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                          junk = #{name} if !#{name} # force initialization for classes
                           if args.size > 0 and args.all?{|x| x.kind_of?(#{collector_class})}
                             #{name}.<<(*args)
                           else
@@ -1155,12 +1134,14 @@ class Doodle
       # need to use string eval because passing block
       if collector_class.nil?
         doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                   junk = #{name} if !#{name} # force initialization for classes
                    args.each do |arg|
                      #{name}[arg.send(:#{key})] = arg
                    end
                  end", __FILE__, __LINE__)
       else
         doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                          junk = #{name} if !#{name} # force initialization for classes
                           if args.size > 0 and args.all?{|x| x.kind_of?(#{collector_class})}
                             args.each do |arg|
                               #{name}[arg.send(:#{key})] = arg
@@ -1173,7 +1154,6 @@ class Doodle
       end
     end
   end
-
 end
 
 ############################################################