sequel 3.13.0 → 3.14.0

data/spec/adapters/mysql_spec.rb

@@ -89,7 +89,7 @@ context "A MySQL database" do
   end
 end
 
-if MYSQL_DB.class.adapter_scheme == :mysql
+if MYSQL_DB.adapter_scheme == :mysql
   context "Sequel::MySQL.convert_tinyint_to_bool" do
     before do
       @db = MYSQL_DB
@@ -536,7 +536,7 @@ context "A MySQL database" do
 end  
 
 # Socket tests should only be run if the MySQL server is on localhost
-if %w'localhost 127.0.0.1 ::1'.include?(MYSQL_URI.host) and MYSQL_DB.class.adapter_scheme == :mysql
+if %w'localhost 127.0.0.1 ::1'.include?(MYSQL_URI.host) and MYSQL_DB.adapter_scheme == :mysql
   context "A MySQL database" do
     specify "should accept a socket option" do
       db = Sequel.mysql(MYSQL_DB.opts[:database], :host => 'localhost', :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
@@ -895,7 +895,7 @@ context "MySQL::Dataset#complex_expression_sql" do
   end
 end
 
-unless MYSQL_DB.class.adapter_scheme == :do
+unless MYSQL_DB.adapter_scheme == :do
   context "MySQL Stored Procedures" do
     before do
       MYSQL_DB.create_table(:items){Integer :id; Integer :value}
@@ -940,7 +940,7 @@ unless MYSQL_DB.class.adapter_scheme == :do
   end
 end
 
-if MYSQL_DB.class.adapter_scheme == :mysql
+if MYSQL_DB.adapter_scheme == :mysql
   context "MySQL bad date/time conversions" do
     after do
       Sequel::MySQL.convert_invalid_date_time = false

data/spec/adapters/postgres_spec.rb

@@ -962,7 +962,7 @@ context "Postgres::Database functions, languages, and triggers" do
   end
 end
 
-if POSTGRES_DB.class.adapter_scheme == :postgres
+if POSTGRES_DB.adapter_scheme == :postgres
 context "Postgres::Dataset #use_cursor" do
   before(:all) do
     @db = POSTGRES_DB

data/spec/adapters/spec_helper.rb

@@ -34,12 +34,12 @@ class Spec::Example::ExampleGroup
     pending = false
     checked.each do |c|
       case c
-      when INTEGRATION_DB.class.adapter_scheme
+      when INTEGRATION_DB.adapter_scheme
         pending = c
       when Proc
         pending = c if c.first.call(INTEGRATION_DB)
       when Array
-        pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last == INTEGRATION_DB.call(INTEGRATION_DB)
+        pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.call(INTEGRATION_DB)
       end
     end
     if pending

data/spec/core/database_spec.rb

@@ -186,6 +186,11 @@ context "A new Database" do
     db.should be_a_kind_of(Sequel::Database)
     db.opts[:uri].should == 'do:test://host/db_name'
   end
+
+  specify "should populate :adapter option when using connection string" do
+    Sequel::Database.should_receive(:adapter_class).once.with(:do).and_return(Sequel::Database)
+    Sequel.connect('do:test://host/db_name').opts[:adapter] == :do
+  end
 end
 
 context "Database#disconnect" do
@@ -311,7 +316,7 @@ context "Database#uri" do
   end
 end
 
-context "Database.adapter_scheme" do
+context "Database.adapter_scheme and #adapter_scheme" do
   specify "should return the database schema" do
     Sequel::Database.adapter_scheme.should be_nil
 
@@ -320,6 +325,7 @@ context "Database.adapter_scheme" do
     end
     
     @c.adapter_scheme.should == :mau
+    @c.new({}).adapter_scheme.should == :mau
   end
 end
 
@@ -1493,6 +1499,7 @@ context "Database#each_server" do
     @db.each_server do |db|
       db.should be_a_kind_of(Sequel::Database)
       db.should_not == @db
+      db.opts[:adapter].should == :mock
       db.opts[:database].should == 2
       hosts << db.opts[:host]
     end

data/spec/core/dataset_spec.rb

@@ -3089,6 +3089,41 @@ context "Dataset#grep" do
       "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def') OR (body LIKE 'abc') OR (body LIKE 'def'))"
   end
   
+  specify "should support the :all_patterns option" do
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true).sql.should ==
+      "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (body LIKE 'abc')) AND ((title LIKE 'def') OR (body LIKE 'def')))"
+  end
+  
+  specify "should support the :all_columns option" do
+    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true).sql.should ==
+      "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (title LIKE 'def')) AND ((body LIKE 'abc') OR (body LIKE 'def')))"
+  end
+  
+  specify "should support the :case_insensitive option" do
+    @ds.grep([:title, :body], ['abc', 'def'], :case_insensitive=>true).sql.should ==
+      "SELECT * FROM posts WHERE ((title ILIKE 'abc') OR (title ILIKE 'def') OR (body ILIKE 'abc') OR (body ILIKE 'def'))"
+  end
+  
+  specify "should support the :all_patterns and :all_columns options together" do
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true).sql.should ==
+      "SELECT * FROM posts WHERE ((title LIKE 'abc') AND (body LIKE 'abc') AND (title LIKE 'def') AND (body LIKE 'def'))"
+  end
+  
+  specify "should support the :all_patterns and :case_insensitive options together" do
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :case_insensitive=>true).sql.should ==
+      "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (body ILIKE 'abc')) AND ((title ILIKE 'def') OR (body ILIKE 'def')))"
+  end
+  
+  specify "should support the :all_columns and :case_insensitive options together" do
+    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true, :case_insensitive=>true).sql.should ==
+      "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (title ILIKE 'def')) AND ((body ILIKE 'abc') OR (body ILIKE 'def')))"
+  end
+  
+  specify "should support the :all_patterns, :all_columns, and :case_insensitive options together" do
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true, :case_insensitive=>true).sql.should ==
+      "SELECT * FROM posts WHERE ((title ILIKE 'abc') AND (body ILIKE 'abc') AND (title ILIKE 'def') AND (body ILIKE 'def'))"
+  end
+
   specify "should support regexps though the database may not support it" do
     @ds.grep(:title, /ruby/).sql.should ==
       "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
@@ -3596,7 +3631,7 @@ describe "Sequel timezone support" do
     @dataset.literal(t).should == "#{s}#{@offset}'"
 
     t = DateTime.now.new_offset(0)
-    s = t.new_offset(Sequel::LOCAL_DATETIME_OFFSET).strftime("'%Y-%m-%d %H:%M:%S")
+    s = t.new_offset(DateTime.now.offset).strftime("'%Y-%m-%d %H:%M:%S")
     @dataset.literal(t).should == "#{s}#{@offset}'"
   end
   

data/spec/extensions/pagination_spec.rb

@@ -33,7 +33,7 @@ context "A paginated dataset" do
     @d.paginate(4, 50).next_page.should be_nil
   end
   
-  specify "should return the previous page number or nil if we're on the last" do
+  specify "should return the previous page number or nil if we're on the first" do
     @paginated.prev_page.should be_nil
     @d.paginate(4, 50).prev_page.should == 3
   end

data/spec/extensions/rcte_tree_spec.rb

@@ -33,16 +33,24 @@ describe Sequel::Model, "rcte_tree" do
     @c.plugin :rcte_tree
     @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
     @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
-    @o.ancestors_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (id = 1) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t'
-    @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (parent_id = 2) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t'
+    @o.ancestors_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (id = 1) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes'
+    @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (parent_id = 2) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes'
   end
   
   it "should use the correct SQL for lazy associations when giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :cte_name=>:cte, :order=>:name, :ancestors=>{:name=>:as}, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}, :parent=>{:name=>:p}
     @o.p_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
     @o.cs_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
-    @o.as_dataset.sql.should == 'WITH cte AS (SELECT * FROM nodes WHERE (i = 4) UNION ALL SELECT nodes.* FROM nodes INNER JOIN cte ON (cte.pi = nodes.i)) SELECT * FROM cte ORDER BY name'
-    @o.ds_dataset.sql.should == 'WITH cte AS (SELECT * FROM nodes WHERE (pi = 3) UNION ALL SELECT nodes.* FROM nodes INNER JOIN cte ON (cte.i = nodes.pi)) SELECT * FROM cte ORDER BY name'
+    @o.as_dataset.sql.should == 'WITH cte AS (SELECT * FROM nodes WHERE (i = 4) UNION ALL SELECT nodes.* FROM nodes INNER JOIN cte ON (cte.pi = nodes.i)) SELECT * FROM cte AS nodes ORDER BY name'
+    @o.ds_dataset.sql.should == 'WITH cte AS (SELECT * FROM nodes WHERE (pi = 3) UNION ALL SELECT nodes.* FROM nodes INNER JOIN cte ON (cte.i = nodes.pi)) SELECT * FROM cte AS nodes ORDER BY name'
+  end
+
+  it "should use the correct SQL for lazy associations with :conditions option" do
+    @c.plugin :rcte_tree, :conditions => {:i => 1}
+    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (i = 1)) LIMIT 1'
+    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (i = 1))'
+    @o.ancestors_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE ((id = 1) AND (i = 1)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)'
+    @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE ((parent_id = 2) AND (i = 1)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)'
   end
   
   it "should add all parent associations when lazily loading ancestors" do
@@ -93,7 +101,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     os = @ds.eager(:ancestors).all
     MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t/
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D'), @c.load(:id=>9, :parent_id=>nil, :name=>'E')]
     os.map{|o| o.ancestors}.should == [[@c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
       [@c.load(:id=>2, :name=>'AA', :parent_id=>1), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
@@ -126,7 +134,19 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.p.p.p.p if o.p and o.p.p and o.p.p.p}.should == [nil, nil, nil, nil]
     MODEL_DB.new_sqls.should == []
   end
-  
+
+  it "should eagerly load ancestors respecting association option :conditions" do
+    @c.plugin :rcte_tree, :conditions => {:i => 1}
+    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}, {:id=>9, :parent_id=>nil, :name=>'E'}],
+      [{:id=>2, :name=>'AA', :parent_id=>1, :x_root_x=>2},
+       {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
+       {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
+    os = @ds.eager(:ancestors).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(id IN \([12], [12]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
+    MODEL_DB.new_sqls.should == []
+  end
+
   it "should eagerly load descendants" do
     @c.plugin :rcte_tree
     @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
@@ -135,7 +155,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     os = @ds.eager(:descendants).all
     MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t/
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
     os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E'), @c.load(:id=>3, :name=>'00', :parent_id=>6)],
       [@c.load(:id=>3, :name=>'00', :parent_id=>6)],
@@ -173,7 +193,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7, :x_level_x=>0}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7, :x_level_x=>1}]]
     os = @ds.eager(:descendants=>2).all
     MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t/
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
     os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E'), @c.load(:id=>3, :name=>'00', :parent_id=>6)],
       [@c.load(:id=>3, :name=>'00', :parent_id=>6)],
@@ -202,4 +222,16 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs].map{|o3| o3.associations[:cs]}}}.should == [[[[]], []], [[]], [[nil]]]
     MODEL_DB.new_sqls.should == []
   end
+
+  it "should eagerly load descendants respecting association option :conditions" do
+    @c.plugin :rcte_tree, :conditions => {:i => 1}
+    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+      [{:id=>6, :parent_id=>2, :name=>'C', :x_root_x=>2}, {:id=>9, :parent_id=>2, :name=>'E', :x_root_x=>2},
+       {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
+       {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
+    os = @ds.eager(:descendants).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(parent_id IN \([267], [267], [267]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
+    MODEL_DB.new_sqls.should == []
+  end
 end

data/spec/extensions/schema_spec.rb

@@ -53,6 +53,11 @@ describe Sequel::Model, "create_table and schema" do
     MODEL_DB.sqls.should == ['CREATE TABLE items (name text, price float NOT NULL)']
   end
 
+  it "should allow setting schema and creating the table in one call" do
+    @model.create_table { text :name }
+    MODEL_DB.sqls.should == ['CREATE TABLE items (name text)']
+  end
+
   it "should reload the schema from the database" do
     schem = {:name=>{:type=>:string}, :price=>{:type=>:float}}
     @model.db.should_receive(:schema).with(:items, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})

data/spec/extensions/serialization_spec.rb

@@ -71,7 +71,7 @@ describe "Serialization plugin" do
     @c.create(:ghi => [1])
     @c.create(:ghi => ["hello"])
     
-    x = JSON.generate ["hello"]
+    x = ["hello"].to_json
     MODEL_DB.sqls.should == [ \
       "INSERT INTO items (ghi) VALUES ('[1]')", \
       "INSERT INTO items (ghi) VALUES ('#{x}')", \
@@ -129,7 +129,7 @@ describe "Serialization plugin" do
     
     ds = @c.dataset
     def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => JSON.generate([1]), :def => JSON.generate(["hello"]))
+      block.call(:id => 1, :abc => [1].to_json, :def => ["hello"].to_json)
     end
     
     o = @c.first
@@ -142,8 +142,8 @@ describe "Serialization plugin" do
     o.update(:abc => [23])
     @c.create(:abc => [1,2,3])
     
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{JSON.generate([23])}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{JSON.generate([1,2,3])}')"]
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')"]
   end
 
   it "should copy serialization formats and columns to subclasses" do

data/spec/extensions/single_table_inheritance_spec.rb

@@ -88,6 +88,13 @@ describe Sequel::Model, "#sti_key" do
     MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')"]
   end
 
+  it "should have the before_create hook handle columns with the same name as existing method names" do
+    StiTest.plugin :single_table_inheritance, :type
+    StiTest.columns :id, :type
+    StiTest.create
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (type) VALUES ('StiTest')"]
+  end
+
   it "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 (sti_tests.kind IN ('StiTestSub1'))"

data/spec/extensions/tree_spec.rb

@@ -103,6 +103,15 @@ describe Sequel::Model, "tree plugin" do
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
   end
 
+  it "should have root? return true for a root node and false for a child node" do
+    @c.load(:parent_id => nil).root?.should be_true
+    @c.load(:parent_id => 1).root?.should be_false
+  end
+
+  it "should have root? return false for an new node" do
+    @c.new.root?.should be_false
+  end
+
   it "should have self_and_siblings return the children of the current node's parent" do
     y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
     @o.self_and_siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
@@ -116,4 +125,31 @@ describe Sequel::Model, "tree plugin" do
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
+
+  describe ":single_root option" do
+    before do
+      @c = klass(:single_root => true)
+    end
+
+    it "should have root class method return the root" do
+      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.root.should == @c.load(:id=>1, :parent_id=>nil, :name=>'r')
+    end
+
+    it "prevents creating a second root" do
+      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+    end
+
+    it "errors when promoting an existing record to a second root" do
+      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      n = @c.load(:id => 2, :parent_id => 1)
+      lambda { n.update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+    end
+
+    it "allows updating existing root" do
+      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+    end
+  end
 end

data/spec/integration/dataset_test.rb

@@ -869,6 +869,25 @@ describe "Dataset string methods" do
     @ds.grep([:a, :b], %w'boo far').all.should == []
   end
   
+  it "#grep should work with :all_patterns and :all_columns options" do
+    @ds.insert('foo bar', '')
+    @ds.insert('foo d', 'bar')
+    @ds.insert('foo e', '')
+    @ds.insert('', 'bar')
+    @ds.insert('foo f', 'baz')
+    @ds.insert('foo baz', 'bar baz')
+    @ds.insert('foo boo', 'boo foo')
+
+    @ds.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true).all.should == [{:a=>'foo bar', :b=>''}, {:a=>'foo baz', :b=>'bar baz'}, {:a=>'foo d', :b=>'bar'}]
+    @ds.grep([:a, :b], %w'%foo% %bar% %blob%', :all_patterns=>true).all.should == []
+
+    @ds.grep([:a, :b], %w'%bar% %foo%', :all_columns=>true).all.should == [{:a=>"foo baz", :b=>"bar baz"}, {:a=>"foo boo", :b=>"boo foo"}, {:a=>"foo d", :b=>"bar"}]
+    @ds.grep([:a, :b], %w'%baz%', :all_columns=>true).all.should == [{:a=>'foo baz', :b=>'bar baz'}]
+
+    @ds.grep([:a, :b], %w'%baz% %foo%', :all_columns=>true, :all_patterns=>true).all.should == []
+    @ds.grep([:a, :b], %w'%boo% %foo%', :all_columns=>true, :all_patterns=>true).all.should == [{:a=>'foo boo', :b=>'boo foo'}]
+  end
+  
   it "#like should return matching rows" do
     @ds.insert('foo', 'bar')
     @ds.filter(:a.like('foo')).all.should == [{:a=>'foo', :b=>'bar'}]

data/spec/integration/prepared_statement_test.rb

@@ -118,7 +118,7 @@ describe "Prepared Statements and Bound Arguments" do
     INTEGRATION_DB.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
     @ds.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
     INTEGRATION_DB.call(:select_n, :n=>10).should == {:id=>1, :number=>10}
-    if INTEGRATION_DB.class.adapter_scheme == :jdbc and INTEGRATION_DB.database_type == :sqlite
+    if INTEGRATION_DB.adapter_scheme == :jdbc and INTEGRATION_DB.database_type == :sqlite
       # Work around for open prepared statements on a table not allowing the
       # dropping of a table when using SQLite over JDBC
       INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}
@@ -204,7 +204,7 @@ describe "Prepared Statements and Bound Arguments" do
     INTEGRATION_DB.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
     @c.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
     INTEGRATION_DB.call(:select_n, :n=>10).should == @c.load(:id=>1, :number=>10)
-    if INTEGRATION_DB.class.adapter_scheme == :jdbc and INTEGRATION_DB.database_type == :sqlite
+    if INTEGRATION_DB.adapter_scheme == :jdbc and INTEGRATION_DB.database_type == :sqlite
       # Work around for open prepared statements on a table not allowing the
       # dropping of a table when using SQLite over JDBC
       INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}

data/spec/integration/schema_test.rb

@@ -53,7 +53,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items)
   end
 
-  cspecify "should parse primary keys from the schema properly", [proc{|db| db.class.adapter_scheme != :jdbc}, :mssql] do
+  cspecify "should parse primary keys from the schema properly", [proc{|db| db.adapter_scheme != :jdbc}, :mssql] do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
     INTEGRATION_DB.create_table!(:items){primary_key :number}

data/spec/integration/spec_helper.rb

@@ -39,17 +39,17 @@ class Spec::Example::ExampleGroup
       when Array
         case c.length
         when 1
-          pending = c if c.first == INTEGRATION_DB.class.adapter_scheme
+          pending = c if c.first == INTEGRATION_DB.adapter_scheme
         when 2
           if c.first.is_a?(Proc)
             pending = c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
           elsif c.last.is_a?(Proc)
-            pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last.call(INTEGRATION_DB)
+            pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last.call(INTEGRATION_DB)
           else
-            pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last == INTEGRATION_DB.database_type
+            pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.database_type
           end
         when 3
-          pending = c if c[0] == INTEGRATION_DB.class.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
+          pending = c if c[0] == INTEGRATION_DB.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
         end          
       end
       break if pending

data/spec/integration/timezone_test.rb

@@ -2,25 +2,31 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Sequel timezone support" do
   def test_timezone
-    t = Time.now
-    @db[:t].insert(t)
-    t2 = @db[:t].single_value
-    t2 = Sequel.database_to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
-    (t2 - t).should be_close(0, 2)
-    t2.utc_offset.should == 0 if Sequel.application_timezone == :utc
-    t2.utc_offset.should == t.getlocal.utc_offset if Sequel.application_timezone == :local
-    @db[:t].delete
-    
-    dt = DateTime.now
+    # Tests should cover both DST and non-DST times.
+    [Time.now, Time.local(2010,1,1,12), Time.local(2010,6,1,12)].each do |t|
+      @db[:t].insert(t)
+      t2 = @db[:t].single_value
+      t2 = Sequel.database_to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
+      (t2 - t).should be_close(0, 2)
+      t2.utc_offset.should == 0 if Sequel.application_timezone == :utc
+      t2.utc_offset.should == t.getlocal.utc_offset if Sequel.application_timezone == :local
+      @db[:t].delete
+    end
+
     Sequel.datetime_class = DateTime
-    @db[:t].insert(dt)
-    dt2 = @db[:t].single_value
-    dt2 = Sequel.database_to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
-    (dt2 - dt).should be_close(0, 0.00002)
-    dt2.offset.should == 0 if Sequel.application_timezone == :utc
-    dt2.offset.should == dt.offset if Sequel.application_timezone == :local
+    local_dst_offset = Rational(Time.local(2010, 6).utc_offset, 60*60*24)
+    local_std_offset = Rational(Time.local(2010, 1).utc_offset, 60*60*24)
+    [DateTime.now, DateTime.civil(2010,1,1,12,0,0,local_std_offset), DateTime.civil(2010,6,1,12,0,0,local_dst_offset)].each do |dt|
+      @db[:t].insert(dt)
+      dt2 = @db[:t].single_value
+      dt2 = Sequel.database_to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
+      (dt2 - dt).should be_close(0, 0.00002)
+      dt2.offset.should == 0 if Sequel.application_timezone == :utc
+      dt2.offset.should == dt.offset if Sequel.application_timezone == :local
+      @db[:t].delete
+    end
   end
-  
+
   before do
     @db = INTEGRATION_DB
     @db.create_table!(:t){DateTime :t}
@@ -36,19 +42,19 @@ describe "Sequel timezone support" do
     Sequel.application_timezone = :local
     test_timezone
   end
-  
+
   cspecify "should support using local time for database storage and UTC for the application", [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     test_timezone
   end
-  
+
   cspecify "should support using UTC for both database storage and for application", [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.default_timezone = :utc
     test_timezone
   end
-  
-  specify "should support using local time for both database storage and for application" do
+
+  cspecify "should support using local time for both database storage and for application", [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.default_timezone = :local
     test_timezone
   end