doodle 0.1.9 → 0.2.0

data/History.txt

@@ -1,3 +1,22 @@
+== 0.2.0 / 2009-02-08
+- Features:
+  - object.doodle.values for easy access to array of attribute values
+  - object.default?(:name) returns true if :name has default and not been assigned
+  - equality
+    - doodles are equal if both have the same class and values
+  - comparability
+    - defines <=> (so doodles are sortable by default)
+  - XML serialization - require 'doodle/xml'
+    simple XML serialization using Doodle class names as tag
+    names. Works for me. YMMV :)
+    - to_xml
+    - from_xml
+  - reworked website using webby
+
+- Bug fixes:
+  - all specs now pass in ruby 1.8.6, 1.9.1 and JRuby 1.1.6 (1 pending)
+  - renabled String collectors
+
 == 0.1.9 / 2008-08-13
 - Features:
   - to_hash
@@ -9,15 +28,15 @@
     class Animal
       has :species
     end
-    
+
     class Barn
       has :animals, :collect => Animal
     end
-    
+
     class Farm
       has Barn
     end
-    
+
     farm = Farm do
       # this is new - will call Barn.new(&block)
       barn do
@@ -25,9 +44,9 @@
         animal 'pig'
       end
     end
-    
+
     Will not try this for an attribute with :abstract => true
-    
+
   - attributes now have :doc option
   - attributes now have :abstract option - will not try to
     auto-instantiate an object from this class
@@ -39,11 +58,11 @@
       optionally recurse into child hashes
     - symbolize_keys!(hash, recursive = false)
     - stringify_keys!(hash, recursive = false)
-    
+
 - Experimental:
   - Doodle::App for handlng command line application options
   - doodle/datatypes - added more datatypes
-  
+
 - Bug fixes:
   - fixed reversion in 0.1.8 which enabled full backtrace from within
     doodle.rb
@@ -129,7 +148,7 @@
 
 == 0.1.5 / 2008-05-06
 - Bug fixes:
-  - fixed bug where defaults were preventing validation working when loading from 
+  - fixed bug where defaults were preventing validation working when loading from
     YAML and added spec
 
 == 0.1.4 / 2008-05-06
@@ -159,7 +178,7 @@
 - created a Google group: http://groups.google.com/group/ruby-doodle
 - major change: changed Doodle from module to class so you now use
     class Foo < Doodle
-  instead of 
+  instead of
     class Foo < Doodle::Base
 - Doodle::Helper renamed Doodle::Core
 - added #parent method - returns outer object in initialization blocks
@@ -234,7 +253,7 @@
 
 - tidied up validation specs
 
-- fixed dumb bug where validations were getting duplicated resulting from using push on the source array. D'oh! 
+- fixed dumb bug where validations were getting duplicated resulting from using push on the source array. D'oh!
 
 - added Doodle::DoodleInfo.raise_exception_on_error - set to false to have errors collected only
   without raising an exception (which is the default behaviour)

data/Manifest.txt

@@ -28,6 +28,7 @@ lib/doodle/datatypes.rb
 lib/doodle/rfc822.rb
 lib/doodle/utils.rb
 lib/doodle/version.rb
+lib/doodle/xml.rb
 lib/molic_orderedhash.rb
 log/debug.log
 script/console
@@ -37,6 +38,7 @@ script/txt2html
 setup.rb
 spec/arg_order_spec.rb
 spec/attributes_spec.rb
+spec/block_init_spec.rb
 spec/bugs_spec.rb
 spec/class_spec.rb
 spec/class_validation_spec.rb
@@ -46,21 +48,31 @@ spec/conversion_spec.rb
 spec/defaults_spec.rb
 spec/doodle_context_spec.rb
 spec/doodle_spec.rb
+spec/equality_spec.rb
 spec/extra_args_spec.rb
 spec/factory_spec.rb
 spec/flatten_first_level_spec.rb
+spec/from_spec.rb
+spec/has_spec.rb
 spec/inheritance_spec.rb
 spec/init_spec.rb
+spec/kind_spec.rb
+spec/member_init_spec.rb
 spec/new_doodle_spec.rb
+spec/readonly_spec.rb
 spec/required_spec.rb
 spec/serialization_spec.rb
 spec/singleton_spec.rb
 spec/spec.opts
+spec/spec.template
 spec/spec_helper.rb
 spec/specialized_attribute_class_spec.rb
 spec/superclass_spec.rb
+spec/symbolize_keys_spec.rb
+spec/to_hash_spec.rb
 spec/validation2_spec.rb
 spec/validation_spec.rb
+spec/xml_spec.rb
 tasks/deployment.rake
 tasks/environment.rake
 tasks/rspec.rake

data/README.txt

@@ -1,6 +1,7 @@
 = doodle
 
-* http://doodle.rubyforge.org
+* Homepage: http://doodle.rubyforge.org
+* Github repo: http://github.com/seanohalpin/doodle/tree/master
 
 == DESCRIPTION:
 
@@ -11,8 +12,8 @@ Doodle is eco-friendly: it does not globally modify Object, Class or
 Module, nor does it pollute instances with its own instance variables
 (i.e. it plays nice with yaml).
 
-Doodle has been tested with Ruby 1.8.6 and JRuby 1.1. It does not yet
-work with Ruby 1.9 or Rubinius.
+Doodle has been tested with Ruby 1.8.6, 1.9.1 and JRuby 1.1. It has
+not yet been tested with Rubinius.
 
 Please feel free to post bug reports, feature requests, and any
 comments or discussion topics to the doodle Google group: 
@@ -144,7 +145,7 @@ http://groups.google.com/group/ruby-doodle
 
 (The MIT License)
 
-Copyright (c) 2008 Sean O'Halpin
+Copyright (c) 2007-2009 Sean O'Halpin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/doodle.rb

@@ -1,15 +1,21 @@
 # doodle
 # -*- mode: ruby; ruby-indent-level: 2; tab-width: 2 -*- vim: sw=2 ts=2
-# Copyright (C) 2007-2008 by Sean O'Halpin
+# Copyright (C) 2007-2009 by Sean O'Halpin
 # 2007-11-24 first version
 # 2008-04-18 latest release 0.0.12
 # 2008-05-07 0.1.6
 # 2008-05-12 0.1.7
+# 2009-02-26 0.2.0
+# 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
+
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 if RUBY_VERSION < '1.9.0'
-  require 'molic_orderedhash'  # todo[replace this with own (required functions only) version]
+  require 'molic_orderedhash'  # TODO: replace this with own (required functions only) version
 else
   # 1.9+ hashes are ordered by default
   class Doodle
@@ -17,45 +23,6 @@ else
   end
 end
 
-# 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
-
-#
-# instance_exec for ruby 1.8 by Mauricio Fernandez
-# http://eigenclass.org/hiki.rb?bounded+space+instance_exec
-# thread-safe and handles frozen objects in bounded space
-#
-# (tag "ruby instance_exec")
-#
-if !Object.respond_to?(:instance_exec)
-  class Object
-    module InstanceExecHelper; end
-    include InstanceExecHelper
-    def instance_exec(*args, &block)
-      begin
-        old_critical, Thread.critical = Thread.critical, true
-        n = 0
-        methods = InstanceExecHelper.instance_methods
-        # this in order to make the lookup O(1), and name generation O(n) on the
-        # number of nested/concurrent instance_exec calls instead of O(n**2)
-        table = Hash[*methods.zip(methods).flatten]
-        n += 1 while table.has_key?(mname="__instance_exec#{n}")
-      ensure
-        Thread.critical = old_critical
-      end
-      InstanceExecHelper.module_eval{ define_method(mname, &block) }
-      begin
-        ret = send(mname, *args)
-      ensure
-        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-      end
-      ret
-    end
-  end
-end
-
 require 'yaml'
 
 # *doodle* is my attempt at an eco-friendly metaprogramming framework that does not
@@ -79,6 +46,32 @@ class Doodle
     end
   end
 
+  # two doodles of the same class with the same attribute values are
+  # considered equal
+  module Equality
+    def eql?(o)
+#       p [:comparing, self.class, o.class, self.class == o.class]
+#       p [:values, self.doodle.values, o.doodle.values, self.doodle.values == o.doodle.values]
+#       p [:attributes, doodle.attributes.map { |k, a| [k, send(k).==(o.send(k))] }]
+      res = self.class == o.class &&
+        #self.doodle.values == o.doodle.values
+        # short circuit comparison
+        doodle.attributes.all? { |k, a| send(k).==(o.send(k)) }
+#       p [:res, res]
+      res
+    end
+    def ==(o)
+      eql?(o)
+    end
+  end
+
+  # doodles are compared (sorted) on values
+  module Comparable
+    def <=>(o)
+      doodle.values <=> o.doodle.values
+    end
+  end
+
   # debugging utilities
   module Debug
     class << self
@@ -99,13 +92,26 @@ class Doodle
     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 }
+        enum.inject([]) {|arr, i|
+          if i.kind_of?(Array)
+            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.to_s.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+        # if all caps, just downcase it
+        if camel_cased_word =~ /^[A-Z]+$/
+          camel_cased_word.downcase
+        else
+          camel_cased_word.to_s.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+        end
       end
-      # resolve a constant of the form Some::Class::Or::Module
+      # resolve a constant of the form Some::Class::Or::Module -
+      # doesn't work with constants defined in anonymous
+      # classes/modules
       def const_resolve(constant)
         constant.to_s.split(/::/).reject{|x| x.empty?}.inject(Object) { |prev, this| prev.const_get(this) }
       end
@@ -117,17 +123,19 @@ class Doodle
       # - updates target hash
       # - optionally recurse into child hashes
       def normalize_keys!(hash, recursive = false, method = :to_sym)
-        hash.keys.each do |key|
-          normalized_key = key.respond_to?(method) ? key.send(method) : key
-          v = hash.delete(key)
-          if recursive
-            if v.kind_of?(Hash)
-              v = normalize_keys!(v, recursive, method)
-            elsif v.kind_of?(Array)
-              v = v.map{ |x| normalize_keys!(x, recursive, method) }
+        if hash.kind_of?(Hash)
+          hash.keys.each do |key|
+            normalized_key = key.respond_to?(method) ? key.send(method) : key
+            v = hash.delete(key)
+            if recursive
+              if v.kind_of?(Hash)
+                v = normalize_keys!(v, recursive, method)
+              elsif v.kind_of?(Array)
+                v = v.map{ |x| normalize_keys!(x, recursive, method) }
+              end
             end
+            hash[normalized_key] = v
           end
-          hash[normalized_key] = v
         end
         hash
       end
@@ -389,6 +397,13 @@ class Doodle
       results
     end
 
+    # returns array of values
+    # - if tf == true, returns all inherited values (default)
+    # - if tf == false, returns only those values defined in current object
+    def values(tf = true)
+      attributes(tf).map{ |k, a| @this.send(k)}
+    end
+
     # return class level attributes
     def class_attributes
       attrs = Doodle::OrderedHash.new
@@ -591,6 +606,18 @@ class Doodle
     include SelfClass
     include SmokeAndMirrors
 
+# NOTE: can't do either of these
+
+#     include Equality
+#     include Comparable
+
+    #     def self.included(other)
+#       other.module_eval {
+#         include Equality
+#         include Comparable
+#       }
+#     end
+
     # 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
@@ -635,7 +662,7 @@ class Doodle
 
     # either get an attribute value (if no args given) or set it
     # (using args and/or block)
-    # fixme: move
+    # FIXME: move
     def getter_setter(name, *args, &block)
       #p [:getter_setter, name]
       name = name.to_sym
@@ -650,39 +677,43 @@ class Doodle
     private :getter_setter
 
     # get an attribute by name - return default if not otherwise defined
-    # fixme: init deferred blocks are not getting resolved in all cases
+    # FIXME: init deferred blocks are not getting resolved in all cases
     def _getter(name, &block)
-      #p [:_getter, name]
-      ivar = "@#{name}"
-      if instance_variable_defined?(ivar)
-        #p [:_getter, :instance_variable_defined, name, ivar, instance_variable_get(ivar)]
-        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 = __doodle__.lookup_attribute(name)
-        # special case for class/singleton :init
-        if att && att.optional?
-          optional_value = att.init_defined? ? att.init : att.default
-          #p [:optional_value, optional_value]
-          case optional_value
-          when DeferredBlock
-            #p [:deferred_block]
-            v = instance_eval(&optional_value.block)
-          when Proc
-            v = instance_eval(&optional_value)
+      begin
+        #p [:_getter, name]
+        ivar = "@#{name}"
+        if instance_variable_defined?(ivar)
+          #p [:_getter, :instance_variable_defined, name, ivar, instance_variable_get(ivar)]
+          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 = __doodle__.lookup_attribute(name)
+          # special case for class/singleton :init
+          if att && att.optional?
+            optional_value = att.init_defined? ? att.init : att.default
+            #p [:optional_value, optional_value]
+            case optional_value
+            when DeferredBlock
+              #p [:deferred_block]
+              v = instance_eval(&optional_value.block)
+            when Proc
+              v = instance_eval(&optional_value)
+            else
+              v = optional_value
+            end
+            if att.init_defined?
+              _setter(name, v)
+            end
+            v
           else
-            v = optional_value
-          end
-          if att.init_defined?
-            _setter(name, v)
+            # This is an internal error (i.e. shouldn't happen)
+            __doodle__.handle_error name, NoDefaultError, "'#{name}' has no default defined", Doodle::Utils.doodle_caller
           end
-          v
-        else
-          # This is an internal error (i.e. shouldn't happen)
-          __doodle__.handle_error name, NoDefaultError, "'#{name}' has no default defined", Doodle::Utils.doodle_caller
         end
+      rescue Object => e
+        __doodle__.handle_error name, e, e.to_s, Doodle::Utils.doodle_caller
       end
     end
     private :_getter
@@ -690,6 +721,7 @@ class Doodle
     def after_update(params)
     end
 
+    # set an instance variable by symbolic name and call after_update if changed
     def ivar_set(name, *args)
       ivar = "@#{name}"
       if instance_variable_defined?(ivar)
@@ -707,11 +739,10 @@ class Doodle
     private :ivar_set
 
     # set an attribute by name - apply validation if defined
-    # fixme: move
+    # FIXME: move
     def _setter(name, *args, &block)
       ##DBG: Doodle::Debug.d { [:_setter, name, args] }
       #p [:_setter, name, *args]
-      #ivar = "@#{name}"
       att = __doodle__.lookup_attribute(name)
       if att && doodle.validation_on && att.readonly
         raise Doodle::ReadOnlyError, "Trying to set a readonly attribute: #{att.name}", Doodle::Utils.doodle_caller
@@ -730,7 +761,6 @@ class Doodle
           # this is used by init do ... block
           args.unshift(DeferredBlock.new(block))
         end
-        #elsif
       end
       if att # = __doodle__.lookup_attribute(name)
         if att.kind && !att.abstract && klass = att.kind.first
@@ -744,9 +774,7 @@ class Doodle
             end
           end
         end
-        #  args = [klass.new(*args, &block)]        ##DBG: Doodle::Debug.d { [:_setter, name, args] }
         #p [:_setter, :got_att1, name, ivar, *args]
-        #        v = instance_variable_set(ivar, att.validate(self, *args))
         v = ivar_set(name, att.validate(self, *args))
 
         #p [:_setter, :got_att2, name, ivar, :value, v]
@@ -754,7 +782,6 @@ class Doodle
       else
         #p [:_setter, :no_att, name, *args]
         ##DBG: Doodle::Debug.d { [:_setter, "no attribute"] }
-        #        v = instance_variable_set(ivar, *args)
         v = ivar_set(name, *args)
       end
       validate!(false)
@@ -798,7 +825,7 @@ class Doodle
     end
 
     # convert a value according to conversion rules
-    # fixme: move
+    # FIXME: move
     def convert(owner, *args)
       #pp( { :convert => 1, :owner => owner, :args => args, :conversions => __doodle__.conversions } )
       begin
@@ -807,7 +834,6 @@ class Doodle
           if (converter = __doodle__.conversions[value.class])
             #p [:convert, 3, value, self, caller]
             value = converter[value]
-            #value = instance_exec(value, &converter)
             #!p [:convert, 4, value]
           else
             #!p [:convert, 5, value]
@@ -825,7 +851,6 @@ class Doodle
               if converter = __doodle__.conversions[converter_class]
                 #!p [:convert, 11, converter]
                 value = converter[value]
-                #value = instance_exec(value, &converter)
                 #!p [:convert, 12, value]
               end
             else
@@ -838,7 +863,6 @@ class Doodle
                   if converter = mappable_kind.doodle.conversions[value.class]
                     #!p [:convert, 15, value, mappable_kind, args]
                     value = converter[value]
-                    #value = instance_exec(value, &converter)
                     break
                   else
                     #!p [:convert, 16, :no_conversion_for, value.class]
@@ -973,6 +997,12 @@ class Doodle
     end
     private :ivar_defined?
 
+    # return true if attribute has default defined and not yet been
+    # assigned to (i.e. still has default value)
+    def default?(name)
+      doodle.attributes[name.to_sym].optional? && !ivar_defined?(name)
+    end
+
     # 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)
@@ -1002,7 +1032,7 @@ class Doodle
             ##DBG: Doodle::Debug.d { [:validate!, :optional, name ]}
             next
           elsif self.class != Class
-            __doodle__.handle_error name, Doodle::ValidationError, "#{self} missing required attribute '#{name}'", Doodle::Utils.doodle_caller
+            __doodle__.handle_error name, Doodle::ValidationError, "#{self.kind_of?(Class) ? self : self.class } missing required attribute '#{name}'", Doodle::Utils.doodle_caller
           end
         end
 
@@ -1044,7 +1074,7 @@ class Doodle
       #p [:doodle_parent, __doodle__.parent]
     end
 
-    # create 'pure' hash of scalars only from attributes - hacky but works fine
+    # create 'pure' hash of scalars only from attributes - hacky but works (kinda)
     def to_hash
       Doodle::Utils.symbolize_keys!(YAML::load(to_yaml.gsub(/!ruby\/object:.*$/, '')) || { }, true)
       #begin
@@ -1074,17 +1104,65 @@ class Doodle
   #   end
   #   stimpy = Dog(:name => 'Stimpy')
   # etc.
+  module Utils
+    # normalize a name to contain only legal characters for a Ruby
+    # constant
+    def self.normalize_const(const)
+      const.to_s.gsub(/[^A-Za-z_0-9]/, '')
+    end
+
+    # lookup a constant along the module nesting path
+    def const_lookup(const, context = self)
+      #p [:const_lookup, const, context]
+      const = Utils.normalize_const(const)
+      result = nil
+      if !context.kind_of?(Module)
+        context = context.class
+      end
+      klasses = context.to_s.split(/::/)
+      #p klasses
+
+      path = []
+      0.upto(klasses.size - 1) do |i|
+        path << Doodle::Utils.const_resolve(klasses[0..i].join('::'))
+      end
+      path = (path.reverse + context.ancestors).flatten
+      #p [:const, context, path]
+      path.each do |ctx|
+        #p [:checking, ctx]
+        if ctx.const_defined?(const)
+          result = ctx.const_get(const)
+          break
+        end
+      end
+      raise NameError, "Uninitialized constant #{const} in context #{context}" if result.nil?
+      result
+    end
+    module_function :const_lookup
+  end
+
   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)
+      def self.factory(konst)
+        #p [:factory, :ancestors, konst, konst.ancestors]
+        #p [:factory, :lookup, Module.nesting]
         name = konst.to_s
+        #p [:factory, :name, name]
+        anon_class = false
+        if name =~ /#<Class:0x[a-fA-F0-9]+>::/
+          #p [:factory_anon_class, name]
+          anon_class = true
+        end
         names = name.split(/::/)
         name = names.pop
-        if names.empty?
+        # TODO: the code below is almost the same - refactor
+        #p [:factory, :names, names, name]
+        if names.empty? && !anon_class
+          #p [:factory, :top_level_class]
           # top level class - should be available to all
-          klass = Object
+          parent_class = Object
           method_defined = begin
                              method(name)
                              true
@@ -1092,25 +1170,48 @@ class Doodle
                              false
                            end
 
-          if name =~ Factory::RX_IDENTIFIER && !method_defined && !klass.respond_to?(name) && !eval("respond_to?(:#{name})", TOPLEVEL_BINDING)
+          if name =~ Factory::RX_IDENTIFIER && !method_defined && !parent_class.respond_to?(name) && !eval("respond_to?(:#{name})", TOPLEVEL_BINDING)
             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)}
-          # todo[check how many times this is being called]
-          if name =~ Factory::RX_IDENTIFIER && !klass.respond_to?(name)
-            klass.module_eval("def self.#{name}(*args, &block); #{name}.new(*args, &block); end", __FILE__, __LINE__)
+          #p [:factory, :other_level_class]
+          parent_class = Object
+          if !anon_class
+            parent_class = names.inject(parent_class) {|c, n| c.const_get(n)}
+            #p [:factory, :parent_class, parent_class]
+            if name =~ Factory::RX_IDENTIFIER && !parent_class.respond_to?(name)
+              parent_class.module_eval("def self.#{name}(*args, &block); #{name}.new(*args, &block); end", __FILE__, __LINE__)
+            end
+          else
+            # NOTE: ruby 1.9.1 specific
+            parent_class_name = names.join('::')
+            #p [:factory, :parent_class_name, parent_class_name]
+            #p [:parent_class_name, parent_class_name]
+            # FIXME: this is truly horrible...
+            hex_object_id = parent_class_name.match(/:(0x[a-zA-Z0-9]+)/)[1]
+            oid = hex_object_id.to_i(16) >> 1
+#             p [:object_id, oid, hex_object_id, hex_object_id.to_i(16) >> 1]
+            parent_class = ObjectSpace._id2ref(oid)
+
+            #p [:parent_object_id, parent_class.object_id, names, parent_class, parent_class_name, parent_class.name]
+#             p [:names, :oid, "%x" % (oid << 1), :konst, konst, :pc, parent_class, :names, names, :self, self]
+            if name =~ Factory::RX_IDENTIFIER && !parent_class.respond_to?(name)
+              #p [:context, context]
+              parent_class.module_eval("def #{name}(*args, &block); #{name}.new(*args, &block); end", __FILE__, __LINE__)
+            end
           end
+          # TODO: check how many times this is being called
         end
       end
 
       # inherit the factory function capability
-      def included(other)
+      def self.included(other)
+        #p [:included, other]
         super
         # make +factory+ method available
         factory other
       end
-    end
+    #end
   end
 
   # Include Doodle::Core if you want to derive from another class
@@ -1120,6 +1221,9 @@ class Doodle
     def self.included(other)
       super
       other.module_eval {
+        # FIXME: this is getting a bit arbitrary
+        include Doodle::Equality
+        include Doodle::Comparable
         extend Embrace
         embrace BaseMethods
         include Factory
@@ -1127,10 +1231,6 @@ class Doodle
     end
   end
 
-  # wierd 1.9 shit
-  class IAmNotUsedBut1_9GoesIntoAnInfiniteRegressInInspectIfIAmNotDefined
-    include Core
-  end
   include Core
 end
 
@@ -1190,7 +1290,9 @@ class Doodle
             collector_class = collector.to_s
             #p [:collector_klass, collector_klass]
             collector_name = Utils.snake_case(collector_class.split(/::/).last)
-            #p [:collector_name, collector_name]
+            #p [:collector_name, collector_class, collector_name]
+            # FIXME: sanitize class name (make this a Utils function)
+            collector_class = collector_class.gsub(/#<Class:0x[a-fA-F0-9]+>::/, '')
             if collector_class !~ /^[A-Z]/
               collector_class = nil
             end
@@ -1289,10 +1391,13 @@ class Doodle
     end
     def resolve_value(value)
       if value.kind_of?(collector_class)
+        #p [:resolve_value, :value, value]
         value
       elsif collector_class.__doodle__.conversions.key?(value.class)
+        #p [:resolve_value, :collector_class_from, value]
         collector_class.from(value)
       else
+        #p [:resolve_value, :collector_class_new, value]
         collector_class.new(value)
       end
     end
@@ -1307,11 +1412,19 @@ class Doodle
         end
       end
       from Enumerable do |enum|
+        #p [:enum, Enumerable]
         resolve_collector_class
-        post_process( enum.map{ |value| resolve_value(value) } )
+        # this is not very elegant but String is a classified as an
+        # Enumerable in 1.8.x (but behaves differently)
+        if enum.kind_of?(String) && self.init.kind_of?(String)
+          post_process( resolve_value(enum) )
+        else
+          post_process( enum.map{ |value| resolve_value(value) } )
+        end
       end
     end
     def post_process(results)
+      #p [:post_process, results]
       self.init.clone.replace(results)
     end
   end
@@ -1324,6 +1437,7 @@ class Doodle
     # define a collector for appendable collections
     # - collection should provide a :<< method
     def define_collection
+      # FIXME: don't use eval in 1.9+
       if collector_class.nil?
         doodle_owner.sc_eval("def #{collector_name}(*args, &block)
                    junk = #{name} if !#{name} # force initialization for classes
@@ -1361,6 +1475,7 @@ class Doodle
     # - collection should provide a :[] method
     def define_collection
       # need to use string eval because passing block
+      # FIXME: don't use eval in 1.9+
       if collector_class.nil?
         doodle_owner.sc_eval("def #{collector_name}(*args, &block)
                    junk = #{name} if !#{name} # force initialization for classes