doodle 0.0.10 → 0.1.0

data/examples/test-datatypes.rb

@@ -0,0 +1,55 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.join(File.dirname(__FILE__), '.'))
+
+require 'doodle/datatypes'
+require 'doodle/utils'
+
+class DateRange < Doodle
+  doodle do
+    date :start
+    date :end do
+      default { start + 1 }
+    end
+    version :version, :default => "0.0.1"
+  end
+end
+
+#pp DateRange.instance_methods(false)
+
+module UserTypes
+  # include Doodle::DataTypes
+  def printable(name, params = { }, &block)
+    string(name, params, &block).instance_eval do
+      must "not contain non-printing characters" do |s|
+        s !~ /[\x00-\x1F]/
+      end
+    end
+  end
+  def name(name, params = { }, &block)
+    printable(name, { :size => 1..255 }.merge(params), &block)
+  end
+end
+
+class Person < Doodle
+  doodle UserTypes do
+    #    string :name, :max => 10
+    name :name, :size => 3..10
+    integer :age
+    email :email, :default => ''
+  end
+end
+
+pp try { DateRange "2007-01-18", :version => [0,0,9] }
+pp try { Person 'Sean', '45', 'someone@example.com' }
+pp try { Person 'Sean', '45' }
+pp try { Person 'Sean', 'old' }
+pp try { Person 'Sean', 45, 'this is not an email address' }
+pp try { Person 'This name is too long', 45 }
+pp try { Person 'Sean', 45, 42 }
+pp try { Person 'A', 45 }
+pp try { Person '123', 45 }
+pp try { Person '', 45 }
+#   pp try {
+#     person = Person 'Sean', 45
+#     person.name.silly
+#   }

data/examples/yaml-example.rb

@@ -0,0 +1,40 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'doodle'
+require 'doodle/utils'
+require 'yaml'
+
+class Foo < Doodle
+  has :name, :kind => String
+end
+
+# load valid data
+str = %[
+--- !ruby/object:Foo
+name: Stimpy
+]
+bar = nil
+rv = try do
+  bar = YAML::load(str).validate!
+end
+rv # => #<Foo:0xb7b02cc0 @name="Stimpy">
+bar # => #<Foo:0xb7b02cc0 @name="Stimpy">
+
+str = %[
+--- !ruby/object:Foo
+name: 1
+]
+
+# load invalid data
+baz = nil
+rv = try do
+  baz = YAML::load(str).validate!
+end
+rv # => #<Doodle::ValidationError: name must be String - got Fixnum(1)>
+baz # => nil
+
+# load from hash
+str = %[
+name: Qux
+]
+
+qux = Foo(YAML::load(str)) # => #<Foo:0xb7aff520 @name="Qux">

data/examples/yaml-example2.rb

@@ -0,0 +1,42 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.join(File.dirname(__FILE__), '.'))
+
+require 'rubygems'
+require 'yaml'
+require 'doodle'
+require 'pp'
+
+class AddressLine < Doodle
+  has :text, :kind => String
+end
+
+class Person < Doodle
+  has :name, :kind => String
+  has :address, :collect => { :line => AddressLine }
+end
+
+yaml = %[
+---
+:address: 
+- Henry Wood House
+- London
+:name: Sean
+]
+
+person = Person(YAML.load(yaml))
+pp person
+yaml = person.to_yaml
+puts yaml
+
+yaml = %[
+--- !ruby/object:Person 
+address: 
+- !ruby/object:AddressLine 
+  text: Henry Wood House
+- !ruby/object:AddressLine 
+  text: London
+name: Sean
+]
+person = YAML.load(yaml).validate!
+pp person
+

data/lib/doodle.rb

@@ -1,46 +1,37 @@
 # doodle
-# Copyright (C) 2007 by Sean O'Halpin, 2007-11-24
+# Copyright (C) 2007-2008 by Sean O'Halpin
+# 2007-11-24 first version
+# 2008-04-18 latest release 0.0.12
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'molic_orderedhash'  # todo[replace this with own (required functions only) version]
-require 'pp'
 #require 'bleak_house' if ENV['BLEAK_HOUSE']
 
+# require Ruby 1.8.6 or higher
+if RUBY_VERSION < '1.8.6'
+  raise Exception, "Sorry - doodle does not work with versions of Ruby below 1.8.6"
+end
+
 # *doodle* is my attempt at an eco-friendly metaprogramming framework that does not
 # have pollute core Ruby objects such as Object, Class and Module.
-
+#
 # While doodle itself is useful for defining classes, my main goal is to
 # come up with a useful DSL notation for class definitions which can be
 # reused in many contexts.
-
+#
 # 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.10'
-  # where are we?
+#
+class Doodle
   class << self
+    # provide somewhere to hold thread-specific context information
+    # (I'm claiming the :doodle_xxx namespace)
     def context
       Thread.current[:doodle_context] ||= []
     end
-    def parent
-      context[-2]
-    end
   end
 
+  # debugging utilities
   module Debug
     class << self
       # output result of block if ENV['DEBUG_DOODLE'] set
@@ -50,15 +41,40 @@ module Doodle
     end
   end
 
-  # Set of utility functions to avoid changing base classes
-  module Utils    
-    # Unnest arrays by one level of nesting, e.g. [1, [[2], 3]] => [1, [2], 3].
-    def self.flatten_first_level(enum)
-      enum.inject([]) {|arr, i| if i.kind_of? Array then arr.push(*i) else arr.push(i) end }
-    end
-    # from facets/string/case.rb, line 80
-    def self.snake_case(camel_cased_word)
-      camel_cased_word.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+  # Place to hold ref to built-in classes that need special handling
+  module BuiltIns
+    BUILTINS = [String, Hash, Array]
+  end
+
+  # Set of utility functions to avoid monkeypatching base classes
+  module Utils
+    class << self
+      # Unnest arrays by one level of nesting, e.g. [1, [[2], 3]] => [1, [2], 3].
+      def flatten_first_level(enum)
+        enum.inject([]) {|arr, i| if i.kind_of? Array then arr.push(*i) else arr.push(i) end }
+      end
+      # from facets/string/case.rb, line 80
+      def snake_case(camel_cased_word)
+        camel_cased_word.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+      end
+      # what kind of object are we dealing with?
+      def doodle_category(obj)
+        # note[this uses regex match on object's inspect string - kludgy
+        # - is there a better way?]
+        return :nil if obj.class == NilClass
+        case obj.real_inspect
+        when /#<Class:#<.*0x[a-z0-9]+>+$/
+          :instance_singleton_class
+        when /#<Class:[A-Z]/
+            :class_singleton_class
+        else
+          if obj.kind_of?(Module)
+            :class
+          else
+            :instance
+          end
+        end
+      end
     end
   end
 
@@ -70,14 +86,14 @@ module Doodle
   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
+  # raised when an unknown parameter is passed to initialize
   class UnknownAttributeError < Exception
   end
   # raised when a conversion fails
@@ -90,7 +106,6 @@ module Doodle
   # provides more direct access to the singleton class and a way to
   # treat 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)
@@ -98,15 +113,14 @@ module Doodle
       sc.module_eval(&block) if block_given?
       sc
     end
-
-    def is_class_self_defn?
-      defined?(ancestors) && ancestors.include?(Class)
-    end
-    def is_singleton_defn?
-      defined?(superclass) && superclass.ancestors.include?(Class) && !is_class_self_defn?
-    end
-    def is_instance_defn?
-      !is_class_self_defn? && !is_singleton_defn?
+    # evaluate in class context of self, whether Class, Module or singleton
+    def sc_eval(*args, &block)
+      if self.kind_of?(Module)
+        klass = self
+      else
+        klass = self.singleton_class
+      end
+      klass.module_eval(*args, &block)
     end
   end
 
@@ -114,67 +128,40 @@ module Doodle
   # classes as well as modules, classes and instances
   module Inherited
 
-    # 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]
-
-    # this function is a ~mess~ - refactor!!!
+    # parents returns the set of parent classes of an object
     def parents
-      # d { [:parents, self.to_s, defined?(superclass)] }
-      klasses = []
-      if defined?(superclass)
-        klass = superclass
-        if self != superclass
-          #
-          # fixme[any other way to do this? seems really clunky to have to hack strings]
-          #
-          # What's this doing? Finding the class of which this is the singleton class
-          regexen = [/Class:(?:#<)?([A-Z_][A-Za-z_]+)/, /Class:(([A-Z_][A-Za-z_]+))/]
-          regexen.each do |regex|
-            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
-              until klass.nil?
-                klasses.unshift klass
-                if klass == klass.superclass
-                  return klasses # oof
-                end
-                klass = klass.superclass
-              end
-            else
-              until klass.nil?
-                klasses << klass
-                klass = klass.superclass
-              end
-            end
-          end
-        end
-      else
+      # if singleton class (e.g. class << [Ff]oo; self; end) then it has
+      # no parents
+      case Doodle::Utils.doodle_category(self)
+      when :instance
         klass = self.class
-        until klass.nil?
-          klasses << klass
-          klass = klass.superclass
-        end
+      when :instance_singleton_class
+        klass = nil
+      when :class
+        klass = superclass
+      when :class_singleton_class
+        klass = nil
+      end
+      klasses = []
+      until klass.nil? || klass == klass.superclass
+        klasses << klass
+        klass = klass.superclass
       end
       klasses
     end
-
+    
+    # need concepts of
+    # - attributes
+    # - instance_attributes
+    # - singleton_attributes
+    # - class_attributes
+   
     # send message to all parents and collect results 
     def collect_inherited(message)
       result = []
-      klasses = parents
-      #p [:parents, parents]
-      # d { [:collect_inherited, :parents, message, klasses] }
-      klasses.each do |klass|
-        #p [:testing, klass]
+      parents.each do |klass|
         if klass.respond_to?(message)
-          # d { [:collect_inherited, :responded, message, klass] }
-          result.unshift(*klass.send(message))
+          result.unshift(*klass.__send__(message))
         else
           break
         end
@@ -184,9 +171,11 @@ module Doodle
     private :collect_inherited
   end
 
-  # the intent of embrace is to provide a way to create directives that
-  # affect all members of a class 'family' without having to modify
-  # Module, Class or Object - in some ways, it's similar to Ara Howard's mixable[http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/197296]
+  # the intent of embrace is to provide a way to create directives
+  # that affect all members of a class 'family' without having to
+  # modify Module, Class or Object - in some ways, it's similar to Ara
+  # Howard's mixable[http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/197296]
+  # though not as tidy :S
   #
   # 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
@@ -197,9 +186,8 @@ module Doodle
     def embrace(other, &block)
       # include in instance method chain
       include other
-      #extend other
       sc = class << self; self; end
-      sc.class_eval {
+      sc.module_eval {
         # class method chain
         include other
         # singleton method chain
@@ -207,16 +195,17 @@ module Doodle
         # ensure that subclasses are also embraced
         define_method :inherited do |klass|
           #p [:embrace, :inherited, klass]
-          klass.send(:embrace, other)       # n.b. closure
-          klass.send(:include, Factory)     # is there another way to do this? i.e. not in embrace
+          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
       }
-      sc.class_eval(&block) if block_given?
+      sc.module_eval(&block) if block_given?
     end
   end
 
-  class SaveBlock
+  # save a block for later execution
+  class DeferredBlock
     attr_accessor :block
     def initialize(arg_block = nil, &block)
       arg_block = block if block_given?
@@ -238,6 +227,7 @@ module Doodle
     end
   end
 
+  # place to stash bookkeeping info
   class DoodleInfo
     attr_accessor :local_attributes
     attr_accessor :local_validations
@@ -245,6 +235,7 @@ module Doodle
     attr_accessor :validation_on
     attr_accessor :arg_order
     attr_accessor :errors
+    attr_accessor :parent
 
     def initialize(object)
       @local_attributes = OrderedHash.new
@@ -253,14 +244,70 @@ module Doodle
       @local_conversions = {}
       @arg_order = []
       @errors = []
+      @parent = nil
+    end
+    real_inspect = Object.instance_method(:inspect)
+    define_method :real_inspect do
+      real_inspect.bind(self).call
+    end
+    def inspect
+      ''
     end
   end
 
+  # what it says on the tin :) various hacks to hide @__doodle__ variable
+  module SmokeAndMirrors
+    # redefine instance_variables to ignore our private @__doodle__ variable
+    # (hack to fool yaml and anything else that queries instance_variables)
+    meth = Object.instance_method(:instance_variables)
+    define_method :instance_variables do
+      meth.bind(self).call.reject{ |x| x =~ /@__doodle__/}
+    end
+
+    # hide @__doodle__ from inspect
+    # variants:
+    # #<Foo:0xb7de0064>
+    # #<Foo:0xb7c52d28 @name="Arthur Dent", @age=42>
+    # #<Class:#<Foo:0xb7de0064>>
+    # #<Class:Class>
+    # #<Class:#<Class:#<Foo:0xb7de0064>>>
+
+    # strip off all trailing > (count them = nesting)
+    # take leading chars up to first space (or EOS)
+    # rebuild rest
+
+    real_inspect = Object.instance_method(:inspect)
+    define_method :real_inspect do
+      real_inspect.bind(self).call
+    end
+    define_method :inspect do
+      # have to handle some built-ins as special case
+      built_in = Doodle::BuiltIns::BUILTINS.select{ |x| self.kind_of?(x) }.first
+      if built_in
+        built_in.instance_method(:inspect).bind(self).call
+      else
+        istr = real_inspect.bind(self).call
+        str = istr.gsub(/(>+$)/, '')
+        trailing = $1
+        klass = str.split(/\s/, 2).first
+        ivars = self.kind_of?(Module) ? [] : instance_variables
+        separator = ivars.size > 0 ? ' ' : ''
+        
+        #pp [:istr, istr, :str, str, :trailing, trailing, :klass, klass]
+        # note to self: changing klass to <self.class will highlight cases that need the hack in parents
+        #%[<#{self.class}#{separator}#{instance_variables.map{|x| "#{x}=#{instance_variable_get(x).inspect}"}.join(' ')}#{trailing}]
+        %[#{klass}#{separator}#{ivars.map{|x| "#{x}=#{instance_variable_get(x).inspect}"}.join(' ')}#{trailing}]
+      end
+    end
+    
+  end
+
   # the core module of Doodle - to get most facilities provided by Doodle
-  # without inheriting from Doodle::Base, include Doodle::Helper, not this module
+  # without inheriting from Doodle, include Doodle::Core, not this module
   module BaseMethods
     include SelfClass
     include Inherited
+    include SmokeAndMirrors
 
     # this is the only way to get at internal values. Note: this is
     # initialized on the fly rather than in #initialize because
@@ -270,17 +317,12 @@ module Doodle
     end
     private :__doodle__
 
-    # 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
-
+    # helper for Marshal.dump
     def marshal_dump
+      # note: perhaps should also dump singleton attribute definitions?
       instance_variables.map{|x| [x, instance_variable_get(x)] }
     end
+    # helper for Marshal.load
     def marshal_load(data)
       data.each do |name, value|
         instance_variable_set(name, value)
@@ -291,7 +333,8 @@ module Doodle
     def errors
       __doodle__.errors
     end
-  
+
+    # clear out the errors collection
     def clear_errors
       #pp [:clear_errors, self, caller]
       __doodle__.errors.clear
@@ -299,8 +342,6 @@ module Doodle
     
     # 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]
@@ -310,6 +351,17 @@ module Doodle
       end
     end
 
+    def _handle_inherited_hash(tf, method)
+      if tf
+        collect_inherited(method).inject(OrderedHash.new){ |hash, item|
+          hash.merge(OrderedHash[*item])
+        }.merge(__send__(method))
+      else
+        __send__(method)
+      end
+    end
+    private :_handle_inherited_hash
+    
     # return attributes defined in instance
     def local_attributes
       __doodle__.local_attributes
@@ -320,18 +372,39 @@ module Doodle
     # - if tf == true, returns all inherited attributes
     # - if tf == false, returns only those attributes defined in the current object/class
     def attributes(tf = true)
-      if tf
-        a = collect_inherited(:local_attributes).inject(OrderedHash.new){ |hash, item|
-          #p [:hash, hash, :item, item]
+      results = _handle_inherited_hash(tf, :local_attributes)
+      if !kind_of?(Class) && singleton_class.respond_to?(:attributes)
+        results = results.merge(singleton_class.attributes)
+      end
+      results
+    end
+
+    # return attributes for class
+    def class_attributes(tf = true)
+      attrs = OrderedHash.new
+      if self.kind_of?(Class)
+        attrs = collect_inherited(:class_attributes).inject(OrderedHash.new){ |hash, item|
           hash.merge(OrderedHash[*item])
-        }.merge(local_attributes)
-        # d { [:attributes, self.to_s, a] }
-        a
+        }.merge(singleton_class.respond_to?(:attributes) ? singleton_class.attributes : { })
+        attrs
       else
-        local_attributes
+        self.class.class_attributes
       end
     end
 
+    # the set of conversions defined in the current class (i.e. without inheritance)
+    def local_conversions
+      __doodle__.local_conversions
+    end
+    protected :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
+    def conversions(tf = true)
+      _handle_inherited_hash(tf, :local_conversions)
+    end
+
     # the set of validations defined in the current class (i.e. without inheritance)
     def local_validations
       __doodle__.local_validations
@@ -343,51 +416,35 @@ module Doodle
     # - if tf == false, returns only those validations defined in the current object/class
     def validations(tf = true)
       if tf
-        #p [:inherited_validations, collect_inherited(:local_validations)]
-        #p [:local_validations, local_validations]
+        # note: validations are handled differently to attributes and
+        # conversions because ~all~ validations apply (so are stored
+        # as an array), whereas attributes and conversions are keyed
+        # by name and kind respectively, so only the most recent
+        # applies
+        
         local_validations + collect_inherited(:local_validations)
       else
         local_validations
       end
     end
 
-    # the set of conversions defined in the current class (i.e. without inheritance)
-    def local_conversions
-      __doodle__.local_conversions
-    end
-    protected :local_conversions
-
-    # returns array of conversions
-    # - if tf == true, returns all inherited conversions
-    # - if tf == false, returns only those conversions defined in the current object/class
-    def conversions(tf = true)
-      if tf
-        a = collect_inherited(:local_conversions).inject(OrderedHash.new){ |hash, item|
-          #p [:hash, hash, :item, item]
-          hash.merge(OrderedHash[*item])
-        }.merge(self.local_conversions)
-        # d { [:conversions, self.to_s, a] }
-        a
-      else
-        local_conversions
-      end
-    end
-
     # lookup a single attribute by name, searching the singleton class first
     def lookup_attribute(name)
       # (look at singleton attributes first)
-      # fixme[this smells like a hack to me - why not handled in attributes?]
-      singleton_class.attributes[name] || attributes[name]
+      # fixme[this smells like a hack to me]
+      if self.class == Class
+        class_attributes[name]
+      else
+        attributes[name]
+      end
     end
     private :lookup_attribute
 
     # either get an attribute value (if no args given) or set it
     # (using args and/or block)
     def getter_setter(name, *args, &block)
-      # d { [:getter_setter, name, args, block] }
       name = name.to_sym
       if block_given? || args.size > 0
-        # setter
         _setter(name, *args, &block)
       else
         _getter(name)
@@ -397,21 +454,20 @@ module Doodle
 
     # get an attribute by name - return default if not otherwise defined
     def _getter(name, &block)
-      ## d { [:_getter, 1, self.to_s, name, block, instance_variables] }
-      # getter
       ivar = "@#{name}"
       if instance_variable_defined?(ivar)
-        ## d { [:_getter, 2, name, block] }
         instance_variable_get(ivar)
       else
         # handle default
         # Note: use :init => value to cover cases where defaults don't work
         # (e.g. arrays that disappear when you go out of scope)
         att = lookup_attribute(name)
-        #d { [:getter, name, att, block] }
-        if att.default_defined?
+        # special case for class/singleton :init
+        if att.init_defined?
+          _setter(name, att.init)
+        elsif att.default_defined?
           case att.default
-          when SaveBlock
+          when DeferredBlock
             instance_eval(&att.default.block)
           when Proc
             instance_eval(&att.default)
@@ -428,20 +484,16 @@ module Doodle
 
     # set an attribute by name - apply validation if defined
     def _setter(name, *args, &block)
-      #pp [:_setter, self, self.class, name, args, block, caller]
+      Doodle::Debug.d { [:_setter, name, args] }
       ivar = "@#{name}"
       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) ] }
+        args.unshift(DeferredBlock.new(block))
+      end
+      if att = lookup_attribute(name)
+        Doodle::Debug.d { [:_setter, name, args] }
         v = instance_variable_set(ivar, att.validate(self, *args))
       else
-        #d { [:_setter, :instance_variable_set, ivar, args ] }
+        Doodle::Debug.d { [:_setter, "no attribute"] }
         v = instance_variable_set(ivar, *args)
       end
       validate!(false)
@@ -452,13 +504,11 @@ module Doodle
     # if block passed, define a conversion from class
     # if no args, apply conversion to arguments
     def from(*args, &block)
-      # d { [:from, self, self.class, self.name, args, block] }
       if block_given?
         # set the rule for each arg given
         args.each do |arg|
           local_conversions[arg] = block
         end
-        # d { [:from, conversions] }
       else
         convert(self, *args)
       end
@@ -471,7 +521,6 @@ module Doodle
 
     # add a validation that attribute must be of class <= kind
     def kind(*args, &block)
-      # d { [:kind, args, block] }
       if args.size > 0
         # todo[figure out how to handle kind being specified twice?]
         @kind = args.first
@@ -492,16 +541,14 @@ module Doodle
           ancestors = value.class.ancestors
           matches = ancestors & conversions.keys
           indexed_matches = matches.map{ |x| ancestors.index(x)}
-          #p [matches, indexed_matches, indexed_matches.min]
           if indexed_matches.size > 0
             converter_class = ancestors[indexed_matches.min]
-            #p [:converter, converter_class]
             if converter = conversions[converter_class]
               value = converter[*args]
             end
           end
         end
-      rescue => e
+      rescue Exception => e
         owner.handle_error name, ConversionError, e.to_s, [caller[-1]]
       end
       value
@@ -511,34 +558,30 @@ module Doodle
     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, value] }
         if !v.block[value]
           owner.handle_error name, ValidationError, "#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", [caller[-1]]
         end
       end
-      #d { [:validate, :value, value ] }
       value
     end
-    
+
     # define a getter_setter
     def define_getter_setter(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", __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
-#       }
+      sc_eval "def #{name}(*args, &block); getter_setter(:#{name}, *args, &block); end", __FILE__, __LINE__
+      sc_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
 
@@ -547,9 +590,15 @@ 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", __FILE__, __LINE__
+        sc_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", __FILE__, __LINE__
+        sc_eval("def #{name}(*args, &block);
+                          if args.all?{|x| x.kind_of?(#{klass})}
+                            #{collection}.<<(*args)
+                          else
+                            #{collection} << #{klass}.new(*args, &block);
+                          end
+                     end", __FILE__, __LINE__)
       end
     end
     private :define_collector
@@ -577,13 +626,11 @@ module Doodle
     #  end
     #    
     def has(*args, &block)
-      #what_am_i?([:has, 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)}
       handle_error name, ArgumentError, "Too many arguments" if positional_args.size > 0
-      # d { [:has_args, self, key_values, positional_args, args] }
       params = { :name => name }
       params = key_values.inject(params){ |acc, item| acc.merge(item)}
 
@@ -607,7 +654,6 @@ module Doodle
         define_collector name, collector_name, collector_klass
       end
       
-      # d { [:has_args, :params, params] }
       # define getter setter before setting up attribute
       define_getter_setter name, *args, &block
       local_attributes[name] = attribute = Attribute.new(params, &block)
@@ -620,23 +666,18 @@ module Doodle
             else
               tmp_klass = collector_klass
             end
-            enum.map{|x| tmp_klass.new(x)}
+            enum.map{|x|
+              if x.kind_of?(tmp_klass)
+                x
+              elsif tmp_klass.conversions.key?(x.class)
+                tmp_klass.from(x)
+              else
+                tmp_klass.new(x)
+              end
+            }
           end
         }
       end
-      if is_class_self_defn? or is_singleton_defn?
-        #pp [:args, args]
-         init_values = get_init_values(false)
-#         if init_values.size > 0
-           #p [:init_values, name, self, is_class_self_defn? ? :CLASS : is_singleton_defn? ? :SINGLETON : '?', init_values, methods(false)]
-#           #define_getter_setter(name)
-#           #instance_variable_set("@#{name}", init_values[name])
-#         end
-#         #         singleton_class do
-#            #_setter(name, init_values[name])
-#         #         end
-      end
-      
       attribute
     end
 
@@ -644,7 +685,6 @@ module Doodle
     def arg_order(*args)
       if args.size > 0
         begin
-          #p [:arg_order, 1, self, self.class, args]
           args.uniq!
           args.each do |x|
             handle_error :arg_order, ArgumentError, "#{x} not a Symbol" if !(x.class <= Symbol)
@@ -652,11 +692,9 @@ module Doodle
           end
           __doodle__.arg_order = args
         rescue Exception => e
-          #p [InvalidOrderError, e.to_s]
           handle_error :arg_order, InvalidOrderError, e.to_s, [caller[-1]]
         end
       else
-        #p [:arg_order, 3, self, self.class, :default]
         __doodle__.arg_order + (attributes.keys - __doodle__.arg_order)
       end
     end
@@ -666,63 +704,18 @@ 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]
+                    when DeferredBlock
                       instance_eval(&a.init.block)
                     else
-                      #p [:init, :clone]
                       a.init.clone 
                     end
                   rescue Exception => e
-                    #p [:init, :rescue, e]
                     a.init
                   end
         ; hash }
     end
     private :get_init_values
-    
-    # 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)
-      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)}
-        Doodle::Debug.d { [:initialize_from_hash, :key_values, key_values, :args, args] }
-
-        # match up positional args with attribute names (from arg_order) using idiom to create hash from array of assocs
-        arg_keywords = Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))]
-        # d { [:initialize, :arg_keywords, arg_keywords] }
-
-        # set up initial values with ~clones~ of specified values (so not shared between instances)
-        init_values = get_init_values
-
-        # add to start of key_values array (so can be overridden by params)
-        key_values.unshift(init_values)
-
-        # merge all hash args into one
-        key_values = key_values.inject(arg_keywords) { |hash, item| hash.merge(item)}
-
-        # convert key names to symbols
-        key_values = key_values.inject({}) {|h, (k, v)| h[k.to_sym] = v; h}
-        Doodle::Debug.d { [:initialize_from_hash, :key_values2, key_values, :args2, args] }
-        
-        # create attributes
-        key_values.keys.each do |key|
-          Doodle::Debug.d { [:initialize_from_hash, :setting, key, key_values[key]] }
-          if respond_to?(key)
-            send(key, key_values[key])
-          else
-            # raise error if not defined
-            handle_error key, Doodle::UnknownAttributeError, "Unknown attribute '#{key}' #{key_values[key].inspect}"
-          end
-        end
-      end
-    end
-    #private :initialize_from_hash
 
     # return true if instance variable +name+ defined
     def ivar_defined?(name)
@@ -733,38 +726,48 @@ 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]
+      Doodle::Debug.d { [: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
         if self.class == Class
-          attribs = singleton_class.attributes
+          attribs = class_attributes
+          Doodle::Debug.d { [:validate!, "using class_attributes", class_attributes] }
         else
           attribs = attributes
+          Doodle::Debug.d { [:validate!, "using instance_attributes", attributes] }
         end
-        #pp [:validate!, self, self.class, attributes]
         attribs.each do |name, att|
           # treat default as special case
-          if [:default, :init].include?(att.name) || att.default_defined? || is_class_self_defn? || is_singleton_defn?
-            # nop
-          elsif !ivar_defined?(att.name) && self.class != Class
-            handle_error name, Doodle::ValidationError, "#{self} missing required attribute '#{name}'", [caller[-1]]
+          if att.default_defined?
+            Doodle::Debug.d { [:validate!, "default_defined - breaking" ]}
+            break
           end
-          # if all == true, reset values so conversions and validations are applied to raw instance variables
-          # e.g. when loaded from YAML
-          att_name = "@#{att.name}"
-          if all && instance_variable_defined?(att_name)
-            send(att.name, instance_variable_get(att_name))
+          ivar_name = "@#{att.name}"
+          if instance_variable_defined?(ivar_name)
+            # if all == true, reset values so conversions and
+            # validations are applied to raw instance variables
+            # e.g. when loaded from YAML
+            if all
+              Doodle::Debug.d { [:validate!, :sending, att.name, instance_variable_get(ivar_name) ] }
+              __send__(att.name, instance_variable_get(ivar_name))
+            end
+          elsif self.class != Class
+            handle_error name, Doodle::ValidationError, "#{self} missing required attribute '#{name}'", [caller[-1]]
           end
         end
         # now apply instance level validations
+        
+        Doodle::Debug.d { [:validate!, "validations", validations ]}
         validations.each do |v|
           Doodle::Debug.d { [:validate!, self, v ] }
-          if !instance_eval(&v.block)
-            handle_error :validate!, ValidationError, "#{ self.inspect } must #{ v.message }", [caller[-1]]
+          begin
+            if !instance_eval(&v.block)
+              handle_error self, ValidationError, "#{ self.class } must #{ v.message }", [caller[-1]]
+            end
+          rescue Exception => e
+            handle_error self, ValidationError, e.to_s, [caller[-1]]
           end
         end
       end
@@ -787,20 +790,66 @@ module Doodle
       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)
+      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)}
+        Doodle::Debug.d { [self.class, :initialize_from_hash, :key_values, key_values, :args, args] }
+
+        # match up positional args with attribute names (from arg_order) using idiom to create hash from array of assocs
+        arg_keywords = Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))]
+
+        # set up initial values with ~clones~ of specified values (so not shared between instances)
+        init_values = get_init_values
+
+        # add to start of key_values array (so can be overridden by params)
+        key_values.unshift(init_values)
+
+        # merge all hash args into one
+        key_values = key_values.inject(arg_keywords) { |hash, item| hash.merge(item)}
+
+        # convert key names to symbols
+        key_values = key_values.inject({}) {|h, (k, v)| h[k.to_sym] = v; h}
+        Doodle::Debug.d { [self.class, :initialize_from_hash, :key_values2, key_values, :args2, args] }
+        
+        # create attributes
+        key_values.keys.each do |key|
+          Doodle::Debug.d { [self.class, :initialize_from_hash, :setting, key, key_values[key]] }
+          if respond_to?(key)
+            __send__(key, key_values[key])
+          else
+            # raise error if not defined
+            handle_error key, Doodle::UnknownAttributeError, "Unknown attribute '#{key}' #{key_values[key].inspect}"
+          end
+        end
+      end
+    end
+    #private :initialize_from_hash
+
+    # return containing object (set during initialization)
+    def 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)
+      built_in = Doodle::BuiltIns::BUILTINS.select{ |x| self.kind_of?(x) }.first
+      if built_in
+        super
+      end
       __doodle__.validation_on = true
-      #p [:Doodle_context_push, self]
+      __doodle__.parent = Doodle.context[-1]
       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
@@ -822,35 +871,36 @@ module Doodle
   # etc.
   module Factory
     RX_IDENTIFIER = /^[A-Za-z_][A-Za-z_0-9]+\??$/
-    class << self   
+    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
+          method_defined = begin
+                             method(name)
+                             true
+                           rescue
+                             false
+                           end
+
+          if !method_defined && !klass.respond_to?(name) && !eval("respond_to?(:#{name})", TOPLEVEL_BINDING) && 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
+          # 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__)
+            klass.module_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
@@ -858,12 +908,11 @@ module Doodle
     end
   end
 
-  # Include Doodle::Helper if you want to derive from another class
+  # Include Doodle::Core if you want to derive from another class
   # but still get Doodle goodness in your class (including Factory
   # methods).
-  module Helper
+  module Core
     def self.included(other)
-      #p [:Helper, :included, self, other ]
       super
       other.module_eval {
         extend Embrace
@@ -872,17 +921,27 @@ module Doodle
       }
     end
   end
+  # deprecated
+  Helper = Core
 
-  # derive from Base if you want all the Doodle goodness
+  # deprecated
   class Base
-    include Helper
+    include Core
   end
+  include Core
+end
 
-  # todo[need to extend this]
-  class Attribute < Doodle::Base
+class Doodle
+  # Attribute is itself a Doodle object that is created by #has and
+  # added to the #attributes collection in an object's DoodleInfo
+  #
+  # It is used to provide a context for defining #must and #from rules
+  #
+  class Attribute < Doodle
+    # todo[want to design Attribute so it's extensible, e.g. to specific datatypes & built-in validations]
     # must define these methods before using them in #has below
 
-    # bump off +validate!+ for Attributes - maybe better way of doing
+    # hack: bump off +validate!+ for Attributes - maybe better way of doing
     # this however, without this, tries to validate Attribute to :kind
     # specified, e.g. if you have
     #
@@ -891,6 +950,8 @@ module Doodle
     # it will fail because Attribute is not a kind of Date -
     # obviously, I have to think about this some more :S
     #
+    # at least, I could hand roll a custom validate! method for Attribute
+    #
     def validate!(all = true)
     end
 
@@ -920,9 +981,11 @@ module Doodle
         s.to_sym
       end
     end
+
     # default value (can be a block)
     has :default, :default => nil
-    # initial value
+
+    # initial value
     has :init, :default => nil
 
   end