doodle 0.2.2 → 0.2.3

data/lib/doodle/validation.rb

@@ -0,0 +1,122 @@
+class Doodle
+  # A Validation represents a validation rule applied to the instance
+  # after initialization. Generated using the Doodle::BaseMethods#must directive.
+  class Validation
+    attr_accessor :message
+    attr_accessor :block
+    # create a new validation rule. This is typically a result of
+    # calling +must+ so the text should work following the word
+    # "must", e.g. "must not be nil", "must be >= 10", etc.
+    def initialize(message = 'not be nil', &block)
+      @message = message
+      @block = block_given? ? block : proc { |x| !self.nil? }
+    end
+  end
+
+  module ValidationHelper
+    # add a validation
+    def must(constraint = 'be valid', &block)
+      __doodle__.local_validations << Validation.new(constraint, &block)
+    end
+
+    # add a validation that attribute must be of class <= kind
+    def kind(*args, &block)
+      if args.size > 0
+        @kind = [args].flatten
+        # todo[figure out how to handle kind being specified twice?]
+        if @kind.size > 2
+          kind_text = "be a kind of #{ @kind[0..-2].map{ |x| x.to_s }.join(', ') } or #{@kind[-1].to_s}" # =>
+        else
+          kind_text = "be a kind of #{@kind.to_s}"
+        end
+        __doodle__.local_validations << (Validation.new(kind_text) { |x| @kind.any? { |klass| x.kind_of?(klass) } })
+      else
+        @kind ||= []
+      end
+    end
+
+    # validate that individual attribute args meet rules defined with +must+
+    # fixme: move
+    def validate(owner, *args)
+      ##DBG: Doodle::Debug.d { [:validate, self, :owner, owner, :args, args ] }
+      #p [:validate, 1, args]
+      begin
+        value = convert(owner, *args)
+      rescue Exception => e
+        owner.__doodle__.handle_error name, ConversionError, "#{owner.kind_of?(Class) ? owner : owner.class}.#{ name } - #{e.message}", Doodle::Utils.doodle_caller
+      end
+      #
+      # Note to self: these validations are not affected by
+      # doodle.validation_on because they are for ~individual
+      # attributes~ - validation_on is for the ~object as a whole~ -
+      # so don't futz with this again :)
+      #
+      # p [:validate, 2, args, :becomes, value]
+      __doodle__.validations.each do |v|
+        ##DBG: Doodle::Debug.d { [:validate, self, v, args, value] }
+        if !v.block[value]
+          owner.__doodle__.handle_error name, ValidationError, "#{owner.kind_of?(Class) ? owner : owner.class}.#{ name } must #{ v.message } - got #{ value.class }(#{ value.inspect })", Doodle::Utils.doodle_caller
+        end
+      end
+      #p [:validate, 3, value]
+      value
+    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)
+      ##DBG: Doodle::Debug.d { [:validate!, all, caller] }
+      if all
+        __doodle__.errors.clear
+      end
+
+      # first check that individual attributes are valid
+
+      if __doodle__.validation_on
+        if self.class == Class
+          attribs = __doodle__.class_attributes
+          ##DBG: Doodle::Debug.d { [:validate!, "using class_attributes", class_attributes] }
+        else
+          attribs = __doodle__.attributes
+          ##DBG: Doodle::Debug.d { [:validate!, "using instance_attributes", doodle.attributes] }
+        end
+        attribs.each do |name, att|
+          if ivar_defined?(name)
+            # if all == true, reset values so conversions and
+            # validations are applied to raw instance variables
+            # e.g. when loaded from YAML
+            if all && !att.readonly
+              ##DBG: Doodle::Debug.d { [:validate!, :sending, att.name, instance_variable_get(ivar_name) ] }
+              __send__("#{name}=", ivar_get(name))
+            end
+          elsif att.optional?   # treat default/init as special case
+            ##DBG: Doodle::Debug.d { [:validate!, :optional, name ]}
+            next
+          elsif self.class != Class
+            __doodle__.handle_error name, Doodle::ValidationError, "#{self.kind_of?(Class) ? self : self.class } missing required attribute '#{name}'", Doodle::Utils.doodle_caller
+          end
+        end
+
+        # now apply whole object level validations
+
+        ##DBG: Doodle::Debug.d { [:validate!, "validations", doodle_validations ]}
+        __doodle__.validations.each do |v|
+          ##DBG: Doodle::Debug.d { [:validate!, self, v ] }
+          begin
+            if !instance_eval(&v.block)
+              __doodle__.handle_error self, ValidationError, "#{ self.class } must #{ v.message }", Doodle::Utils.doodle_caller
+            end
+          rescue Exception => e
+            __doodle__.handle_error self, ValidationError, e.to_s, Doodle::Utils.doodle_caller
+          end
+        end
+      end
+      # if OK, then return self
+      self
+    end
+
+  end
+end

data/lib/doodle/version.rb

@@ -2,7 +2,7 @@ class Doodle #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 2
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/molic_orderedhash.rb

@@ -1,14 +1,14 @@
-# AUTHOR
-#    jan molic /mig/at/1984/dot/cz/
-#
-# DESCRIPTION
-#    Hash with preserved order and some array-like extensions
-#    Public domain.
-#
-# THANKS
-#    Andrew Johnson for his suggestions and fixes of Hash[],
-#    merge, to_a, inspect and shift
 class Doodle
+  # AUTHOR
+  #    jan molic /mig/at/1984/dot/cz/
+  #
+  # DESCRIPTION
+  #    Hash with preserved order and some array-like extensions
+  #    Public domain.
+  #
+  # THANKS
+  #    Andrew Johnson for his suggestions and fixes of Hash[],
+  #    merge, to_a, inspect and shift
   class OrderedHash < ::Hash
     attr_accessor :order
 
@@ -29,6 +29,16 @@ class Doodle
       super
       @order = []
     end
+    def clone
+      c = super
+      c.order = order.clone
+      c
+    end
+    def dup
+      c = super
+      c.order = order.dup
+      c
+    end
     def store_only(a,b)
       store a,b
     end
@@ -39,9 +49,13 @@ class Doodle
     end
     alias []= store
     def ==(hsh2)
+      return false if !hsh2.respond_to?(:order)
       return false if @order != hsh2.order
       super hsh2
     end
+#     def eql?(hsh2)
+#       super hsh2
+#     end
     def clear
       @order = []
       super

data/spec/assigned_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Doodle, 'assigned? with default' do
+  temporary_constant :Foo do
+
+    before :each do
+      class Foo < Doodle
+        has :name, :default => nil
+      end
+    end
+
+    it 'should return false if attribute not assigned' do
+      foo = Foo.new
+      foo.assigned?(:name).should_be false
+    end
+
+    it 'should return true if attribute assigned' do
+      foo = Foo.new('foo')
+      foo.assigned?(:name).should_be true
+    end
+
+  end
+end
+
+describe Doodle, 'assigned? with init' do
+  temporary_constant :Foo do
+
+    before :each do
+      class Foo < Doodle
+        has :name, :init => ""
+      end
+    end
+
+    it 'should return true if attribute has init even when not specifically assigned' do
+      foo = Foo.new
+      foo.assigned?(:name).should_be true
+    end
+
+    it 'should return true if attribute has init and has been assigned' do
+      foo = Foo.new('foo')
+      foo.assigned?(:name).should_be true
+    end
+
+  end
+end

data/spec/attributes_spec.rb

@@ -16,7 +16,7 @@ describe Doodle::DoodleAttribute, 'basics' do
           has :cvar2
         end
       end
-    
+
       @foo = Foo.new
       class << @foo
         has :svar1
@@ -31,7 +31,7 @@ describe Doodle::DoodleAttribute, 'basics' do
       @bar = nil
       @foo = nil
     end
-    
+
     it 'should have attribute :ivar1 with default defined' do
       @foo.doodle.attributes[:ivar1].default.should == 'Hello'
     end
@@ -68,7 +68,7 @@ describe Doodle::DoodleAttribute, 'basics' do
 #       expected_doodle.parents = RUBY_VERSION <= "1.8.6" ? [Foo, Object] : [Foo, Object, BasicObject]
 #       Bar.doodle.parents.should == expected_doodle.parents
 #     end
-    
+
     it "should have Bar's singleton doodle.parents in reverse order of definition" do
       @bar.singleton_class.doodle.parents.should == []
     end
@@ -84,20 +84,20 @@ describe Doodle::DoodleAttribute, 'basics' do
     it 'should have inherited class_attributes in order of definition' do
       @bar.doodle.class_attributes.keys.should == [:cvar1, :cvar2]
     end
-    
+
     it 'should have local class attributes in order of definition' do
       Bar.singleton_class.doodle.attributes(false).keys.should == [:cvar2]
     end
 
     # bit iffy this test - testing implementation, not interface
     it 'should not inherit singleton doodle.local_attributes' do
-      @bar.singleton_class.class_eval { doodle.collect_inherited(:local_attributes).map { |x| x[0]} }.should == []
+      @bar.singleton_class.class_eval { doodle.send(:collect_inherited, :local_attributes).map { |x| x[0]} }.should == []
     end
 
     it 'should not inherit singleton attributes#1' do
       @bar.singleton_class.doodle.attributes.map { |x| x[0]} .should == [:svar2]
     end
-    
+
     it 'should not inherit singleton attributes#2' do
       @bar.singleton_class.doodle.attributes.keys.should == [:svar2]
     end
@@ -128,7 +128,7 @@ describe Doodle::DoodleAttribute, 'attribute order' do
         has :c
       end
     end
-  
+
 #     it 'should keep order of inherited attributes' do
 #       expected_doodle.parents = RUBY_VERSION <= "1.8.6" ? [B, A, Doodle, Object] : [B, A, Doodle, Object, BasicObject]
 #       C.doodle.parents.should == expected_doodle.parents

data/spec/collector_spec.rb

@@ -113,12 +113,12 @@ describe Doodle, "typed collector with specified collector name" do
     end
     it "should collect items into attribute :list" do
       event = nil
-      proc {
+      no_error {
         event = Event do
           place "Stage 1"
           place "Stage 2"
         end
-      }.should_not raise_error
+      }
       event.locations.map{|loc| loc.name}.should_be ["Stage 1", "Stage 2"]
       event.locations.map{|loc| loc.class}.should_be [::Location, ::Location]
     end
@@ -150,9 +150,9 @@ describe Doodle, "typed collector with specified collector name initialized from
               :locations =>
               [ { :name => 'Backstage' } ] } ] }, { :name => "Stage 2" } ] }
       # note: wierd formatting above simply to pass coverage
-      proc {
+      no_error {
         event = Event(data)
-      }.should_not raise_error
+      }
       event.locations.map{|loc| loc.name}.should_be ["Stage 1", "Stage 2"]
       event.locations.map{|loc| loc.class}.should_be [::Location, ::Location]
       event.locations[0].events[0].kind_of?(Event).should_be true
@@ -180,7 +180,8 @@ describe Doodle, "Simple keyed collector" do
     end
 
     it "should collect items into attribute :list" do
-      @foo.list.should_be( { 5 => "World" } )
+      # @foo.list.should_be( Doodle::OrderedHash[5, "World"] )
+      @foo.list.to_a.flatten.should_be( [5, "World"] )
     end
 
   end
@@ -208,7 +209,7 @@ describe Doodle, "Simple keyed collector #2" do
         item "Hello"
         item "World"
       end
-      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+      foo.list.to_a.sort.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
     end
 
     it "should collect keyword argument enumerable into attribute :list" do
@@ -218,7 +219,7 @@ describe Doodle, "Simple keyed collector #2" do
                  { :name => "World" }
                 ]
                 )
-      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+      foo.list.to_a.sort.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
     end
 
     it "should collect positional argument enumerable into attribute :list" do
@@ -227,7 +228,7 @@ describe Doodle, "Simple keyed collector #2" do
                 { :name => "World" }
                 ]
                 )
-      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+      foo.list.to_a.sort.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
     end
 
     it "should collect named argument hash into attribute :list" do
@@ -236,7 +237,7 @@ describe Doodle, "Simple keyed collector #2" do
                   "World" => { :name => "World" }
                 }
                 )
-      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+      foo.list.to_a.sort.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
     end
 
   end
@@ -255,12 +256,12 @@ describe Doodle, 'using String as collector' do
     end
 
     it 'should not raise an exception' do
-      proc {
+      no_error {
         text = Text do
           line "line 1"
           line "line 2"
         end
-      }.should_not raise_error
+      }
     end
 
     it 'should concatenate strings' do
@@ -291,11 +292,11 @@ describe Doodle, 'collecting text values into non-String collector' do
     end
 
     it 'should not raise an exception' do
-      proc {
+      no_error {
         signed_by = SignedBy do
           signature "Sean"
         end
-      }.should_not raise_error
+      }
     end
 
     it 'should convert String values to instances of collector class' do
@@ -308,3 +309,89 @@ describe Doodle, 'collecting text values into non-String collector' do
     end
   end
 end
+
+describe Doodle, ':collect' do
+  temporary_constants :ItemList, :Item do
+
+    before :each do
+      class ::Item < Doodle
+        has :title, :kind => String
+      end
+      class ItemList < Doodle
+        has :items, :collect => Item
+        # TODO: add warning/exception if collection name same as item name
+      end
+    end
+
+    it 'should allow adding items of specified type' do
+      no_error {
+        list = ItemList do
+          item Item("one")
+          item Item("two")
+        end
+      }
+    end
+
+    it 'should allow adding items of specified type via implicit type constructor' do
+      no_error {
+        list = ItemList do
+          item "one"
+          item "two"
+        end
+      }
+    end
+
+    it 'should restrict collected items to specified type' do
+      expect_error(Doodle::ValidationError) {
+        list = ItemList do
+          item Date.new
+        end
+      }
+    end
+
+  end
+end
+
+describe Doodle, ':collect' do
+  temporary_constants :Canvas, :Shape, :Circle, :Square do
+    before :each do
+      class ::Shape < Doodle
+        has :x
+        has :y
+      end
+      class ::Circle < Shape
+        has :radius
+      end
+      class ::Square < Shape
+        has :size
+      end
+    end
+
+    it 'should accept an array of types' do
+      class ::Canvas < Doodle
+        has :shapes, :collect => [Circle, Square]
+      end
+      canvas = Canvas do
+        circle 10,10,5
+        square 20,30,40
+      end
+      canvas.shapes.size.should_be 2
+      canvas.shapes[0].kind_of?(Circle).should_be true
+      canvas.shapes[1].should_be Square(20, 30, 40)
+    end
+
+    it 'should accept a hash of types' do
+      class ::Canvas < Doodle
+        has :shapes, :collect => { :circle => Circle, :square => Square }
+      end
+      canvas = Canvas do
+        circle 10,10,5
+        square 20,30,40
+      end
+      canvas.shapes.size.should_be 2
+      canvas.shapes[0].kind_of?(Circle).should_be true
+      canvas.shapes[1].kind_of?(Square).should_be true
+    end
+  end
+end
+