sequel 2.11.0 → 2.12.0

data/spec/integration/dataset_test.rb

@@ -48,6 +48,37 @@ describe "Simple Dataset operations" do
     @ds.first.should == {:id=>1, :number=>10}
     sqls_should_be('SELECT * FROM items LIMIT 1')
   end
+
+  specify "should alias columns correctly" do
+    @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
+    sqls_should_be("SELECT id AS 'x', number AS 'n' FROM items LIMIT 1")
+  end
+end
+
+describe "Simple Dataset operations" do
+  before do
+    INTEGRATION_DB.create_table!(:items) do
+      Integer :number
+      TrueClass :flag
+    end
+    @ds = INTEGRATION_DB[:items]
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items)
+  end
+
+  specify "should deal with boolean conditions correctly" do
+    @ds.insert(:number=>1, :flag=>true)
+    @ds.insert(:number=>2, :flag=>false)
+    @ds.insert(:number=>3, :flag=>nil)
+    @ds.order!(:number)
+    @ds.filter(:flag=>true).map(:number).should == [1]
+    @ds.filter(:flag=>false).map(:number).should == [2]
+    @ds.filter(:flag=>nil).map(:number).should == [3]
+    @ds.exclude(:flag=>true).map(:number).should == [2, 3]
+    @ds.exclude(:flag=>false).map(:number).should == [1, 3]
+    @ds.exclude(:flag=>nil).map(:number).should == [1, 2]
+  end
 end
 
 describe "Simple Dataset operations in transactions" do

data/spec/integration/eager_loader_test.rb

@@ -69,7 +69,7 @@ describe "Eagerly loading a tree structure" do
     clear_sqls
   end
   after do
-    Node.drop_table
+    INTEGRATION_DB.drop_table :nodes
     Object.send(:remove_const, :Node)
   end
 
@@ -138,26 +138,18 @@ describe "Association Extensions" do
   before do
     module ::FindOrCreate
       def find_or_create(vals)
-        # Exploits the fact that Sequel filters are ruby objects that
-        # can be introspected.
-        author_id = @opts[:where].args[1]
-        first(vals) || \
-          @opts[:models][nil].create(vals.merge(:author_id=>author_id))
+        first(vals) || model.create(vals.merge(:author_id=>model_object.pk))
       end 
+      def find_or_create_by_name(name)
+        first(:name=>name) || model.create(:name=>name, :author_id=>model_object.pk)
+      end
     end
     INTEGRATION_DB.instance_variable_set(:@schemas, nil)
     INTEGRATION_DB.create_table!(:authors) do
       primary_key :id
     end
     class ::Author < Sequel::Model
-      one_to_many :authorships, :extend=>FindOrCreate, :dataset=>(proc do
-        key = pk
-        ds = Authorship.filter(:author_id=>key)
-        ds.meta_def(:find_or_create_by_name) do |name|
-          first(:name=>name) || Authorship.create(:name=>name, :author_id=>key)
-        end 
-        ds  
-      end)
+      one_to_many :authorships, :extend=>FindOrCreate
     end
     INTEGRATION_DB.create_table!(:authorships) do
       primary_key :id
@@ -171,8 +163,7 @@ describe "Association Extensions" do
     clear_sqls
   end
   after do
-    Authorship.drop_table
-    Author.drop_table
+    INTEGRATION_DB.drop_table :authorships, :authors
     Object.send(:remove_const, :Author)
     Object.send(:remove_const, :Authorship)
   end
@@ -181,7 +172,7 @@ describe "Association Extensions" do
     Authorship.count.should == 0
     sqls_should_be('SELECT COUNT(*) FROM authorships LIMIT 1')
     authorship = @author.authorships_dataset.find_or_create_by_name('Bob')
-    sqls_should_be("SELECT * FROM authorships WHERE ((author_id = 1) AND (name = 'Bob')) LIMIT 1",
+    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Bob')) LIMIT 1",
       /INSERT INTO authorships \((author_id, name|name, author_id)\) VALUES \((1, 'Bob'|'Bob', 1)\)/,
       "SELECT * FROM authorships WHERE (id = 1) LIMIT 1")
     Authorship.count.should == 1
@@ -190,11 +181,11 @@ describe "Association Extensions" do
     authorship.name.should == 'Bob'
     authorship.author_id.should == @author.id
     @author.authorships_dataset.find_or_create_by_name('Bob').should == authorship
-    sqls_should_be("SELECT * FROM authorships WHERE ((author_id = 1) AND (name = 'Bob')) LIMIT 1")
+    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Bob')) LIMIT 1")
     Authorship.count.should == 1
     sqls_should_be('SELECT COUNT(*) FROM authorships LIMIT 1')
     authorship2 = @author.authorships_dataset.find_or_create(:name=>'Jim')
-    sqls_should_be("SELECT * FROM authorships WHERE ((author_id = 1) AND (name = 'Jim')) LIMIT 1",
+    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Jim')) LIMIT 1",
       /INSERT INTO authorships \((author_id, name|name, author_id)\) VALUES \((1, 'Jim'|'Jim', 1)\)/,
       "SELECT * FROM authorships WHERE (id = 2) LIMIT 1")
     Authorship.count.should == 2
@@ -204,7 +195,7 @@ describe "Association Extensions" do
     authorship2.name.should == 'Jim'
     authorship2.author_id.should == @author.id
     @author.authorships_dataset.find_or_create(:name=>'Jim').should == authorship2
-    sqls_should_be("SELECT * FROM authorships WHERE ((author_id = 1) AND (name = 'Jim')) LIMIT 1")
+    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Jim')) LIMIT 1")
   end
 end
 
@@ -291,9 +282,7 @@ describe "has_many :through has_many and has_one :through belongs_to" do
     clear_sqls
   end
   after do
-    Invoice.drop_table
-    Client.drop_table
-    Firm.drop_table
+    INTEGRATION_DB.drop_table :invoices, :clients, :firms
     Object.send(:remove_const, :Firm)
     Object.send(:remove_const, :Client)
     Object.send(:remove_const, :Invoice)
@@ -379,9 +368,10 @@ describe "Polymorphic Associations" do
       text :attachable_type
     end
     class ::Asset < Sequel::Model
+      m = method(:constantize)
       many_to_one :attachable, :reciprocal=>:assets, \
         :dataset=>(proc do
-          klass = attachable_type.constantize
+          klass = m.call(attachable_type)
           klass.filter(klass.primary_key=>attachable_id)
         end), \
         :eager_loader=>(proc do |key_hash, assets, associations|
@@ -391,7 +381,7 @@ describe "Polymorphic Associations" do
             ((id_map[asset.attachable_type] ||= {})[asset.attachable_id] ||= []) << asset
           end 
           id_map.each do |klass_name, id_map|
-            klass = klass_name.constantize
+            klass = m.call(klass_name)
             klass.filter(klass.primary_key=>id_map.keys).all do |attach|
               id_map[attach.pk].each do |asset|
                 asset.associations[:attachable] = attach
@@ -469,9 +459,7 @@ describe "Polymorphic Associations" do
     clear_sqls
   end
   after do
-    Asset.drop_table
-    Post.drop_table
-    Note.drop_table
+    INTEGRATION_DB.drop_table :assets, :posts, :notes
     Object.send(:remove_const, :Asset)
     Object.send(:remove_const, :Post)
     Object.send(:remove_const, :Note)
@@ -609,8 +597,7 @@ describe "many_to_one/one_to_many not referencing primary key" do
     clear_sqls
   end
   after do
-    Invoice.drop_table
-    Client.drop_table
+    INTEGRATION_DB.drop_table :invoices, :clients
     Object.send(:remove_const, :Client)
     Object.send(:remove_const, :Invoice)
   end

data/spec/integration/schema_test.rb

@@ -20,11 +20,11 @@ describe "Database schema parser" do
     INTEGRATION_DB.identifier_input_method = :reverse
     INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
     INTEGRATION_DB.create_table!(:items){integer :number}
-    INTEGRATION_DB.schema(nil, :reload=>true)[:items].should be_a_kind_of(Array)
+    INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
     INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
   end
 
-  specify "should be a hash with table_names as symbols" do
+  deprec_specify "should be a hash with table_names as symbols" do
     INTEGRATION_DB.create_table!(:items){integer :number}
     schema = INTEGRATION_DB.schema(nil, :reload=>true)
     schema.should be_a_kind_of(Hash)
@@ -33,13 +33,16 @@ describe "Database schema parser" do
 
   specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
     INTEGRATION_DB.create_table!(:items){integer :number}
-    INTEGRATION_DB.schema(nil, :reload=>true)
+    INTEGRATION_DB.schema(:items, :reload=>true)
     clear_sqls
-    INTEGRATION_DB.schema
+    INTEGRATION_DB.schema(:items)
     sqls_should_be
+    clear_sqls
+    INTEGRATION_DB.schema(:items, :reload=>true)
+    sqls_should_be "PRAGMA table_info('items')"
   end
 
-  specify "should give the same result for a single table regardless of whether schema was called for a single table" do
+  deprec_specify "should give the same result for a single table regardless of whether schema was called for a single table" do
     INTEGRATION_DB.create_table!(:items){integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items]
   end

data/spec/integration/spec_helper.rb

@@ -8,6 +8,23 @@ begin
 rescue LoadError
 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

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Database transactions" do
+  before do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    INTEGRATION_DB.create_table(:items){String :name; Integer :value}
+    @d = INTEGRATION_DB[:items]
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+  end
+
+  specify "should support transactions" do
+    INTEGRATION_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+
+  specify "should have #transaction yield the connection" do
+    INTEGRATION_DB.transaction do |conn|
+      conn.should_not == nil
+    end
+  end
+
+  specify "should correctly rollback transactions" do
+    proc do
+      INTEGRATION_DB.transaction do
+        @d << {:name => 'abc', :value => 1}
+        raise Interrupt, 'asdf'
+      end
+    end.should raise_error(Interrupt)
+
+    proc do
+      INTEGRATION_DB.transaction do
+        @d << {:name => 'abc', :value => 1}
+        raise Sequel::Rollback
+      end
+    end.should_not raise_error
+
+    @d.count.should == 0
+  end
+
+  specify "should handle returning inside of the block by committing" do
+    def INTEGRATION_DB.ret_commit
+      transaction do
+        self[:items] << {:name => 'abc'}
+        return
+        self[:items] << {:name => 'd'}
+      end
+    end
+
+    @d.count.should == 0
+    INTEGRATION_DB.ret_commit
+    @d.count.should == 1
+    INTEGRATION_DB.ret_commit
+    @d.count.should == 2
+    proc do
+      INTEGRATION_DB.transaction do
+        raise Interrupt, 'asdf'
+      end
+    end.should raise_error(Interrupt)
+
+    @d.count.should == 2
+  end
+end

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

@@ -392,7 +392,7 @@ describe Sequel::Model, "many_to_one" do
     proc{c.parent = p}.should raise_error(Sequel::Error)
   end
 
-  it "should have belongs_to alias" do
+  deprec_specify "should have belongs_to alias" do
     @c2.belongs_to :parent, :class => @c2
 
     d = @c2.load(:id => 1)
@@ -567,7 +567,7 @@ describe Sequel::Model, "one_to_many" do
     v = n.historical_values_dataset
     v.should be_a_kind_of(Sequel::Dataset)
     v.sql.should == 'SELECT * FROM historical_values WHERE (historical_values.node_id = 1234)'
-    v.model_classes.should == {nil => HistoricalValue}
+    v.model.should == HistoricalValue
   end
   
   it "should use class inside a module if given as a string" do
@@ -582,7 +582,7 @@ describe Sequel::Model, "one_to_many" do
     v = n.historical_values_dataset
     v.should be_a_kind_of(Sequel::Dataset)
     v.sql.should == 'SELECT * FROM values WHERE (values.node_id = 1234)'
-    v.model_classes.should == {nil => Historical::Value}
+    v.model.should == Historical::Value
   end
 
   it "should use explicit key if given" do
@@ -599,7 +599,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    a.save!
+    a.save
     MODEL_DB.reset
     a.should == n.add_attribute(a)
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234 WHERE (id = 2345)']
@@ -610,7 +610,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    a.save!
+    a.save
     MODEL_DB.reset
     a.should == n.remove_attribute(a)
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (id = 2345)']
@@ -621,7 +621,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.new(:id => 1234, :xxx=>5)
     a = @c1.new(:id => 2345)
-    a.save!
+    a.save
     MODEL_DB.reset
     a.should == n.add_attribute(a)
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 5 WHERE (id = 2345)']
@@ -866,7 +866,7 @@ describe Sequel::Model, "one_to_many" do
     im2.should_not(include('remove_all_attributes'))
   end
 
-  it "should have has_many alias" do
+  deprec_specify "should have has_many alias" do
     @c2.has_many :attributes, :class => @c1
     
     n = @c2.new(:id => 1234)
@@ -936,7 +936,7 @@ describe Sequel::Model, "one_to_many" do
     d = @c1.dataset
     def d.fetch_rows(s); end
     node.attributes.should == []
-    def attrib.save!; self end
+    def attrib.save; self end
     node.add_attribute(attrib)
     node.associations[:attributes].should == [attrib]
     node.remove_all_attributes.should == [attrib]
@@ -958,7 +958,7 @@ describe Sequel::Model, "one_to_many" do
     node = @c2.new(:id => 1234)
     node.attributes.should == []
     attrib.node.should == nil
-    def attrib.save!; self end
+    def attrib.save; self end
     node.add_attribute(attrib)
     attrib.associations[:node].should == node 
     node.remove_all_attributes
@@ -1006,6 +1006,19 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.last.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))'
   end
 
+  it "should use a transaction in the setter method if the :one_to_one option is true" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
+    @c2.use_transactions = true
+    MODEL_DB.sqls.clear
+    attrib = @c1.load(:id=>3)
+    @c2.new(:id => 1234).attribute = attrib
+    MODEL_DB.sqls.length.should == 4
+    MODEL_DB.sqls.first.should == 'BEGIN'
+    MODEL_DB.sqls[1].should =~ /UPDATE attributes SET (node_id = 1234, id = 3|id = 3, node_id = 1234) WHERE \(id = 3\)/
+    MODEL_DB.sqls[2].should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))'
+    MODEL_DB.sqls.last.should == 'COMMIT'
+  end
+
   it "should have the setter method for the :one_to_one option respect the :primary_key option" do
     @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true, :primary_key=>:xxx
     attrib = @c1.new(:id=>3)
@@ -1519,7 +1532,7 @@ describe Sequel::Model, "many_to_many" do
     im2.should_not(include('remove_all_attributes'))
   end
 
-  it "should have has_and_belongs_to_many alias" do
+  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)

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

@@ -37,7 +37,7 @@ describe "Model#serialize" do
     MODEL_DB.reset
   end
 
-  it "should translate values to YAML when creating records" do
+  deprec_specify "should translate values to YAML when creating records" do
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
       serialize :abc
@@ -53,7 +53,7 @@ describe "Model#serialize" do
     ]
   end
 
-  it "should support calling after the class is defined" do
+  deprec_specify "should support calling after the class is defined" do
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
       columns :def
@@ -70,7 +70,7 @@ describe "Model#serialize" do
     ]
   end
 
-  it "should support using the Marshal format" do
+  deprec_specify "should support using the Marshal format" do
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
       serialize :abc, :format => :marshal
@@ -87,7 +87,7 @@ describe "Model#serialize" do
     ]
   end
 
-  it "should translate values to and from YAML using accessor methods" do
+  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
@@ -127,7 +127,7 @@ describe "Model#serialize" do
     o.abc.should == 1
     o.def.should == "hello"
 
-    o.update_values(:abc => 23)
+    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"}
@@ -184,9 +184,8 @@ describe Sequel::Model, "dataset" do
 end
 
 describe Sequel::Model, ".def_dataset_method" do
-  setup do
+  before do
     @c = Class.new(Sequel::Model(:items)) do
-      @dataset = Object.new
     end
   end
   
@@ -233,18 +232,18 @@ describe Sequel::Model, ".def_dataset_method" do
 end
 
 describe "A model class with implicit table name" do
-  setup do
+  before do
     class Donkey < Sequel::Model
     end
   end
   
   specify "should have a dataset associated with the model class" do
-    Donkey.dataset.model_classes.should == {nil => Donkey}
+    Donkey.dataset.model.should == Donkey
   end
 end
 
 describe "A model inheriting from a model" do
-  setup do
+  before do
     class Feline < Sequel::Model
     end
     
@@ -253,18 +252,18 @@ describe "A model inheriting from a model" do
   end
   
   specify "should have a dataset associated with itself" do
-    Feline.dataset.model_classes.should == {nil => Feline}
-    Leopard.dataset.model_classes.should == {nil => Leopard}
+    Feline.dataset.model.should == Feline
+    Leopard.dataset.model.should == Leopard
   end
 end
 
 describe "Model.db=" do
-  setup do
+  before do
     $db1 = MockDatabase.new
     $db2 = MockDatabase.new
     
     class BlueBlue < Sequel::Model(:items)
-      set_dataset $db1[:blue]
+      set_dataset $db1[:blue].filter(:x=>1)
     end
   end
   
@@ -274,10 +273,20 @@ describe "Model.db=" do
     BlueBlue.dataset.db.should === $db2
     BlueBlue.dataset.db.should_not === $db1
   end
+
+  specify "should keep the same dataset options" do
+    BlueBlue.db = $db2
+    BlueBlue.dataset.sql.should == 'SELECT * FROM blue WHERE (x = 1)'
+  end
+
+  specify "should use the database for subclasses" do
+    BlueBlue.db = $db2
+    Class.new(BlueBlue).db.should === $db2
+  end
 end
 
 describe Sequel::Model, ".(allowed|restricted)_columns " do
-  setup do
+  before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z
       def refresh
@@ -340,7 +349,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
 end
 
 describe Sequel::Model, ".(un)?restrict_primary_key\\??" do
-  setup do
+  before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       set_primary_key :id
       columns :x, :y, :z, :id
@@ -382,7 +391,7 @@ describe Sequel::Model, ".(un)?restrict_primary_key\\??" do
 end
 
 describe Sequel::Model, ".strict_param_setting" do
-  setup do
+  before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z, :id
       set_restricted_columns :z
@@ -419,7 +428,7 @@ describe Sequel::Model, ".strict_param_setting" do
 end
 
 describe Sequel::Model, ".[] optimization" do
-  setup do
+  before do
     @c = Class.new(Sequel::Model(:a))
     @c.instance_eval do
       def simple_table
@@ -466,8 +475,8 @@ describe Sequel::Model, ".[] optimization" do
     Class.new(@c).simple_table.should == "'b'"
   end
 
-  it "should have simple_table = nil if inheriting and sti_key is set" do
-    @c.set_sti_key :x
+  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