doodle 0.1.5 → 0.1.6

data/lib/doodle/version.rb

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

data/spec/attributes_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
-describe Doodle::Attribute, 'basics' do
+describe Doodle::DoodleAttribute, 'basics' do
   temporary_constants :Foo, :Bar do
     before(:each) do
       class Foo
@@ -33,7 +33,7 @@ describe Doodle::Attribute, 'basics' do
     end
     
     it 'should have attribute :ivar1 with default defined' do
-      @foo.attributes[:ivar1].default.should == 'Hello'
+      @foo.doodle_attributes[:ivar1].default.should == 'Hello'
     end
 
     it 'should have default name' do
@@ -45,36 +45,36 @@ describe Doodle::Attribute, 'basics' do
     end
 
     it 'should have name required == false (because has default)' do
-      @foo.attributes[:ivar1].required?.should == false
+      @foo.doodle_attributes[:ivar1].required?.should == false
     end
 
     it 'should have ivar2 required == true' do
-      @bar.attributes[:ivar2].required?.should == true
+      @bar.doodle_attributes[:ivar2].required?.should == true
     end
 
     it 'should have name.optional? == true (because has default)' do
-      @foo.attributes[:ivar1].optional?.should == true
+      @foo.doodle_attributes[:ivar1].optional?.should == true
     end
 
     it 'should inherit attribute from parent' do
-      @bar.attributes[:ivar1].should == @foo.attributes[:ivar1]
+      @bar.doodle_attributes[:ivar1].should == @foo.doodle_attributes[:ivar1]
     end
 
     it 'should have ivar2.optional? == false' do
-      @bar.attributes[:ivar2].optional?.should == false
+      @bar.doodle_attributes[:ivar2].optional?.should == false
     end
 
-#     it "should have parents in correct order" do
-#       expected_parents = RUBY_VERSION <= "1.8.6" ? [Foo, Object] : [Foo, Object, BasicObject]
-#       Bar.parents.should == expected_parents
+#     it "should have doodle_parents in correct order" 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 parents in reverse order of definition" do
-      @bar.singleton_class.parents.should == []
+    it "should have Bar's singleton doodle_parents in reverse order of definition" do
+      @bar.singleton_class.doodle_parents.should == []
     end
 
     it 'should have singleton_class attributes in order of definition' do
-      Bar.singleton_class.attributes.keys.should == [:cvar2]
+      Bar.singleton_class.doodle_attributes.keys.should == [:cvar2]
     end
 
     it 'should have inherited class_attributes in order of definition' do
@@ -86,33 +86,33 @@ describe Doodle::Attribute, 'basics' do
     end
     
     it 'should have local class attributes in order of definition' do
-      Bar.singleton_class.attributes(false).keys.should == [:cvar2]
+      Bar.singleton_class.doodle_attributes(false).keys.should == [:cvar2]
     end
 
-    it 'should not inherit singleton local_attributes' do
-      @bar.singleton_class.class_eval { collect_inherited(:local_attributes).map { |x| x[0]} }.should == []
+    it 'should not inherit singleton doodle_local_attributes' do
+      @bar.singleton_class.class_eval { doodle_collect_inherited(:doodle_local_attributes).map { |x| x[0]} }.should == []
     end
 
     it 'should not inherit singleton attributes#1' do
-      @bar.singleton_class.attributes.map { |x| x[0]} .should == [:svar2]
+      @bar.singleton_class.doodle_attributes.map { |x| x[0]} .should == [:svar2]
     end
     
     it 'should not inherit singleton attributes#2' do
-      @bar.singleton_class.attributes.keys.should == [:svar2]
+      @bar.singleton_class.doodle_attributes.keys.should == [:svar2]
     end
 
     it 'should not inherit singleton attributes#3' do
-      @bar.singleton_class.attributes(false).keys.should == [:svar2]
+      @bar.singleton_class.doodle_attributes(false).keys.should == [:svar2]
     end
 
     it 'should show singleton attributes in attributes' do
-      @bar.attributes.keys.should == [:ivar1, :ivar2, :svar2]
+      @bar.doodle_attributes.keys.should == [:ivar1, :ivar2, :svar2]
     end
 
   end
 end
 
-describe Doodle::Attribute, 'attribute order' do
+describe Doodle::DoodleAttribute, 'attribute order' do
   temporary_constants :A, :B, :C do
     before :each do
       class A < Doodle
@@ -129,12 +129,12 @@ describe Doodle::Attribute, 'attribute order' do
     end
   
 #     it 'should keep order of inherited attributes' do
-#       expected_parents = RUBY_VERSION <= "1.8.6" ? [B, A, Doodle, Object] : [B, A, Doodle, Object, BasicObject]
-#       C.parents.should == expected_parents
+#       expected_doodle_parents = RUBY_VERSION <= "1.8.6" ? [B, A, Doodle, Object] : [B, A, Doodle, Object, BasicObject]
+#       C.doodle_parents.should == expected_doodle_parents
 #     end
 
     it 'should keep order of inherited attributes' do
-      C.attributes.keys.should == [:a, :b, :c]
+      C.doodle_attributes.keys.should == [:a, :b, :c]
     end
   end
 end

data/spec/bugs_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 require 'yaml'
 
-describe 'Doodle', 'parents' do
+describe 'Doodle', 'inheriting validations' do
   temporary_constant :Foo do
     before :each do
       class Foo < Doodle
@@ -15,8 +15,8 @@ describe 'Doodle', 'parents' do
     
     it 'should not duplicate validations when accessing them!' do
       foo = Foo 2
-      foo.validations.size.should_be 1
-      foo.validations.size.should_be 1
+      foo.doodle_validations.size.should_be 1
+      foo.doodle_validations.size.should_be 1
     end
   end
 end

data/spec/class_spec.rb

@@ -36,11 +36,11 @@ describe Doodle, 'class attributes' do
     end
 
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes(false).keys.should_be [:metadata]
+      Foo.singleton_class.doodle_attributes(false).keys.should_be [:metadata]
     end
   
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes.keys.should_be [:metadata]
+      Foo.singleton_class.doodle_attributes.keys.should_be [:metadata]
     end
 
     it 'should create Bar class attribute' do
@@ -73,11 +73,11 @@ describe Doodle, 'class attributes' do
     end
   
     it "should list all class's own attributes" do
-      Bar.singleton_class.attributes(false).keys.should_be [:doc]
+      Bar.singleton_class.doodle_attributes(false).keys.should_be [:doc]
     end
   
     it "should list all class's singleton attributes" do
-      Bar.singleton_class.attributes.keys.should_be [:doc]
+      Bar.singleton_class.doodle_attributes.keys.should_be [:doc]
     end
     it "should list all class's class_attributes" do
       Bar.class_attributes.keys.should_be [:metadata, :doc]

data/spec/collector_spec.rb

@@ -1,5 +1,31 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
+describe Doodle, "Default collector" do
+  temporary_constant :Foo do
+    before :each do
+      class Foo < Doodle
+        has :list, :collect => :item
+      end
+      @foo = Foo do
+        item "Hello"
+        item "World"
+      end
+    end
+    after :each do
+      remove_ivars :foo
+    end
+    
+    it "should define a collector method :item" do
+      @foo.methods.map{ |x| x.to_sym }.include?(:item).should_be true
+    end
+    
+    it "should collect items into attribute :list" do
+      @foo.list.should_be ["Hello", "World"]
+    end
+
+  end
+end
+
 describe Doodle, "Simple collector" do
   temporary_constant :Foo do
     before :each do
@@ -100,6 +126,7 @@ describe Doodle, "typed collector with specified collector name" do
 end
 
 describe Doodle, "typed collector with specified collector name initialized from hash (with default :init param)" do
+  # note: this spec also checks for resolving collector class
   temporary_constant :Location, :Event do
     before :each do
       class Location < Doodle
@@ -202,6 +229,15 @@ describe Doodle, "Simple keyed collector #2" do
                 )
       foo.list.to_a.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
+      foo = Foo(:list => {
+                  "Hello" => { :name => "Hello" },
+                  "World" => { :name => "World" }
+                }
+                )
+      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+    end
     
   end
 end

data/spec/conversion_spec.rb

@@ -47,7 +47,7 @@ describe Doodle, 'conversions' do
   end
 
   it 'should return class_conversions' do
-    Foo.conversions.keys.should == [String]
+    Foo.doodle_conversions.keys.should == [String]
   end
 
 end

data/spec/defaults_spec.rb

@@ -17,22 +17,22 @@ describe Doodle, 'attributes with defaults' do
     end
   
     it 'should have instance attribute default via class' do
-      Foo.attributes[:name].default.should_be 'D1'
+      Foo.doodle_attributes[:name].default.should_be 'D1'
     end
     it 'should have instance attribute default via instance' do
-      @foo.attributes[:name].default.should_be 'D1'
+      @foo.doodle_attributes[:name].default.should_be 'D1'
     end
     it 'should have class attribute default via class.meta' do
-      Foo.singleton_class.attributes(false)[:metadata].default.should_be 'D2'
+      Foo.singleton_class.doodle_attributes(false)[:metadata].default.should_be 'D2'
     end
     it 'should have class attribute default via class.meta' do
-      Foo.singleton_class.attributes[:metadata].default.should_be 'D2'
+      Foo.singleton_class.doodle_attributes[:metadata].default.should_be 'D2'
     end
-    it 'should have singleton attribute default via instance.singleton_class.attributes(false)' do
-      @foo.singleton_class.attributes(false)[:special].default.should_be 'D3'
+    it 'should have singleton attribute default via instance.singleton_class.doodle_attributes(false)' do
+      @foo.singleton_class.doodle_attributes(false)[:special].default.should_be 'D3'
     end
-    it 'should have singleton attribute default via instance.singleton_class.attributes' do
-      @foo.singleton_class.attributes[:special].default.should_be 'D3'
+    it 'should have singleton attribute default via instance.singleton_class.doodle_attributes' do
+      @foo.singleton_class.doodle_attributes[:special].default.should_be 'D3'
     end
     it 'should have singleton attribute name by default' do
       @foo.name.should_be 'D1'

data/spec/doodle_spec.rb

@@ -24,15 +24,15 @@ describe Doodle, 'instance attributes' do
     end
 
     it 'should list instance attributes(false)' do
-      @foo.attributes(false).keys.should_be []
+      @foo.doodle_attributes(false).keys.should_be []
     end
 
     it 'should list instance attributes' do
-      @foo.attributes.keys.should_be [:name]
+      @foo.doodle_attributes.keys.should_be [:name]
     end
   
     it 'should list all instance attributes(false) at class level' do
-      Foo.attributes(false).keys.should_be [:name]
+      Foo.doodle_attributes(false).keys.should_be [:name]
     end
   end
 end
@@ -68,11 +68,11 @@ describe Doodle, 'class attributes(false)' do
     end
 
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes(false).keys.should_be [:metadata]
+      Foo.singleton_class.doodle_attributes(false).keys.should_be [:metadata]
     end
   
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes.keys.should_be [:metadata]
+      Foo.singleton_class.doodle_attributes.keys.should_be [:metadata]
     end
   end
 end
@@ -137,19 +137,19 @@ describe Doodle, 'inherited class attributes(false)' do
     end
   
     it "should list class's own attributes" do
-      Foo.singleton_class.attributes(false).keys.should_be [:metadata]
+      Foo.singleton_class.doodle_attributes(false).keys.should_be [:metadata]
     end
   
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes.keys.should_be [:metadata]
+      Foo.singleton_class.doodle_attributes.keys.should_be [:metadata]
     end
 
     it "should list class's own attributes(false)" do
-      Bar.singleton_class.attributes(false).keys.should_be [:doc]
+      Bar.singleton_class.doodle_attributes(false).keys.should_be [:doc]
     end
 
     it "should list all singleton class attributes" do
-      Bar.singleton_class.attributes.keys.should_be [:doc]
+      Bar.singleton_class.doodle_attributes.keys.should_be [:doc]
     end
 
     it "should list all inherited meta class attributes" do
@@ -157,7 +157,7 @@ describe Doodle, 'inherited class attributes(false)' do
     end
     
     it "should list all inherited class's attributes" do
-      Bar.attributes.keys.should_be [:name, :location]
+      Bar.doodle_attributes.keys.should_be [:name, :location]
     end
   end
 end
@@ -188,15 +188,15 @@ describe Doodle, 'singleton class attributes' do
     end
 
     it 'should list singleton instance attributes(false)' do
-      @foo.singleton_class.attributes(false).keys.should_be [:special]
+      @foo.singleton_class.doodle_attributes(false).keys.should_be [:special]
     end
 
     it 'should list singleton instance attributes' do
-      @foo.singleton_class.attributes.keys.should_be [:special]
+      @foo.singleton_class.doodle_attributes.keys.should_be [:special]
     end
 
     it 'should list instance attributes' do
-      @foo.attributes.keys.should_be [:name, :special]
+      @foo.doodle_attributes.keys.should_be [:name, :special]
     end
 
   end
@@ -245,19 +245,19 @@ describe Doodle, 'inherited singleton class attributes' do
     end
 
     it 'should list instance attributes' do
-      @foo.class.attributes(false).keys.should_be [:name]
-      @bar.class.attributes(false).keys.should_be [:info]
-      @bar2.class.attributes(false).keys.should_be [:info]
+      @foo.class.doodle_attributes(false).keys.should_be [:name]
+      @bar.class.doodle_attributes(false).keys.should_be [:info]
+      @bar2.class.doodle_attributes(false).keys.should_be [:info]
     end
 
     it 'should list instance meta attributes' do
-      @foo.singleton_class.attributes(false).keys.should_be [:special]
-      @bar.singleton_class.attributes(false).keys.should_be [:extra]
+      @foo.singleton_class.doodle_attributes(false).keys.should_be [:special]
+      @bar.singleton_class.doodle_attributes(false).keys.should_be [:extra]
     end
 
     it 'should list singleton attributes only' do
-      @foo.singleton_class.attributes.keys.should_be [:special]
-      @bar.singleton_class.attributes.keys.should_be [:extra]
+      @foo.singleton_class.doodle_attributes.keys.should_be [:special]
+      @bar.singleton_class.doodle_attributes.keys.should_be [:extra]
     end
   
     it 'should keep meta attributes separate' do
@@ -287,7 +287,7 @@ describe Doodle, 'inherited singleton class attributes' do
 
     it 'should inherit singleton methods from class' do
       @foo.singleton_class.respond_to?(:metadata).should_be true
-      @foo.singleton_class.attributes[:metadata].should_be nil
+      @foo.singleton_class.doodle_attributes[:metadata].should_be nil
       @foo.singleton_class.metadata = 'foo meta'
       @foo.singleton_class.instance_eval { @metadata }.should_be 'foo meta'
       if RUBY_VERSION < '1.9.0'

data/spec/extra_args_spec.rb

@@ -13,8 +13,8 @@ describe Doodle, ' unspecified attributes' do
   end
 end
 
-describe Doodle::Attribute, ' unspecified attributes' do  
+describe Doodle::DoodleAttribute, ' unspecified attributes' do  
   it 'should raise Doodle::UnknownAttributeError for unspecified attributes' do
-    proc { foo = Doodle::Attribute(:name => 'foo', :extra => 'unwanted') }.should raise_error(Doodle::UnknownAttributeError)
+    proc { foo = Doodle::DoodleAttribute(:name => 'foo', :extra => 'unwanted') }.should raise_error(Doodle::UnknownAttributeError)
   end
-end
+end

data/spec/inheritance_spec.rb

@@ -19,8 +19,8 @@ describe Doodle, "inheritance" do
 
     it "should collect_inherited for instance" do
       foo = Foo.new(:ivar => "foo")
-      foo.send(:collect_inherited, :attributes).map{ |key, value| key}.should_be [:ivar] 
-      foo.attributes.map{ |key, value| key}.should_be [:ivar] 
+      foo.send(:doodle_collect_inherited, :doodle_attributes).map{ |key, value| key}.should_be [:ivar] 
+      foo.doodle_attributes.map{ |key, value| key}.should_be [:ivar] 
     end
 
     it "should collect inherited for singleton" do
@@ -28,8 +28,8 @@ describe Doodle, "inheritance" do
       class << foo
         has :svar
       end
-      foo.attributes.map{ |key, value| key}.should_be [:ivar, :svar] 
-      foo.singleton_class.attributes.map{ |key, value| key}.should_be [:svar] 
+      foo.doodle_attributes.map{ |key, value| key}.should_be [:ivar, :svar] 
+      foo.singleton_class.doodle_attributes.map{ |key, value| key}.should_be [:svar] 
     end
 
     it "should collect singleton class attributes for singleton" do
@@ -38,7 +38,7 @@ describe Doodle, "inheritance" do
         has :svar
       end
       foo.singleton_class.respond_to?(:cvar).should_be true
-      foo.attributes.map{ |key, value| key}.should_be [:ivar, :svar]
+      foo.doodle_attributes.map{ |key, value| key}.should_be [:ivar, :svar]
       # is this what I want? not sure
 #      foo.class.singleton_class.should_be foo.singleton_class.superclass
 #      foo.singleton_class.singleton_class                         # => #<Class:#<Class:#<Foo:0xb7bc8dd0>>>
@@ -53,22 +53,22 @@ describe Doodle, "inheritance" do
       class << bar
         has :svar2
       end
-      bar.attributes.map{ |key, value| key}.should_be [:ivar, :ivar2, :svar2] 
-      bar.singleton_class.attributes.map{ |key, value| key}.should_be [:svar2] 
+      bar.doodle_attributes.map{ |key, value| key}.should_be [:ivar, :ivar2, :svar2] 
+      bar.singleton_class.doodle_attributes.map{ |key, value| key}.should_be [:svar2] 
     end
     
     it "should show instance attributes for class" do
-      Foo.attributes.map{ |key, value| key}.should_be [:ivar] 
-      Bar.attributes.map{ |key, value| key}.should_be [:ivar, :ivar2] 
+      Foo.doodle_attributes.map{ |key, value| key}.should_be [:ivar] 
+      Bar.doodle_attributes.map{ |key, value| key}.should_be [:ivar, :ivar2] 
     end
 
-    it "should collect_inherited for class" do
+    it "should inherite class attributes for class" do
       Foo.class_attributes.map{ |key, value| key}.should_be [:cvar] 
       Bar.class_attributes.map{ |key, value| key}.should_be [:cvar, :cvar2] 
     end
     
     it "should not inherit class attributes via singleton_class" do
-      Bar.singleton_class.attributes.map{ |key, value| key}.should_be [:cvar2] 
+      Bar.singleton_class.doodle_attributes.map{ |key, value| key}.should_be [:cvar2] 
     end
   end
 end