sequel 4.46.0 → 4.49.0

data/spec/extensions/class_table_inheritance_spec.rb

@@ -62,6 +62,11 @@ describe "class_table_inheritance plugin" do
     Employee.cti_table_map.frozen?.must_equal true
   end
 
+  deprecated "should support cti_key and cti_model_map" do
+    Employee.cti_key.must_equal Employee.sti_key
+    Employee.cti_model_map.must_equal Employee.sti_model_map
+  end
+
   deprecated "should not attempt to use prepared statements" do
     Manager.plugin :prepared_statements
     Manager[1]
@@ -572,11 +577,15 @@ describe "class_table_inheritance plugin with :alias option" do
     @db.sqls.must_equal ["SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)) AS employees WHERE (id = 1) LIMIT 1"]
   end
 
-  it "#cti_base_model should be the model that loaded the plugin" do
+  deprecated "#cti_base_model should be the model that loaded the plugin" do
     Executive.cti_base_model.must_equal Employee
   end
 
-  it "#cti_columns should be a mapping of table names to columns" do
+  it "#cti_models.first should be the model that loaded the plugin" do
+    Executive.cti_models.first.must_equal Employee
+  end
+
+  deprecated "#cti_columns should be a mapping of table names to columns" do
     Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
   end
 
@@ -668,6 +677,39 @@ describe "class_table_inheritance plugin with :alias option" do
       "INSERT INTO executives (id) VALUES (1)"]
   end
 
+  it "should sets the model class name for the key when creating new subclass records" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Object.send(:remove_const, :Ceo)
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    class ::Manager < Employee; end 
+    class ::Executive < Manager; end 
+    class ::Ceo < Executive; end 
+    Ceo.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('3')",
+      "INSERT INTO managers (id) VALUES (1)",
+      "INSERT INTO executives (id) VALUES (1)"]
+  end
+
+  it "should sets the model class name for the key when creating new subclass records" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Object.send(:remove_const, :Ceo)
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    class ::Manager < Employee; end 
+    class ::Executive < Employee; end 
+    class ::Ceo < Employee; end 
+    Ceo.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('3')"]
+  end
+
+  it "should not use a subquery for a class that doesn't join to a separate table" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Object.send(:remove_const, :Ceo)
+    class ::Ceo < Employee; end 
+    Ceo.dataset.sql.must_equal 'SELECT * FROM employees WHERE (employees.kind IN (3))'
+  end
+
   it "should ignore existing cti_key value when creating new records" do
     Employee.create(:kind=>'Manager')
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
@@ -1038,15 +1080,13 @@ describe "class_table_inheritance plugin with :alias option" do
     class ::Staff < Employee
       many_to_one :manager
     end 
+    class ::Intern < Employee
+    end 
     @ds = Employee.dataset
     @db.sqls
   end
   after do
-    Object.send(:remove_const, :Ceo)
-    Object.send(:remove_const, :Executive)
-    Object.send(:remove_const, :Manager)
-    Object.send(:remove_const, :Staff)
-    Object.send(:remove_const, :Employee)
+    [:Intern, :Ceo, :Executive, :Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s)}
   end
 
   it "should freeze CTI information when freezing model class" do
@@ -1069,11 +1109,15 @@ describe "class_table_inheritance plugin with :alias option" do
     @db.sqls.must_equal ["SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)) AS employees WHERE (id = 1) LIMIT 1"]
   end
 
-  it "#cti_base_model should be the model that loaded the plugin" do
+  deprecated "#cti_base_model should be the model that loaded the plugin" do
     Executive.cti_base_model.must_equal Employee
   end
 
-  it "#cti_columns should be a mapping of table names to columns" do
+  it "#cti_models.first should be the model that loaded the plugin" do
+    Executive.cti_models.first.must_equal Employee
+  end
+
+  deprecated "#cti_columns should be a mapping of table names to columns" do
     Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
   end
 
@@ -1082,6 +1126,7 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.simple_table.must_be_nil
     Ceo.simple_table.must_be_nil
     Staff.simple_table.must_be_nil
+    Intern.simple_table.must_be_nil
   end
   
   it "should have working row_proc if using set_dataset in subclass to remove columns" do
@@ -1096,10 +1141,11 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)) AS employees'
     Ceo.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (employees.kind IN (\'Ceo\'))) AS employees'
     Staff.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)) AS employees'
+    Intern.dataset.sql.must_equal 'SELECT * FROM employees WHERE (employees.kind IN (\'Intern\'))'
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    @ds.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]).all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff]
+    @ds.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}, {:kind=>'Intern'}]).all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff, Intern]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
@@ -1119,7 +1165,7 @@ describe "class_table_inheritance plugin with :alias option" do
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance, :alias=>:employees)
-    Employee.dataset.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]).all.map{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee]
+    Employee.dataset.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}, {:kind=>'Intern'}]).all.map{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee, Employee]
   end
   
   it "should return rows with the current class if cti_key is nil in subclasses" do
@@ -1132,15 +1178,17 @@ describe "class_table_inheritance plugin with :alias option" do
   end
   
   it "should handle a model map with integer values" do
-    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo, 4=>:Intern}, :alias=>:employees)
+    Object.send(:remove_const, :Intern)
     Object.send(:remove_const, :Ceo)
     Object.send(:remove_const, :Executive)
     Object.send(:remove_const, :Manager)
+    class ::Intern < Employee; end 
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
     class ::Ceo < Executive; end 
-    Employee.dataset = Employee.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}])
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive, Ceo]
+    Employee.dataset = Employee.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}, {:kind=>4}])
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive, Ceo, Intern]
     Manager.dataset = Manager.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}])
     Manager.all.collect{|x| x.class}.must_equal [Manager, Employee, Manager, Executive, Ceo]
   end
@@ -1158,6 +1206,11 @@ describe "class_table_inheritance plugin with :alias option" do
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
   
+  it "should sets the model class name for the key when creating new class records for subclass without separate table" do
+    Intern.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Intern')"]
+  end
+  
   it "should sets the model class name for the key when creating new subclass records" do
     Ceo.create
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Ceo')",
@@ -1232,10 +1285,11 @@ describe "class_table_inheritance plugin with :alias option" do
     Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer})
     Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer})
     Staff.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer})
+    Intern.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string})
   end
 
   it "should use the correct primary key (which should have the same name in all subclasses)" do
-    [Employee, Manager, Executive, Ceo, Staff].each{|c| c.primary_key.must_equal :id}
+    [Employee, Manager, Executive, Ceo, Staff, Intern].each{|c| c.primary_key.must_equal :id}
   end
 
   it "should have table_name return the table name of the most specific table" do
@@ -1244,20 +1298,43 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.table_name.must_equal :employees
     Ceo.table_name.must_equal :employees
     Staff.table_name.must_equal :employees
+    Intern.table_name.must_equal :employees
   end
 
   it "should delete the correct rows from all tables when deleting" do
+    Employee.load(:id=>1).delete
+    @db.sqls.must_equal ["DELETE FROM employees WHERE (id = 1)"]
+
+    Intern.load(:id=>1).delete
+    @db.sqls.must_equal ["DELETE FROM employees WHERE (id = 1)"]
+
     Ceo.load(:id=>1).delete
     @db.sqls.must_equal ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
   end
 
   it "should not allow deletion of frozen object" do
-    o = Ceo.load(:id=>1)
-    o.freeze
-    proc{o.delete}.must_raise(Sequel::Error)
-    @db.sqls.must_equal []
+    [Ceo, Executive, Employee, Manager, Intern].each do |c|
+      o = c.load(:id=>1)
+      o.freeze
+      proc{o.delete}.must_raise(Sequel::Error)
+      @db.sqls.must_equal []
+    end
   end
 
+  it "should insert the correct rows into all tables when inserting into parent class" do
+    Employee.create(:name=>'E')
+    sqls = @db.sqls
+    sqls.length.must_equal 1
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Employee)', '(E|Employee)'\)/)
+  end
+    
+  it "should insert the correct rows into all tables when inserting into subclass without separate table" do
+    Intern.create(:name=>'E')
+    sqls = @db.sqls
+    sqls.length.must_equal 1
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Intern)', '(E|Intern)'\)/)
+  end
+    
   it "should insert the correct rows into all tables when inserting" do
     Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
     sqls = @db.sqls
@@ -1296,6 +1373,16 @@ describe "class_table_inheritance plugin with :alias option" do
     sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/)
   end
 
+  it "should update the correct rows in all tables when updating parent class" do
+    Employee.load(:id=>2).update(:name=>'E')
+    @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)"]
+  end
+
+  it "should update the correct rows in all tables when updating subclass without separate table" do
+    Intern.load(:id=>2).update(:name=>'E')
+    @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)"]
+  end
+
   it "should update the correct rows in all tables when updating" do
     Ceo.load(:id=>2).update(:num_managers=>3, :num_staff=>2, :name=>'E')
     @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)", "UPDATE managers SET num_staff = 2 WHERE (id = 2)", "UPDATE executives SET num_managers = 3 WHERE (id = 2)"]

data/spec/extensions/column_conflicts_spec.rb

@@ -39,6 +39,17 @@ describe "column_conflicts plugin" do
     @o.get_column_value(:model).must_equal 2
   end
 
+  it "should not erase existing column conflicts when loading the plugin" do
+    @c.send(:define_method, :foo){raise}
+    @c.send(:define_method, :model=){raise}
+    @c.get_column_conflict!(:foo)
+    @c.set_column_conflict!(:model)
+    @c.plugin :column_conflicts
+    @o.get_column_value(:foo).must_equal 4
+    @o.set_column_value(:model=, 2).must_equal 2
+    @o.get_column_value(:model).must_equal 2
+  end
+
   it "should work correctly in subclasses" do
     @o = Class.new(@c).load(:model=>1, :use_transactions=>2)
     @o.get_column_value(:model).must_equal 1

data/spec/extensions/column_select_spec.rb

@@ -114,6 +114,7 @@ describe "Sequel::Plugins::ColumnSelect" do
     def @db.supports_schema_parsing?() true end
     def @db.schema_parse_table(t, *) [] end
     @db.extend_datasets{def columns; raise Sequel::DatabaseError; end}
+    @Album.require_valid_table = false
     @Album.plugin :column_select
     @Album.dataset.sql.must_equal 'SELECT * FROM albums'
   end

data/spec/extensions/composition_spec.rb

@@ -44,6 +44,19 @@ describe "Composition plugin" do
     o.valid?.must_equal true
   end
 
+  it "should have decomposer work with column_conflicts plugin" do
+    @c.plugin :column_conflicts
+    @c.set_column_conflict! :year
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    o = @c.new
+    def o.validate
+      [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
+    end
+    o.valid?.must_equal false
+    o.date = Date.new(1, 2, 3)
+    o.valid?.must_equal true
+  end
+
   it "should set column values even when not validating" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @c.load({}).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)

data/spec/extensions/connection_validator_spec.rb

@@ -104,7 +104,7 @@ connection_validator_specs = shared_description do
     end
 
     it "should handle case where determining validity requires a connection" do
-      @db.meta_def(:valid_connection?){|c| synchronize{}; true}
+      def @db.valid_connection?(c) synchronize{}; true end
       @db.pool.connection_validation_timeout = -1
       c1 = @db.synchronize{|c| c}
       @db.synchronize{|c| c}.must_be_same_as(c1)

data/spec/extensions/dataset_associations_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::DatasetAssociations" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock(:host=>'postgres')
     @db.extend_datasets do
       def supports_window_functions?; true; end
       def supports_distinct_on?; true; end
@@ -13,14 +13,17 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Artist = Class.new(@Base)
     @Album = Class.new(@Base)
     @Tag = Class.new(@Base)
+    @Track = Class.new(@Base)
 
-    @Artist.meta_def(:name){'Artist'}
-    @Album.meta_def(:name){'Album'}
-    @Tag.meta_def(:name){'Tag'}
+    def @Artist.name; 'Artist' end
+    def @Album.name; 'Album' end
+    def @Tag.name; 'Tag' end
+    def @Track.name; 'Track' end
 
     @Artist.dataset = @db[:artists]
     @Album.dataset = @db[:albums]
     @Tag.dataset = @db[:tags]
+    @Track.dataset = @db[:tracks]
 
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
@@ -28,6 +31,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
 
     @Album.plugin :many_through_many
     @Artist.plugin :many_through_many
+    @Track.plugin :many_through_many
     @Artist.plugin :pg_array_associations
     @Tag.plugin :pg_array_associations
     @Artist.one_to_many :albums, :class=>@Album
@@ -41,6 +45,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Tag.many_to_pg_array :artists, :class=>@Artist
     @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
     @Artist.one_through_many :otag, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @Track.many_through_many :artist_tracks, [[:albums, :id, :artist_id], [:albums, :artist_id, :id]], :class=>@Track, :left_primary_key=>:album_id, :right_primary_key=>:album_id
   end
 
   it "should work for many_to_one associations" do
@@ -85,6 +90,13 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
   end
 
+  it "should work for self referential many_through_many associations" do
+    ds = @Track.artist_tracks
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Track
+    ds.sql.must_equal "SELECT tracks.* FROM tracks WHERE (tracks.album_id IN (SELECT albums_0.id FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums AS albums_0 ON (albums_0.artist_id = albums.artist_id) INNER JOIN tracks AS tracks_0 ON (tracks_0.album_id = albums_0.id) WHERE (albums.id IN (SELECT tracks.album_id FROM tracks))))"
+  end
+
   it "should work for many_through_many associations with a single join table" do
     ds = @Album.mthm_tags
     ds.must_be_kind_of(Sequel::Dataset)
@@ -142,7 +154,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds = @Tag.artists
     ds.must_be_kind_of(Sequel::Dataset)
     ds.model.must_equal @Artist
-    ds.sql.must_equal "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), 'f')"
+    ds.sql.must_equal "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), false)"
   end
 
   it "should have an associated method that takes an association symbol" do
@@ -261,9 +273,9 @@ describe "Sequel::Plugins::DatasetAssociations with composite keys" do
     @Album = Class.new(@Base)
     @Tag = Class.new(@Base)
 
-    @Artist.meta_def(:name){'Artist'}
-    @Album.meta_def(:name){'Album'}
-    @Tag.meta_def(:name){'Tag'}
+    def @Artist.name; 'Artist' end
+    def @Album.name; 'Album' end
+    def @Tag.name; 'Tag' end
 
     @Artist.dataset = @db[:artists]
     @Album.dataset = @db[:albums]

data/spec/extensions/defaults_setter_spec.rb

@@ -9,7 +9,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
     @c.instance_variable_set(:@db_schema, {:a=>{}})
     @c.plugin :defaults_setter
     @c.columns :a
-    @pr = proc{|x| db.meta_def(:schema){|*| [[:id, {:primary_key=>true}], [:a, {:ruby_default => x, :primary_key=>false}]]}; c.dataset = c.dataset; c}
+    @pr = proc{|x| meta_def(db, :schema){|*| [[:id, {:primary_key=>true}], [:a, {:ruby_default => x, :primary_key=>false}]]}; c.dataset = c.dataset; c}
   end
   after do
     Sequel.datetime_class = Time
@@ -72,6 +72,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
 
   it "should contain the default values in default_values" do
     @pr.call(2).default_values.must_equal(:a=>2)
+    @c.default_values.clear
     @pr.call(nil).default_values.must_equal({})
   end
 
@@ -93,6 +94,19 @@ describe "Sequel::Plugins::DefaultsSetter" do
     @c.new.a.must_be_nil
   end
 
+  it "should work in subclasses" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{1}
+    c = Class.new(@c)
+
+    @c.new.a.must_equal 1
+    c.new.a.must_equal 1
+
+    c.default_values[:a] = proc{2}
+    @c.new.a.must_equal 1
+    c.new.a.must_equal 2
+  end
+
   it "should work correctly on a model without a dataset" do
     @pr.call(2)
     c = Class.new(Sequel::Model(@db[:bar]))

data/spec/extensions/filter_having_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "filter_having extension" do
   before do
-    @ds = Sequel.mock[:t].extension(:filter_having)
+    deprecated do
+      @ds = Sequel.mock[:t].extension(:filter_having)
+    end
     @dsh = @ds.having(:a)
   end
 
@@ -14,11 +16,11 @@ describe "filter_having extension" do
     @ds.filter(:b).sql.must_equal 'SELECT * FROM t WHERE b'
   end
 
-  it "should make and operate on HAVING clause if dataset has a HAVING clause" do
+  deprecated "should make and operate on HAVING clause if dataset has a HAVING clause" do
     @dsh.and(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND b)'
   end
 
-  it "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
+  deprecated "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
     @ds.where(:a).and(:b).sql.must_equal 'SELECT * FROM t WHERE (a AND b)'
   end
 

data/spec/extensions/hash_aliases_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "hash_aliases extension" do
   before do
-    @ds = Sequel.mock.dataset.extension(:hash_aliases)
+    deprecated do
+      @ds = Sequel.mock.dataset.extension(:hash_aliases)
+    end
   end
 
   it "should make from treat hash arguments as alias specifiers" do

data/spec/extensions/identifier_columns_spec.rb

@@ -6,7 +6,9 @@ describe "identifier_columns plugin" do
     @c = Class.new(Sequel::Model(@db[:test]))
     @ds = @c.dataset
     @c.columns :id, :a__b
-    @c.plugin :identifier_columns
+    deprecated do
+      @c.plugin :identifier_columns
+    end
     @db.sqls
   end
 

data/spec/extensions/implicit_subquery_spec.rb

@@ -9,13 +9,15 @@ describe "Sequel::Dataset::ImplicitSubquery" do
     ods = db[:c]
     ods.columns(:id, :b)
 
-    ds.and(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+    deprecated do
+      ds.and(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+      ds.exclude_where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
+    end
     ds.cross_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 CROSS JOIN c"
     ds.distinct.sql.must_equal "SELECT DISTINCT * FROM (SELECT * FROM table) AS t1"
     ds.except(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 EXCEPT SELECT * FROM c) AS t1"
     ds.exclude(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
     ds.exclude_having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING NOT c"
-    ds.exclude_where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
     ds.filter(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
     ds.for_update.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
     ds.full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL JOIN c"

data/spec/extensions/json_serializer_spec.rb

@@ -65,6 +65,12 @@ describe "Sequel::Plugins::JsonSerializer" do
     Album.from_json(@album.to_json(:include=>:artist), :associations=>:artist).artist.must_equal @artist
   end
 
+  it "should have #to_json support blocks for transformations" do
+    values = {}
+    @artist.values.each{|k,v| values[k.to_s] = v}
+    Sequel.parse_json(@artist.to_json{|h| {'data'=>h}}).must_equal({'data'=>values})
+  end
+
   it "should raise an error if attempting to parse json when providing array to non-array association or vice-versa" do
     proc{Artist.from_json('{"albums":{"id":1,"name":"RF","artist_id":2},"id":2,"name":"YJM"}', :associations=>:albums)}.must_raise(Sequel::Error)
     proc{Album.from_json('{"artist":[{"id":2,"name":"YJM"}],"id":1,"name":"RF","artist_id":2}', :associations=>:artist)}.must_raise(Sequel::Error)
@@ -186,6 +192,18 @@ describe "Sequel::Plugins::JsonSerializer" do
     Sequel.parse_json(ds.to_json).must_equal [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
+  it "should have class and dataset to_json method accept blocks for transformations" do
+    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
+    Sequel.parse_json(Album.to_json{|h| {'data'=>h}}).must_equal('data'=>[@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}])
+    Sequel.parse_json(Album.dataset.to_json{|h| {'data'=>h}}).must_equal('data'=>[@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}])
+  end
+
+  it "should have class and dataset to_json method support :instance_block option for instance_transformations" do
+    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
+    Sequel.parse_json(Album.to_json(:instance_block=>lambda{|h| {'data'=>h}})).must_equal [{'data'=>@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}}]
+    Sequel.parse_json(Album.dataset.to_json(:instance_block=>lambda{|h| {'data'=>h}})).must_equal [{'data'=>@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}}]
+  end
+
   it "should have dataset to_json method respect :array option for the array to use" do
     a = Album.new(:name=>'RF', :artist_id=>3)
     Album.array_from_json(Album.to_json(:array=>[a])).must_equal [a]

data/spec/extensions/lazy_attributes_spec.rb

@@ -5,13 +5,13 @@ describe "Sequel::Plugins::LazyAttributes" do
   before do
     @db = Sequel.mock
     def @db.supports_schema_parsing?() true end
-    @db.meta_def(:schema){|*a| [[:id, {:type=>:integer}], [:name,{:type=>:string}]]}
+    def @db.schema(*a) [[:id, {:type=>:integer}], [:name,{:type=>:string}]] end
     class ::LazyAttributesModel < Sequel::Model(@db[:la])
       plugin :lazy_attributes
       set_columns([:id, :name])
-      meta_def(:columns){[:id, :name]}
+      def self.columns; [:id, :name] end
       lazy_attributes :name
-      meta_def(:columns){[:id]}
+      def self.columns; [:id] end
       set_dataset dataset.with_fetch(proc do |sql|
         if sql !~ /WHERE/
           if sql =~ /name/

data/spec/extensions/many_through_many_spec.rb

@@ -59,10 +59,10 @@ describe Sequel::Model, "many_through_many" do
     DB.sqls.must_equal []
   end
 
-  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
+  it "should handle a :predicate_key option to change the SQL used in the lookup" do
     @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
-    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>(Sequel[:albums_artists][:artist_id] / 3)
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :predicate_key=>(Sequel[:albums_artists][:artist_id] / 3)
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id => 1)]
     DB.sqls.must_equal ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id / 3) IN (1))"]
@@ -1231,10 +1231,10 @@ describe Sequel::Model, "one_through_many" do
     DB.sqls.must_equal []
   end
 
-  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
+  it "should handle a :predicate_key option to change the SQL used in the lookup" do
     @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
-    @c1.one_through_many :tag, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>(Sequel[:albums_artists][:artist_id] / 3)
+    @c1.one_through_many :tag, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :predicate_key=>(Sequel[:albums_artists][:artist_id] / 3)
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id => 1)]
     DB.sqls.must_equal ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id / 3) IN (1))"]

data/spec/extensions/meta_def_spec.rb

@@ -1,6 +1,15 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Metaprogramming" do
+  before do
+    deprecated do
+      Sequel.extension :meta_def
+    end
+  end
+  after do
+    Sequel::Metaprogramming.send(:remove_method, :meta_def)
+  end
+
   it "should add meta_def method to Database, Dataset, and Model classes and instances" do
     Sequel::Database.meta_def(:foo){1}
     Sequel::Database.foo.must_equal 1

data/spec/extensions/migration_spec.rb

@@ -429,13 +429,13 @@ describe "Sequel::IntegerMigrator" do
   end
 
   it "should use transactions by default if the database supports transactional ddl" do
-    @db.meta_def(:supports_transactional_ddl?){true}
+    def @db.supports_transactional_ddl?; true end
     Sequel::Migrator.apply(@db, "spec/files/transaction_unspecified_migrations")
     @db.sqls.must_equal ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2", "COMMIT"]
   end
 
   it "should respect transaction use on a per migration basis" do
-    @db.meta_def(:supports_transactional_ddl?){true}
+    def @db.supports_transactional_ddl?; true end
     Sequel::Migrator.apply(@db, "spec/files/transaction_specified_migrations")
     @db.sqls.must_equal ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
   end
@@ -753,7 +753,7 @@ describe "Sequel::TimestampMigrator" do
   end
 
   it "should use transactions by default if database supports transactional ddl" do
-    @db.meta_def(:supports_transactional_ddl?){true}
+    def @db.supports_transactional_ddl?; true end
     Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_unspecified_migrations")
     @db.sqls.must_equal ["SELECT NULL AS nil FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL AS nil FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')", "COMMIT"]
   end