doodle 0.0.10 → 0.1.0

data/spec/required_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe Doodle, 'defaults which have not been set' do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :baz
         has :start, :default => 1
       end

data/spec/serialization_spec.rb

@@ -4,7 +4,7 @@ require 'yaml'
 describe Doodle, "Serialization" do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
         has :var, :kind => Integer
       end
       @foo = Foo 42 
@@ -15,11 +15,8 @@ describe Doodle, "Serialization" do
     
     it "should be serializable to yaml" do
       # 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
+      # (note: all on one line to pass coverage)
+      RUBY_PLATFORM == 'java' ? @foo.to_yaml.should == "--- !ruby/object:Foo\nvar: 42\n" : @foo.to_yaml.should == "--- !ruby/object:Foo \nvar: 42\n"
     end
     
     it "should be loadable from yaml" do

data/spec/singleton_spec.rb

@@ -3,7 +3,7 @@ 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 Foo < Doodle
         class << self
           has :c1
         end
@@ -17,7 +17,7 @@ describe Doodle, "singletons" do
 
     it "should allow creating attributes on classes via module inclusion" do
       class Foo
-        include Doodle::Helper
+        include Doodle::Core
         class << self
           has :c2
         end
@@ -30,13 +30,13 @@ describe Doodle, "singletons" do
     end
 
     it "should allow creating attributes on singletons via inheritance" do
-      class Foo < Doodle::Base
+      class Foo < Doodle
       end
       foo = Foo.new
       class << foo
         has :i1
       end
-      foo.attributes.should == OrderedHash.new
+      foo.attributes.keys.should == [:i1]
       foo.singleton_class.attributes.should_not == OrderedHash.new
       foo.singleton_class.attributes.map{ |name, attr| name }.should == [:i1]
       foo.i1 = 1
@@ -45,7 +45,7 @@ describe Doodle, "singletons" do
 
     it "should allow creating attributes on a singleton's singleton via module inclusion" do
       class Foo
-        include Doodle::Helper
+        include Doodle::Core
       end
       foo = Foo.new
       class << foo

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'doodle'
+require 'date'
+
+# functions to help clean up namespace after defining classes
+def undefine_const(*consts)
+  consts.each do |const|
+    if Object.const_defined?(const)
+      Object.send(:remove_const, const)
+    end
+  end
+end
+
+def raise_if_defined(*args)
+  defined, undefined = args.partition{ |x| Object.const_defined?(x)}
+  raise "Namespace pollution: #{defined.join(', ')}" if defined.size > 0
+end
+
+def temporary_constants(*args, &block)
+  before :each do
+    raise_if_defined(*args)
+  end
+  after :each do
+    undefine_const(*args)
+  end
+  raise_if_defined(*args)
+  yield
+  raise_if_defined(*args)
+end
+alias :temporary_constant :temporary_constants
+
+def remove_ivars(*args)
+  args.each do |ivar|
+    remove_instance_variable "@#{ivar}"
+  end
+end 

data/spec/superclass_spec.rb

@@ -3,21 +3,22 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe 'Doodle', 'parents' do
   temporary_constant :Foo do
     before :each do
-      class Foo < Doodle::Base
+      class Foo < Doodle
       end
       @foo = Foo.new
       @sc = class << @foo; self; end
       @scc = class << @sc; self; end
-      @sclass_doodle_root = class << Doodle::Base; self; end
+      @sclass_doodle_root = class << Doodle; self; end
       @sclass_foo = class << @foo; class << self; self; end; end
     end
   
-    it 'should have singleton class parents == class, doodle root' do
-      @sc.parents.should == [@sclass_foo, @sclass_doodle_root]
+    it 'should have no singleton parents ' do
+      @sc.parents.should == []
     end
 
     it "should have singleton class's singleton class parents == []" do
-      @scc.parents.should == []
+      expected_parents = RUBY_VERSION <= "1.8.6" ? [] : [Module, Object, BasicObject]
+      @scc.parents.should == expected_parents
     end
   end
 end

data/spec/validation2_spec.rb

@@ -0,0 +1,248 @@
+# this file is frankly a bit of a mess - trying to do too many things
+# at once
+
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+shared_code = proc do
+  class DateRange < Doodle
+    has :start_date, :kind => Date do
+      from String do |s|
+        Date.parse(s)
+      end
+      from Array do |y,m,d|
+        #p [:from, Array, y, m, d]
+        Date.new(y, m, d)
+      end
+      from Integer do |jd|
+        #Doodle::Debug.d { [:converting_from, Integer, jd] }
+        Date.new(*Date.send(:jd_to_civil, jd))
+      end
+      #Doodle::Debug.d { [:start_date, self, self.class] }
+      default { Date.today }
+    end
+    has :end_date, :kind => Date do
+      from String do |s|
+        Date.parse(s)
+      end
+      from Array do |y,m,d|
+        #p [:from, Array, y, m, d]
+        Date.new(y, m, d)
+      end
+      from Integer do |jd|
+        #Doodle::Debug.d { [:converting_from, Integer, jd] }
+        Date.new(*Date.send(:jd_to_civil, jd))
+      end
+      default { start_date }
+    end
+    must "have end_date >= start_date" do
+      end_date >= start_date
+    end
+  end
+end
+
+describe :DateRange, ' validation' do
+  temporary_constants :DateRange do
+
+    before :each, &shared_code
+    
+    it 'should not raise an exception if end_date >= start_date' do
+      proc { DateRange.new('2007-01-01', '2007-01-02') }.should_not raise_error
+    end
+
+    it 'should raise an exception if end_date < start_date' do
+      proc { DateRange.new('2007-11-01', '2007-01-02') }.should raise_error
+    end
+  end
+end
+
+[:DateRange, :DerivedDateRange, :SecondLevelDerivedDateRange].each do |klass|
+
+  describe klass, ' validation' do
+    temporary_constants :DateRange, :DerivedDateRange, :SecondLevelDerivedDateRange do
+
+      before :each, &shared_code
+      before :each do
+
+        class DerivedDateRange < DateRange
+        end
+
+        class SecondLevelDerivedDateRange < DateRange
+        end
+
+        @klass = self.class.const_get(klass)
+        @meth = @klass.method(:new)
+
+      end
+
+      it 'should not raise an exception if end_date > start_date' do
+        proc { @meth.call('2007-01-01', '2007-01-02') }.should_not raise_error
+      end
+
+      it 'should not raise an exception if end_date == start_date' do
+        proc { @klass.new('2007-01-02', '2007-01-02') }.should_not raise_error
+      end
+
+      it 'should raise an exception if end_date is < start_date' do
+        proc { @klass.new('2007-01-03', '2007-01-02') }.should raise_error(Doodle::ValidationError)
+      end
+
+      # distinguish between objects which have invalid classes and objects which have classes
+      # which can be converted (i.e. in from clause) but which have unconvertible values
+
+      invalid_dates = [Object.new, Object, Hash.new, { :key => 42 }, 1.2, :today]
+      keys = [:start_date, :end_date]
+  
+      keys.each do |key|
+        invalid_dates.each do |o|
+          it "should not validate #{o.inspect} for #{key}" do
+            proc { @klass.new(key => o) }.should raise_error(Doodle::ValidationError)
+          end
+        end
+      end
+
+      unconvertible_dates = [
+        'Hello', 
+        [], 
+        'tomorrow', 
+        'today', 
+        'yesterday',
+        "-9999999999999991-12-31",
+        "9999999999999990-12-31", 
+        9999999999999999999, 
+        -9999999999999999999,
+        ]
+      keys = [:start_date, :end_date]
+
+      keys.each do |key|
+        unconvertible_dates.each do |o|
+          it "should not convert #{o.inspect} to #{key}" do
+            proc { @klass.new(key => o) }.should raise_error(Doodle::ConversionError)
+          end
+        end
+      end
+
+      # could do with more bad_dates...
+      # note, these are splatted so need [] around args
+      bad_date_pairs = [
+                        [[2007,1,2],[2007,1,1]],
+                        [{ :end_date => '2007-01-01' }],
+                        [{ :start_date => '2007-01-01', :end_date => '2006-01-01' }]
+                       ]
+  
+      bad_date_pairs.each do |o|
+        it "should not allow #{o.inspect[1..-2]}" do
+          proc { @klass.new(*o) }.should raise_error(Doodle::ValidationError)
+        end
+      end
+  
+      # note, these are splatted so need [] around args
+      good_dates = [
+                    [[2007,1,1],[2007,1,2]],
+                    [{ :start_date => '2007-01-01' }],
+                    [{ :start_date => '2007-01-01', :end_date => '2007-01-01' }],
+                    [{ :start_date => -1, :end_date => 0 }]
+                   ]
+  
+      good_dates.each do |o|
+        it "should allow #{o.inspect[1..-2]}" do
+          proc { @klass.new(*o) }.should_not raise_error
+        end
+      end
+    end
+  end
+
+  describe klass, ' defaults' do
+    temporary_constants :AttributeDate, :Base, :DateRange, :DerivedDateRange, :SecondLevelDerivedDateRange do
+      before :each, &shared_code
+      before :each do
+        class DerivedDateRange < DateRange
+        end
+
+        class SecondLevelDerivedDateRange < DateRange
+        end
+
+        @klass = self.class.const_get(klass)
+        @dr = @klass.new
+      end
+  
+      it 'should have default start_date == Date.today' do
+        @dr.start_date == Date.today
+      end
+
+      it 'should have default end_date == start_date' do
+        @dr.end_date.should == @dr.start_date
+      end
+    end
+  end
+
+  describe klass, ' setting attributes after initialization' do
+    temporary_constants :AttributeDate, :Base, :DateRange, :DerivedDateRange, :SecondLevelDerivedDateRange do
+      before :each, &shared_code
+      before :each do
+        class DerivedDateRange < DateRange
+        end
+
+        class SecondLevelDerivedDateRange < DateRange
+        end
+
+        @klass = self.class.const_get(klass)
+        @dr = @klass.new
+      end
+
+      it "should not allow end_date < start_date" do
+        proc { @dr.end_date = @dr.start_date - 1 }.should raise_error(Doodle::ValidationError)
+      end
+
+      it "should allow end_date >= start_date" do
+        proc { @dr.end_date = @dr.start_date + 1 }.should_not raise_error
+      end
+
+      it "should allow changing start_date (and have dependent end_date follow)" do
+        proc { @dr.start_date = @dr.start_date + 1 }.should_not raise_error
+        @dr.end_date.should == @dr.start_date
+      end
+
+      it "should not raise an error when changing start_date and changing end_date using defer_validation" do
+        proc {
+          @dr.defer_validation do
+            self.start_date = self.start_date + 1
+            self.end_date = self.start_date
+          end
+        }.should_not raise_error
+      end
+
+      it "should allow changing start_date and changing end_date using defer_validation" do
+        @dr.defer_validation do
+          start_date start_date + 1
+          end_date start_date
+        end
+        @dr.start_date.should >= @dr.end_date
+      end
+  
+      it "should not allow changing start_date to be > end_date" do
+        proc {
+          @dr.end_date = @dr.start_date
+          @dr.start_date = @dr.start_date + 1
+        }.should raise_error(Doodle::ValidationError)
+      end
+
+      it "should not allow changing start_date to be > end_date" do
+        proc {
+          @dr.instance_eval {
+            end_date  start_date
+            start_date start_date + 1
+          }
+        }.should raise_error(Doodle::ValidationError)
+      end
+  
+      it "should not allow changing end_date to be < start_date" do
+        proc {
+          @dr.instance_eval {
+            end_date  start_date - 1
+          }
+        }.should raise_error(Doodle::ValidationError)
+      end
+  
+    end
+  end
+end

data/spec/validation_spec.rb

@@ -1,52 +1,41 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe :DateRange, 'validation & conversions' do
-  temporary_constants :Base, :DateRange, :ClassMethods do
+  temporary_constants :DateRange do
     
     before :each do
-      module ClassMethods
-        def date(*a, &b)
-  #        if a.size > 0
-            name = a.shift
-  #        else
-  #          name = :date
-  #        end
-          td = has(name, :kind => Date, *a) do
-            # it is a bit clumsy to define these conversions &
-            # conditions for every attribute/typedef - could define a
-            # subclass of Typedef which does this by default (so we
-            # instances can override or defer to class level conversions
-            # and conditions)
-            from String do |s|
-              Date.parse(s)
-            end
-            from Array do |y,m,d|
-              #p [:from, Array, y, m, d]
-              Date.new(y, m, d)
-            end
-            from Integer do |jd|
-              Doodle::Debug.d { [:converting_from, Integer, jd] }
-              Date.new(*Date.jd_to_civil(jd))
-            end
-          end
-          Doodle::Debug.d { [:date, td] }
-          td.instance_eval(&b) if block_given? # user's block should override default
-        end
-      end
 
-      class Base < Doodle::Base
-        extend ClassMethods
-      end
-
-      class DateRange < Base
-        date :start_date do
+      class DateRange < Doodle
+        has :start_date, :kind => Date do
           Doodle::Debug.d { [:start_date, self, self.class] }
+          from String do |s|
+            Date.parse(s)
+          end
+          from Array do |y,m,d|
+            #p [:from, Array, y, m, d]
+            Date.new(y, m, d)
+          end
+          from Integer do |jd|
+            Doodle::Debug.d { [:converting_from, Integer, jd] }
+            Date.new(*Date.send(:jd_to_civil, jd))
+          end
           default { Date.today }
           must "be >= 2007-01-01" do |d|
             d >= Date.new(2007, 01, 01)
           end
         end
-        date :end_date do
+        has :end_date, { :kind => Date } do
+          from String do |s|
+            Date.parse(s)
+          end
+          from Array do |y,m,d|
+            #p [:from, Array, y, m, d]
+            Date.new(y, m, d)
+          end
+          from Integer do |jd|
+            Doodle::Debug.d { [:converting_from, Integer, jd] }
+            Date.new(*Date.send(:jd_to_civil, jd))
+          end
           default { start_date }
         end
         must "have end_date >= start_date" do