doodle 0.1.3 → 0.1.4

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2008 Sean O'Halpin <monkeymind.textdriven.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/History.txt

@@ -1,3 +1,12 @@
+== 0.1.4 / 2008-05-06
+- Features:
+  - keyed collections - see http://doodle.rubyforge.org/#keyed_collections for details
+  - specialized Attribute classes in #has - see
+    spec/specialized_attribute_class_spec.rb for example
+
+- Bug fixes:
+  - fixed bug when using a collect generated method with a type but no arguments
+
 == 0.1.3 / 2008-05-01
 - really avoid wierd interaction with ActiveRecord this time
 - also, managed to get rid of crufty reliance on inspect and found

data/Manifest.txt

@@ -1,31 +1,33 @@
+COPYING
+CREDITS
 History.txt
 License.txt
 Manifest.txt
+PostInstall.txt
 README.txt
-CREDITS
 Rakefile
 config/hoe.rb
 config/requirements.rb
-examples/smtp_tls.rb
-examples/example-01.rdoc
-examples/profile-options.rb
 examples/doodle-errors.rb
 examples/event-location.rb
-examples/parent.rb
+examples/example-01.rb
+examples/example-01.rdoc
 examples/example-02.rb
 examples/example-02.rdoc
-examples/example-01.rb
+examples/mail-datatypes.rb
 examples/mail.rb
-examples/yaml-example2.rb
-examples/yaml-example.rb
+examples/parent.rb
+examples/profile-options.rb
+examples/smtp_tls.rb
 examples/test-datatypes.rb
-examples/mail-datatypes.rb
+examples/yaml-example.rb
+examples/yaml-example2.rb
 lib/doodle.rb
-lib/molic_orderedhash.rb
 lib/doodle/datatypes.rb
 lib/doodle/rfc822.rb
 lib/doodle/utils.rb
 lib/doodle/version.rb
+lib/molic_orderedhash.rb
 log/debug.log
 script/console
 script/destroy
@@ -36,6 +38,7 @@ spec/arg_order_spec.rb
 spec/attributes_spec.rb
 spec/bugs_spec.rb
 spec/class_spec.rb
+spec/class_validation_spec.rb
 spec/class_var_spec.rb
 spec/collector_spec.rb
 spec/conversion_spec.rb
@@ -45,6 +48,7 @@ spec/doodle_spec.rb
 spec/extra_args_spec.rb
 spec/factory_spec.rb
 spec/flatten_first_level_spec.rb
+spec/inheritance_spec.rb
 spec/init_spec.rb
 spec/new_doodle_spec.rb
 spec/required_spec.rb
@@ -52,10 +56,10 @@ spec/serialization_spec.rb
 spec/singleton_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/specialized_attribute_class_spec.rb
 spec/superclass_spec.rb
-spec/validation_spec.rb
 spec/validation2_spec.rb
+spec/validation_spec.rb
 tasks/deployment.rake
 tasks/environment.rake
 tasks/rspec.rake
-tasks/website.rake

data/PostInstall.txt

@@ -0,0 +1 @@
+For more information on doodle, see http://doodle.rubyforge.org

data/lib/doodle.rb

@@ -6,7 +6,6 @@ $:.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 'bleak_house' if ENV['BLEAK_HOUSE']
 
 # require Ruby 1.8.6 or higher
 if RUBY_VERSION < '1.8.6'
@@ -57,19 +56,6 @@ class Doodle
       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)
-        return :nil if obj.class == NilClass
-        if obj.kind_of?(Module)
-          if obj.ancestors.include?(obj)
-            :class
-          else
-            :singleton_class
-          end
-        else
-          :instance
-        end
-      end
     end
   end
 
@@ -125,22 +111,17 @@ class Doodle
 
     # parents returns the set of parent classes of an object
     def parents
-      # 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
-      when :class
-        klass = superclass
-      when :singleton_class
-        klass = nil
-      end
-      klasses = []
-      until klass.nil? || klass == klass.superclass
-        klasses << klass
-        klass = klass.superclass
-      end
-      klasses
+      anc = if respond_to?(:ancestors)
+              if ancestors.include?(self)
+                ancestors[1..-1]
+              else
+                # singletons have no parents (they're orphans)
+                []
+              end
+            else
+              self.class.ancestors
+            end
+      anc.select{|x| x.kind_of?(Class)}
     end
     
     # need concepts of
@@ -164,6 +145,7 @@ class Doodle
     private :collect_inherited
   end
 
+  # = embrace
   # 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
@@ -286,6 +268,8 @@ class Doodle
       end
     end
 
+    #### ERRORS COLLECTION
+
     # where should I put this?
     def errors
       __doodle__.errors
@@ -308,6 +292,8 @@ class Doodle
       end
     end
 
+    #### ERRORS COLLECTION
+    
     def _handle_inherited_hash(tf, method)
       if tf
         collect_inherited(method).inject(OrderedHash.new){ |hash, item|
@@ -330,6 +316,7 @@ class Doodle
     # - if tf == false, returns only those attributes defined in the current object/class
     def attributes(tf = true)
       results = _handle_inherited_hash(tf, :local_attributes)
+      # if an instance, include the singleton_class attributes
       if !kind_of?(Class) && singleton_class.respond_to?(:attributes)
         results = results.merge(singleton_class.attributes)
       end
@@ -402,8 +389,10 @@ class Doodle
     def getter_setter(name, *args, &block)
       name = name.to_sym
       if block_given? || args.size > 0
+        #!p [:getter_setter, :setter, name, *args]
         _setter(name, *args, &block)
       else
+        #!p [:getter_setter, :getter, name]
         _getter(name)
       end
     end
@@ -413,6 +402,7 @@ class Doodle
     def _getter(name, &block)
       ivar = "@#{name}"
       if instance_variable_defined?(ivar)
+        #!p [:_getter, name, ivar, instance_variable_get(ivar)]
         instance_variable_get(ivar)
       else
         # handle default
@@ -421,6 +411,7 @@ class Doodle
         att = lookup_attribute(name)
         # special case for class/singleton :init
         if att.init_defined?
+          #!p [:_setter, att.init]
           _setter(name, att.init)
         elsif att.default_defined?
           case att.default
@@ -441,17 +432,20 @@ class Doodle
 
     # set an attribute by name - apply validation if defined
     def _setter(name, *args, &block)
-      #Doodle::Debug.d { [:_setter, name, args] }
+      ##DBG: Doodle::Debug.d { [:_setter, name, args] }
       ivar = "@#{name}"
       if block_given?
         args.unshift(DeferredBlock.new(block))
       end
       if att = lookup_attribute(name)
-        #Doodle::Debug.d { [:_setter, name, args] }
+        ##DBG: Doodle::Debug.d { [:_setter, name, args] }
+        #!p [:_setter, :got_att, name, *args]
         v = instance_variable_set(ivar, att.validate(self, *args))
+        #!p [:_setter, :got_att, name, :value, v]
         #v = instance_variable_set(ivar, *args)
       else
-        #Doodle::Debug.d { [:_setter, "no attribute"] }
+        #!p [:_setter, :no_att, name, *args]
+        ##DBG: Doodle::Debug.d { [:_setter, "no attribute"] }
         v = instance_variable_set(ivar, *args)
       end
       validate!(false)
@@ -491,37 +485,43 @@ class Doodle
     # convert a value according to conversion rules
     def convert(owner, *args)
       begin
-        value = args.first
-        if (converter = conversions[value.class])
-          value = converter[*args]
-        else
-          # try to find nearest ancestor
-          ancestors = value.class.ancestors
-          matches = ancestors & conversions.keys
-          indexed_matches = matches.map{ |x| ancestors.index(x)}
-          if indexed_matches.size > 0
-            converter_class = ancestors[indexed_matches.min]
-            if converter = conversions[converter_class]
-              value = converter[*args]
+        args = args.map do |value|
+          if (converter = conversions[value.class])
+            #p [:convert, :using, value.class]
+            value = converter[*args]
+          else
+            # try to find nearest ancestor
+            ancestors = value.class.ancestors
+            matches = ancestors & conversions.keys
+            indexed_matches = matches.map{ |x| ancestors.index(x)}
+            if indexed_matches.size > 0
+              converter_class = ancestors[indexed_matches.min]
+              if converter = conversions[converter_class]
+                #p [:convert, :using, converter_class]
+                value = converter[*args]
+              end
             end
           end
+          value
         end
       rescue Exception => e
         owner.handle_error name, ConversionError, e.to_s, [caller[-1]]
       end
-      value
+      if args.size > 1
+        args
+      else
+        args.first
+      end
     end
 
     # validate that args meet rules defined with +must+
     def validate(owner, *args)
-      #Doodle::Debug.d { [:validate, self, :owner, owner, :args, args ] }
-      # if I bypass convert here, the AR inspect wierdness stops
-      # so what is going on?
-      #return args.first
+      ##DBG: Doodle::Debug.d { [:validate, self, :owner, owner, :args, args ] }
+      #!p [:validate, :before_conversion, args]
       value = convert(owner, *args)
-      #return args.first
+      #!p [:validate, :after_conversion, args, :becomes, value]
       validations.each do |v|
-        #Doodle::Debug.d { [:validate, self, v, args, value] }
+        ##DBG: 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
@@ -547,24 +547,50 @@ class Doodle
     end
     private :define_getter_setter
 
-    # define a collector
+    # define a collector for appendable collections
     # - collection should provide a :<< method
-    def define_collector(collection, name, klass = nil, &block)
+    def define_appendable_collector(collection, name, klass = nil, &block)
       # need to use string eval because passing block
       if klass.nil?
         sc_eval("def #{name}(*args, &block); args.unshift(block) if block_given?; #{collection}.<<(*args); end", __FILE__, __LINE__)
       else
-        sc_eval("def #{name}(*args, &block);
-                          if args.all?{|x| x.kind_of?(#{klass})}
+        sc_eval("def #{name}(*args, &block)
+                          if args.size > 0 and args.all?{|x| x.kind_of?(#{klass})}
                             #{collection}.<<(*args)
                           else
-                            #{collection} << #{klass}.new(*args, &block);
+                            #{collection} << #{klass}.new(*args, &block)
                           end
                      end", __FILE__, __LINE__)
       end
     end
-    private :define_collector
+    private :define_appendable_collector
 
+    # define a collector for keyed collections
+    # - collection should provide a :[] method
+    def define_keyed_collector(collection, name, key_method, klass = nil, &block)
+      #DBG: Doodle::Debug.d { [:define_keyed_collector, collection, name, key_method, klass]}
+      # need to use string eval because passing block
+      if klass.nil?
+        sc_eval("def #{name}(*args, &block)
+                   args.each do |arg|
+                     #{collection}[arg.send(:#{key_method})] = arg
+                   end
+                 end", __FILE__, __LINE__)
+      else
+        sc_eval("def #{name}(*args, &block)
+                          if args.size > 0 and args.all?{|x| x.kind_of?(#{klass})}
+                            args.each do |arg|
+                              #{collection}[arg.send(:#{key_method})] = arg
+                            end
+                          else
+                            obj = #{klass}.new(*args, &block)
+                            #{collection}[obj.send(:#{key_method})] = obj
+                          end
+                     end", __FILE__, __LINE__)
+      end
+    end
+    private :define_keyed_collector
+    
     # +has+ is an extended +attr_accessor+
     #
     # simple usage - just like +attr_accessor+:
@@ -588,19 +614,37 @@ class Doodle
     #  end
     #    
     def has(*args, &block)
-      Doodle::Debug.d { [:has, self, self.class, args] }
-      name = args.shift.to_sym
+      #DBG: Doodle::Debug.d { [:has, self, self.class, args] }
       # 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
-      params = { :name => name }
+      if positional_args.size > 0
+        name = positional_args.shift.to_sym
+        params = { :name => name }
+      else
+        params = { }
+      end
       params = key_values.inject(params){ |acc, item| acc.merge(item)}
+      #DBG: Doodle::Debug.d { [:has, self, self.class, params] }
+      if !params.key?(:name)
+        handle_error name, ArgumentError, "Must have a name"
+      else
+        name = params[:name].to_sym
+      end
+      handle_error name, ArgumentError, "Too many arguments" if positional_args.size > 0
 
       # don't pass collector params through to Attribute
       collector_klass = nil
+      # fixme: this should be in specialized attribute class
+      # (and also distinction between appendable and keyed collections
       if collector = params.delete(:collect)
         if !params.key?(:init)
-          params[:init] = []
+          if params.key?(:key)
+            #!p [:defining, :hash, name]
+            params[:init] = { }
+          else
+            #!p [:defining, :array, name]
+            params[:init] = []
+          end
         end
         if collector.kind_of?(Hash)
           collector_name, collector_klass = collector.to_a[0]
@@ -612,23 +656,40 @@ class Doodle
           if collector_klass !~ /^[A-Z]/
             collector_klass = nil
           end
+          #!p [:collector_klass, collector_klass, params[:init]]
+        end
+        if key = params.delete(:key)
+          define_keyed_collector name, collector_name, key, collector_klass
+        else
+          define_appendable_collector name, collector_name, collector_klass
         end
-        define_collector name, collector_name, collector_klass
       end
+
+      # get specialized attribute class or use default
+      attribute_class = params.delete(:using) || Attribute
       
       # define getter setter before setting up attribute
       define_getter_setter name, *args, &block
-      local_attributes[name] = attribute = Attribute.new(params, &block)
+      local_attributes[name] = attribute = attribute_class.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
+        # fixme: this should be in specialized attribute class
+        #!p [:collector_klass2, collector_klass, params[:init]]
         attribute.instance_eval {
+          # applying map to hashes returns an array, so avoid that by simply passing it through
+          from Hash do |hash|
+            hash
+          end
           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|
+            #!p [:enumerating, name, enum]
+            results = enum.map{|x|
+              #!p [:enumerating, x]
               if x.kind_of?(tmp_klass)
                 x
               elsif tmp_klass.conversions.key?(x.class)
@@ -637,6 +698,16 @@ class Doodle
                 tmp_klass.new(x)
               end
             }
+            #!p [:enumerating, :results, results]
+            # fixme: this is all getting a bit too specific to arrays and hashes
+            # figure out a way to do this with specialized Doodle::Attribute?
+            if !key.nil?
+              results = results.inject({ }) do |hash, result|
+                hash[result.send(key)] = result
+                hash
+              end
+            end
+            results
           end
         }
       end
@@ -647,7 +718,7 @@ class Doodle
     def arg_order(*args)
       if args.size > 0
         begin
-          args.uniq!
+          args = args.uniq
           args.each do |x|
             handle_error :arg_order, ArgumentError, "#{x} not a Symbol" if !(x.class <= Symbol)
             handle_error :arg_order, NameError, "#{x} not an attribute name" if !attributes.keys.include?(x)
@@ -662,7 +733,8 @@ class Doodle
     end
 
     def get_init_values(tf = true)
-      attributes(tf).select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)| 
+      attributes(tf).select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)|
+        #!p [:get_init_values, a.init]
         hash[n] = begin
                     case a.init
                     when NilClass, TrueClass, FalseClass, Fixnum
@@ -675,7 +747,8 @@ class Doodle
                   rescue Exception => e
                     a.init
                   end
-        ; hash }
+        hash
+      }
     end
     private :get_init_values
 
@@ -688,22 +761,22 @@ class 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)
-      #Doodle::Debug.d { [:validate!, all, caller] }
+      ##DBG: Doodle::Debug.d { [:validate!, all, caller] }
       if all
         clear_errors
       end
       if __doodle__.validation_on
         if self.class == Class
           attribs = class_attributes
-          #Doodle::Debug.d { [:validate!, "using class_attributes", class_attributes] }
+          ##DBG: Doodle::Debug.d { [:validate!, "using class_attributes", class_attributes] }
         else
           attribs = attributes
-          #Doodle::Debug.d { [:validate!, "using instance_attributes", attributes] }
+          ##DBG: Doodle::Debug.d { [:validate!, "using instance_attributes", attributes] }
         end
         attribs.each do |name, att|
           # treat default as special case
           if att.default_defined?
-            #Doodle::Debug.d { [:validate!, "default_defined - breaking" ]}
+            ##DBG: Doodle::Debug.d { [:validate!, "default_defined - breaking" ]}
             break
           end
           ivar_name = "@#{att.name}"
@@ -712,7 +785,7 @@ class Doodle
             # 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) ] }
+              ##DBG: 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
@@ -721,9 +794,9 @@ class Doodle
         end
         # now apply instance level validations
         
-        #Doodle::Debug.d { [:validate!, "validations", validations ]}
+        ##DBG: Doodle::Debug.d { [:validate!, "validations", validations ]}
         validations.each do |v|
-          #Doodle::Debug.d { [:validate!, self, v ] }
+          ##DBG: Doodle::Debug.d { [:validate!, self, v ] }
           begin
             if !instance_eval(&v.block)
               handle_error self, ValidationError, "#{ self.class } must #{ v.message }", [caller[-1]]
@@ -756,31 +829,38 @@ class Doodle
     # after initialization (validate! is called if this method is
     # called after initialization)
     def initialize_from_hash(*args)
+      #!p [:initialize_from_hash, :args, *args]
       defer_validation do
         # hash initializer
         # separate into array of hashes of form [{:k1 => v1}, {:k2 => v2}] and positional args 
         key_values, args = args.partition{ |x| x.kind_of?(Hash)}
-        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)))]
+        #DBG: Doodle::Debug.d { [self.class, :initialize_from_hash, :key_values, key_values, :args, args] }
+        #!p [self.class, :initialize_from_hash, :key_values, key_values, :args, args]
 
         # set up initial values with ~clones~ of specified values (so not shared between instances)
         init_values = get_init_values
-
-        # add to start of key_values array (so can be overridden by params)
-        key_values.unshift(init_values)
+        #p [:init_values, init_values]
+        
+        # match up positional args with attribute names (from arg_order) using idiom to create hash from array of assocs
+        arg_keywords = init_values.merge(Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))])
+        #p [self.class, :initialize_from_hash, :arg_keywords, arg_keywords]
 
         # merge all hash args into one
-        key_values = key_values.inject(arg_keywords) { |hash, item| hash.merge(item)}
+        key_values = key_values.inject(arg_keywords) { |hash, item|
+          #p [self.class, :initialize_from_hash, :merge, hash, item]
+          hash.merge(item)
+        }
+        #p [self.class, :initialize_from_hash, :key_values2, key_values]
 
         # 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] }
+        #DBG: Doodle::Debug.d { [self.class, :initialize_from_hash, :key_values2, key_values, :args2, args] }
+        #p [self.class, :initialize_from_hash, :key_values3, key_values]
         
         # create attributes
         key_values.keys.each do |key|
-          Doodle::Debug.d { [self.class, :initialize_from_hash, :setting, key, key_values[key]] }
+          #DBG: Doodle::Debug.d { [self.class, :initialize_from_hash, :setting, key, key_values[key]] }
+          #p [self.class, :initialize_from_hash, :setting, key, key_values[key]]
           if respond_to?(key)
             __send__(key, key_values[key])
           else