doodle 0.1.7 → 0.1.8

data/lib/doodle/version.rb

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

data/spec/attributes_spec.rb

@@ -33,7 +33,7 @@ describe Doodle::DoodleAttribute, 'basics' do
     end
     
     it 'should have attribute :ivar1 with default defined' do
-      @foo.doodle_attributes[:ivar1].default.should == 'Hello'
+      @foo.doodle.attributes[:ivar1].default.should == 'Hello'
     end
 
     it 'should have default name' do
@@ -45,68 +45,69 @@ describe Doodle::DoodleAttribute, 'basics' do
     end
 
     it 'should have name required == false (because has default)' do
-      @foo.doodle_attributes[:ivar1].required?.should == false
+      @foo.doodle.attributes[:ivar1].required?.should == false
     end
 
     it 'should have ivar2 required == true' do
-      @bar.doodle_attributes[:ivar2].required?.should == true
+      @bar.doodle.attributes[:ivar2].required?.should == true
     end
 
     it 'should have name.optional? == true (because has default)' do
-      @foo.doodle_attributes[:ivar1].optional?.should == true
+      @foo.doodle.attributes[:ivar1].optional?.should == true
     end
 
     it 'should inherit attribute from parent' do
-      @bar.doodle_attributes[:ivar1].should == @foo.doodle_attributes[:ivar1]
+      @bar.doodle.attributes[:ivar1].should == @foo.doodle.attributes[:ivar1]
     end
 
     it 'should have ivar2.optional? == false' do
-      @bar.doodle_attributes[:ivar2].optional?.should == false
+      @bar.doodle.attributes[:ivar2].optional?.should == false
     end
 
-#     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
+#     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 doodle_parents in reverse order of definition" do
-      @bar.singleton_class.doodle_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.doodle_attributes.keys.should == [:cvar2]
+      Bar.singleton_class.doodle.attributes.keys.should == [:cvar2]
     end
 
     it 'should have inherited class_attributes in order of definition' do
-      Bar.class_attributes.keys.should == [:cvar1, :cvar2]
+      Bar.doodle.class_attributes.keys.should == [:cvar1, :cvar2]
     end
 
     it 'should have inherited class_attributes in order of definition' do
-      @bar.class_attributes.keys.should == [:cvar1, :cvar2]
+      @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]
+      Bar.singleton_class.doodle.attributes(false).keys.should == [:cvar2]
     end
 
-    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 == []
+    # 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 == []
     end
 
     it 'should not inherit singleton attributes#1' do
-      @bar.singleton_class.doodle_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.doodle_attributes.keys.should == [:svar2]
+      @bar.singleton_class.doodle.attributes.keys.should == [:svar2]
     end
 
     it 'should not inherit singleton attributes#3' do
-      @bar.singleton_class.doodle_attributes(false).keys.should == [:svar2]
+      @bar.singleton_class.doodle.attributes(false).keys.should == [:svar2]
     end
 
     it 'should show singleton attributes in attributes' do
-      @bar.doodle_attributes.keys.should == [:ivar1, :ivar2, :svar2]
+      @bar.doodle.attributes.keys.should == [:ivar1, :ivar2, :svar2]
     end
 
   end
@@ -129,12 +130,12 @@ describe Doodle::DoodleAttribute, 'attribute order' do
     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
+#       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.doodle_attributes.keys.should == [:a, :b, :c]
+      C.doodle.attributes.keys.should == [:a, :b, :c]
     end
   end
 end

data/spec/bugs_spec.rb

@@ -15,8 +15,8 @@ describe 'Doodle', 'inheriting validations' do
     
     it 'should not duplicate validations when accessing them!' do
       foo = Foo 2
-      foo.doodle_validations.size.should_be 1
-      foo.doodle_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.doodle_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.doodle_attributes.keys.should_be [:metadata]
+      Foo.singleton_class.doodle.attributes.keys.should_be [:metadata]
     end
 
     it 'should create Bar class attribute' do
@@ -73,14 +73,14 @@ describe Doodle, 'class attributes' do
     end
   
     it "should list all class's own attributes" do
-      Bar.singleton_class.doodle_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.doodle_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]
+      Bar.doodle.class_attributes.keys.should_be [:metadata, :doc]
     end
   end
 end

data/spec/conversion_spec.rb

@@ -47,7 +47,7 @@ describe Doodle, 'conversions' do
   end
 
   it 'should return class_conversions' do
-    Foo.doodle_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.doodle_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.doodle_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.doodle_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.doodle_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.doodle_attributes(false)' do
-      @foo.singleton_class.doodle_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.doodle_attributes' do
-      @foo.singleton_class.doodle_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_context_spec.rb

@@ -20,7 +20,7 @@ describe Doodle, "doodle_context" do
           # during initialization - this is a way to capture that
           # value for ues later
           
-          init { doodle_parent }
+          init { doodle.parent }
         end
       end
 
@@ -38,7 +38,7 @@ describe Doodle, "doodle_context" do
 
       sean = dad.children[0]
       sean.dad.name.should_be 'Conn'
-      sean.doodle_parent.name.should_be 'Conn'
+      sean.doodle.parent.name.should_be 'Conn'
     end
   end
 end

data/spec/doodle_spec.rb

@@ -24,15 +24,15 @@ describe Doodle, 'instance attributes' do
     end
 
     it 'should list instance attributes(false)' do
-      @foo.doodle_attributes(false).keys.should_be []
+      @foo.doodle.attributes(false).keys.should_be []
     end
 
     it 'should list instance attributes' do
-      @foo.doodle_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.doodle_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.doodle_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.doodle_attributes.keys.should_be [:metadata]
+      Foo.singleton_class.doodle.attributes.keys.should_be [:metadata]
     end
   end
 end
@@ -137,27 +137,27 @@ describe Doodle, 'inherited class attributes(false)' do
     end
   
     it "should list class's own attributes" do
-      Foo.singleton_class.doodle_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.doodle_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.doodle_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.doodle_attributes.keys.should_be [:doc]
+      Bar.singleton_class.doodle.attributes.keys.should_be [:doc]
     end
 
     it "should list all inherited meta class attributes" do
-      Bar.class_attributes.keys.should_be [:metadata, :doc]
+      Bar.doodle.class_attributes.keys.should_be [:metadata, :doc]
     end
     
     it "should list all inherited class's attributes" do
-      Bar.doodle_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.doodle_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.doodle_attributes.keys.should_be [:special]
+      @foo.singleton_class.doodle.attributes.keys.should_be [:special]
     end
 
     it 'should list instance attributes' do
-      @foo.doodle_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.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]
+      @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.doodle_attributes(false).keys.should_be [:special]
-      @bar.singleton_class.doodle_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.doodle_attributes.keys.should_be [:special]
-      @bar.singleton_class.doodle_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.doodle_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/from_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe 'Doodle', 'applying Doodle type conversions' do
+  temporary_constant :Foo, :Name do
+    before :each do
+      class Name < String
+        include Doodle::Core
+        from String do |s|
+          Name.new(s)
+        end
+        must "be > 3 chars long" do
+          size > 3
+        end
+      end
+
+      class Foo < Doodle
+        has Name do
+          must "start with A" do |s|
+            s =~ /^A/
+          end
+        end
+      end
+    end
+
+    it 'should convert a value based on conversions in doodle class' do
+      proc { foo = Foo 'Arthur' }.should_not raise_error
+    end
+    
+    it 'should convert a value based on conversions in doodle class to the correct class' do
+      foo = Foo 'Arthur'
+      foo.name.class.should_be Name
+    end
+
+    it 'should apply validations from attribute' do
+      proc { Foo 'Zaphod' }.should raise_error(Doodle::ValidationError)
+    end
+
+    it 'should apply validations from doodle type' do
+      proc { Foo 'Art' }.should raise_error(Doodle::ConversionError)
+    end
+    
+  end
+end

data/spec/has_spec.rb

@@ -8,9 +8,9 @@ describe Doodle, 'has Class' do
       class Foo < Doodle
         has Bar
       end
-      att = Foo.doodle_attributes.values.first
+      att = Foo.doodle.attributes.values.first
       att.name.should_be :bar
-      att.kind.should_be Bar
+      att.kind.should_be [Bar]
     end
     it "should allow overriding name of attribute when using 'has Bar'" do
       class Bar
@@ -18,9 +18,9 @@ describe Doodle, 'has Class' do
       class Foo < Doodle
         has Bar, :name => :baz
       end
-      att = Foo.doodle_attributes.values.first
+      att = Foo.doodle.attributes.values.first
       att.name.should_be :baz
-      att.kind.should_be Bar
+      att.kind.should_be [Bar]
     end
     it "should convert class name to snakecase when using CamelCase class constant" do
       class AudioClip
@@ -28,9 +28,18 @@ describe Doodle, 'has Class' do
       class Foo < Doodle
         has AudioClip
       end
-      att = Foo.doodle_attributes.values.first
+      att = Foo.doodle.attributes.values.first
       att.name.should_be :audio_clip
-      att.kind.should_be AudioClip
+      att.kind.should_be [AudioClip]
+    end
+    it "should apply validations for 'has Bar' as if 'has :bar, :kind => Bar' was used" do
+      class Bar
+      end
+      class Foo < Doodle
+        has Bar
+      end
+      proc {  Foo.new(:bar => Bar.new) }.should_not raise_error
+      proc {  Foo.new(:bar => "Hello") }.should raise_error(Doodle::ValidationError)
     end
   end
 end

data/spec/inheritance_spec.rb

@@ -19,8 +19,7 @@ describe Doodle, "inheritance" do
 
     it "should collect_inherited for instance" do
       foo = Foo.new(:ivar => "foo")
-      foo.send(:doodle_collect_inherited, :doodle_attributes).map{ |key, value| key}.should_be [:ivar] 
-      foo.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 +27,8 @@ describe Doodle, "inheritance" do
       class << foo
         has :svar
       end
-      foo.doodle_attributes.map{ |key, value| key}.should_be [:ivar, :svar] 
-      foo.singleton_class.doodle_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 +37,7 @@ describe Doodle, "inheritance" do
         has :svar
       end
       foo.singleton_class.respond_to?(:cvar).should_be true
-      foo.doodle_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 +52,22 @@ describe Doodle, "inheritance" do
       class << bar
         has :svar2
       end
-      bar.doodle_attributes.map{ |key, value| key}.should_be [:ivar, :ivar2, :svar2] 
-      bar.singleton_class.doodle_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.doodle_attributes.map{ |key, value| key}.should_be [:ivar] 
-      Bar.doodle_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 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] 
+      Foo.doodle.class_attributes.map{ |key, value| key}.should_be [:cvar] 
+      Bar.doodle.class_attributes.map{ |key, value| key}.should_be [:cvar, :cvar2] 
     end
     
     it "should not inherit class attributes via singleton_class" do
-      Bar.singleton_class.doodle_attributes.map{ |key, value| key}.should_be [:cvar2] 
+      Bar.singleton_class.doodle.attributes.map{ |key, value| key}.should_be [:cvar2] 
     end
   end
 end