sequel 2.11.0 → 2.12.0

data/spec/{sequel_core → core}/expression_filters_spec.rb

@@ -43,8 +43,8 @@ context "Blockless Ruby Filters" do
   it "should support = via Hash" do
     @d.l(:x => 100).should == '(x = 100)'
     @d.l(:x => 'a').should == '(x = \'a\')'
-    @d.l(:x => true).should == '(x = \'t\')'
-    @d.l(:x => false).should == '(x = \'f\')'
+    @d.l(:x => true).should == '(x IS TRUE)'
+    @d.l(:x => false).should == '(x IS FALSE)'
     @d.l(:x => nil).should == '(x IS NULL)'
     @d.l(:x => [1,2,3]).should == '(x IN (1, 2, 3))'
   end
@@ -52,8 +52,8 @@ context "Blockless Ruby Filters" do
   it "should support != via Hash#~" do
     @d.l(~{:x => 100}).should == '(x != 100)'
     @d.l(~{:x => 'a'}).should == '(x != \'a\')'
-    @d.l(~{:x => true}).should == '(x != \'t\')'
-    @d.l(~{:x => false}).should == '(x != \'f\')'
+    @d.l(~{:x => true}).should == '(x IS NOT TRUE)'
+    @d.l(~{:x => false}).should == '(x IS NOT FALSE)'
     @d.l(~{:x => nil}).should == '(x IS NOT NULL)'
   end
   
@@ -198,49 +198,49 @@ context "Blockless Ruby Filters" do
 
   it "should support hashes by ANDing the conditions" do
     @d.l(:x => 100, :y => 'a')[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
-    @d.l(:x => true, :y => false)[1...-1].split(' AND ').sort.should == ['(x = \'t\')', '(y = \'f\')']
+    @d.l(:x => true, :y => false)[1...-1].split(' AND ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
     @d.l(:x => nil, :y => [1,2,3])[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
   
   it "should support sql_negate on hashes" do
     @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
-    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != \'t\')', '(y != \'f\')']
+    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
     @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
   end
   
   it "should support ~ on hashes" do
     @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.should == ['(x != 100)', '(y != \'a\')']
-    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x != \'t\')', '(y != \'f\')']
+    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
     @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
   end
   
   it "should support sql_or on hashes" do
     @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = 100)', '(y = \'a\')']
-    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = \'t\')', '(y = \'f\')']
+    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
     @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
   
   it "should support arrays with all two pairs the same as hashes" do
     @d.l([[:x, 100],[:y, 'a']]).should == '((x = 100) AND (y = \'a\'))'
-    @d.l([[:x, true], [:y, false]]).should == '((x = \'t\') AND (y = \'f\'))'
+    @d.l([[:x, true], [:y, false]]).should == '((x IS TRUE) AND (y IS FALSE))'
     @d.l([[:x, nil], [:y, [1,2,3]]]).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
   end
   
   it "should support sql_negate on arrays with all two pairs" do
     @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x != \'t\') AND (y != \'f\'))'
+    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x IS NOT TRUE) AND (y IS NOT FALSE))'
     @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).should == '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
   end
   
   it "should support ~ on arrays with all two pairs" do
     @d.l(~[[:x, 100],[:y, 'a']]).should == '((x != 100) OR (y != \'a\'))'
-    @d.l(~[[:x, true], [:y, false]]).should == '((x != \'t\') OR (y != \'f\'))'
+    @d.l(~[[:x, true], [:y, false]]).should == '((x IS NOT TRUE) OR (y IS NOT FALSE))'
     @d.l(~[[:x, nil], [:y, [1,2,3]]]).should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
   end
   
   it "should support sql_or on arrays with all two pairs" do
     @d.l([[:x, 100],[:y, 'a']].sql_or).should == '((x = 100) OR (y = \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_or).should == '((x = \'t\') OR (y = \'f\'))'
+    @d.l([[:x, true], [:y, false]].sql_or).should == '((x IS TRUE) OR (y IS FALSE))'
     @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
   end
   
@@ -249,7 +249,7 @@ context "Blockless Ruby Filters" do
     @d.lit([:x].sql_string_join(', ')).should == '(x)'
     @d.lit([:x, :y].sql_string_join).should == '(x || y)'
     @d.lit([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
-    @d.lit([:x.sql_function(1), :y|1].sql_string_join).should == '(x(1) || y[1])'
+    @d.lit([:x.sql_function(1), :y.sql_subscript(1)].sql_string_join).should == '(x(1) || y[1])'
     @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
     @d.lit([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
     @d.lit([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"

data/spec/core/migration_spec.rb

@@ -0,0 +1,263 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Migration classes" do
+  before do
+    deprec{Sequel::Migration.descendants.clear}
+  end
+
+  deprec_specify "should be registred in Migration.descendants" do
+    @class = Class.new(Sequel::Migration)
+    
+    Sequel::Migration.descendants.should == [@class]
+  end
+  
+  deprec_specify "should be registered in the right order" do
+    @c1 = Class.new(Sequel::Migration)
+    @c2 = Class.new(Sequel::Migration)
+    @c3 = Class.new(Sequel::Migration)
+    
+    Sequel::Migration.descendants.should == [@c1, @c2, @c3]
+  end
+end
+
+context "Migration#apply" do
+  before do
+    @c = Class.new do
+      define_method(:one) {|x| [1111, x]}
+      define_method(:two) {|x| [2222, x]}
+    end
+    @db = @c.new
+    
+    deprec do
+      @migration = Class.new(Sequel::Migration) do
+        define_method(:up) {one(3333)}
+        define_method(:down) {two(4444)}
+      end
+    end
+  end
+  
+  deprec_specify "should raise for an invalid direction" do
+    proc {@migration.apply(@db, :hahaha)}.should raise_error(ArgumentError)
+  end
+  
+  deprec_specify "should apply the up direction correctly" do
+    @migration.apply(@db, :up).should == [1111, 3333]
+  end
+
+  deprec_specify "should apply the down direction correctly" do
+    @migration.apply(@db, :down).should == [2222, 4444]
+  end
+end
+
+class DummyMigrationDataset
+  attr_reader :from
+  
+  def initialize(x); @from = x; end
+  
+  @@version = nil
+  
+  def version; @@version; end
+  def version=(x); @@version = x; end
+  def first; @@version ? {:version => @@version} : nil; end
+  def update(h); @@version = h[:version]; end
+  def <<(h); @@version = h[:version]; end
+end
+
+class DummyMigrationDB
+  attr_reader :creates, :drops, :table_created
+  
+  def initialize
+    @creates = []
+    @drops = []
+  end
+  
+  def create(x); @creates << x; end
+  def drop(x); @drops << x; end
+  
+  def [](x); DummyMigrationDataset.new(x); end
+  
+  def create_table(x); raise if @table_created == x; @table_created = x; end
+  def table_exists?(x); @table_created == x; end
+  
+  def transaction; yield; end
+end
+
+MIGRATION_001 = %[
+  class CreateSessions < Sequel::Migration
+    def up
+      create(1111)
+    end
+    
+    def down
+      drop(1111)
+    end
+  end
+]
+
+MIGRATION_002 = %[
+  class CreateNodes < Sequel::Migration
+    def up
+      create(2222)
+    end
+    
+    def down
+      drop(2222)
+    end
+  end
+]
+
+MIGRATION_003 = %[
+  class CreateUsers < Sequel::Migration
+    def up
+      create(3333)
+    end
+    
+    def down
+      drop(3333)
+    end
+  end
+]
+
+MIGRATION_005 = %[
+  class CreateAttributes < Sequel::Migration
+    def up
+      create(5555)
+    end
+    
+    def down
+      drop(5555)
+    end
+  end
+]
+
+context "Sequel::Migrator" do
+  before do
+    @db = DummyMigrationDB.new
+    
+    File.open('001_create_sessions.rb', 'w') {|f| f << MIGRATION_001}
+    File.open('002_create_nodes.rb', 'w') {|f| f << MIGRATION_002}
+    File.open('003_create_users.rb', 'w') {|f| f << MIGRATION_003}
+    File.open('005_create_attributes.rb', 'w') {|f| f << MIGRATION_005}
+    
+    @db[:schema_info].version = nil
+  end
+  
+  after do
+    Object.send(:remove_const, "CreateSessions") if Object.const_defined?("CreateSessions")
+    Object.send(:remove_const, "CreateNodes") if Object.const_defined?("CreateNodes")
+    Object.send(:remove_const, "CreateUsers") if Object.const_defined?("CreateUsers")
+    Object.send(:remove_const, "CreateAttributes") if Object.const_defined?("CreateAttributes")
+
+    File.delete('001_create_sessions.rb')
+    File.delete('002_create_nodes.rb')
+    File.delete('003_create_users.rb')
+    File.delete('005_create_attributes.rb')
+  end
+  
+  deprec_specify "should return the list of files for a specified version range" do
+    Sequel::Migrator.migration_files('.', 1..1).should == \
+      ['./001_create_sessions.rb']
+
+    Sequel::Migrator.migration_files('.', 1..3).should == \
+      ['./001_create_sessions.rb', './002_create_nodes.rb', './003_create_users.rb']
+
+    Sequel::Migrator.migration_files('.', 3..5).should == \
+      ['./003_create_users.rb', './005_create_attributes.rb']
+      
+    Sequel::Migrator.migration_files('.', 7..8).should == []
+  end
+  
+  deprec_specify "should return the latest version available" do
+    Sequel::Migrator.latest_migration_version('.').should == 5
+  end
+  
+  deprec_specify "should load the migration classes for the specified range" do
+    Sequel::Migrator.migration_classes('.', 3, 0, :up).should == \
+      [CreateSessions, CreateNodes, CreateUsers]
+  end
+  
+  deprec_specify "should load the migration classes for the specified range" do
+    Sequel::Migrator.migration_classes('.', 0, 5, :down).should == \
+      [CreateAttributes, CreateUsers, CreateNodes, CreateSessions]
+  end
+  
+  deprec_specify "should start from current + 1 for the up direction" do
+    Sequel::Migrator.migration_classes('.', 3, 1, :up).should == \
+      [CreateNodes, CreateUsers]
+  end
+  
+  deprec_specify "should end on current + 1 for the down direction" do
+    Sequel::Migrator.migration_classes('.', 2, 5, :down).should == \
+      [CreateAttributes, CreateUsers]
+  end
+  
+  deprec_specify "should automatically create the schema_info table" do
+    @db.table_exists?(:schema_info).should be_false
+    Sequel::Migrator.schema_info_dataset(@db)
+    @db.table_exists?(:schema_info).should be_true
+    
+    # should not raise if table already exists
+    proc {Sequel::Migrator.schema_info_dataset(@db)}.should_not raise_error
+  end
+  
+  deprec_specify "should return a dataset for the schema_info table" do
+    d = Sequel::Migrator.schema_info_dataset(@db)
+    d.from.should == :schema_info
+  end
+  
+  deprec_specify "should get the migration version stored in the database" do
+    # default is 0
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+    
+    Sequel::Migrator.schema_info_dataset(@db) << {:version => 4321}
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 4321
+  end
+  
+  deprec_specify "should set the migration version stored in the database" do
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+    Sequel::Migrator.set_current_migration_version(@db, 6666)
+    Sequel::Migrator.get_current_migration_version(@db).should == 6666
+  end
+  
+  deprec_specify "should apply migrations correctly in the up direction" do
+    Sequel::Migrator.apply(@db, '.', 3, 2)
+    @db.creates.should == [3333]
+    
+    Sequel::Migrator.get_current_migration_version(@db).should == 3
+
+    Sequel::Migrator.apply(@db, '.', 5)
+    @db.creates.should == [3333, 5555]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 5
+  end
+  
+  deprec_specify "should apply migrations correctly in the down direction" do
+    Sequel::Migrator.apply(@db, '.', 1, 5)
+    @db.drops.should == [5555, 3333, 2222]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 1
+  end
+
+  deprec_specify "should apply migrations up to the latest version if no target is given" do
+    Sequel::Migrator.apply(@db, '.')
+    @db.creates.should == [1111, 2222, 3333, 5555]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 5
+  end
+
+  deprec_specify "should apply migrations down to 0 version correctly" do
+    Sequel::Migrator.apply(@db, '.', 0, 5)
+    @db.drops.should == [5555, 3333, 2222, 1111]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+  end
+  
+  deprec_specify "should return the target version" do
+    Sequel::Migrator.apply(@db, '.', 3, 2).should == 3
+
+    Sequel::Migrator.apply(@db, '.', 0).should == 0
+
+    Sequel::Migrator.apply(@db, '.').should == 5
+  end
+end

data/spec/{sequel_core → core}/object_graph_spec.rb

@@ -206,6 +206,14 @@ describe Sequel::Dataset, " graphing" do
     results[3].should == {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}
   end
 
+  it "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
+    ds = @ds1.graph(@ds2, :x=>:id)
+    def ds.fetch_rows(sql, &block)
+      block.call(:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil)
+    end
+    ds.all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
+  end
+
   it "#graph_each should not included tables graphed with the :select => false option in the result set" do
     ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
     def ds.fetch_rows(sql, &block)
@@ -250,23 +258,15 @@ describe Sequel::Dataset, " graphing" do
     results.first.should == {:points=>{:z1=>2}, :lines=>{:z2=>3}}
   end
 
-  it "#graph_each should run the row_proc and transform for graphed datasets" do
+  it "#graph_each should run the row_proc for graphed datasets" do
     @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
     @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
-    @ds1.transform(:x=>[
-      proc{|v| 123},
-      proc{|v| 123}
-    ])
-    @ds2.transform(:x=>[
-      proc{|v| 321},
-      proc{|v| 321}
-    ])
     ds = @ds1.graph(@ds2, :x=>:id)
     def ds.fetch_rows(sql, &block)
       yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
     end
     results = ds.all
     results.length.should == 1
-    results.first.should == {:points=>{:id=>2, :x=>246, :y=>6}, :lines=>{:id=>12, :x=>963, :y=>18, :graph_id=>21}}
+    results.first.should == {:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}
   end
 end

data/spec/{sequel_core → core}/pretty_table_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'stringio'
 
 context "PrettyTable" do
-  setup do
+  before do
     @data1 = [
       {:x => 3, :y => 4}
     ]
@@ -24,7 +24,7 @@ context "PrettyTable" do
     $stdout = @output
   end
 
-  teardown do
+  after do
     $stdout = @orig_stdout
   end
   

data/spec/{sequel_core → core}/schema_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 context "DB#create_table" do
-  setup do
+  before do
     @db = SchemaDummyDatabase.new
   end
   
@@ -492,7 +492,7 @@ context "DB#create_table" do
 end
 
 context "DB#create_table!" do
-  setup do
+  before do
     @db = SchemaDummyDatabase.new
   end
   
@@ -503,7 +503,7 @@ context "DB#create_table!" do
 end
 
 context "DB#drop_table" do
-  setup do
+  before do
     @db = SchemaDummyDatabase.new
   end
 
@@ -514,7 +514,7 @@ context "DB#drop_table" do
 end
 
 context "DB#alter_table" do
-  setup do
+  before do
     @db = SchemaDummyDatabase.new
   end
   
@@ -680,7 +680,7 @@ context "DB#alter_table" do
 end
 
 context "Schema Parser" do
-  setup do
+  before do
     @sqls = []
     @db = Sequel::Database.new
   end
@@ -710,7 +710,7 @@ context "Schema Parser" do
     @sqls.should == ['x', 'x']
   end
 
-  specify "should parse the schema correctly for all tables" do
+  deprec_specify "should parse the schema correctly for all tables" do
     sqls = @sqls
     proc{@db.schema}.should raise_error(Sequel::Error)
     @db.meta_def(:tables){[:x]}
@@ -732,14 +732,12 @@ context "Schema Parser" do
     end
     s1 = @db.schema(:x)
     s1.should == [['x', {:db_type=>'x'}]]
-    @db.schema[:x].object_id.should == s1.object_id
+    @db.schema(:x).object_id.should == s1.object_id
     @db.schema(:x.identifier).object_id.should == s1.object_id
-    @db.schema[:x.identifier].object_id.should == s1.object_id
     s2 = @db.schema(:x__y)
     s2.should == [['y', {:db_type=>'y'}]]
-    @db.schema[:x__y].object_id.should == s2.object_id
+    @db.schema(:x__y).object_id.should == s2.object_id
     @db.schema(:y.qualify(:x)).object_id.should == s2.object_id
-    @db.schema[:y.qualify(:x)].object_id.should == s2.object_id
   end
 
   specify "should correctly parse all supported data types" do