doodle 0.0.4 → 0.0.5

data/ChangeLog

@@ -1,12 +1,41 @@
-2008-03-12  seano  <sean.ohalpin@gmail.com>
+= ChangeLog for doodle
 
-	* added init_spec
+== 0.0.5 / 2008-03-16
 
-	* tweaked Rakefile (don't run profile by default, fix dcov task)
+- added collector_spec
 
-	* allow :collect => :name form for collecting raw
-	  objects (i.e. don't do a klass.new(*args) on values)
+- tidied up validation specs
 
-	* use snake_case (from facets) when generating name from class for
-	  collect
+- 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)
+  - errors - returns array of error information
+  - clear_errors - clears errors array
+  - this is still a bit rough - work in progress
+
+- fixed problem with init borking when given non-cloneable object (e.g. Fixnum)
+
+- added serialize_spec
+
+- validate! now validates all attributes too by default (no need to use validate!(true) any more)
+
+== 2008-03-15  Sean O'Halpin  <ohalps01@MC-S001853.local>
+
+- added option (all=true|false) to validate! if true, will
+  validate all attributes as well as invoking object level validation
+
+- made validate! public
+
+== 2008-03-12  seano  <sean.ohalpin@gmail.com>
+
+- added init_spec
+
+- tweaked Rakefile (don't run profile by default, fix dcov task)
+
+- allow :collect => :name form for collecting raw
+  objects (i.e. don't do a klass.new(*args) on values)
+
+- use snake_case (from facets) when generating name from class for
+  collect
 

data/lib/doodle.rb

@@ -1,11 +1,10 @@
 # doodle
 # Copyright (C) 2007 by Sean O'Halpin, 2007-11-24
 
-require 'molic_orderedhash'  # todo[replace this with own (required function only) version]
+require 'molic_orderedhash'  # todo[replace this with own (required functions only) version]
 
-# *doodle* is my attempt at a metaprogramming framework that does not
-# have to inject methods into core Ruby objects such as Object, Class
-# and Module.
+# *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
@@ -16,16 +15,16 @@ require 'molic_orderedhash'  # todo[replace this with own (required function onl
 module Doodle
   module Debug
     class << self
-      # output result of block if DEBUG_DOODLE set
+      # output result of block if ENV['DEBUG_DOODLE'] set
       def d(&block)
         p(block.call) if ENV['DEBUG_DOODLE']
       end
     end
   end
 
-  module Utils
-    # Unnest arrays by one level of nesting - for example, [1, [[2], 3]] => [1, [2], 3].
-    # This is a function to avoid changing base classes.
+  # 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
@@ -190,10 +189,6 @@ module Doodle
           break
         end
       end
-      # d { [:collect_inherited, :result, message, result] }
-      if self.class.respond_to?(message)
-        result.unshift(*self.class.send(message))
-      end
       result
     end
     private :collect_inherited
@@ -255,11 +250,20 @@ module Doodle
 
   class DoodleInfo
     DOODLES = {}
+    @@raise_exception_on_error = true
     attr_accessor :local_attributes
     attr_accessor :local_validations
     attr_accessor :local_conversions
     attr_accessor :validation_on
     attr_accessor :arg_order
+    attr_accessor :errors
+    
+    def self.raise_exception_on_error
+      @@raise_exception_on_error
+    end
+    def self.raise_exception_on_error=(tf)
+      @@raise_exception_on_error = tf
+    end
     
     def initialize(object)
       @local_attributes = OrderedHash.new
@@ -267,8 +271,12 @@ module Doodle
       @validation_on = true
       @local_conversions = {}
       @arg_order = []
+      @errors = []
+
       oid = object.object_id
       ObjectSpace.define_finalizer(object) do
+        # this seems to be called only on exit
+        Doodle::Debug.d { "finalizing #{oid}" }
         DOODLES.delete(oid)
       end
     end
@@ -281,13 +289,36 @@ module Doodle
     include Inherited
 
     # this is the only way to get at internal values
-    # FIXME: this is going to leak memory
+    # FIXME: this is going to leak memory (I think)
     
     def __doodle__
       DoodleInfo::DOODLES[object_id] ||= DoodleInfo.new(self)
     end
     private :__doodle__
     
+    # handle errors either by collecting in :errors or raising an exception
+    def handle_error(name, *args)
+      __doodle__.errors << [name, *args]
+      if DoodleInfo.raise_exception_on_error
+        raise *args
+      end
+    end
+
+    # get list of errors
+    def errors
+      errs = attributes.inject([]) do |e, (n, a)|
+        e.push(*a.send(:__doodle__).errors)
+        e
+      end
+      errs.push(__doodle__.errors).reject{|x| x.size == 0}
+    end
+    def clear_errors
+      attributes.each do |n, a|
+        a.send(:__doodle__).errors.clear
+      end
+      __doodle__.errors.clear
+    end
+
     # return attributes defined in instance
     def local_attributes
       __doodle__.local_attributes
@@ -321,7 +352,9 @@ module Doodle
     # - if tf == false, returns only those validations defined in the current object/class
     def validations(tf = true)
       if tf
-        local_validations.push(*collect_inherited(:local_validations))
+        #p [:inherited_validations, collect_inherited(:local_validations)]
+        #p [:local_validations, local_validations]
+        local_validations + collect_inherited(:local_validations)
       else
         local_validations
       end
@@ -340,7 +373,7 @@ module Doodle
       if tf
         a = collect_inherited(:local_conversions).inject(OrderedHash.new){ |hash, item|
           #p [:hash, hash, :item, item]
-          hash.merge(Hash[*item])
+          hash.merge(OrderedHash[*item])
         }.merge(self.local_conversions)
         # d { [:conversions, self.to_s, a] }
         a
@@ -353,7 +386,7 @@ module Doodle
     def lookup_attribute(name)
       # (look at singleton attributes first)
       # fixme[this smells like a hack to me - why not handled in attributes?]
-      att = meta.attributes[name] || attributes[name]
+      meta.attributes[name] || attributes[name]
     end
     private :lookup_attribute
 
@@ -387,23 +420,19 @@ module Doodle
         v
       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] }
+        #d { [:getter, name, att, block] }
         if att.default_defined?
           if att.default.kind_of?(Proc)
-            default = instance_eval(&att.default)
+            instance_eval(&att.default)
           else
-            default = att.default
+            att.default
           end
-          #d { [:_getter, :default, name, default] } Note: once the
-          # default is accessed, the instance variable is set. I think
-          # I would prefer not to do this and to have :init => value
-          # instead to cover cases where defaults don't work
-          # (e.g. arrays that disappear when you go out of scope)
-          #instance_variable_set("@#{name}", default)
-          default
         else
-          raise NoDefaultError, "'#{name}' has no default defined", [caller[-1]]
+          # This is an internal error (i.e. shouldn't happen)
+          handle_error name, NoDefaultError, "Internal error - '#{name}' has no default defined", [caller[-1]]
         end
       end
     end
@@ -424,7 +453,7 @@ module Doodle
         #d { [:_setter, :instance_variable_set, ivar, args ] }
         v = instance_variable_set(ivar, *args)
       end
-      validate!
+      validate!(false)
       v
     end
     private :_setter
@@ -479,7 +508,7 @@ module Doodle
           end
         end
       rescue => e
-        raise ValidationError, e.to_s, [caller[-1]]
+        handle_error name, ConversionError, e.to_s, [caller[-1]]
       end
       value
     end
@@ -491,7 +520,7 @@ module Doodle
       validations.each do |v|
         Doodle::Debug.d { [:validate, self, v, args ] }
         if !v.block[value]
-          raise ValidationError, "#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", [caller[-1]]
+          handle_error name, ValidationError, "#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", [caller[-1]]
         end
       end
       #d { [:validate, :value, value ] }
@@ -547,7 +576,7 @@ module Doodle
       name = args.shift.to_sym
       # d { [:has2, name, args] }
       key_values, positional_args = args.partition{ |x| x.kind_of?(Hash)}
-      raise ArgumentError, "Too many arguments" if positional_args.size > 0
+      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)}
@@ -581,13 +610,13 @@ module Doodle
           #p [:arg_order, 1, self, self.class, args]
           args.uniq!
           args.each do |x|
-            raise Exception, "#{x} not a Symbol" if !(x.class <= Symbol)
-            raise Exception, "#{x} not an attribute name" if !attributes.keys.include?(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)
           end
           __doodle__.arg_order = args
         rescue Exception => e
           #p [InvalidOrderError, e.to_s]
-          raise InvalidOrderError, e.to_s, [caller[-1]]
+          handle_error :arg_order, InvalidOrderError, e.to_s, [caller[-1]]
         end
       else
         #p [:arg_order, 3, self, self.class, :default]
@@ -610,7 +639,7 @@ module Doodle
         # d { [:initialize, :arg_keywords, arg_keywords] }
 
         # set up initial values with ~clones~ of specified values (so not shared between instances)
-        init_values = attributes.select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)| hash[n] = a.init.clone; hash }
+        init_values = attributes.select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)| hash[n] = a.init.clone rescue a.init; hash }
           
         # add to start of key_values (so can be overridden by params)
         key_values.unshift(init_values)
@@ -638,8 +667,8 @@ module Doodle
     private :ivar_defined?
 
     # validate this object by applying all validations in sequence
-    # - if all == true, validate all attributes, e.g. when loaded from YAML
-    def validate!(all = false)
+    # - 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!, self] }
       #Doodle::Debug.d { [:validate!, self, __doodle__.validation_on] }
       if __doodle__.validation_on
@@ -648,7 +677,7 @@ module Doodle
           if att.name == :default || att.default_defined?
             # nop
           elsif !ivar_defined?(att.name)
-            raise ArgumentError, "#{self} missing required attribute '#{name}'", [caller[-1]]
+            handle_error name, ArgumentError, "#{self} missing required attribute '#{name}'", [caller[-1]]
           end
           # if all == true, validate all attributes - e.g. when loaded from YAML
           if all
@@ -657,9 +686,9 @@ module Doodle
         end
 
         validations.each do |v|
-          Doodle::Debug.d { [:validate!, self, v ] }
+          #Doodle::Debug.d { [:validate!, self, v ] }
           if !instance_eval(&v.block)
-            raise ValidationError, "#{ self.inspect } must #{ v.message }", [caller[-1]]
+            handle_error :validate!, ValidationError, "#{ self.inspect } must #{ v.message }", [caller[-1]]
           end
         end
       end
@@ -676,7 +705,7 @@ module Doodle
       ensure
         __doodle__.validation_on = old_validation
       end
-      validate!
+      validate!(false)
       v
     end
 
@@ -775,7 +804,7 @@ module Doodle
     # it will fail because Attribute is not a kind of Date -
     # obviously, I have to think about this some more :S
     #
-    def validate!
+    def validate!(all = true)
     end
 
     # is this attribute optional? true if it has a default defined for it

data/spec/arg_order_spec.rb

@@ -1,125 +1,108 @@
-require 'lib/spec_helper'
+require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe 'arg_order' do
-  before :each do
-    raise_if_defined :Foo
-    class Foo < Doodle::Base
-      has :name
-      has :extra
-      has :value
-      arg_order :value, :name
+  temporary_constant :Foo do
+    before :each do
+      class Foo < Doodle::Base
+        has :name
+        has :extra
+        has :value
+        arg_order :value, :name
+      end
+    end
+    it 'should specify order of positional arguments' do
+      foo = Foo.new 1, 2, 3
+      foo.value.should == 1
+      foo.name.should == 2
+      foo.extra.should == 3
     end
-  end
-  after :each do
-    undefine_const :Foo
-  end
-  it 'should specify order of positional arguments' do
-    foo = Foo.new 1, 2, 3
-    foo.value.should == 1
-    foo.name.should == 2
-    foo.extra.should == 3
-  end
 
-  it 'should allow only symbols as arguments to arg_order' do
-    proc { Foo.arg_order Foo}.should raise_error(Doodle::InvalidOrderError)
-    proc { Foo.arg_order 1}.should raise_error(Doodle::InvalidOrderError)
-    proc { Foo.arg_order Date.new}.should raise_error(Doodle::InvalidOrderError)
-  end
+    it 'should allow only symbols as arguments to arg_order' do
+      proc { Foo.arg_order Foo}.should raise_error(Doodle::InvalidOrderError)
+      proc { Foo.arg_order 1}.should raise_error(Doodle::InvalidOrderError)
+      proc { Foo.arg_order Date.new}.should raise_error(Doodle::InvalidOrderError)
+    end
 
-  it 'should not allow invalid positional arguments' do
-    proc { Foo.arg_order :smoo}.should raise_error(Doodle::InvalidOrderError)
-    proc { Foo.arg_order :name, :value}.should_not raise_error
-  end  
+    it 'should not allow invalid positional arguments' do
+      proc { Foo.arg_order :smoo}.should raise_error(Doodle::InvalidOrderError)
+      proc { Foo.arg_order :name, :value}.should_not raise_error
+    end
+  end
 end
 
 describe 'arg_order' do
-  before :each do
-    raise_if_defined :Foo, :Bar
-    class Foo < Doodle::Base
-      has :name
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Foo < Doodle::Base
+        has :name
+      end
+      class Bar < Foo
+        has :value
+      end
     end
-    class Bar < Foo
-      has :value
+    it 'should specify order of positional arguments' do
+      f = Bar.new 1, 2
+      f.name.should == 1
+      f.value.should == 2
     end
   end
-  after :each do
-    undefine_const(:Bar)
-    undefine_const(:Foo)
-  end
-  it 'should specify order of positional arguments' do
-    f = Bar.new 1, 2
-    f.name.should == 1
-    f.value.should == 2
-  end  
 end
 
 describe 'arg_order' do
-  before :each do
-    raise_if_defined(:Foo, :Bar)
-    class Foo < Doodle::Base
-      has :name
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Foo < Doodle::Base
+        has :name
+      end
+      class Bar < Foo
+        has :value
+        arg_order :value, :name
+      end
     end
-    class Bar < Foo
-      has :value
-      arg_order :value, :name
-    end
-  end
-  after :each do
-    undefine_const(:Bar)
-    undefine_const(:Foo)
+    it 'should specify order of positional arguments' do
+      f = Bar.new 1, 2
+      f.value.should == 1
+      f.name.should == 2
+    end  
   end
-  it 'should specify order of positional arguments' do
-    f = Bar.new 1, 2
-    f.value.should == 1
-    f.name.should == 2
-  end  
-
 end
 
 describe 'arg_order' do
-  before :each do
-    raise_if_defined(:Foo, :Bar)
-    class Foo < Doodle::Base
-      has :name, :default => proc { self.class.to_s.downcase }
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Foo < Doodle::Base
+        has :name, :default => proc { self.class.to_s.downcase }
+      end
+      class Bar < Foo
+        has :value
+        arg_order :value, :name
+      end
     end
-    class Bar < Foo
-      has :value
-      arg_order :value, :name
-    end
-  end
-  after :each do
-    undefine_const(:Bar, :Foo)
-  end
   
-  it 'should specify order of positional arguments' do
-    f = Bar.new 1
-    f.value.should == 1
-    f.name.should == "bar"
-  end  
-
+    it 'should specify order of positional arguments' do
+      f = Bar.new 1
+      f.value.should == 1
+      f.name.should == "bar"
+    end  
+  end
 end
 
 describe 'arg_order' do
-  after :each do
-    undefine_const(:Bar, :Foo)
-  end
-  before :each do
-    raise_if_defined(:Foo, :Bar)
-    class Foo < Doodle::Base
-      has :name
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Foo < Doodle::Base
+        has :name
+      end
+      class Bar < Foo
+        has :value
+        arg_order :value, :name
+      end
     end
-    class Bar < Foo
-      has :value
-      arg_order :value, :name
-    end
-  end
   
-  it 'should specify order of positional arguments' do
-    f = Bar.new 1, "bar"
-    f.value.should == 1
-    f.name.should == "bar"
-  end  
-
+    it 'should specify order of positional arguments' do
+      f = Bar.new 1, "bar"
+      f.value.should == 1
+      f.name.should == "bar"
+    end  
+  end
 end
-
-raise_if_defined(:Foo, :Bar)