sequel 2.11.0 → 2.12.0

data/spec/model/inflector_spec.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe String do
+  deprec_specify "#camelize and #camelcase should transform the word to CamelCase" do
+    "egg_and_hams".camelize.should == "EggAndHams"
+    "egg_and_hams".camelize(false).should == "eggAndHams"
+    "post".camelize.should == "Post"
+    "post".camelcase.should == "Post"
+  end
+
+  deprec_specify "#constantize should eval the string to get a constant" do
+    "String".constantize.should == String
+    "String::Inflections".constantize.should == String::Inflections
+    proc{"BKSDDF".constantize}.should raise_error
+    proc{"++A++".constantize}.should raise_error
+  end
+  
+  deprec_specify "#dasherize should transform underscores to dashes" do
+    "egg_and_hams".dasherize.should == "egg-and-hams"
+    "post".dasherize.should == "post"
+  end
+  
+  deprec_specify "#demodulize should remove any preceding modules" do
+    "String::Inflections::Blah".demodulize.should == "Blah"
+    "String::Inflections".demodulize.should == "Inflections"
+    "String".demodulize.should == "String"
+  end
+  
+  deprec_specify "#humanize should remove _i, transform underscore to spaces, and capitalize" do
+    "egg_and_hams".humanize.should == "Egg and hams"
+    "post".humanize.should == "Post"
+    "post_id".humanize.should == "Post"
+  end
+  
+  deprec_specify "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
+    "egg-and: hams".titleize.should == "Egg And: Hams"
+    "post".titleize.should == "Post"
+    "post".titlecase.should == "Post"
+  end
+  
+  deprec_specify "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
+    "EggAndHams".underscore.should == "egg_and_hams"
+    "EGGAndHams".underscore.should == "egg_and_hams"
+    "Egg::And::Hams".underscore.should == "egg/and/hams"
+    "post".underscore.should == "post"
+    "post-id".underscore.should == "post_id"
+  end
+
+  deprec_specify "#pluralize should transform words from singular to plural" do
+    "post".pluralize.should == "posts"
+    "octopus".pluralize.should =="octopi"
+    "the blue mailman".pluralize.should == "the blue mailmen"
+    "CamelOctopus".pluralize.should == "CamelOctopi"
+  end
+  
+  deprec_specify "#singularize should transform words from plural to singular" do
+    "posts".singularize.should == "post"
+    "octopi".singularize.should == "octopus"
+    "the blue mailmen".singularize.should == "the blue mailman"
+    "CamelOctopi".singularize.should == "CamelOctopus"
+  end
+  
+  deprec_specify "#tableize should transform class names to table names" do
+    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
+    "egg_and_ham".tableize.should == "egg_and_hams"
+    "fancyCategory".tableize.should == "fancy_categories"
+  end
+  
+  deprec_specify "#classify should tranform table names to class names" do
+    "egg_and_hams".classify.should == "EggAndHam"
+    "post".classify.should == "Post"
+  end
+  
+  deprec_specify "#foreign_key should create a foreign key name from a class name" do
+    "Message".foreign_key.should == "message_id"
+    "Message".foreign_key(false).should == "messageid"
+    "Admin::Post".foreign_key.should == "post_id"
+  end
+end
+
+describe String::Inflections do
+  before do
+    deprec do
+      @plurals, @singulars, @uncountables = String.inflections.plurals.dup, String.inflections.singulars.dup, String.inflections.uncountables.dup
+    end
+  end
+  after do
+    deprec do
+      String.inflections.plurals.replace(@plurals)
+      String.inflections.singulars.replace(@singulars)
+      String.inflections.uncountables.replace(@uncountables)
+      Sequel.inflections.plurals.replace(@plurals)
+      Sequel.inflections.singulars.replace(@singulars)
+      Sequel.inflections.uncountables.replace(@uncountables)
+    end
+  end
+
+  deprec_specify "should be possible to clear the list of singulars, plurals, and uncountables" do
+    String.inflections.clear(:plurals)
+    String.inflections.plurals.should == []
+    String.inflections.plural('blah', 'blahs')
+    String.inflections.clear
+    String.inflections.plurals.should == []
+    String.inflections.singulars.should == []
+    String.inflections.uncountables.should == []
+  end
+
+  deprec_specify "should be able to specify new inflection rules" do
+    String.inflections do |i|
+      i.plural(/xx$/i, 'xxx')
+      i.singular(/ttt$/i, 'tt')
+      i.irregular('yy', 'yyy')
+      i.uncountable(%w'zz')
+    end
+    'roxx'.pluralize.should == 'roxxx'
+    'rottt'.singularize.should == 'rott'
+    'yy'.pluralize.should == 'yyy'
+    'yyy'.singularize.should == 'yy'
+    'zz'.pluralize.should == 'zz'
+    'zz'.singularize.should == 'zz'
+  end
+
+  deprec_specify "should be yielded and returned by String.inflections" do
+    String.inflections{|i| i.should == String::Inflections}.should == String::Inflections
+  end
+end

data/spec/{sequel_model → model}/model_spec.rb

@@ -64,7 +64,7 @@ describe Sequel::Model, "dataset & schema" do
     ds.should respond_to(:destroy)
   end
 
-  it "sets schema with implicit table name" do
+  deprec_specify "sets schema with implicit table name" do
     @model.set_schema do
       primary_key :ssn, :string
     end
@@ -72,7 +72,7 @@ describe Sequel::Model, "dataset & schema" do
     @model.table_name.should == :items
   end
 
-  it "sets schema with explicit table name" do
+  deprec_specify "sets schema with explicit table name" do
     @model.set_schema :foo do
       primary_key :id
     end
@@ -93,10 +93,12 @@ end
 
 describe Sequel::Model, "#sti_key" do
   before do
-    class ::StiTest < Sequel::Model
-      def kind=(x); self[:kind] = x; end
-      def refresh; end
-      set_sti_key :kind
+    deprec do
+      class ::StiTest < Sequel::Model
+        def kind=(x); self[:kind] = x; end
+        def refresh; end
+        set_sti_key :kind
+      end
     end
     class ::StiTestSub1 < StiTest
     end
@@ -106,7 +108,7 @@ describe Sequel::Model, "#sti_key" do
     MODEL_DB.reset
   end
   
-  it "should return rows with the correct class based on the polymorphic_key value" do
+  deprec_specify "should return rows with the correct class based on the polymorphic_key value" do
     def @ds.fetch_rows(sql)
       yield({:kind=>'StiTest'})
       yield({:kind=>'StiTestSub1'})
@@ -115,28 +117,28 @@ describe Sequel::Model, "#sti_key" do
     StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
   end
 
-  it "should fallback to the main class if polymophic_key value is NULL" do
+  deprec_specify "should fallback to the main class if polymophic_key value is NULL" do
     def @ds.fetch_rows(sql)
       yield({:kind=>nil})
     end
     StiTest.all.collect{|x| x.class}.should == [StiTest]
   end
   
-  it "should fallback to the main class if the given class does not exist" do
+  deprec_specify "should fallback to the main class if the given class does not exist" do
     def @ds.fetch_rows(sql)
       yield({:kind=>'StiTestSub3'})
     end
     StiTest.all.collect{|x| x.class}.should == [StiTest]
   end
   
-  it "should add a before_create hook that sets the model class name for the key" do
+  deprec_specify "should add a before_create hook that sets the model class name for the key" do
     StiTest.new.save
     StiTestSub1.new.save
     StiTestSub2.new.save
     MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
   end
   
-  it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
+  deprec_specify "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
     StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
     StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub1')"
     StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub2')"
@@ -233,6 +235,11 @@ describe Sequel::Model, ".subset" do
     @c.new_only.pricey.sql.should == "SELECT * FROM items WHERE ((age < 'new') AND (price > 100))"
   end
 
+  specify "should not override existing model methods" do
+    @c.meta_def(:active){true}
+    @c.subset(:active, :active)
+    @c.active.should == true
+  end
 end
 
 describe Sequel::Model, ".find" do
@@ -284,10 +291,9 @@ describe Sequel::Model, ".fetch" do
 
   it "should return true for .empty? and not raise an error on empty selection" do
     rows = @c.fetch("SELECT * FROM items WHERE FALSE")
-    @c.class_def(:fetch_rows) {|sql| yield({:count => 0})}
+    @c.send(:define_method, :fetch_rows){|sql| yield({:count => 0})}
     proc {rows.empty?}.should_not raise_error
   end
-  
 end
 
 describe Sequel::Model, ".find_or_create" do
@@ -332,7 +338,7 @@ describe Sequel::Model, ".delete_all" do
     @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql}
   end
 
-  it "should delete all records in the dataset" do
+  deprec_specify "should delete all records in the dataset" do
     @c.delete_all
     MODEL_DB.sqls.should == ["DELETE FROM items"]
   end
@@ -350,13 +356,13 @@ describe Sequel::Model, ".destroy_all" do
     @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql}
   end
 
-  it "should delete all records in the dataset" do
+  deprec_specify "should delete all records in the dataset" do
     @c.dataset.meta_def(:destroy) {MODEL_DB << "DESTROY this stuff"}
     @c.destroy_all
     MODEL_DB.sqls.should == ["DESTROY this stuff"]
   end
   
-  it "should call dataset.destroy" do
+  deprec_specify "should call dataset.destroy" do
     @c.dataset.should_receive(:destroy).and_return(true)
     @c.destroy_all
   end
@@ -511,7 +517,7 @@ describe Sequel::Model, ".[]" do
 end
 
 context "Model#inspect" do
-  setup do
+  before do
     @o = Sequel::Model.load(:x => 333)
   end
   
@@ -521,13 +527,12 @@ context "Model#inspect" do
 end
 
 context "Model.db_schema" do
-  setup do
+  before do
     @c = Class.new(Sequel::Model(:items)) do
       def self.columns; orig_columns; end
     end
     @dataset = Sequel::Dataset.new(nil).from(:items)
     @dataset.meta_def(:db){@db ||= Sequel::Database.new}
-    def @dataset.set_model(blah); end
     def @dataset.naked; self; end
     def @dataset.columns; []; end
     def @dataset.def_mutation_method(*names);  end
@@ -579,7 +584,7 @@ context "Model.db_schema" do
 end
 
 context "Model.str_columns" do
-  specify "should return the columns as frozen strings" do
+  deprec_specify "should return the columns as frozen strings" do
     c = Class.new(Sequel::Model)
     c.meta_def(:columns){[:a, :b]}
     c.orig_str_columns.should == %w'a b'

data/spec/model/plugins_spec.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+module Sequel::Plugins
+
+  module Timestamped
+    def self.apply(m, opts)
+      m.meta_def(:stamp_opts) {opts}
+      m.send(:define_method, :before_save){@values[:stamp] = Time.now}
+    end
+    
+    module InstanceMethods
+      def get_stamp(*args); @values[:stamp] end
+      def abc; timestamped_opts; end
+    end
+    
+    module ClassMethods
+      def deff; timestamped_opts; end
+    end
+
+    module DatasetMethods
+      def ghi; timestamped_opts; end
+    end
+  end
+
+end
+
+describe Sequel::Model, "using a plugin" do
+
+  it "should fail if the plugin is not found" do
+    proc do
+      c = Class.new(Sequel::Model)
+      c.class_eval do
+        plugin :something_or_other
+      end
+    end.should raise_error(LoadError)
+  end
+  
+  it "should apply the plugin to the class" do
+    c = nil
+    proc do
+      c = Class.new(Sequel::Model)
+      c.class_eval do
+        set_dataset MODEL_DB[:items]
+        plugin :timestamped, :a => 1, :b => 2
+      end
+    end.should_not raise_error(LoadError)
+    
+    c.should respond_to(:stamp_opts)
+    c.stamp_opts.should == {:a => 1, :b => 2}
+    
+    # instance methods
+    m = c.new
+    m.should respond_to(:get_stamp)
+    m.should respond_to(:abc)
+    m.abc.should == {:a => 1, :b => 2}
+    t = Time.now
+    m[:stamp] = t
+    m.get_stamp.should == t
+    
+    # class methods
+    c.should respond_to(:deff)
+    c.deff.should == {:a => 1, :b => 2}
+    
+    # dataset methods
+    c.dataset.should respond_to(:ghi)
+    c.dataset.ghi.should == {:a => 1, :b => 2}
+
+    # dataset methods called on the class
+    c.should respond_to(:ghi)
+    c.ghi.should == {:a => 1, :b => 2}
+  end
+  
+  deprec_specify "should have an .is alias" do
+    c = nil
+    proc do
+      c = Class.new(Sequel::Model)
+      c.class_eval do
+        set_dataset MODEL_DB[:items]
+        is :timestamped, :a => 1, :b => 2
+      end
+    end.should_not raise_error(LoadError)
+    
+    c.should respond_to(:stamp_opts)
+    c.stamp_opts.should == {:a => 1, :b => 2}
+    
+    # instance methods
+    m = c.new
+    m.should respond_to(:get_stamp)
+    m.should respond_to(:abc)
+    m.abc.should == {:a => 1, :b => 2}
+    t = Time.now
+    m[:stamp] = t
+    m.get_stamp.should == t
+    
+    # class methods
+    c.should respond_to(:deff)
+    c.deff.should == {:a => 1, :b => 2}
+    
+    # dataset methods
+    c.dataset.should respond_to(:ghi)
+    c.dataset.ghi.should == {:a => 1, :b => 2}
+
+    # dataset methods called on the class
+    c.should respond_to(:ghi)
+    c.ghi.should == {:a => 1, :b => 2}
+  end
+  
+  deprec_specify "should have an .is_a alias" do
+    c = nil
+    proc do
+      c = Class.new(Sequel::Model)
+      c.class_eval do
+        set_dataset MODEL_DB[:items]
+        is_a :timestamped, :a => 1, :b => 2
+      end
+    end.should_not raise_error(LoadError)
+    
+    c.should respond_to(:stamp_opts)
+    c.stamp_opts.should == {:a => 1, :b => 2}
+    
+    # instance methods
+    m = c.new
+    m.should respond_to(:get_stamp)
+    m.should respond_to(:abc)
+    m.abc.should == {:a => 1, :b => 2}
+    t = Time.now
+    m[:stamp] = t
+    m.get_stamp.should == t
+    
+    # class methods
+    c.should respond_to(:deff)
+    c.deff.should == {:a => 1, :b => 2}
+    
+    # dataset methods
+    c.dataset.should respond_to(:ghi)
+    c.dataset.ghi.should == {:a => 1, :b => 2}
+
+    # dataset methods called on the class
+    c.should respond_to(:ghi)
+    c.ghi.should == {:a => 1, :b => 2}
+  end
+end

data/spec/{sequel_model → model}/record_spec.rb

@@ -3,11 +3,10 @@ require File.join(File.dirname(__FILE__), "spec_helper")
 describe "Model#save" do
   
   before(:each) do
-    MODEL_DB.reset
-
     @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x, :y
     end
+    MODEL_DB.reset
   end
   
   it "should insert a record for a new model instance" do
@@ -41,7 +40,6 @@ describe "Model#save" do
   it "should update only the given columns if given" do
     o = @c.load(:id => 3, :x => 1, :y => nil)
     o.save(:y)
-    
     MODEL_DB.sqls.first.should == "UPDATE items SET y = NULL WHERE (id = 3)"
   end
   
@@ -55,28 +53,83 @@ describe "Model#save" do
     o.changed_columns.should == []
   end
 
-  it "should preserve changed_columns' and @new's value until all hook finish running" do
+  it "should store previous value of @new in @was_new and as well as the hash used for updating in @columns_updated until after hooks finish running" do
     res = nil
-    @c.after_save { res = [changed_columns, @new].flatten}
+    @c.send(:define_method, :after_save){ res = [@columns_updated, @was_new]}
     o = @c.new(:x => 1, :y => nil)
     o[:x] = 2
     o.save
-    res.should == [:x,true]
+    res.should == [nil, true]
+    o.after_save
+    res.should == [nil, nil]
 
     res = nil
     o = @c.load(:id => 23,:x => 1, :y => nil)
     o[:x] = 2
     o.save
-    res.should == [:x,false]
+    res.should == [{:id => 23,:x => 2, :y => nil}, nil]
+    o.after_save
+    res.should == [nil, nil]
 
     res = nil
-    o = @c.load(:id => 23,:x => 1, :y => nil)
+    o = @c.load(:id => 23,:x => 2, :y => nil)
     o[:x] = 2
     o[:y] = 22
     o.save(:x)
-    res.should == [:x,:y,false]
+    res.should == [{:x=>2},nil]
+    o.after_save
+    res.should == [nil, nil]
   end
   
+  it "should use Model's save_in_transaction setting by default" do
+    @c.use_transactions = true
+    @c.load(:id => 3, :x => 1, :y => nil).save(:y)
+    MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
+    MODEL_DB.reset
+    @c.use_transactions = false
+    @c.load(:id => 3, :x => 1, :y => nil).save(:y)
+    MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
+    MODEL_DB.reset
+  end
+
+  it "should inherit Model's save_in_transaction setting" do
+    @c.use_transactions = true
+    Class.new(@c).load(:id => 3, :x => 1, :y => nil).save(:y)
+    MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
+    MODEL_DB.reset
+    @c.use_transactions = false
+    Class.new(@c).load(:id => 3, :x => 1, :y => nil).save(:y)
+    MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
+    MODEL_DB.reset
+  end
+
+  it "should use object's save_in_transaction setting" do
+    o = @c.load(:id => 3, :x => 1, :y => nil)
+    o.use_transactions = false
+    @c.use_transactions = true
+    o.save(:y)
+    MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
+    MODEL_DB.reset
+    o = @c.load(:id => 3, :x => 1, :y => nil)
+    o.use_transactions = true
+    @c.use_transactions = false 
+    o.save(:y)
+    MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
+    MODEL_DB.reset
+  end
+
+  it "should use :transaction option if given" do
+    o = @c.load(:id => 3, :x => 1, :y => nil)
+    o.use_transactions = true
+    o.save(:y, :transaction=>false)
+    MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
+    MODEL_DB.reset
+    o = @c.load(:id => 3, :x => 1, :y => nil)
+    o.use_transactions = false
+    o.save(:y, :transaction=>true)
+    MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
+    MODEL_DB.reset
+  end
 end
 
 describe "Model#save_changes" do
@@ -142,7 +195,7 @@ describe "Model#save_changes" do
 
   it "should update columns changed in a before_update hook" do
     o = @c.load(:id => 3, :x => 1, :y => nil)
-    @c.before_update{self.x += 1}
+    @c.send(:define_method, :before_update){self.x += 1}
     o.save_changes
     MODEL_DB.sqls.should == []
     o.x = 2
@@ -159,7 +212,7 @@ describe "Model#save_changes" do
 
   it "should update columns changed in a before_save hook" do
     o = @c.load(:id => 3, :x => 1, :y => nil)
-    @c.before_save{self.x += 1}
+    @c.send(:define_method, :before_update){self.x += 1}
     o.save_changes
     MODEL_DB.sqls.should == []
     o.x = 2
@@ -185,20 +238,20 @@ describe "Model#update_values" do
     end
   end
   
-  it "should generate an update statement" do
+  deprec_specify "should generate an update statement" do
     o = @c.new(:id => 1)
     o.update_values(:x => 1)
     MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
   end
   
-  it "should update attribute values" do
+  deprec_specify "should update attribute values" do
     o = @c.new(:id => 1)
     o.x.should be_nil
     o.update_values(:x => 1)
     o.x.should == 1
   end
   
-  it "should support string keys" do
+  deprec_specify "should support string keys" do
     o = @c.new(:id => 1)
     o.x.should be_nil
     o.update_values('x' => 1)
@@ -217,27 +270,27 @@ describe "Model#set_values" do
     end
   end
   
-  it "should not touch the database" do
+  deprec_specify "should not touch the database" do
     o = @c.new(:id => 1)
     o.set_values(:x => 1)
     MODEL_DB.sqls.should == []
   end
   
-  it "should update attribute values" do
+  deprec_specify "should update attribute values" do
     o = @c.new(:id => 1)
     o.x.should be_nil
     o.set_values(:x => 1)
     o.x.should == 1
   end
   
-  it "should support string keys" do
+  deprec_specify "should support string keys" do
     o = @c.new(:id => 1)
     o.x.should be_nil
     o.set_values('x' => 1)
     o.x.should == 1
   end
 
-  it "should raise an error if used with a non-String, non-Symbol key" do
+  deprec_specify "should raise an error if used with a non-String, non-Symbol key" do
     proc{@c.new.set_values(1=>2)}.should raise_error(Sequel::Error)
   end
 end
@@ -435,7 +488,7 @@ describe Sequel::Model, "#set" do
   end
   
   it "should support virtual attributes" do
-    @c.class_def(:blah=) {|v| self.x = v}
+    @c.send(:define_method, :blah=){|v| self.x = v}
     @o1.set(:blah => 333)
     @o1.values.should == {:x => 333}
     MODEL_DB.sqls.should == []
@@ -453,19 +506,19 @@ describe Sequel::Model, "#set" do
     MODEL_DB.sqls.should == []
   end
 
-  it "should be aliased as set_with_params" do
+  deprec_specify "should be aliased as set_with_params" do
     @o1.set_with_params(:x => 1, :z => 2)
     @o1.values.should == {:x => 1}
     MODEL_DB.sqls.should == []
   end
   
   it "should return self" do
-    returned_value = @o1.set_with_params(:x => 1, :z => 2)
+    returned_value = @o1.set(:x => 1, :z => 2)
     returned_value.should == @o1
     MODEL_DB.sqls.should == []
   end
 
-  it "should assume it is a column if no column information is present and the key is a symbol" do
+  deprec_specify "should assume it is a column if no column information is present and the key is a symbol" do
     @c.instance_variable_set(:@columns, nil)
     o = @c.new.set(:x123=>1)
     o[:x123].should == 1
@@ -496,7 +549,7 @@ describe Sequel::Model, "#update" do
   end
   
   it "should support virtual attributes" do
-    @c.class_def(:blah=) {|v| self.x = v}
+    @c.send(:define_method, :blah=){|v| self.x = v}
     @o1.update(:blah => 333)
     MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (333)"
   end
@@ -510,7 +563,7 @@ describe Sequel::Model, "#update" do
     MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
   end
 
-  it "should be aliased as update_with_params" do
+  deprec_specify "should be aliased as update_with_params" do
     @o1.update_with_params(:x => 1, :z => 2)
     MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
   end
@@ -589,19 +642,25 @@ describe Sequel::Model, "#destroy" do
   end
 
   it "should return self" do
-    @model.db.should_receive(:transaction)
-    @model.after_destroy{3}
+    @model.send(:define_method, :after_destroy){3}
     @instance.destroy.should == @instance
   end
 
-  it "should run within a transaction" do
+  it "should run within a transaction if use_transactions is true" do
+    @instance.use_transactions = true
     @model.db.should_receive(:transaction)
     @instance.destroy
   end
 
+  it "should not run within a transaction if use_transactions is false" do
+    @instance.use_transactions = false
+    @model.db.should_not_receive(:transaction)
+    @instance.destroy
+  end
+
   it "should run before_destroy and after_destroy hooks" do
-    @model.before_destroy {MODEL_DB.execute('before blah')}
-    @model.after_destroy {MODEL_DB.execute('after blah')}
+    @model.send(:define_method, :before_destroy){MODEL_DB.execute('before blah')}
+    @model.send(:define_method, :after_destroy){MODEL_DB.execute('after blah')}
     @instance.destroy
     
     MODEL_DB.sqls.should == [
@@ -630,7 +689,7 @@ describe Sequel::Model, "#exists?" do
 end
 
 describe Sequel::Model, "#each" do
-  setup do
+  before do
     @model = Class.new(Sequel::Model(:items))
     @model.columns :a, :b, :id
     @m = @model.load(:a => 1, :b => 2, :id => 4444)
@@ -644,7 +703,7 @@ describe Sequel::Model, "#each" do
 end
 
 describe Sequel::Model, "#keys" do
-  setup do
+  before do
     @model = Class.new(Sequel::Model(:items))
     @model.columns :a, :b, :id
     @m = @model.load(:a => 1, :b => 2, :id => 4444)
@@ -750,7 +809,7 @@ describe Sequel::Model, "#hash" do
 end
 
 describe Sequel::Model, "#initialize" do
-  setup do
+  before do
     @c = Class.new(Sequel::Model) do
       columns :id, :x
     end
@@ -778,8 +837,8 @@ describe Sequel::Model, "#initialize" do
   end
   
   specify "should accept virtual attributes" do
-    @c.class_def(:blah=) {|x| @blah = x}
-    @c.class_def(:blah) {@blah}
+    @c.send(:define_method, :blah=){|x| @blah = x}
+    @c.send(:define_method, :blah){@blah}
     
     m = @c.new(:x => 2, :blah => 3)
     m.values.should == {:x => 2}
@@ -833,7 +892,7 @@ describe Sequel::Model, ".create" do
 end
 
 describe Sequel::Model, "#refresh" do
-  setup do
+  before do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
@@ -872,14 +931,14 @@ describe Sequel::Model, "#refresh" do
 end
 
 describe Sequel::Model, "typecasting" do
-  setup do
+  before do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       columns :x
     end
   end
 
-  teardown do
+  after do
     Sequel.datetime_class = Time
   end
 
@@ -891,7 +950,7 @@ describe Sequel::Model, "typecasting" do
     m.x.should == '1'
   end
 
-  specify "should not convert if serializing the field" do
+  deprec_specify "should not convert if serializing the field" do
     @c.serialize :x
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:string}})
     m = @c.new
@@ -968,7 +1027,7 @@ describe Sequel::Model, "typecasting" do
 
   specify "should raise an error if invalid data is used in an integer field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
-    proc{@c.new.x = 'a'}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid integer" do
@@ -992,7 +1051,7 @@ describe Sequel::Model, "typecasting" do
 
   specify "should raise an error if invalid data is used in an float field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:float}})
-    proc{@c.new.x = 'a'}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid float" do
@@ -1019,7 +1078,7 @@ describe Sequel::Model, "typecasting" do
 
   specify "should raise an error if invalid data is used in an decimal field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:decimal}})
-    proc{@c.new.x = Date.today}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = Date.today}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid decimal" do
@@ -1085,18 +1144,18 @@ describe Sequel::Model, "typecasting" do
     y = Date.new(2007,10,21)
     m.x = '2007-10-21'
     m.x.should == y
-    m.x = '2007-10-21'.to_date
+    m.x = Date.parse('2007-10-21')
     m.x.should == y
-    m.x = '2007-10-21'.to_time
+    m.x = Time.parse('2007-10-21')
     m.x.should == y
-    m.x = '2007-10-21'.to_datetime
+    m.x = DateTime.parse('2007-10-21')
     m.x.should == y
   end
 
   specify "should raise an error if invalid data is used in a date field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
-    proc{@c.new.x = 'a'}.should raise_error(Sequel::Error::InvalidValue)
-    proc{@c.new.x = 100}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
+    proc{@c.new.x = 100}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid date" do
@@ -1111,7 +1170,7 @@ describe Sequel::Model, "typecasting" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:time}})
     m = @c.new
     x = '10:20:30'
-    y = x.to_time
+    y = Time.parse(x)
     m.x = x
     m.x.should == y
     m.x = y
@@ -1122,8 +1181,8 @@ describe Sequel::Model, "typecasting" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:time}})
     proc{@c.new.x = '0000'}.should raise_error
     proc{@c.new.x = 'a'}.should_not raise_error # Valid Time
-    proc{@c.new.x = '2008-10-21'.to_date}.should raise_error(Sequel::Error::InvalidValue)
-    proc{@c.new.x = '2008-10-21'.to_datetime}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = Date.parse('2008-10-21')}.should raise_error(Sequel::InvalidValue)
+    proc{@c.new.x = DateTime.parse('2008-10-21')}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid time" do
@@ -1138,34 +1197,34 @@ describe Sequel::Model, "typecasting" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
     m = @c.new
     x = '2007-10-21T10:20:30-07:00'
-    y = x.to_time
+    y = Time.parse(x)
     m.x = x
     m.x.should == y
-    m.x = x.to_datetime
+    m.x = DateTime.parse(x)
     m.x.should == y
-    m.x = x.to_time
+    m.x = Time.parse(x)
     m.x.should == y
-    m.x = '2007-10-21'.to_date
-    m.x.should == '2007-10-21'.to_time
+    m.x = Date.parse('2007-10-21')
+    m.x.should == Time.parse('2007-10-21')
     Sequel.datetime_class = DateTime
-    y = x.to_datetime
+    y = DateTime.parse(x)
     m.x = x
     m.x.should == y
-    m.x = x.to_datetime
+    m.x = DateTime.parse(x)
     m.x.should == y
-    m.x = x.to_time
+    m.x = Time.parse(x)
     m.x.should == y
-    m.x = '2007-10-21'.to_date
-    m.x.should == '2007-10-21'.to_datetime
+    m.x = Date.parse('2007-10-21')
+    m.x.should == DateTime.parse('2007-10-21')
   end
 
   specify "should raise an error if invalid data is used in a datetime field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
-    proc{@c.new.x = '0000'}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = '0000'}.should raise_error(Sequel::InvalidValue)
     proc{@c.new.x = 'a'}.should_not raise_error # Valid Time
     Sequel.datetime_class = DateTime
-    proc{@c.new.x = '0000'}.should raise_error(Sequel::Error::InvalidValue)
-    proc{@c.new.x = 'a'}.should raise_error(Sequel::Error::InvalidValue)
+    proc{@c.new.x = '0000'}.should raise_error(Sequel::InvalidValue)
+    proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid datetime" do