sequel 2.12.0 → 3.0.0

data/spec/integration/spec_helper.rb

@@ -11,20 +11,6 @@ end
 Sequel.virtual_row_instance_eval = true
 Sequel::Model.use_transactions = false
 
-module Spec::Example::ExampleGroupMethods
-  def deprec_specify(*args, &block)
-    specify(*args) do
-      output = Sequel::Deprecation.output
-      Sequel::Deprecation.output = nil 
-      begin
-        instance_eval(&block)
-      ensure
-        Sequel::Deprecation.output = output
-      end 
-    end 
-  end 
-end
-
 $sqls = []
 def clear_sqls
   $sqls.clear

data/spec/integration/transaction_test.rb

@@ -43,6 +43,33 @@ describe "Database transactions" do
     @d.count.should == 0
   end
 
+  specify "should support nested transactions" do
+    @db = INTEGRATION_DB
+    @db.transaction do
+      @db.transaction do
+        @d << {:name => 'abc', :value => 1}
+      end 
+    end 
+    @d.count.should == 1
+
+    @d.delete
+    proc {@db.transaction do
+      @d << {:name => 'abc', :value => 1}
+      @db.transaction do
+        raise Sequel::Rollback
+      end 
+    end}.should_not raise_error
+    @d.count.should == 0
+
+    proc {@db.transaction do
+      @d << {:name => 'abc', :value => 1}
+      @db.transaction do
+        raise Interrupt, 'asdf'
+      end 
+    end}.should raise_error(Interrupt)
+    @d.count.should == 0
+  end 
+
   specify "should handle returning inside of the block by committing" do
     def INTEGRATION_DB.ret_commit
       transaction do

data/spec/model/associations_spec.rb

@@ -392,20 +392,6 @@ describe Sequel::Model, "many_to_one" do
     proc{c.parent = p}.should raise_error(Sequel::Error)
   end
 
-  deprec_specify "should have belongs_to alias" do
-    @c2.belongs_to :parent, :class => @c2
-
-    d = @c2.load(:id => 1)
-    MODEL_DB.reset
-    d.parent_id = 234
-    d.associations[:parent].should == nil
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end
-    e = d.parent 
-    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
-    d.associations[:parent].should == e
-  end
-
   it "should make the change to the foreign_key value inside a _association= method" do
     @c2.many_to_one :parent, :class => @c2
     @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_parent="))
@@ -866,19 +852,6 @@ describe Sequel::Model, "one_to_many" do
     im2.should_not(include('remove_all_attributes'))
   end
 
-  deprec_specify "should have has_many alias" do
-    @c2.has_many :attributes, :class => @c1
-    
-    n = @c2.new(:id => 1234)
-    atts = n.attributes
-    atts.should be_a_kind_of(Array)
-    atts.size.should == 1
-    atts.first.should be_a_kind_of(@c1)
-    atts.first.values.should == {}
-    
-    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
-  end
-  
   it "should populate the reciprocal many_to_one instance variable when loading the one_to_many association" do
     @c2.one_to_many :attributes, :class => @c1, :key => :node_id
     @c1.many_to_one :node, :class => @c2, :key => :node_id
@@ -1532,15 +1505,6 @@ describe Sequel::Model, "many_to_many" do
     im2.should_not(include('remove_all_attributes'))
   end
 
-  deprec_specify "should have has_and_belongs_to_many alias" do
-    @c2.has_and_belongs_to_many :attributes, :class => @c1 
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
-  end
-  
   it "should have an remove_all_ method that removes all associations" do
     @c2.many_to_many :attributes, :class => @c1
     @c2.new(:id => 1234).remove_all_attributes

data/spec/model/base_spec.rb

@@ -6,135 +6,35 @@ describe "Model attribute setters" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      columns :id, :x, :y
+      columns :id, :x, :y, :"x y"
     end
+    @o = @c.new
   end
 
   it "should mark the column value as changed" do
-    o = @c.new
-    o.changed_columns.should == []
+    @o.changed_columns.should == []
 
-    o.x = 2
-    o.changed_columns.should == [:x]
+    @o.x = 2
+    @o.changed_columns.should == [:x]
 
-    o.y = 3
-    o.changed_columns.should == [:x, :y]
+    @o.y = 3
+    @o.changed_columns.should == [:x, :y]
 
-    o.changed_columns.clear
+    @o.changed_columns.clear
 
-    o[:x] = 2
-    o.changed_columns.should == [:x]
+    @o[:x] = 2
+    @o.changed_columns.should == [:x]
 
-    o[:y] = 3
-    o.changed_columns.should == [:x, :y]
+    @o[:y] = 3
+    @o.changed_columns.should == [:x, :y]
   end
 
-end
-
-describe "Model#serialize" do
-
-  before(:each) do
-    MODEL_DB.reset
-  end
-
-  deprec_specify "should translate values to YAML when creating records" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      serialize :abc
-      columns :abc
-    end
-
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
-      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
-    ]
-  end
-
-  deprec_specify "should support calling after the class is defined" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      columns :def
-    end
-
-    @c.serialize :def
-
-    @c.create(:def => 1)
-    @c.create(:def => "hello")
-
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (def) VALUES ('--- 1\n')", \
-      "INSERT INTO items (def) VALUES ('--- hello\n')", \
-    ]
-  end
-
-  deprec_specify "should support using the Marshal format" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      serialize :abc, :format => :marshal
-      columns :abc
-    end
-
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-    x = [Marshal.dump("hello")].pack('m')
-
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \
-      "INSERT INTO items (abc) VALUES ('#{x}')", \
-    ]
+  it "should have columns that can't be called like normal ruby methods" do
+    @o.send(:"x y=", 3)
+    @o.changed_columns.should == [:"x y"]
+    @o.values.should == {:"x y"=>3}
+    @o.send(:"x y").should == 3
   end
-
-  deprec_specify "should translate values to and from YAML using accessor methods" do
-    @c = Class.new(Sequel::Model(:items)) do
-      serialize :abc, :def
-      columns :abc, :def
-    end
-
-    ds = @c.dataset
-    ds.extend(Module.new {
-      attr_accessor :raw
-
-      def fetch_rows(sql, &block)
-        block.call(@raw)
-      end
-
-      @@sqls = nil
-
-      def insert(*args)
-        @@sqls = insert_sql(*args)
-      end
-
-      def update(*args)
-        @@sqls = update_sql(*args)
-      end
-
-      def sqls
-        @@sqls
-      end
-
-      def columns
-        [:id, :abc, :def]
-      end
-    }
-    )
-
-    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
-    o = @c.first
-    o.id.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-
-    o.update(:abc => 23)
-    ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)"
-
-    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
-    o = @c.create(:abc => [1, 2, 3])
-    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"
-  end
-
 end
 
 describe Sequel::Model, "dataset" do
@@ -289,7 +189,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z
-      def refresh
+      def _refresh(ds)
         self
       end
     end
@@ -475,11 +375,6 @@ describe Sequel::Model, ".[] optimization" do
     Class.new(@c).simple_table.should == "'b'"
   end
 
-  specify "should have simple_table = nil if inheriting and sti_key is set" do
-    @c.plugin :single_table_inheritance, :x
-    Class.new(@c).simple_table.should == nil
-  end
-
   it "should use Dataset#with_sql if simple_table and simple_pk are true" do
     @c.set_dataset :a
     @c.dataset.should_receive(:with_sql).and_return(@c.dataset)

data/spec/model/hooks_spec.rb

@@ -1,173 +1,5 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
-describe "Model hooks" do
-  before do
-    MODEL_DB.reset
-  end
-  
-  deprec_specify "should be definable using a block" do
-    $adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
-      before_save {$adds << 'hi'}
-    end
-    
-    c.new.before_save
-    $adds.should == ['hi']
-  end
-  
-  deprec_specify "should be definable using a method name" do
-    $adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
-      def bye; $adds << 'bye'; end
-      before_save :bye
-    end
-    
-    c.new.before_save
-    $adds.should == ['bye']
-  end
-
-  deprec_specify "should be additive" do
-    $adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
-      after_save {$adds << 'hyiyie'}
-      after_save {$adds << 'byiyie'}
-    end
-
-    c.new.after_save
-    $adds.should == ['hyiyie', 'byiyie']
-  end
-  
-  deprec_specify "before hooks should run in reverse order" do
-    $adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
-      before_save {$adds << 'hyiyie'}
-      before_save {$adds << 'byiyie'}
-    end
-    
-    c.new.before_save
-    $adds.should == ['byiyie', 'hyiyie']
-  end
-
-  deprec_specify "should not be additive if the method or tag already exists" do
-    $adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
-      def bye; $adds << 'bye'; end
-      before_save :bye
-      before_save :bye
-    end
-    
-    c.new.before_save
-    $adds.should == ['bye']
-
-    $adds = []
-    d = Class.new(Sequel::Model)
-    d.class_eval do
-      before_save(:bye){$adds << 'hyiyie'}
-      before_save(:bye){$adds << 'byiyie'}
-    end
-    
-    d.new.before_save
-    $adds.should == ['byiyie']
-
-    $adds = []
-    e = Class.new(Sequel::Model)
-    e.class_eval do
-      def bye; $adds << 'bye'; end
-      before_save :bye
-      before_save(:bye){$adds << 'byiyie'}
-    end
-    
-    e.new.before_save
-    $adds.should == ['byiyie']
-
-    $adds = []
-    e = Class.new(Sequel::Model)
-    e.class_eval do
-      def bye; $adds << 'bye'; end
-      before_save(:bye){$adds << 'byiyie'}
-      before_save :bye
-    end
-    
-    e.new.before_save
-    $adds.should == ['bye']
-  end
-  
-  deprec_specify "should be inheritable" do
-    $adds = []
-    a = Class.new(Sequel::Model)
-    a.class_eval do
-      after_save {$adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      after_save {$adds << '456'}
-      after_save {$adds << '789'}
-    end
-    
-    b.new.after_save
-    $adds.should == ['123', '456', '789']
-  end
-  
-  deprec_specify "should be overridable in descendant classes" do
-    $adds = []
-    a = Class.new(Sequel::Model)
-    a.class_eval do
-      before_save {$adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      def before_save; $adds << '456'; end
-    end
-    
-    a.new.before_save
-    $adds.should == ['123']
-    $adds = []
-    b.new.before_save
-    $adds.should == ['456']
-  end
-  
-  deprec_specify "should stop processing if a hook returns false" do
-    $flag = true
-    $adds = []
-    
-    a = Class.new(Sequel::Model)
-    a.class_eval do
-      after_save {$adds << 'blah'; $flag}
-      after_save {$adds << 'cruel'}
-    end
-    
-    a.new.after_save
-    $adds.should == ['blah', 'cruel']
-
-    # chain should not break on nil
-    $adds = []
-    $flag = nil
-    a.new.after_save
-    $adds.should == ['blah', 'cruel']
-    
-    $adds = []
-    $flag = false
-    a.new.after_save
-    $adds.should == ['blah']
-    
-    b = Class.new(a)
-    b.class_eval do
-      after_save {$adds << 'mau'}
-    end
-    
-    $adds = []
-    b.new.after_save
-    $adds.should == ['blah']
-  end
-end
-
 describe "Model#after_initialize" do
   specify "should be called after initialization" do
     $values1 = nil
@@ -359,8 +191,8 @@ describe "Model#before_validation && Model#after_validation" do
     @c.class_eval do
       def after_validation; MODEL_DB << "BLAH after" end
 
-      def self.validate(o)
-        o.errors[:id] << 'not valid' unless o[:id] == 2233
+      def validate
+        errors.add(:id, 'not valid') unless id == 2233
       end
       columns :id
     end
@@ -405,68 +237,3 @@ describe "Model#before_validation && Model#after_validation" do
     MODEL_DB.sqls.should == []
   end
 end
-
-describe "Model.has_hooks?" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-  end
-  
-  deprec_specify "should return false if no hooks are defined" do
-    @c.has_hooks?(:before_save).should be_false
-  end
-  
-  deprec_specify "should return true if hooks are defined" do
-    @c.before_save {'blah'}
-    @c.has_hooks?(:before_save).should be_true
-  end
-  
-  deprec_specify "should return true if hooks are inherited" do
-    @d = Class.new(@c)
-    @d.has_hooks?(:before_save).should be_false
-  end
-end
-
-describe "Model#add_hook_type" do
-  before do
-    deprec do
-      class Foo < Sequel::Model(:items)
-        add_hook_type :before_bar, :after_bar
-
-        def bar
-          return :b if before_bar == false
-          return :a if after_bar == false
-          true
-        end
-      end
-    end
-    @f = Class.new(Foo)
-  end
-
-  deprec_specify "should have before_bar and after_bar class methods" do
-    @f.should respond_to(:before_bar)
-    @f.should respond_to(:before_bar)
-  end
-
-  deprec_specify "should have before_bar and after_bar instance methods" do
-    @f.new.should respond_to(:before_bar)
-    @f.new.should respond_to(:before_bar)
-  end
-
-  deprec_specify "it should return true for bar when before_bar and after_bar hooks are returing true" do
-    a = 1
-    @f.before_bar { a += 1}
-    @f.new.bar.should be_true
-    a.should == 2
-    @f.after_bar { a *= 2}
-    @f.new.bar.should be_true
-    a.should == 6
-  end
-
-  deprec_specify "it should return nil for bar when before_bar and after_bar hooks are returing false" do
-    @f.new.bar.should be_true
-    @f.after_bar { false }
-    @f.new.bar.should == :a
-    @f.before_bar { false }
-    @f.new.bar.should == :b
-  end
-end