doodle 0.1.8 → 0.1.9

data/spec/class_var_spec.rb

@@ -48,28 +48,42 @@ describe Doodle, 'class attributes:' do
       }.should_not raise_error
     end
 
-    it 'should be possible to set a singleton variable without setting a newly added instance var' do
-      pending 'figuring out if this is a pathological case and if so how to handle it' do
-        proc {
-          foo = Bar.new
-          class << foo
-            has :svar, :init => 43
-          end
-          class Bar < Doodle
-            has :ivar
-          end
-          foo.svar = 44
-        }.should_not raise_error
-      end
+    it 'should not be possible to set a singleton variable without setting a newly added instance var' do
+      proc {
+        foo = Bar.new
+        class << foo
+          has :svar, :init => 43
+        end
+        class Bar < Doodle
+          has :ivar
+        end
+        foo.svar = 44
+      }.should raise_error(Doodle::ValidationError)
     end
     
+    it 'should be possible to set a singleton variable along with setting a newly added instance var using defer_validation' do
+      proc {
+        foo = Bar.new
+        class << foo
+          has :svar, :init => 43
+        end
+        class Bar < Doodle
+          has :ivar
+        end
+        foo.doodle.defer_validation do
+          svar 44
+          ivar 42
+        end
+      }.should_not raise_error
+    end
+
     it 'should validate class var' do
       proc { Foo.cvar = "Hello" }.should raise_error(Doodle::ValidationError)
     end
 
     it 'should be possible to read initialized class var' do
       #pending 'getting this working' do
-        proc { Foo.cvar == 1 }.should_not raise_error
+      proc { Foo.cvar == 1 }.should_not raise_error
       #end
     end
   end

data/spec/conversion_spec.rb

@@ -2,53 +2,51 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 require 'date'
 
 describe Doodle, 'conversions' do
-  after :each do
-    undefine_const(:Foo)
-  end
-  before(:each) do
-    raise_if_defined(:Foo)
-    class Foo < Doodle
-      has :start do
-        default { Date.today }
-        from String do |s|
-          Doodle::Debug.d { [:converting_from, String, s] }
-          Date.parse(s)
+  temporary_constant(:Foo) do
+    before(:each) do
+      class Foo < Doodle
+        has :start do
+          default { Date.today }
+          from String do |s|
+            Doodle::Debug.d { [:converting_from, String, s] }
+            Date.parse(s)
+          end
+          from Integer do |jd|
+            Doodle::Debug.d { [:converting_from, Integer, jd] }
+            Date.new(*Date.send(:jd_to_civil, jd))
+          end
         end
-        from Integer do |jd|
-          Doodle::Debug.d { [:converting_from, Integer, jd] }
-          Date.new(*Date.send(:jd_to_civil, jd))
+        from String do |s|
+          Doodle::Debug.d { [:from, self, self.class] }
+          new(:start => s)
         end
       end
-      from String do |s|
-        Doodle::Debug.d { [:from, self, self.class] }
-        new(:start => s)
-      end
     end
-  end
 
-  it 'should have default date == today' do
-    foo = Foo.new
-    foo.start.should == Date.today
-  end
+    it 'should have default date == today' do
+      foo = Foo.new
+      foo.start.should == Date.today
+    end
 
-  it 'should convert String to Date' do
-    foo = Foo.new(:start => '2007-12-31')
-    foo.start.should == Date.new(2007, 12, 31)
-  end
+    it 'should convert String to Date' do
+      foo = Foo.new(:start => '2007-12-31')
+      foo.start.should == Date.new(2007, 12, 31)
+    end
 
-  it 'should convert Integer representing Julian date to Date' do
-    foo = Foo.new(:start => 2454428)
-    foo.start.should == Date.new(2007, 11, 23)
-  end
+    it 'should convert Integer representing Julian date to Date' do
+      foo = Foo.new(:start => 2454428)
+      foo.start.should == Date.new(2007, 11, 23)
+    end
 
-  it 'should allow from' do
-    foo = Foo.from("2007-12-31")
-    foo.start.should == Date.new(2007, 12, 31)
-  end
+    it 'should allow from' do
+      foo = Foo.from("2007-12-31")
+      foo.start.should == Date.new(2007, 12, 31)
+    end
+
+    it 'should return class_conversions' do
+      Foo.doodle.conversions.keys.should == [String]
+    end
 
-  it 'should return class_conversions' do
-    Foo.doodle.conversions.keys.should == [String]
   end
 
 end
-

data/spec/doodle_spec.rb

@@ -30,7 +30,7 @@ describe Doodle, 'instance attributes' do
     it 'should list instance attributes' do
       @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]
     end
@@ -70,7 +70,7 @@ describe Doodle, 'class attributes(false)' do
     it "should list all class's own attributes" do
       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]
     end
@@ -90,7 +90,7 @@ describe Doodle, 'inherited class attributes(false)' do
       class Bar < Foo
         has :location, :default => nil
         class << self
-          has :doc
+          has :notes
         end
       end
       @foo = Foo.new
@@ -135,27 +135,27 @@ describe Doodle, 'inherited class attributes(false)' do
       Foo.metadata.should_be 'Foo metadata'
       @foo.class.metadata.should_be 'Foo metadata'
     end
-  
+
     it "should list class's own attributes" do
       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]
     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 [:notes]
     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 [:notes]
     end
 
     it "should list all inherited meta class attributes" do
-      Bar.doodle.class_attributes.keys.should_be [:metadata, :doc]
+      Bar.doodle.class_attributes.keys.should_be [:metadata, :notes]
     end
-    
+
     it "should list all inherited class's attributes" do
       Bar.doodle.attributes.keys.should_be [:name, :location]
     end
@@ -165,7 +165,7 @@ end
 describe Doodle, 'singleton class attributes' do
   temporary_constant :Foo do
     before(:each) do
-  
+
       class Foo
         include Doodle::Core
         has :name, :default => nil
@@ -181,7 +181,7 @@ describe Doodle, 'singleton class attributes' do
     after :each do
       remove_ivars :foo
     end
-  
+
     it 'should allow creation of singleton class attributes' do
       @foo.special = 42
       @foo.special.should_be 42
@@ -215,7 +215,7 @@ describe Doodle, 'inherited singleton class attributes' do
       class Bar < Foo
         has :info, :default => nil
         class << self
-          has :doc
+          has :notes
         end
       end
 
@@ -229,11 +229,11 @@ describe Doodle, 'inherited singleton class attributes' do
         has :extra
       end
     end
-    
+
     after :each do
       remove_ivars :foo, :bar, :bar2
     end
-  
+
     it 'should allow creation of singleton class attributes' do
       @foo.special = 42
       @foo.special.should_be 42
@@ -259,13 +259,13 @@ describe Doodle, 'inherited singleton class attributes' do
       @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
       @foo.special = 'foo special'
       @foo.special.should_be 'foo special'
 
       # CHECK
-      
+
       # note: you cannot set any other values on @bar until you have set @bar.extra because it's defined as required
       @bar.extra = 'bar extra'
       @bar.extra.should_be 'bar extra'
@@ -273,8 +273,8 @@ describe Doodle, 'inherited singleton class attributes' do
       Foo.metadata.should_be 'Foo meta'
       Bar.metadata = 'Bar meta'
       Bar.metadata.should_be 'Bar meta'
-      Bar.doc = 'Bar doc'
-      Bar.doc.should_be 'Bar doc'
+      Bar.notes = 'Bar notes'
+      Bar.notes.should_be 'Bar notes'
 
       # now make sure they haven't bumped each other off
       @foo.special.should_be 'foo special'
@@ -282,7 +282,7 @@ describe Doodle, 'inherited singleton class attributes' do
       @bar.extra.should_be 'bar extra'
       Foo.metadata.should_be 'Foo meta'
       Bar.metadata.should_be 'Bar meta'
-      Bar.doc.should_be 'Bar doc'
+      Bar.notes.should_be 'Bar notes'
     end
 
     it 'should inherit singleton methods from class' do
@@ -298,19 +298,19 @@ describe Doodle, 'inherited singleton class attributes' do
         end
       end
     end
-   
+
     it 'should behave predictably when setting singleton attributes' do
       @bar.extra = 'bar extra'
       @bar.extra.should_be 'bar extra'
       @bar.singleton_class.metadata = 'bar meta metadata'
       if RUBY_VERSION < '1.9.0'
         @bar.singleton_class.metadata.should_be 'bar meta metadata'
-        @bar.singleton_class.doc = 'bar doc'
-        @bar.singleton_class.doc.should_be 'bar doc'
+        @bar.singleton_class.notes = 'bar notes'
+        @bar.singleton_class.notes.should_be 'bar notes'
       else
         pending 'figuring out why this fails in 1.9'
       end
-      proc { @foo.singleton_class.doc = 1 }.should raise_error(NoMethodError)
+      proc { @foo.singleton_class.notes = 1 }.should raise_error(NoMethodError)
     end
   end
 end

data/spec/has_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe Doodle, 'has Class' do
-  temporary_constant :Foo, :Bar do
+  temporary_constant :Foo, :Bar, :AudioClip do
     it "should convert 'has Bar' into 'has :bar, :kind => Bar'" do
       class Bar
       end
@@ -41,5 +41,23 @@ describe Doodle, 'has Class' do
       proc {  Foo.new(:bar => Bar.new) }.should_not raise_error
       proc {  Foo.new(:bar => "Hello") }.should raise_error(Doodle::ValidationError)
     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
+    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/init_spec.rb

@@ -17,37 +17,37 @@ describe Doodle, 'init' do
       end
     end
     it 'should have instance attribute init via class' do
-      Foo.doodle.attributes[:moniker].init.should == 'D1'
+      Foo.doodle.attributes[:moniker].init.should_be 'D1'
     end
     it 'should have instance attribute init via instance' do
-      @foo.doodle.attributes[:moniker].init.should == 'D1'
+      @foo.doodle.attributes[:moniker].init.should_be 'D1'
     end
     it 'should have class attribute init via class.singleton_class' do
-      Foo.singleton_class.doodle.attributes(false)[:metadata].init.should == 'D2'
+      Foo.singleton_class.doodle.attributes(false)[:metadata].init.should_be 'D2'
     end
     it 'should have class attribute init via class.singleton_class' do
-      Foo.singleton_class.doodle.attributes[:metadata].init.should == 'D2'
+      Foo.singleton_class.doodle.attributes[:metadata].init.should_be 'D2'
     end
     it 'should have singleton attribute init via instance.singleton_class' do
-      @foo.singleton_class.doodle.attributes(false)[:special].init.should == 'D3'
+      @foo.singleton_class.doodle.attributes(false)[:special].init.should_be 'D3'
     end
     it 'should have singleton attribute init via instance.singleton_class' do
-      @foo.singleton_class.doodle.attributes[:special].init.should == 'D3'
+      @foo.singleton_class.doodle.attributes[:special].init.should_be 'D3'
     end
     it 'should have an attribute :moniker from init' do
-      @foo.moniker.should == 'D1'
+      @foo.moniker.should_be 'D1'
     end
     it 'should have an instance_variable for attribute :moniker' do
-      @foo.instance_variables.map{ |x| x.to_sym }.include?(:@moniker).should == true
+      @foo.instance_variables.map{ |x| x.to_sym }.include?(:@moniker).should_be true
     end
     it 'should have an initialized class attribute :metadata' do
       #pending 'deciding how this should work' do
-        Foo.metadata.should == 'D2'
+        Foo.metadata.should_be 'D2'
       #end
     end
     it 'should have an initialized singleton attribute :special' do
       #pending 'deciding how this should work' do
-        @foo.special.should == 'D3'
+        @foo.special.should_be 'D3'
       #end
     end
   end
@@ -60,7 +60,7 @@ describe Doodle, 'init' do
         has :value, :init => nil
       end
       foo = Foo.new
-      foo.value.should == nil
+      foo.value.should_be nil
     end
   end
   temporary_constant :Foo do
@@ -69,7 +69,7 @@ describe Doodle, 'init' do
         has :value, :init => true
       end
       foo = Foo.new
-      foo.value.should == true
+      foo.value.should_be true
     end
   end
   temporary_constant :Foo do
@@ -78,7 +78,7 @@ describe Doodle, 'init' do
         has :value, :init => 42
       end
       foo = Foo.new
-      foo.value.should == 42
+      foo.value.should_be 42
     end
   end
   temporary_constant :Foo do
@@ -87,20 +87,26 @@ describe Doodle, 'init' do
         has :value, :init => proc { 42 }
       end
       foo = Foo.new
-      foo.value.call.should == 42
+      foo.value.call.should_be 42
     end
   end
   temporary_constant :Foo do
     it 'should evaluate value when block given as :init' do
       class Foo < Doodle
-        has :value do
+        has :value, :kind => Integer do
           init do
             42
           end
         end
+        has :name, :kind => String do
+          init do
+            "foo"
+          end
+        end
       end
       foo = Foo.new
-      foo.value.should == 42
+      foo.value.should_be 42
+      foo.name.should_be "foo"
     end
   end
 end

data/spec/member_init_spec.rb

@@ -0,0 +1,122 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'yaml'
+
+describe 'Doodle', 'initialization of scalar attributes from hash' do
+  temporary_constant :Foo, :Bar do
+    before :each do
+      class Bar < Doodle
+        has :name, :kind => String
+        has :count, :kind => Integer
+      end
+      class Foo < Doodle
+        has Bar
+        has :v2, :kind => String, :default => "bar"
+      end
+    end
+    
+    it 'should initialize an attribute from a hash' do
+      foo = Foo do
+        bar :name => "hello", :count => 1 
+      end
+      foo.bar.name.should_be "hello"
+      foo.bar.count.should_be 1
+    end
+    it 'should fail trying to initialize with incorrect keyword values' do
+      proc { 
+        foo = Foo do
+          bar :name => 1, :count => "hello"
+        end
+      }.should raise_error(Doodle::ValidationError)
+    end
+    it 'should work with positional args' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar "hello", 1
+        end
+      }.should_not raise_error
+      foo.bar.name.should_be "hello"
+      foo.bar.count.should_be 1
+    end
+    it 'should work with block initialization' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar do
+            name "hello"
+            count 1
+          end
+        end
+      }.should_not raise_error
+      foo.bar.name.should_be "hello"
+      foo.bar.count.should_be 1
+    end
+    it 'should work with arg and block initialization' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar "hello" do
+            count 1
+          end
+        end
+      }.should_not raise_error
+      foo.bar.name.should_be "hello"
+      foo.bar.count.should_be 1
+    end
+    it 'should work with keyword and block initialization' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar :name => "hello" do
+            count 1
+          end
+        end
+      }.should_not raise_error
+      foo.bar.name.should_be "hello"
+      foo.bar.count.should_be 1
+    end
+    it 'should raise error with invalid keyword and block initialization' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar :name => 1 do
+            count "hello"
+          end
+        end
+      }.should raise_error(Doodle::ValidationError)
+    end
+    it 'should raise error with keyword and invalid block initialization' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar :name => "hello" do
+            count "hello"
+          end
+        end
+      }.should raise_error(Doodle::ValidationError)
+    end
+    it 'should initialize non-Doodle or Proc with simple value' do
+      foo = nil
+      proc { 
+        foo = Foo do
+          bar :name => "hello", :count => 1
+          v2 "Hello"
+        end
+      }.should_not raise_error
+      foo.bar.name.should_be "hello"
+      foo.bar.count.should_be 1
+      foo.v2.should_be "Hello"
+    end
+    it 'should fail trying to initialize an inappropriate attribute (not a Doodle or Proc) from a block' do
+      proc { 
+        foo = Foo do
+          bar :name => "hello", :count => 1
+          v2 do
+            "Hello"
+          end
+        end
+      }.should raise_error(ArgumentError)
+    end
+  end
+end
+