doodle 0.0.10 → 0.1.0

data/spec/arg_order_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe 'arg_order' do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :name
         has :extra
         has :value
@@ -33,7 +33,7 @@ end
 describe 'arg_order' do
   temporary_constants :Foo, :Bar do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :name
       end
       class Bar < Foo
@@ -51,7 +51,7 @@ end
 describe 'arg_order' do
   temporary_constants :Foo, :Bar do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :name
       end
       class Bar < Foo
@@ -70,7 +70,7 @@ end
 describe 'arg_order' do
   temporary_constants :Foo, :Bar do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :name, :default => proc { self.class.to_s.downcase }
       end
       class Bar < Foo
@@ -90,7 +90,7 @@ end
 describe 'arg_order' do
   temporary_constants :Foo, :Bar do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :name
       end
       class Bar < Foo

data/spec/attributes_spec.rb

@@ -4,29 +4,40 @@ describe Doodle::Attribute, 'basics' do
   temporary_constants :Foo, :Bar do
     before(:each) do
       class Foo
-        include Doodle::Helper
-        has :name, :default => 'Hello'
+        include Doodle::Core
+        has :ivar1, :default => 'Hello'
         class << self
-          has :metadata
+          has :cvar1
         end
       end
       class Bar < Foo
-        has :info
+        has :ivar2
         class << self
-          has :doc
+          has :cvar2
         end
       end
     
       @foo = Foo.new
-      @bar = Bar.new :info => 'Hi'
+      class << @foo
+        has :svar1
+      end
+      @bar = Bar.new :ivar2 => 'Hi'
+      class << @bar
+        has :svar2
+      end
     end
 
-    it 'should have attribute :name with default defined' do
-      @foo.attributes[:name].default.should == 'Hello'
+    after :each do
+      @bar = nil
+      @foo = nil
+    end
+    
+    it 'should have attribute :ivar1 with default defined' do
+      @foo.attributes[:ivar1].default.should == 'Hello'
     end
 
     it 'should have default name' do
-      @foo.name.should == 'Hello'
+      @foo.ivar1.should == 'Hello'
     end
 
     it 'should not have an instance variable for a default' do
@@ -34,47 +45,77 @@ describe Doodle::Attribute, 'basics' do
     end
 
     it 'should have name required == false (because has default)' do
-      @foo.attributes[:name].required?.should == false
+      @foo.attributes[:ivar1].required?.should == false
     end
 
-    it 'should have info required == true' do
-      @bar.attributes[:info].required?.should == true
+    it 'should have ivar2 required == true' do
+      @bar.attributes[:ivar2].required?.should == true
     end
 
     it 'should have name.optional? == true (because has default)' do
-      @foo.attributes[:name].optional?.should == true
+      @foo.attributes[:ivar1].optional?.should == true
     end
 
     it 'should inherit attribute from parent' do
-      @bar.attributes[:name].should == @foo.attributes[:name]
+      @bar.attributes[:ivar1].should == @foo.attributes[:ivar1]
     end
 
-    it 'should have info.optional? == false' do
-      @bar.attributes[:info].optional?.should == false
+    it 'should have ivar2.optional? == false' do
+      @bar.attributes[:ivar2].optional?.should == false
     end
 
     it "should have parents in correct order" do
-      Bar.parents.should == [Foo, Object]
+      expected_parents = RUBY_VERSION <= "1.8.6" ? [Foo, Object] : [Foo, Object, BasicObject]
+      Bar.parents.should == expected_parents
     end
     
     it "should have Bar's singleton parents in reverse order of definition" do
-      @bar.singleton_class.parents.should == [Bar.singleton_class.singleton_class, Bar.singleton_class, Foo.singleton_class]
+      @bar.singleton_class.parents.should == []
+    end
+
+    it 'should have singleton_class attributes in order of definition' do
+      Bar.singleton_class.attributes.keys.should == [:cvar2]
+    end
+
+    it 'should have inherited class_attributes in order of definition' do
+      Bar.class_attributes.keys.should == [:cvar1, :cvar2]
     end
 
-    it 'should have inherited singleton local_attributes in order of definition' do
-      @bar.singleton_class.class_eval { collect_inherited(:local_attributes).map { |x| x[0]} }.should == [:metadata, :doc]
+    it 'should have inherited class_attributes in order of definition' do
+      @bar.class_attributes.keys.should == [:cvar1, :cvar2]
+    end
+    
+    it 'should have local class attributes in order of definition' do
+      Bar.singleton_class.attributes(false).keys.should == [:cvar2]
     end
 
-    it 'should have inherited singleton attributes in order of definition' do
-      @bar.singleton_class.attributes.keys.should == [:metadata, :doc]
+    it 'should not inherit singleton local_attributes' do
+      @bar.singleton_class.class_eval { collect_inherited(: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]
+    end
+    
+    it 'should not inherit singleton attributes#2' do
+      @bar.singleton_class.attributes.keys.should == [:svar2]
+    end
+
+    it 'should not inherit singleton attributes#3' do
+      @bar.singleton_class.attributes(false).keys.should == [:svar2]
+    end
+
+    it 'should show singleton attributes in attributes' do
+      @bar.attributes.keys.should == [:ivar1, :ivar2, :svar2]
+    end
+
   end
 end
 
 describe Doodle::Attribute, 'attribute order' do
   temporary_constants :A, :B, :C do
     before :each do
-      class A < Doodle::Base
+      class A < Doodle
         has :a
       end
 
@@ -88,7 +129,8 @@ describe Doodle::Attribute, 'attribute order' do
     end
   
     it 'should keep order of inherited attributes' do
-      C.parents.should == [B, A, Doodle::Base, Object]
+      expected_parents = RUBY_VERSION <= "1.8.6" ? [B, A, Doodle, Object] : [B, A, Doodle, Object, BasicObject]
+      C.parents.should == expected_parents
     end
 
     it 'should keep order of inherited attributes' do

data/spec/bugs_spec.rb

@@ -4,7 +4,7 @@ require 'yaml'
 describe 'Doodle', 'parents' do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :var1, :kind => Integer
         has :var2, :kind => Integer, :default => 1
         must 'have var1 != var2' do
@@ -24,7 +24,7 @@ end
 describe 'Doodle', ' loading good data from yaml' do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :date, :kind => Date do
           from String do |s|
             Date.parse(s)
@@ -45,7 +45,7 @@ describe 'Doodle', ' loading good data from yaml' do
     it 'should validate ok' do
       proc { foo = YAML::load(@str).validate! }.should_not raise_error
     end
-  
+    
     it 'should apply conversions' do
       foo = YAML::load(@str).validate!
       foo.date.should == Date.new(2000, 7, 1)
@@ -57,7 +57,7 @@ end
 describe 'Doodle', ' loading bad data from yaml' do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :date, :kind => Date do
           from String do |s|
             Date.parse(s)
@@ -81,9 +81,9 @@ describe 'Doodle', ' loading bad data from yaml' do
 end
 
 describe Doodle, 'class attributes:' do
-    temporary_constant :Foo do
+  temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :ivar
         class << self
           has :cvar
@@ -96,3 +96,106 @@ describe Doodle, 'class attributes:' do
     end
   end
 end
+
+describe Doodle, 'initializing from hashes and yaml' do
+  temporary_constants :AddressLine, :Person do
+    before :each do
+      class AddressLine < Doodle
+        has :text, :kind => String
+      end
+
+      class Person < Doodle
+        has :name, :kind => String
+        has :address, :collect => { :line => AddressLine }
+      end
+    end
+
+    it 'should validate ouput from to_yaml' do
+
+      yaml = %[
+---
+:address: 
+- Henry Wood House
+- London
+:name: Sean
+]
+
+      person = Person(YAML.load(yaml))
+      yaml = person.to_yaml
+      # be careful here - Ruby yaml is finicky (spaces after class names)
+      yaml = yaml.gsub(/\s*\n/m, "\n")
+      yaml.should == %[--- !ruby/object:Person
+address:
+- !ruby/object:AddressLine
+  text: Henry Wood House
+- !ruby/object:AddressLine
+  text: London
+name: Sean
+]
+      person = YAML.load(yaml)
+      proc { person.validate! }.should_not raise_error
+      person.address.all?{ |x| x.kind_of? AddressLine }.should == true
+
+    end
+  end
+end
+
+describe 'Doodle', 'hiding @__doodle__' do
+  temporary_constant :Foo, :Bar, :DString, :DHash, :DArray do
+    before :each do
+      class Foo < Doodle
+        has :var1, :kind => Integer
+      end
+      class Bar
+        include Doodle::Core
+        has :var2, :kind => Integer
+      end
+      class DString < String
+        include Doodle::Core
+      end
+      class DHash < Hash
+        include Doodle::Core
+      end
+      class DArray < Array
+        include Doodle::Core
+      end
+    end
+    
+    it 'should not reveal @__doodle__ in inspect string' do
+      foo = Foo 2
+      foo.inspect.should_not =~ /@__doodle__/
+    end
+    it 'should not include @__doodle__ in instance_variables' do
+      foo = Foo 2
+      foo.instance_variables.size.should == 1
+      foo.instance_variables.first.should =~ /^@var1$/
+    end
+    it 'should not reveal @__doodle__ in inspect string' do
+      foo = Bar 2
+      foo.inspect.should_not =~ /@__doodle__/
+    end
+    it 'should not include @__doodle__ in instance_variables' do
+      foo = Bar 2
+      foo.instance_variables.size.should == 1
+      foo.instance_variables.first.should =~ /^@var2$/
+    end
+    it 'should correctly inspect when using included module' do
+      foo = Bar 2
+      foo.inspect.should =~ /#<Bar:0x[a-z0-9]+ @var2=2>/
+    end
+    it 'should correctly inspect string' do
+      foo = DString("Hello")
+      foo.inspect.should == '"Hello"'
+    end
+    it 'should correctly inspect hash' do
+      foo = DHash.new(2)
+      foo[:a] = 1
+      foo.inspect.should == '{:a=>1}'
+      foo[:b].should == 2
+    end
+    it 'should correctly inspect array' do
+      foo = DArray(3, 2)
+      foo.inspect.should == '[2, 2, 2]'
+    end
+  end
+end

data/spec/class_spec.rb

@@ -4,14 +4,14 @@ describe Doodle, 'class attributes' do
   temporary_constants :Bar, :Foo do
     before(:each) do
       class Foo
-        include Doodle::Helper
+        include Doodle::Core
         class << self
           has :metadata
         end
       end
       @foo = Foo.new
       class Bar < Foo
-        include Doodle::Helper
+        include Doodle::Core
         class << self
           has :doc
         end
@@ -76,8 +76,11 @@ describe Doodle, 'class attributes' do
       Bar.singleton_class.attributes(false).keys.should == [:doc]
     end
   
-    it "should list all class's own attributes" do
-      Bar.singleton_class.attributes.keys.should == [:metadata, :doc]
+    it "should list all class's singleton attributes" do
+      Bar.singleton_class.attributes.keys.should == [:doc]
+    end
+    it "should list all class's class_attributes" do
+      Bar.class_attributes.keys.should == [:metadata, :doc]
     end
   end
 end

data/spec/class_validation_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Doodle, 'class validations' do
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Foo < Doodle
+        class << self
+          has :meta, { :default => "data", :kind => String } do
+            must "be >= 3 chars long" do |s|
+              s.size >= 3
+            end
+          end
+        end
+      end
+      class Bar < Foo
+      end
+    end
+
+    it 'should validate singleton class attributes' do
+      proc { Foo.meta = 1 }.should raise_error(Doodle::ValidationError) 
+    end
+
+    it 'should reject invalid singleton class attributes specified with must clause' do
+      proc { Foo.meta = "a" }.should raise_error(Doodle::ValidationError) 
+    end
+    
+    it 'should accept valid singleton class attributes specified with must clause' do
+      proc { Foo.meta = "abc" }.should_not raise_error
+    end
+
+    it 'should validate inherited singleton class attributes' do
+      proc { Bar.meta = 1 }.should raise_error(Doodle::ValidationError) 
+    end
+
+    it 'should reject invalid inherited singleton class attributes specified with must clause' do
+      proc { Bar.meta = "a" }.should raise_error(Doodle::ValidationError) 
+    end
+    
+    it 'should accept valid inherited singleton class attributes specified with must clause' do
+      proc { Bar.meta = "abc" }.should_not raise_error
+    end
+
+  end
+end
+
+

data/spec/class_var_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Doodle, 'class attributes:' do
+  temporary_constant :Foo, :Bar do
+    before :each do
+      class Foo < Doodle
+        has :ivar
+        class << self
+          has :cvar, :kind => Integer, :init => 1
+        end
+      end
+      class Bar < Doodle
+      end
+    end
+
+    it 'should be possible to set a class var without setting an instance var' do
+      proc { Foo.cvar = 42 }.should_not raise_error
+      Foo.cvar.should == 42
+    end
+
+    it 'should be possible to set an instance variable without setting a class var' do
+      proc { Foo.new :ivar => 42 }.should_not raise_error
+    end
+    
+    it 'should be possible to set a class variable without setting an newly added instance var' do
+      proc {
+        foo = Bar.new
+        class << Bar
+          has :cvar, :init => 43
+        end
+        class Bar < Doodle
+          has :ivar
+        end
+        Bar.cvar = 44
+      }.should_not raise_error
+    end
+
+    it 'should be possible to set a singleton variable without setting an instance var' do
+      proc {
+        class Bar < Doodle
+          has :ivar
+        end
+        foo = Bar.new :ivar => 42
+        class << foo
+          has :svar, :init => 43
+        end
+        foo.svar = 44
+      }.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
+    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
+      #end
+    end
+  end
+end