doodle 0.0.8 → 0.0.9

data/lib/semantic.cache

@@ -0,0 +1,8 @@
+;; Object lib/
+;; SEMANTICDB Tags save file
+(semanticdb-project-database-file "lib/"
+  :tables 'nil
+  :file "semantic.cache"
+  :semantic-tag-version "2.0pre4"
+  :semanticdb-version "2.0pre4"
+  )

data/spec/bugs_spec.rb

@@ -77,4 +77,4 @@ describe 'Doodle', ' loading bad data from yaml' do
       proc { foo = YAML::load(@str).validate! }.should raise_error(Doodle::ConversionError)
     end
   end
-end
+end

data/spec/class_spec.rb

@@ -25,7 +25,7 @@ describe Doodle, 'class attributes' do
       Foo.metadata.should == 'Foo metadata'
     end
 
-    it 'should access class attribute via self.class' do
+    it 'should access @foo class attribute via self.class' do
       @foo.class.metadata = '@foo metadata'
       @foo.class.metadata.should == '@foo metadata'
       Foo.metadata.should == '@foo metadata'
@@ -48,7 +48,7 @@ describe Doodle, 'class attributes' do
       Bar.metadata.should == 'Bar metadata'
     end
 
-    it 'should access class attribute via self.class' do
+    it 'should access @bar class attribute via self.class' do
       @bar.class.metadata = '@bar metadata'
       @bar.class.metadata.should == '@bar metadata'
       Bar.metadata.should == '@bar metadata'

data/spec/collector_spec.rb

@@ -71,7 +71,7 @@ describe Doodle, "Typed collector with specified collector name" do
   end
 end
 
-describe Doodle, "Typed collector with specified collector name" do
+describe Doodle, "typed collector with specified collector name" do
   temporary_constant :Location, :Event do
     before :each do
       class Location < Doodle::Base
@@ -95,3 +95,51 @@ describe Doodle, "Typed collector with specified collector name" do
   end
 end
 
+describe Doodle, "typed collector with specified collector name initialized from hash (with default :init param)" do
+  temporary_constant :Location, :Event do
+    before :each do
+      class Location < Doodle::Base
+        has :name, :kind => String
+        has :events, :collect => :Event
+      end
+      class Event < Doodle::Base
+        has :name, :kind => String
+        has :locations, :collect => :Location
+      end
+    end
+    it "should collect items from hash" do
+      event = nil
+      data = {
+        :name => 'RAR',
+        :locations =>
+        [
+         {
+           :name => "Stage 1",
+           :events =>
+           [
+            {
+              :name => 'Foobars',
+              :locations =>
+              [
+               {
+                 :name => 'Backstage'
+               }
+              ]
+            }
+           ]
+         },
+         {
+           :name => "Stage 2"
+         }
+        ]
+      }
+      proc {
+        event = Event(data)
+      }.should_not raise_error
+      event.locations.map{|loc| loc.name}.should == ["Stage 1", "Stage 2"]
+      event.locations.map{|loc| loc.class}.should == [Location, Location]
+      event.locations[0].events[0].kind_of?(Event).should == true
+    end
+  end
+end
+

data/spec/conversion_spec.rb

@@ -45,13 +45,5 @@ describe Doodle, 'defaults which have not been set' do
     foo = Foo.from("2007-12-31")
     foo.start.should == Date.new(2007, 12, 31)
   end
-  
-  it 'should allow factory function' do
-#     class Foo
-#       include Doodle::Factory
-#     end
-    foo = Foo("2007-12-31")
-    foo.start.should == Date.new(2007, 12, 31)
-  end
 end
 

data/spec/doodle_context_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Doodle, "doodle_context" do
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Child < Doodle::Base
+        has :name
+        has :dad do
+          # there is an important difference between a block argument
+          # and a Proc object (proc/lambda) argument
+          # - a proc/lamba is treated as a literal argument, i.e. the
+          # - value is set to a Proc
+          # - a block argument, on the other hand, is instance
+          # - evaluated during initialization
+          # - consequences
+          #   - can only be done in init block
+          #   - somewhat subtle difference (from programmer's point of
+          #   - view) between a proc and a block
+          # Also note re: Doodle.parent - its value is only valid
+          # during initialization - this is a way to capture that
+          # value for ues later
+          
+          init {
+            Doodle.parent
+          }
+        end
+      end
+
+      class Parent < Child
+        has :children, :collect => Child
+      end
+
+    end
+    
+    it 'should provide a means to find out the current parent of an item in initialization block' do
+      dad = Parent 'Conn' do
+        child 'Sean'
+        child 'Paul'
+      end
+
+      sean = dad.children[0]
+      sean.dad.name.should == 'Conn'
+    end
+  end
+end
+

data/spec/doodle_spec.rb

@@ -57,7 +57,7 @@ describe Doodle, 'class attributes(false)' do
       Foo.metadata.should == 'Foo metadata'
     end
 
-    it 'should access class attribute via self.class' do
+    it 'should access @foo.class attribute via self.class' do
       @foo.class.metadata = '@foo metadata'
       @foo.class.metadata.should == '@foo metadata'
       Foo.metadata.should == '@foo metadata'
@@ -108,7 +108,7 @@ describe Doodle, 'inherited class attributes(false)' do
       Foo.metadata.should == 'Foo metadata'
     end
 
-    it 'should access class attribute via self.class' do
+    it 'should access @foo.class attribute via self.class' do
       @foo.class.metadata = '@foo metadata'
       @foo.class.metadata.should == '@foo metadata'
       Foo.metadata.should == '@foo metadata'
@@ -122,7 +122,7 @@ describe Doodle, 'inherited class attributes(false)' do
       @bar.class.metadata.should == 'Bar metadata'
     end
 
-    it 'should access inherited class attribute via self.class' do
+    it 'should access inherited @foo.class attribute via self.class' do
       @foo.class.metadata = '@foo metadata'
       @foo.class.metadata.should == '@foo metadata'
       Foo.metadata.should == '@foo metadata'

data/spec/extra_args_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Doodle, ' unspecified attributes' do
+  temporary_constants :Foo do
+    before :each do 
+      class Foo < Doodle::Base
+      end
+    end
+  
+    it 'should raise Doodle::UnknownAttributeError for unspecified attributes' do
+      proc { foo = Foo(:name => 'foo') }.should raise_error(Doodle::UnknownAttributeError)
+    end
+  end
+end
+
+describe Doodle::Attribute, ' 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)
+  end
+end

data/spec/factory_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Doodle::Factory, " as part of Doodle::Base" do
+  temporary_constant :Foo, :Bar do
+    before(:each) do
+      class Foo < Doodle::Base
+        has :var1
+      end
+      class Bar < Foo
+        has :var2
+      end
+    end
+
+    it 'should provide factory function' do
+      proc {
+        foo = Foo("abcd") 
+        foo.var1.should == "abcd"
+        }.should_not raise_error
+    end
+
+    it 'should inherit factory function' do
+      proc {
+        bar = Bar("abcd", 1234) 
+        bar.var1.should == "abcd"
+        bar.var2.should == 1234
+        }.should_not raise_error
+    end
+  end
+end
+
+describe Doodle::Factory, " included as module" do
+  temporary_constant :Baz, :Qux, :MyDate, :AnotherDate do
+    before(:each) do
+      class Baz
+        include Doodle::Helper
+        has :var1
+      end
+      class Qux < Baz
+        has :var2
+      end
+      class MyDate < Date
+        include Doodle::Factory
+      end
+      class AnotherDate < MyDate
+      end
+    end
+
+    it 'should provide factory function' do
+      proc {
+        foo = Baz("abcd") 
+        foo.var1.should == "abcd"
+        }.should_not raise_error
+    end
+
+    it 'should inherit factory function' do
+      proc {
+        qux = Qux("abcd", 1234) 
+        qux.var1.should == "abcd"
+        qux.var2.should == 1234
+        }.should_not raise_error
+    end
+
+    it 'should be includeable in non-doodle classes' do
+      proc {
+        qux = MyDate(2008, 01, 01) 
+        qux.to_s.should == "2008-01-01" 
+        }.should_not raise_error
+    end
+
+    # do I actually want this? should it be opt-in at each level?
+    # it 'should be inheritable by non-doodle classes' do
+    #   proc {
+    #     qux = AnotherDate(2008, 01, 01) 
+    #     qux.to_s.should == "2008-01-01" 
+    #     }.should_not raise_error
+    # end
+
+  end
+end
+

data/spec/init_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe Doodle, 'init' do
   temporary_constant :Foo do
-  
+    
     before(:each) do
       class Foo
         include Doodle::Helper
@@ -16,7 +16,7 @@ describe Doodle, 'init' do
         has :special, :init => 'D3'
       end
     end
-  
+    
     it 'should have instance attribute init via class' do
       Foo.attributes[:name].init.should == 'D1'
     end
@@ -42,12 +42,66 @@ describe Doodle, 'init' do
       @foo.instance_variables.include?('@name').should == true
     end
     it 'should have an initialized class attribute :metadata' do
-      pending 'deciding how this should work'
-      #Foo.metadata.should == 'D2'
+      pending 'deciding how this should work' do
+        Foo.metadata.should == 'D2'
+      end
     end
     it 'should have an initialized singleton attribute :special' do
-      pending 'deciding how this should work'
-      #@foo.special.should == 'D3'
+      pending 'deciding how this should work' do
+        @foo.special.should == 'D3'
+      end
+    end
+  end
+end
+
+describe Doodle, 'init' do  
+  temporary_constant :Foo do
+    it 'should accept nil as :init' do
+      class Foo < Doodle::Base
+        has :value, :init => nil
+      end
+      foo = Foo.new
+      foo.value.should == nil
+    end
+  end
+  temporary_constant :Foo do
+    it 'should accept true as :init' do
+      class Foo < Doodle::Base
+        has :value, :init => true
+      end
+      foo = Foo.new
+      foo.value.should == true
+    end
+  end
+  temporary_constant :Foo do
+    it 'should accept Fixnum as :init' do
+      class Foo < Doodle::Base
+        has :value, :init => 42
+      end
+      foo = Foo.new
+      foo.value.should == 42
+    end
+  end
+  temporary_constant :Foo do
+    it 'should not evaluate value when proc given as :init' do
+      class Foo < Doodle::Base
+        has :value, :init => proc { 42 }
+      end
+      foo = Foo.new
+      foo.value.call.should == 42
+    end
+  end
+  temporary_constant :Foo do
+    it 'should evaluate value when block given as :init' do
+      class Foo < Doodle::Base
+        has :value do
+          init do
+            42
+          end
+        end
+      end
+      foo = Foo.new
+      foo.value.should == 42
     end
   end
 end

data/spec/serialization_spec.rb

@@ -14,7 +14,12 @@ describe Doodle, "Serialization" do
     end
     
     it "should be serializable to yaml" do
-      @foo.to_yaml.should == "--- !ruby/object:Foo \nvar: 42\n"
+      # is this a bug in the MRI yaml implementation? why the space after Foo?
+      if RUBY_PLATFORM == 'java'
+        @foo.to_yaml.should == "--- !ruby/object:Foo\nvar: 42\n"
+      else
+        @foo.to_yaml.should == "--- !ruby/object:Foo \nvar: 42\n"
+      end
     end
     
     it "should be loadable from yaml" do
@@ -24,7 +29,7 @@ describe Doodle, "Serialization" do
     end
     
     it "should make it possible to validate already set instance variables" do
-      new_foo = YAML::load("--- !ruby/object:Foo \nvar: Hello World!\n")
+      new_foo = YAML::load("--- !ruby/object:Foo\nvar: Hello World!\n")
       proc { new_foo.validate!(true) }.should raise_error(Doodle::ValidationError)
     end
     

data/spec/singleton_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + "/spec_helper.rb"
+
+describe Doodle, "singletons" do
+  temporary_constant :Foo do    
+    it "should allow creating attributes on classes via inheritance" do
+      class Foo < Doodle::Base
+        class << self
+          has :c1
+        end
+      end
+      Foo.attributes.should == OrderedHash.new
+      Foo.singleton_class.attributes.should_not == OrderedHash.new
+      Foo.singleton_class.attributes.map{ |name, attr| name }.should == [:c1]
+      Foo.c1 = 1
+      Foo.c1.should == 1
+    end
+
+    it "should allow creating attributes on classes via module inclusion" do
+      class Foo
+        include Doodle::Helper
+        class << self
+          has :c2
+        end
+      end
+      Foo.attributes.should == OrderedHash.new
+      Foo.singleton_class.attributes.should_not == OrderedHash.new
+      Foo.singleton_class.attributes.map{ |name, attr| name }.should == [:c2]
+      Foo.c2 = 1
+      Foo.c2.should == 1
+    end
+
+    it "should allow creating attributes on singletons via inheritance" do
+      class Foo < Doodle::Base
+      end
+      foo = Foo.new
+      class << foo
+        has :i1
+      end
+      foo.attributes.should == OrderedHash.new
+      foo.singleton_class.attributes.should_not == OrderedHash.new
+      foo.singleton_class.attributes.map{ |name, attr| name }.should == [:i1]
+      foo.i1 = 1
+      foo.i1.should == 1
+    end
+
+    it "should allow creating attributes on a singleton's singleton via module inclusion" do
+      class Foo
+        include Doodle::Helper
+      end
+      foo = Foo.new
+      class << foo
+        class << self
+          has :i2
+        end
+      end
+      foo.attributes.should == OrderedHash.new
+      foo.singleton_class.singleton_class.attributes.should_not == OrderedHash.new
+      foo.singleton_class.singleton_class.attributes.map{ |name, attr| name }.should == [:i2]
+      foo.singleton_class.i2 = 1
+      foo.singleton_class.i2.should == 1
+    end
+  end
+end