doodle 0.1.3 → 0.1.4

data/spec/defaults_spec.rb

@@ -17,44 +17,44 @@ describe Doodle, 'attributes with defaults' do
     end
   
     it 'should have instance attribute default via class' do
-      Foo.attributes[:name].default.should == 'D1'
+      Foo.attributes[:name].default.should_be 'D1'
     end
     it 'should have instance attribute default via instance' do
-      @foo.attributes[:name].default.should == 'D1'
+      @foo.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 == 'D2'
+      Foo.singleton_class.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 == 'D2'
+      Foo.singleton_class.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 == 'D3'
+      @foo.singleton_class.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 == 'D3'
+      @foo.singleton_class.attributes[:special].default.should_be 'D3'
     end
     it 'should have singleton attribute name by default' do
-      @foo.name.should == 'D1'
+      @foo.name.should_be 'D1'
     end
     it 'should have singleton attribute name by default' do
-      Foo.metadata.should == 'D2'
+      Foo.metadata.should_be 'D2'
     end
     it 'should have singleton attribute special by default' do
-      @foo.special.should == 'D3'
+      @foo.special.should_be 'D3'
     end
 
     it 'should not have a @name instance variable' do
-      @foo.instance_variables.include?("@name").should == false
-      @foo.instance_variables.sort.should == []
+      @foo.instance_variables.include?("@name").should_be false
+      @foo.instance_variables.sort.should_be []
     end
     it 'should not have a @metadata class instance variable' do
-      Foo.instance_variables.include?("@metadata").should == false
-      Foo.instance_variables.sort.should == []
+      Foo.instance_variables.include?("@metadata").should_be false
+      Foo.instance_variables.sort.should_be []
     end
     it 'should not have @special singleton instance variable' do
-      @foo.singleton_class.instance_variables.include?("@special").should == false
-      @foo.singleton_class.instance_variables.sort.should == []
+      @foo.singleton_class.instance_variables.include?("@special").should_be false
+      @foo.singleton_class.instance_variables.sort.should_be []
     end
   end
 end
@@ -90,11 +90,11 @@ describe Doodle, 'defaults which have been set' do
     end
 
     it 'should have default value set from hash arg' do
-      @foo.baz.should == 'Hi!'
+      @foo.baz.should_be 'Hi!'
     end
 
     it 'should have default value set from block' do
-      @foo.start.should == Date.today
+      @foo.start.should_be Date.today
     end
   end
 end
@@ -120,8 +120,8 @@ describe Doodle, "overriding inherited defaults" do
   
     it 'should allow initialization using defaults' do
       text = Text.new(:value => 'any')
-      text.name.should == 'text'
-      text.value.should == 'any'
+      text.name.should_be 'text'
+      text.value.should_be 'any'
     end
   
     it 'should raise Doodle::ValidationError if initialized without all required values' do
@@ -130,8 +130,8 @@ describe Doodle, "overriding inherited defaults" do
   
     it 'should allow initialization using inherited defaults' do
       text = Text2.new
-      text.name.should == 'text'
-      text.value.should == 'any2'
+      text.name.should_be 'text'
+      text.value.should_be 'any2'
     end
   end
 end

data/spec/doodle_context_spec.rb

@@ -37,8 +37,8 @@ describe Doodle, "doodle_context" do
       end
 
       sean = dad.children[0]
-      sean.dad.name.should == 'Conn'
-      sean.doodle_parent.name.should == 'Conn'
+      sean.dad.name.should_be 'Conn'
+      sean.doodle_parent.name.should_be 'Conn'
     end
   end
 end

data/spec/doodle_spec.rb

@@ -15,24 +15,24 @@ describe Doodle, 'instance attributes' do
 
     it 'should create attribute' do
       @foo.name = 'Smee'
-      @foo.name.should == 'Smee'
+      @foo.name.should_be 'Smee'
     end
 
     it 'should create attribute using getter_setter' do
       @foo.name 'Smee'
-      @foo.name.should == 'Smee'
+      @foo.name.should_be 'Smee'
     end
 
     it 'should list instance attributes(false)' do
-      @foo.attributes(false).keys.should == []
+      @foo.attributes(false).keys.should_be []
     end
 
     it 'should list instance attributes' do
-      @foo.attributes.keys.should == [:name]
+      @foo.attributes.keys.should_be [:name]
     end
   
     it 'should list all instance attributes(false) at class level' do
-      Foo.attributes(false).keys.should == [:name]
+      Foo.attributes(false).keys.should_be [:name]
     end
   end
 end
@@ -54,25 +54,25 @@ describe Doodle, 'class attributes(false)' do
 
     it 'should create class attribute' do
       Foo.metadata = 'Foo metadata'
-      Foo.metadata.should == 'Foo metadata'
+      Foo.metadata.should_be 'Foo metadata'
     end
 
     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'
+      @foo.class.metadata.should_be '@foo metadata'
+      Foo.metadata.should_be '@foo metadata'
 
       Foo.metadata = 'Foo metadata'
-      Foo.metadata.should == 'Foo metadata'
-      @foo.class.metadata.should == 'Foo metadata'
+      Foo.metadata.should_be 'Foo metadata'
+      @foo.class.metadata.should_be 'Foo metadata'
     end
 
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes(false).keys.should == [:metadata]
+      Foo.singleton_class.attributes(false).keys.should_be [:metadata]
     end
   
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes.keys.should == [:metadata]
+      Foo.singleton_class.attributes.keys.should_be [:metadata]
     end
   end
 end
@@ -103,61 +103,61 @@ describe Doodle, 'inherited class attributes(false)' do
     it 'should create inherited class attribute' do
       Foo.metadata = 'Foo metadata'
       Bar.metadata = 'Bar metadata'
-      Foo.metadata.should == 'Foo metadata'
-      Bar.metadata.should == 'Bar metadata'
-      Foo.metadata.should == 'Foo metadata'
+      Foo.metadata.should_be 'Foo metadata'
+      Bar.metadata.should_be 'Bar metadata'
+      Foo.metadata.should_be 'Foo metadata'
     end
 
     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'
+      @foo.class.metadata.should_be '@foo metadata'
+      Foo.metadata.should_be '@foo metadata'
 
       Foo.metadata = 'Foo metadata'
       Bar.metadata = 'Bar metadata'
-      Foo.metadata.should == 'Foo metadata'
-      Bar.metadata.should == 'Bar metadata'
-      Foo.metadata.should == 'Foo metadata'
-      @foo.class.metadata.should == 'Foo metadata'
-      @bar.class.metadata.should == 'Bar metadata'
+      Foo.metadata.should_be 'Foo metadata'
+      Bar.metadata.should_be 'Bar metadata'
+      Foo.metadata.should_be 'Foo metadata'
+      @foo.class.metadata.should_be 'Foo metadata'
+      @bar.class.metadata.should_be 'Bar metadata'
     end
 
     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'
+      @foo.class.metadata.should_be '@foo metadata'
+      Foo.metadata.should_be '@foo metadata'
       Foo.metadata = 'Foo metadata'
 
       Bar.metadata = 'Bar metadata'
-      Bar.metadata.should == 'Bar metadata'
-      @bar.class.metadata.should == 'Bar metadata'
+      Bar.metadata.should_be 'Bar metadata'
+      @bar.class.metadata.should_be 'Bar metadata'
 
-      Foo.metadata.should == 'Foo metadata'
-      @foo.class.metadata.should == 'Foo metadata'
+      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.attributes(false).keys.should == [:metadata]
+      Foo.singleton_class.attributes(false).keys.should_be [:metadata]
     end
   
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes.keys.should == [:metadata]
+      Foo.singleton_class.attributes.keys.should_be [:metadata]
     end
 
     it "should list class's own attributes(false)" do
-      Bar.singleton_class.attributes(false).keys.should == [:doc]
+      Bar.singleton_class.attributes(false).keys.should_be [:doc]
     end
 
     it "should list all singleton class attributes" do
-      Bar.singleton_class.attributes.keys.should == [:doc]
+      Bar.singleton_class.attributes.keys.should_be [:doc]
     end
 
     it "should list all inherited meta class attributes" do
-      Bar.class_attributes.keys.should == [:metadata, :doc]
+      Bar.class_attributes.keys.should_be [:metadata, :doc]
     end
     
     it "should list all inherited class's attributes" do
-      Bar.attributes.keys.should == [:name, :location]
+      Bar.attributes.keys.should_be [:name, :location]
     end
   end
 end
@@ -184,19 +184,19 @@ describe Doodle, 'singleton class attributes' do
   
     it 'should allow creation of singleton class attributes' do
       @foo.special = 42
-      @foo.special.should == 42
+      @foo.special.should_be 42
     end
 
     it 'should list singleton instance attributes(false)' do
-      @foo.singleton_class.attributes(false).keys.should == [:special]
+      @foo.singleton_class.attributes(false).keys.should_be [:special]
     end
 
     it 'should list singleton instance attributes' do
-      @foo.singleton_class.attributes.keys.should == [:special]
+      @foo.singleton_class.attributes.keys.should_be [:special]
     end
 
     it 'should list instance attributes' do
-      @foo.attributes.keys.should == [:name, :special]
+      @foo.attributes.keys.should_be [:name, :special]
     end
 
   end
@@ -236,65 +236,81 @@ describe Doodle, 'inherited singleton class attributes' do
   
     it 'should allow creation of singleton class attributes' do
       @foo.special = 42
-      @foo.special.should == 42
+      @foo.special.should_be 42
       @bar.extra = 84
-      @bar.extra.should == 84
+      @bar.extra.should_be 84
       proc { @foo.extra = 1 }.should raise_error(NoMethodError)
       proc { @bar2.extra = 1 }.should raise_error(NoMethodError)
       proc { @bar.special = 1 }.should raise_error(NoMethodError)
     end
 
     it 'should list instance attributes' do
-      @foo.class.attributes(false).keys.should == [:name]
-      @bar.class.attributes(false).keys.should == [:info]
-      @bar2.class.attributes(false).keys.should == [:info]
+      @foo.class.attributes(false).keys.should_be [:name]
+      @bar.class.attributes(false).keys.should_be [:info]
+      @bar2.class.attributes(false).keys.should_be [:info]
     end
 
     it 'should list instance meta attributes' do
-      @foo.singleton_class.attributes(false).keys.should == [:special]
-      @bar.singleton_class.attributes(false).keys.should == [:extra]
+      @foo.singleton_class.attributes(false).keys.should_be [:special]
+      @bar.singleton_class.attributes(false).keys.should_be [:extra]
     end
 
     it 'should list singleton attributes only' do
-      @foo.singleton_class.attributes.keys.should == [:special]
-      @bar.singleton_class.attributes.keys.should == [:extra]
+      @foo.singleton_class.attributes.keys.should_be [:special]
+      @bar.singleton_class.attributes.keys.should_be [:extra]
     end
   
     it 'should keep meta attributes separate' do
       @foo.special = 'foo special'
-      @foo.special.should == 'foo special'
-#      @foo.singleton_class.methods.map{ |x| x.to_sym}.include?(:metadata).should == false
-#      @foo.singleton_class.metadata = 'foo meta'
-#      @foo.singleton_class.metadata.should == 'foo meta'
+      @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 == 'bar extra'
+      @bar.extra.should_be 'bar extra'
       Foo.metadata = 'Foo meta'
-      Foo.metadata.should == 'Foo meta'
+      Foo.metadata.should_be 'Foo meta'
       Bar.metadata = 'Bar meta'
-      Bar.metadata.should == 'Bar meta'
+      Bar.metadata.should_be 'Bar meta'
       Bar.doc = 'Bar doc'
-      Bar.doc.should == 'Bar doc'
+      Bar.doc.should_be 'Bar doc'
 
       # now make sure they haven't bumped each other off
-      @foo.special.should == 'foo special'
-#      @foo.singleton_class.metadata.should == 'foo meta'
-      @bar.extra.should == 'bar extra'
-      Foo.metadata.should == 'Foo meta'
-      Bar.metadata.should == 'Bar meta'
-      Bar.doc.should == 'Bar doc'
+      @foo.special.should_be 'foo special'
+
+      @bar.extra.should_be 'bar extra'
+      Foo.metadata.should_be 'Foo meta'
+      Bar.metadata.should_be 'Bar meta'
+      Bar.doc.should_be 'Bar doc'
+    end
+
+    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.metadata = 'foo meta'
+      @foo.singleton_class.instance_eval { @metadata }.should_be 'foo meta'
+      if RUBY_VERSION < '1.9.0'
+        @foo.singleton_class.metadata.should_be 'foo meta'
+      else
+        pending 'figuring out why this fails in 1.9' do
+          @foo.singleton_class.metadata.should_be 'foo meta'
+        end
+      end
     end
-    
+   
     it 'should behave predictably when setting singleton attributes' do
       @bar.extra = 'bar extra'
-      @bar.extra.should == 'bar extra'
-      # pending 'working out how to make this work' do
-      #   @bar.singleton_class.metadata = 'bar meta metadata'
-      #   @bar.singleton_class.metadata.should == 'bar meta metadata'
-      #   @bar.singleton_class.doc = 'bar doc'
-      #   @bar.singleton_class.doc.should == 'bar doc'
-      #   proc { @foo.singleton_class.doc = 1 }.should raise_error(NoMethodError)
-      # end
+      @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'
+      else
+        pending 'figuring out why this fails in 1.9'
+      end
+      proc { @foo.singleton_class.doc = 1 }.should raise_error(NoMethodError)
     end
   end
 end

data/spec/factory_spec.rb

@@ -14,15 +14,15 @@ describe Doodle::Factory, " as part of Doodle" do
     it 'should provide factory function' do
       proc {
         foo = Foo("abcd") 
-        foo.var1.should == "abcd"
+        foo.var1.should_be "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
+        bar.var1.should_be "abcd"
+        bar.var2.should_be 1234
         }.should_not raise_error
     end
   end
@@ -48,22 +48,22 @@ describe Doodle::Factory, " included as module" do
     it 'should provide factory function' do
       proc {
         foo = Baz("abcd") 
-        foo.var1.should == "abcd"
+        foo.var1.should_be "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
+        qux.var1.should_be "abcd"
+        qux.var2.should_be 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" 
+        qux.to_s.should_be "2008-01-01" 
         }.should_not raise_error
     end
 
@@ -71,7 +71,7 @@ describe Doodle::Factory, " included as module" do
     # it 'should be inheritable by non-doodle classes' do
     #   proc {
     #     qux = AnotherDate(2008, 01, 01) 
-    #     qux.to_s.should == "2008-01-01" 
+    #     qux.to_s.should_be "2008-01-01" 
     #     }.should_not raise_error
     # end
 

data/spec/inheritance_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Doodle, "inheritance" do
+  temporary_constants :Foo, :Bar do
+    before :each do
+      class Foo < Doodle
+        class << self
+          has :cvar
+        end
+        has :ivar
+      end
+      class Bar < Foo
+        class << self
+          has :cvar2
+        end
+        has :ivar2
+      end
+    end
+
+    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] 
+    end
+
+    it "should collect inherited for singleton" do
+      foo = Foo.new(:ivar => "foo")
+      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] 
+    end
+
+    it "should collect singleton class attributes for singleton" do
+      foo = Foo.new(:ivar => "foo")
+      class << foo
+        has :svar
+      end
+      foo.singleton_class.respond_to?(:cvar).should_be true
+      foo.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>>>
+      # and now it's false
+      # all different in 1.9
+#      foo.class.singleton_class.should_not == foo.singleton_class.superclass # => false
+#      foo.singleton_class.respond_to?(:cvar).should_be true
+    end
+    
+    it "should collect inherited for subclass singleton" do
+      bar = Bar.new(:ivar => "foo", :ivar2 => "bar")
+      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] 
+    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] 
+    end
+
+    it "should collect_inherited 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] 
+    end
+  end
+end