doodle 0.0.8 → 0.0.9

data/ChangeLog

@@ -1,5 +1,41 @@
 = ChangeLog for doodle
 
+== 0.0.9 / 2008-04-12
+
+- new features:
+  - added Doodle.context and Doodle.parent (only valid during
+    initialization)
+  - use SaveBlock to distinguish between Proc and block args to :init
+  - :collect now creates array by default if no :init specified (thanks to
+    James Adam :)
+  - attributes defined with collect now have :init => [] if no :init
+    specified
+  - :collect can now initialize from Enumerables by default
+  - raise UnknownAttributeError if initialize called with unspecified attribute key
+- new examples:
+  - mail example (with gmail smtp support)
+  - Doodle.parent
+  - datatypes
+- new specs for singletons, Doodle.context and Doodle.parent, factory
+- updated docs
+- removed unused code and tidied up
+- bug fixes:
+  - fixed memory leak and provided custom to_yaml and marshal_dump/load
+  - fixed regex for factory methods
+  - fixed bug where validate! was creating instance variables with defaults
+  - fixed errors collection
+  - fixed yaml test for JRuby
+  - don't define factory method if one by same name already defined
+
+== 0.0.8 / 2008-03-25
+
+- renamed rake task upload_gem to publish_gem
+- bumped version and updated todo list
+- don't define factory method if one by same name already defined
+- apply validation! to raw instance variables - also, raise Doodle::ValidationError rather than ArgumentError if missing required values
+- tweaked bugs_spec
+- added spec to cover applying conversions to yaml loaded data
+
 == 0.0.7 / 2008-03-22
 
 - return self from validate! (so you can use idiom foo = YAML::load(yaml).validate!)

data/examples/event-location.rb

@@ -1,3 +1,4 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'rubygems'
 require 'date'
 require 'doodle'
@@ -25,11 +26,15 @@ class Event
       Date.parse(s)
     end
   end
-  has :locations, :init => [], :collect => {:place => "Location"}
+  has :locations, :init => [], :collect => {:place => "Location"} do
+    from Array do |array|
+      array.map{|x| Location(x)}
+    end
+  end
 end  
 
 event = Event "Festival" do
-  date '2008-04-01'
+  date '2018-04-01'
   place "The muddy field"
   place "Beer tent" do
     event "Drinking"
@@ -46,7 +51,46 @@ str =<<EOS
 name: Glastonbury
 date: 2000-07-01
 EOS
-event = YAML::load(str).validate! # will raise Doodle::ValidationError
+
+def capture(&block)
+  begin
+    block.call
+  rescue Exception => e
+    e
+  end
+end
+
+res = capture {
+  event = YAML::load(str).validate! # will raise Doodle::ValidationError
+}
+pp res
+
+hash_data = {
+  :name => "Festival",
+  :date => '2010-04-01',
+  :locations =>
+  [
+   {
+     :events => [],
+     :name => "The muddy field",
+   },
+   {
+     :name => "Beer tent",
+     :events =>
+     [
+      {
+        :name => "Drinking",
+        :locations => [],
+      }
+     ]
+   }
+  ]
+}
+
+pp hash_data
+
+e = Event(hash_data)
+pp e
 
 __END__
 --- !ruby/object:Event 

data/examples/event.rb

@@ -1,30 +1,39 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
 require 'date'
+require 'pp'
 require 'doodle'
 
-class Event < Doodle::Base
-  has :start_date, :kind => Date do
-    from String do |value|
-      Date.parse(value)
+class Location < Doodle::Base
+  has :name, :kind => String
+  has :events, :init => [], :collect => :Event
+end
+
+class Event
+  # or if you want to inherit from another class
+  include Doodle::Helper
+  include Doodle::Factory
+
+  has :name, :kind => String
+  has :date do
+    kind Date
+    default { Date.today }
+    must 'be >= today' do |value|
+      value >= Date.today
     end
-  end
-  has :end_date, :kind => Date  do
-    from String do |value|
-      Date.parse(value)
+    from String do |s|
+      Date.parse(s)
     end
   end
-  from String do |value|
-    args = value.split(' to ')
-    new(*args)
-  end
+  has :locations, :init => [], :collect => {:place => "Location"}
 end
-event = Event.from '2008-03-05 to 2008-03-06'
-event.start_date.to_s   # => "2008-03-05"
-event.end_date.to_s     # => "2008-03-06"
-event.start_date = '2001-01-01'
-event.start_date        # =>
-event.start_date.to_s   # =>
 
-class Date
-  include Doodle::Factory
+event = Event "Festival" do
+  date '2008-04-01'
+  place "The muddy field"
+  place "Beer tent" do
+    event "Drinking"
+  end
 end
-date = Date(2008, 03, 01) # =>
+
+pp event

data/examples/example-01.rb

@@ -1,3 +1,4 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'date'
 require 'doodle'
 

data/examples/example-01.rdoc

@@ -1,3 +1,4 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'date'
 require 'doodle'
 
@@ -11,6 +12,6 @@ class DateRange < Doodle::Base
 end
 
 dr = DateRange.new
-dr.start_date                   # => #<Date: 4909053/2,0,2299161>
-dr.end_date                     # => #<Date: 4909053/2,0,2299161>
+dr.start_date                   # => #<Date: 4909137/2,0,2299161>
+dr.end_date                     # => #<Date: 4909137/2,0,2299161>
 

data/examples/example-02.rb

@@ -1,3 +1,4 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'date'
 require 'doodle'
 

data/examples/example-02.rdoc

@@ -1,3 +1,4 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'date'
 require 'doodle'
 
@@ -59,4 +60,4 @@ dr.end_date                     # => #<Date: 4908931/2,0,2299161>
 dr = DateRange '2008-01-01', '2007-12-31' 
 dr.start_date                   # => 
 dr.end_date                     # => 
-# ~> -:59: #<DateRange:0x747fc @start_date=#<Date: 4908933/2,0,2299161>, @end_date=#<Date: 4908931/2,0,2299161>> must have end_date >= start_date (Doodle::ValidationError)
+# ~> -:60: #<DateRange:0xb7a52640 @end_date=#<Date: 4908931/2,0,2299161>, @start_date=#<Date: 4908933/2,0,2299161>> must have end_date >= start_date (Doodle::ValidationError)

data/examples/example-03.rb

@@ -0,0 +1,45 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'doodle'
+
+# collect works for anything that provides a :<< method
+
+class Text < Doodle::Base
+  has :text, :init => "", :collect => :part
+end
+
+text = Text do
+  part "Hello"
+  part " "
+  part "World"
+end
+
+puts text.text
+
+class Lines < Doodle::Base
+  has :lines, :init => [], :collect => :line
+end
+
+lines = Lines do
+  line "Hello"
+  line "World"
+end
+
+puts lines.lines.join("\n")
+
+require 'set'
+
+class Thing < Doodle::Base
+  has :properties, :init => Set.new, :collect => :prop
+end
+
+# this is a contrived example
+thing = Thing do
+  prop 'name'
+  prop 'size'
+  prop 'size'
+  prop 'name'
+end
+
+thing.prop 'name'
+p thing
+

data/examples/example-03.rdoc

@@ -0,0 +1,55 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'doodle'
+
+# collect works for anything that provides a :<< method
+
+class Text < Doodle::Base
+  has :text, :init => "", :collect => :part
+end
+
+text = Text do
+  part "Hello"
+  part " "
+  part "World"
+end
+
+puts text.text
+
+class Lines < Doodle::Base
+  has :lines, :init => [], :collect => :line
+end
+
+lines = Lines do
+  line "Hello"
+  line "World"
+end
+
+puts lines.lines.join("\n")
+
+require 'set'
+
+class Thing < Doodle::Base
+  has :properties, :init => Set.new, :collect => :prop
+end
+
+# this is a contrived example
+thing = Thing do
+  prop 'name'
+  prop 'size'
+  prop 'size'
+  prop 'name'
+end
+
+thing.prop 'name'
+p thing
+
+# >> [:collector_klass, nil]
+# >> [:collector_klass, nil]
+# >> [:collector_klass, nil]
+# >> [:collector_klass, nil]
+# >> Hello World
+# >> [:collector_klass, nil]
+# >> Hello
+# >> World
+# >> [:collector_klass, nil]
+# >> #<Thing:0xb7b6a6b8 @properties=#<Set: {"name", "size"}>>

data/lib/doodle.rb

@@ -2,6 +2,8 @@
 # Copyright (C) 2007 by Sean O'Halpin, 2007-11-24
 
 require 'molic_orderedhash'  # todo[replace this with own (required functions only) version]
+require 'pp'
+#require 'bleak_house' if ENV['BLEAK_HOUSE']
 
 # *doodle* is my attempt at an eco-friendly metaprogramming framework that does not
 # have pollute core Ruby objects such as Object, Class and Module.
@@ -12,7 +14,33 @@ require 'molic_orderedhash'  # todo[replace this with own (required functions on
 
 # Docs at http://doodle.rubyforge.org
 
+# patch 1.8.5 to add instance_variable_defined?
+# note: this does not seem to work so well with singletons
+if RUBY_VERSION < '1.8.6'
+  if !Object.method_defined?(:instance_variable_defined?)
+    class Object
+      __doodle__inspect = instance_method(:inspect)
+      define_method :instance_variable_defined? do |name|
+        res = __doodle__inspect.bind(self).call
+        rx = /\B#{name}=/
+        rx =~ res ? true : false
+      end
+    end
+  end
+end
+
 module Doodle
+  VERSION = '0.0.9'
+  # where are we?
+  class << self
+    def context
+      Thread.current[:doodle_context] ||= []
+    end
+    def parent
+      context[-2]
+    end
+  end
+
   module Debug
     class << self
       # output result of block if ENV['DEBUG_DOODLE'] set
@@ -34,12 +62,24 @@ module Doodle
     end
   end
 
+  # error handling
+  @@raise_exception_on_error = true
+  def self.raise_exception_on_error
+    @@raise_exception_on_error
+  end
+  def self.raise_exception_on_error=(tf)
+    @@raise_exception_on_error = tf
+  end
+  
   # internal error raised when a default was expected but not found
   class NoDefaultError < Exception
   end
   # raised when a validation rule returns false
   class ValidationError < Exception
   end
+  # raised when a validation rule returns false
+  class UnknownAttributeError < Exception
+  end
   # raised when a conversion fails
   class ConversionError < Exception
   end
@@ -59,39 +99,12 @@ module Doodle
       sc
     end
 
-    # return self if a Module, else the singleton class
-    def self_class
-      self.kind_of?(Module) ? self : singleton_class
-    end
-    
-    # frankly a hack to allow init options to work for singleton classes
-    def class_init(params = {}, &block)
-      sc = singleton_class(&block)
-      sc.attributes.select{|n, a| a.init_defined? }.each do |n, a|
-        send(n, a.init)
-      end
-      sc
-    end
   end
 
   # provide an alternative inheritance chain that works for singleton
   # classes as well as modules, classes and instances
   module Inherited
 
-    # def supers
-    #   supers = []
-    #   s = superclass rescue nil
-    #   while !s.nil?
-    #     supers << s
-    #     last_s = s.superclass rescue nil
-    #     if last_s == s
-    #       last_s = nil
-    #     end
-    #     s = last_s
-    #   end
-    #   supers
-    # end
-    
     # parents returns the set of parent classes of an object.
     # note[this is horribly complicated and kludgy - is there a better way?
     # could do with refactoring]
@@ -102,13 +115,7 @@ module Doodle
       klasses = []
       if defined?(superclass)
         klass = superclass
-        #p [:klass_superclass, klass]
-        if self == superclass
-          # d { [:parents, 'self == superclass'] }
-          klass = nil
-        else
-          #p [:klass_singleton_class, klass]
-          #p [:parents, 'klass = superclass', self, klass, self.ancestors]
+        if self != superclass
           #
           # fixme[any other way to do this? seems really clunky to have to hack strings]
           #
@@ -118,38 +125,21 @@ module Doodle
             if cap = self.to_s.match(regex)
               if cap.captures.size > 0
                 k = const_get(cap[1])
+                # push onto front of array
                 if k.respond_to?(:superclass) && k.superclass.respond_to?(:singleton_class)
                   klasses.unshift k.superclass.singleton_class
                 end
               end
-              #p [:klass_self_klass, klass]
-              #p [:klasses, klasses]
-              loop do
-                if klass.nil?
-                  break
-                end
+              until klass.nil?
                 klasses.unshift klass
-                #p [:loop_klasses, klasses]
                 if klass == klass.superclass
-                  #p [:HERE_HERE_BEFORE, klasses]
-                  #break
                   return klasses # oof
                 end
                 klass = klass.superclass
               end
-              #p [:HERE_HERE, klasses]
             else
-              #p [:klass_self_klass, klass]
-              #p [:klasses, klasses]
-              loop do
-                if klass.nil?
-                  break
-                end
+              until klass.nil?
                 klasses << klass
-                #p [:loop_klasses, klasses]
-                if klass == klass.superclass
-                  break
-                end
                 klass = klass.superclass
               end
             end
@@ -157,21 +147,11 @@ module Doodle
         end
       else
         klass = self.class
-        #p [:klass_self_klass, klass]
-        #p [:klasses, klasses]
-        loop do
-          if klass.nil?
-            break
-          end
+        until klass.nil?
           klasses << klass
-          #p [:loop_klasses, klasses]
-          if klass == klass.superclass
-            break
-          end
           klass = klass.superclass
         end
       end
-      #p [:HERE_HERE_END, klasses]
       klasses
     end
 
@@ -181,7 +161,6 @@ module Doodle
       klasses = parents
       #p [:parents, parents]
       # d { [:collect_inherited, :parents, message, klasses] }
-      #klasses = self_class.ancestors # this produces quite different behaviour
       klasses.each do |klass|
         #p [:testing, klass]
         if klass.respond_to?(message)
@@ -202,7 +181,7 @@ module Doodle
   #
   # this works down to third level <tt>class << self</tt> - in practice, this is
   # perfectly good - it would be great to have a completely general
-  # solution but I'm doubt whether the payoff is worth the time
+  # solution but I'm doubt whether the payoff is worth the effort
 
   module Embrace
     # fake module inheritance chain
@@ -219,8 +198,8 @@ module Doodle
         # ensure that subclasses are also embraced
         define_method :inherited do |klass|
           #p [:embrace, :inherited, klass]
-          klass.send(:embrace, other)
-          klass.send(:include, Factory) # yikes!
+          klass.send(:embrace, other)       # n.b. closure
+          klass.send(:include, Factory)     # is there another way to do this? i.e. not in embrace
           super(klass) if defined?(super)
         end
       }
@@ -228,14 +207,14 @@ module Doodle
     end
   end
 
-  # Lazy is a Proc that caches the result of a call
-  class Lazy < Proc
-    # return the result of +call+ing this Proc - cached after first +call+
-    def value
-      @value ||= call
+  class SaveBlock
+    attr_accessor :block
+    def initialize(arg_block = nil, &block)
+      arg_block = block if block_given?
+      @block = arg_block
     end
   end
-
+  
   # A Validation represents a validation rule applied to the instance
   # after initialization. Generated using the Doodle::BaseMethods#must directive.
   class Validation
@@ -251,22 +230,13 @@ module Doodle
   end
 
   class DoodleInfo
-    DOODLES = {}
-    @@raise_exception_on_error = true
     attr_accessor :local_attributes
     attr_accessor :local_validations
     attr_accessor :local_conversions
     attr_accessor :validation_on
     attr_accessor :arg_order
     attr_accessor :errors
-    
-    def self.raise_exception_on_error
-      @@raise_exception_on_error
-    end
-    def self.raise_exception_on_error=(tf)
-      @@raise_exception_on_error = tf
-    end
-    
+
     def initialize(object)
       @local_attributes = OrderedHash.new
       @local_validations = []
@@ -274,13 +244,6 @@ module Doodle
       @local_conversions = {}
       @arg_order = []
       @errors = []
-
-      oid = object.object_id
-      ObjectSpace.define_finalizer(object) do
-        # this seems to be called only on exit
-        Doodle::Debug.d { "finalizing #{oid}" }
-        DOODLES.delete(oid)
-      end
     end
   end
 
@@ -290,36 +253,53 @@ module Doodle
     include SelfClass
     include Inherited
 
-    # this is the only way to get at internal values
-    # FIXME: this is going to leak memory (I think)
-    
+    # this is the only way to get at internal values. Note: this is
+    # initialized on the fly rather than in #initialize because
+    # classes and singletons don't call #initialize
     def __doodle__
-      DoodleInfo::DOODLES[object_id] ||= DoodleInfo.new(self)
+      @__doodle__ ||= DoodleInfo.new(self)
     end
     private :__doodle__
-    
-    # handle errors either by collecting in :errors or raising an exception
-    def handle_error(name, *args)
-      __doodle__.errors << [name, *args]
-      if DoodleInfo.raise_exception_on_error
-        raise(*args)
+
+    # hack to fool yaml (and anything else that queries instance_variables)
+    # pick a name that no-one else is likely to use
+    alias :seoh_doodle_instance_variables_8b016735_bd60_44d9_bda5_5f9d0aade5a6 :instance_variables
+    # redefine instance_variables to ignore our private @__doodle__ variable
+    def instance_variables
+      seoh_doodle_instance_variables_8b016735_bd60_44d9_bda5_5f9d0aade5a6.reject{ |x| x == '@__doodle__'}
+    end
+
+    def marshal_dump
+      instance_variables.map{|x| [x, instance_variable_get(x)] }
+    end
+    def marshal_load(data)
+      data.each do |name, value|
+        instance_variable_set(name, value)
       end
     end
 
-    # get list of errors
+    # where should I put this?
     def errors
-      errs = attributes.inject([]) do |e, (n, a)|
-        e.push(*a.send(:__doodle__).errors)
-        e
-      end
-      errs.push(__doodle__.errors).reject{|x| x.size == 0}
+      __doodle__.errors
     end
+  
     def clear_errors
-      attributes.each do |n, a|
-        a.send(:__doodle__).errors.clear
-      end
+      #pp [:clear_errors, self, caller]
       __doodle__.errors.clear
     end
+    
+    # handle errors either by collecting in :errors or raising an exception
+    def handle_error(name, *args)
+      #pp [:caller, self, caller]
+      #pp [:handle_error, name, args]
+      # don't include duplicates (FIXME: hacky - shouldn't have duplicates in the first place)
+      if !self.errors.include?([name, *args])
+        self.errors << [name, *args]
+      end
+      if Doodle.raise_exception_on_error
+        raise(*args)
+      end
+    end
 
     # return attributes defined in instance
     def local_attributes
@@ -413,13 +393,7 @@ module Doodle
       ivar = "@#{name}"
       if instance_variable_defined?(ivar)
         ## d { [:_getter, 2, name, block] }
-        v = instance_variable_get(ivar)
-        #d { [:_getter, :defined, name, v] }
-        #         if v.kind_of?(Lazy)
-        #          p [name, self, self.class, v]
-        #          v = instance_eval &v.block
-        #         end
-        v
+        instance_variable_get(ivar)
       else
         # handle default
         # Note: use :init => value to cover cases where defaults don't work
@@ -427,14 +401,17 @@ module Doodle
         att = lookup_attribute(name)
         #d { [:getter, name, att, block] }
         if att.default_defined?
-          if att.default.kind_of?(Proc)
+          case att.default
+          when SaveBlock
+            instance_eval(&att.default.block)
+          when Proc
             instance_eval(&att.default)
           else
             att.default
           end
         else
           # This is an internal error (i.e. shouldn't happen)
-          handle_error name, NoDefaultError, "Internal error - '#{name}' has no default defined", [caller[-1]]
+          handle_error name, NoDefaultError, "Error - '#{name}' has no default defined", [caller[-1]]
         end
       end
     end
@@ -442,15 +419,18 @@ module Doodle
 
     # set an attribute by name - apply validation if defined
     def _setter(name, *args, &block)
-      # d { [:_setter, self, self.class,  name, args, block] }
+      #pp [:_setter, self, self.class,  name, args, block]
       ivar = "@#{name}"
-      args.unshift(block) if block_given?
+      if block_given?
+        args.unshift(SaveBlock.new(block))
+        #p [:instance_eval_block, self, block]
+      end
       # d { [:_setter, 3, :setting,  name, ivar, args] }
       att = lookup_attribute(name)
       # d { [:_setter, 4, :setting,  name, att] }
       if att
         #d { [:_setter, :instance_variable_set, :ivar, ivar, :args, args, :att_validate, att.validate(*args) ] }
-        v = instance_variable_set(ivar, att.validate(*args))
+        v = instance_variable_set(ivar, att.validate(self, *args))
       else
         #d { [:_setter, :instance_variable_set, ivar, args ] }
         v = instance_variable_set(ivar, *args)
@@ -471,7 +451,7 @@ module Doodle
         end
         # d { [:from, conversions] }
       else
-        convert(*args)
+        convert(self, *args)
       end
     end
 
@@ -493,10 +473,11 @@ module Doodle
     end
 
     # convert a value according to conversion rules
-    def convert(value)
+    def convert(owner, *args)
       begin
+        value = args.first
         if (converter = conversions[value.class])
-          value = converter[value]
+          value = converter[*args]
         else
           # try to find nearest ancestor
           ancestors = value.class.ancestors
@@ -507,24 +488,25 @@ module Doodle
             converter_class = ancestors[indexed_matches.min]
             #p [:converter, converter_class]
             if converter = conversions[converter_class]
-              value = converter[value]
+              value = converter[*args]
             end
           end
         end
       rescue => e
-        handle_error name, ConversionError, e.to_s, [caller[-1]]
+        owner.handle_error name, ConversionError, e.to_s, [caller[-1]]
       end
       value
     end
 
     # validate that args meet rules defined with +must+
-    def validate(*args)
-      value = convert(*args)
+    def validate(owner, *args)
+      Doodle::Debug.d { [:validate, self, :owner, owner, :args, args ] }
+      value = convert(owner, *args)
       #d { [:validate, self, :args, args, :value, value ] }
       validations.each do |v|
-        Doodle::Debug.d { [:validate, self, v, args ] }
+        Doodle::Debug.d { [:validate, self, v, args, value] }
         if !v.block[value]
-          handle_error name, ValidationError, "#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", [caller[-1]]
+          owner.handle_error name, ValidationError, "#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", [caller[-1]]
         end
       end
       #d { [:validate, :value, value ] }
@@ -533,11 +515,21 @@ module Doodle
     
     # define a getter_setter
     def define_getter_setter(name, *args, &block)      
-      # d { [:define_getter_setter, [self, self.class, self_class], name, args, block] }
+      # d { [:define_getter_setter, [self, self.class], name, args, block] }
 
       # need to use string eval because passing block
-      module_eval "def #{name}(*args, &block); getter_setter(:#{name}, *args, &block); end"
-      module_eval "def #{name}=(*args, &block); _setter(:#{name}, *args); end"
+      module_eval "def #{name}(*args, &block); getter_setter(:#{name}, *args, &block); end", __FILE__, __LINE__
+      module_eval "def #{name}=(*args, &block); _setter(:#{name}, *args); end", __FILE__, __LINE__
+
+      # this is how it should be done (in 1.9)      
+#       module_eval {
+#         define_method name do |*args, &block|
+#           getter_setter(name.to_sym, *args, &block)
+#         end
+#         define_method "#{name}=" do |*args, &block|
+#           _setter(name.to_sym, *args, &block)
+#         end
+#       }
     end
     private :define_getter_setter
 
@@ -546,9 +538,9 @@ module Doodle
     def define_collector(collection, name, klass = nil, &block)
       # need to use string eval because passing block
       if klass.nil?
-        module_eval "def #{name}(*args, &block); args.unshift(block) if block_given?; #{collection}.<<(*args); end"
+        module_eval "def #{name}(*args, &block); args.unshift(block) if block_given?; #{collection}.<<(*args); end", __FILE__, __LINE__
       else
-        module_eval "def #{name}(*args, &block); #{collection} << #{klass}.new(*args, &block); end"
+        module_eval "def #{name}(*args, &block); #{collection} << #{klass}.new(*args, &block); end", __FILE__, __LINE__
       end
     end
     private :define_collector
@@ -576,7 +568,7 @@ module Doodle
     #  end
     #    
     def has(*args, &block)
-      Doodle::Debug.d { [:has, self, self.class, self_class, args] }
+      Doodle::Debug.d { [:has, self, self.class, args] }
       name = args.shift.to_sym
       # d { [:has2, name, args] }
       key_values, positional_args = args.partition{ |x| x.kind_of?(Hash)}
@@ -586,24 +578,42 @@ module Doodle
       params = key_values.inject(params){ |acc, item| acc.merge(item)}
 
       # don't pass collector params through to Attribute
+      collector_klass = nil
       if collector = params.delete(:collect)
+        if !params.key?(:init)
+          params[:init] = []
+        end
         if collector.kind_of?(Hash)
-          collector_name, klass = collector.to_a[0]
+          collector_name, collector_klass = collector.to_a[0]
         else
           # if Capitalized word given, treat as classname
           # and create collector for specific class
-          klass = collector.to_s
-          collector_name = Utils.snake_case(klass)
-          if klass !~ /^[A-Z]/
-            klass = nil
+          collector_klass = collector.to_s
+          collector_name = Utils.snake_case(collector_klass)
+          if collector_klass !~ /^[A-Z]/
+            collector_klass = nil
           end
         end
-        define_collector name, collector_name, klass
+        define_collector name, collector_name, collector_klass
       end
       
       # d { [:has_args, :params, params] }
-      local_attributes[name] = attribute = Attribute.new(params, &block)        
+      # define getter setter before setting up attribute
       define_getter_setter name, *args, &block
+      local_attributes[name] = attribute = Attribute.new(params, &block)
+      # if a collector has been defined and has a specific class, then you can pass in an array of hashes
+      if collector_klass
+        attribute.instance_eval {
+          from Enumerable do |enum|
+            if !collector_klass.kind_of?(Class)
+              tmp_klass = self.class.const_get(collector_klass)
+            else
+              tmp_klass = collector_klass
+            end
+            enum.map{|x| tmp_klass.new(x)}
+          end
+        }
+      end
       attribute
     end
 
@@ -647,11 +657,17 @@ module Doodle
           hash[n] = begin
             case a.init
             when NilClass, TrueClass, FalseClass, Fixnum
+              #p [:init, :no_clone]
               a.init
+            when SaveBlock
+              #p [:init, :save_block]
+              instance_eval(&a.init.block)
             else
+              #p [:init, :clone]
               a.init.clone 
             end
-          rescue 
+          rescue Exception => e
+            #p [:init, :rescue, e]
             a.init
           end
           ; hash }
@@ -672,7 +688,8 @@ module Doodle
           if respond_to?(key)
             send(key, key_values[key])
           else
-            _setter(key, key_values[key])
+            # raise error if not defined
+            handle_error key, Doodle::UnknownAttributeError, "Unknown attribute '#{key}' #{key_values[key].inspect}"
           end
         end
       end
@@ -688,6 +705,10 @@ module Doodle
     # validate this object by applying all validations in sequence
     # - if all == true, validate all attributes, e.g. when loaded from YAML, else validate at object level only
     def validate!(all = true)
+      #pp [:validate!, all, caller]
+      if all
+        clear_errors
+      end
       #Doodle::Debug.d { [:validate!, self] }
       #Doodle::Debug.d { [:validate!, self, __doodle__.validation_on] }
       if __doodle__.validation_on
@@ -700,13 +721,14 @@ module Doodle
           end
           # if all == true, reset values so conversions and validations are applied to raw instance variables
           # e.g. when loaded from YAML
-          if all
-            send(att.name, instance_variable_get("@#{att.name}"))
+          att_name = "@#{att.name}"
+          if all && instance_variable_defined?(att_name)
+            send(att.name, instance_variable_get(att_name))
           end
         end
         # now apply instance level validations
         validations.each do |v|
-          #Doodle::Debug.d { [:validate!, self, v ] }
+          Doodle::Debug.d { [:validate!, self, v ] }
           if !instance_eval(&v.block)
             handle_error :validate!, ValidationError, "#{ self.inspect } must #{ v.message }", [caller[-1]]
           end
@@ -735,13 +757,16 @@ module Doodle
     # hash of keyword value pairs and a block which is instance_eval'd
     def initialize(*args, &block)
       __doodle__.validation_on = true
-      
+      #p [:Doodle_context_push, self]
+      Doodle.context.push(self)
       defer_validation do
         # d { [:initialize, self.to_s, args, block] }
         initialize_from_hash(*args)
         # d { [:initialize, self.to_s, args, block, :calling_block] }
         instance_eval(&block) if block_given?
       end
+      Doodle.context.pop
+      #p [:Doodle_context_pop, ]
     end
 
   end
@@ -762,38 +787,40 @@ module Doodle
   #   stimpy = Dog(:name => 'Stimpy')
   # etc.
   module Factory
-    # create a factory function called +name+ for the current class
-    def factory(name = self)
-      name = self.to_s
-      names = name.split(/::/)
-      name = names.pop
-      if names.empty?
-        # top level class - should be available to all
-        mklass = klass = Object
-        #p [:names_empty, klass, mklass]
-        eval src = "def #{ name }(*args, &block); ::#{name}.new(*args, &block); end", ::TOPLEVEL_BINDING
-      else
-        klass = names.inject(self) {|c, n| c.const_get(n)}
-        mklass = class << klass; self; end
-        #p [:names, klass, mklass]
-        #eval src = "def #{ names.join('::') }::#{name}(*args, &block); #{ names.join('::') }::#{name}.new(*args, &block); end"
-        # TODO: check how many times this is being called
-        if !klass.respond_to?(name)
-          klass.class_eval(src = "def self.#{name}(*args, &block); #{name}.new(*args, &block); end")
+    RX_IDENTIFIER = /^[A-Za-z_][A-Za-z_0-9]+\??$/
+    class << self   
+      # create a factory function in appropriate module for the specified class
+      def factory(konst)
+        #p [:factory, name]
+        name = konst.to_s
+        names = name.split(/::/)
+        name = names.pop
+        if names.empty?
+          # top level class - should be available to all
+          klass = Object
+          #p [:names_empty, klass, mklass]
+          if !klass.respond_to?(name) && name =~ Factory::RX_IDENTIFIER
+            eval("def #{ name }(*args, &block); ::#{name}.new(*args, &block); end", ::TOPLEVEL_BINDING, __FILE__, __LINE__)
+          end
+        else
+          klass = names.inject(self) {|c, n| c.const_get(n)}
+          mklass = class << klass; self; end
+          #p [:names, klass, mklass]
+          # TODO: check how many times this is being called
+          if !klass.respond_to?(name) && name =~ Factory::RX_IDENTIFIER
+            klass.class_eval("def self.#{name}(*args, &block); #{name}.new(*args, &block); end", __FILE__, __LINE__)
+          end
         end
+        #p [:factory, mklass, klass, src]
+      end
+
+      # inherit the factory function capability
+      def included(other)
+        #p [:factory, :included, self, other ]
+        super
+        # make +factory+ method available
+        factory other
       end
-      #p [:factory, mklass, klass, src]
-    end
-    # inherit the factory function capability
-    def self.included(other)
-      #p [:factory, :included, self, other ]
-      super
-      #raise Exception, "#{self} can only be included in a Class" if !other.kind_of? Class
-      # make +factory+ method available
-      other.extend self
-      other.module_eval {
-        factory
-      }
     end
   end
 
@@ -807,6 +834,7 @@ module Doodle
       other.module_eval {
         extend Embrace
         embrace BaseMethods
+        include Factory
       }
     end
   end
@@ -834,13 +862,13 @@ module Doodle
 
     # is this attribute optional? true if it has a default defined for it
     def optional?
-      !self.required?
+      default_defined? or init_defined?
     end
 
     # an attribute is required if it has no default or initial value defined for it
     def required?
       # d { [:default?, self.class, self.name, instance_variable_defined?("@default"), @default] }
-      !(default_defined? or init_defined?)
+      !optional?
     end
 
     # has default been defined?
@@ -853,12 +881,18 @@ module Doodle
     end
 
     # name of attribute
-    has :name
+    has :name, :kind => Symbol do
+      from String do |s|
+        s.to_sym
+      end
+    end
     # default value (can be a block)
-    has :default
+    has :default, :default => nil
     # initial value
-    has :init
+    has :init, :default => nil
+
   end
+
 end
 
 ############################################################