sequel 3.46.0 → 3.47.0

data/spec/core/expression_filters_spec.rb

@@ -44,7 +44,7 @@ describe "Blockless Ruby Filters" do
   end
 
   it "should use = 't' and != 't' OR IS NULL if IS TRUE is not supported" do
-    @d.meta_def(:supports_is_true?){false}
+    meta_def(@d, :supports_is_true?){false}
     @d.l(:x => true).should == "(x = 't')"
     @d.l(~Sequel.expr(:x => true)).should == "((x != 't') OR (x IS NULL))"
     @d.l(:x => false).should == "(x = 'f')"
@@ -169,7 +169,7 @@ describe "Blockless Ruby Filters" do
   end
   
   it "should emulate multiple column in if not supported" do
-    @d.meta_def(:supports_multiple_column_in?){false}
+    meta_def(@d, :supports_multiple_column_in?){false}
     @d.l([:x, :y]=>Sequel.value_list([[1,2], [3,4]])).should == '(((x = 1) AND (y = 2)) OR ((x = 3) AND (y = 4)))'
     @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).should == '(((x = 1) AND (y = 2) AND (z = 5)) OR ((x = 3) AND (y = 4) AND (z = 6)))'
   end
@@ -398,7 +398,7 @@ describe Sequel::SQL::VirtualRow do
     db = Sequel::Database.new
     db.quote_identifiers = true
     @d = db[:items]
-    @d.meta_def(:supports_window_functions?){true}
+    meta_def(@d, :supports_window_functions?){true}
     def @d.l(*args, &block)
       literal(filter_expr(*args, &block))
     end
@@ -481,7 +481,8 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should raise an error if window functions are not supported" do
-    @d.meta_def(:supports_window_functions?){false}
+    class << @d; remove_method :supports_window_functions? end
+    meta_def(@d, :supports_window_functions?){false}
     proc{@d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.should raise_error(Sequel::Error)
     proc{Sequel::Dataset.new(nil).filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
   end
@@ -980,7 +981,7 @@ describe "Sequel.delay" do
         @a += 1
       end
       def _a
-        @a
+        @a if defined?(@a)
       end
 
       attr_accessor :b

data/spec/core/object_graph_spec.rb

@@ -163,7 +163,6 @@ describe Sequel::Dataset, " graphing" do
     @ds1.opts.should == o2
     ds1.opts.should_not == o1
     o3 = ds1.opts
-    o4 = o3.dup
     ds2 = ds1.add_graph_aliases(:y=>[:blah,:id])
     ds1.opts.should == o3
     ds1.opts.should == o3

data/spec/core/schema_spec.rb

@@ -389,7 +389,7 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
   end
 
-  specify "should accept unique index definitions" do
+  specify "should accept unique constraint definitions" do
     @db.create_table(:cats) do
       text :name
       unique :name
@@ -443,7 +443,7 @@ describe "DB#create_table" do
   end
 
   specify "should ignore errors if the database raises an error on an index creation statement and the :ignore_index_errors option is used" do
-    @db.meta_def(:execute_ddl){|*a| raise Sequel::DatabaseError if /blah/.match(a.first); super(*a)}
+    meta_def(@db, :execute_ddl){|*a| raise Sequel::DatabaseError if /blah/.match(a.first); super(*a)}
     lambda{@db.create_table(:cats){Integer :id; index :blah; index :id}}.should raise_error(Sequel::DatabaseError)
     @db.sqls.should == ['CREATE TABLE cats (id integer)']
     lambda{@db.create_table(:cats, :ignore_index_errors=>true){Integer :id; index :blah; index :id}}.should_not raise_error(Sequel::DatabaseError)
@@ -643,13 +643,13 @@ describe "DB#create_table!" do
   end
   
   specify "should create the table if it does not exist" do
-    @db.meta_def(:table_exists?){|a| false}
+    meta_def(@db, :table_exists?){|a| false}
     @db.create_table!(:cats){|*a|}
     @db.sqls.should == ['CREATE TABLE cats ()']
   end
   
   specify "should drop the table before creating it if it already exists" do
-    @db.meta_def(:table_exists?){|a| true}
+    meta_def(@db, :table_exists?){|a| true}
     @db.create_table!(:cats){|*a|}
     @db.sqls.should == ['DROP TABLE cats', 'CREATE TABLE cats ()']
   end
@@ -661,19 +661,19 @@ describe "DB#create_table?" do
   end
   
   specify "should not create the table if the table already exists" do
-    @db.meta_def(:table_exists?){|a| true}
+    meta_def(@db, :table_exists?){|a| true}
     @db.create_table?(:cats){|*a|}
     @db.sqls.should == []
   end
   
   specify "should create the table if the table doesn't already exist" do
-    @db.meta_def(:table_exists?){|a| false}
+    meta_def(@db, :table_exists?){|a| false}
     @db.create_table?(:cats){|*a|}
     @db.sqls.should == ['CREATE TABLE cats ()']
   end
   
   specify "should use IF NOT EXISTS if the database supports that" do
-    @db.meta_def(:supports_create_table_if_not_exists?){true}
+    meta_def(@db, :supports_create_table_if_not_exists?){true}
     @db.create_table?(:cats){|*a|}
     @db.sqls.should == ['CREATE TABLE IF NOT EXISTS cats ()']
   end
@@ -787,37 +787,37 @@ describe "DB#drop_table?" do
   end
   
   specify "should drop the table if it exists" do
-    @db.meta_def(:table_exists?){|a| true}
+    meta_def(@db, :table_exists?){|a| true}
     @db.drop_table?(:cats)
     @db.sqls.should == ["DROP TABLE cats"]
   end
   
   specify "should do nothing if the table does not exist" do
-    @db.meta_def(:table_exists?){|a| false}
+    meta_def(@db, :table_exists?){|a| false}
     @db.drop_table?(:cats)
     @db.sqls.should == []
   end
   
   specify "should operate on multiple tables at once" do
-    @db.meta_def(:table_exists?){|a| a == :cats}
+    meta_def(@db, :table_exists?){|a| a == :cats}
     @db.drop_table? :cats, :dogs
     @db.sqls.should == ['DROP TABLE cats']
   end
 
   specify "should take an options hash and support the :cascade option" do
-    @db.meta_def(:table_exists?){|a| true}
+    meta_def(@db, :table_exists?){|a| true}
     @db.drop_table? :cats, :dogs, :cascade=>true
     @db.sqls.should == ['DROP TABLE cats CASCADE', 'DROP TABLE dogs CASCADE']
   end
 
   specify "should use IF NOT EXISTS if the database supports that" do
-    @db.meta_def(:supports_drop_table_if_exists?){true}
+    meta_def(@db, :supports_drop_table_if_exists?){true}
     @db.drop_table? :cats, :dogs
     @db.sqls.should == ['DROP TABLE IF EXISTS cats', 'DROP TABLE IF EXISTS dogs']
   end
 
   specify "should use IF NOT EXISTS with CASCADE if the database supports that" do
-    @db.meta_def(:supports_drop_table_if_exists?){true}
+    meta_def(@db, :supports_drop_table_if_exists?){true}
     @db.drop_table? :cats, :dogs, :cascade=>true
     @db.sqls.should == ['DROP TABLE IF EXISTS cats CASCADE', 'DROP TABLE IF EXISTS dogs CASCADE']
   end
@@ -926,7 +926,7 @@ describe "DB#alter_table" do
   end
 
   specify "should ignore errors if the database raises an error on an add_index call and the :ignore_errors option is used" do
-    @db.meta_def(:execute_ddl){|*a| raise Sequel::DatabaseError}
+    meta_def(@db, :execute_ddl){|*a| raise Sequel::DatabaseError}
     lambda{@db.add_index(:cats, :id)}.should raise_error(Sequel::DatabaseError)
     lambda{@db.add_index(:cats, :id, :ignore_errors=>true)}.should_not raise_error(Sequel::DatabaseError)
     @db.sqls.should == []
@@ -1065,7 +1065,7 @@ describe "DB#alter_table" do
   end
 
   specify "should combine operations into a single query if the database supports it" do
-    @db.meta_def(:supports_combining_alter_table_ops?){true}
+    meta_def(@db, :supports_combining_alter_table_ops?){true}
     @db.alter_table(:cats) do
       add_column :a, Integer
       drop_column :b
@@ -1080,7 +1080,7 @@ describe "DB#alter_table" do
   end
   
   specify "should combine operations into consecutive groups of combinable operations if the database supports combining operations" do
-    @db.meta_def(:supports_combining_alter_table_ops?){true}
+    meta_def(@db, :supports_combining_alter_table_ops?){true}
     @db.alter_table(:cats) do
       add_column :a, Integer
       drop_column :b
@@ -1342,21 +1342,21 @@ describe "Schema Parser" do
   end
 
   specify "should raise an error if there are no columns" do
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       []
     end
     proc{@db.schema(:x)}.should raise_error(Sequel::Error)
   end
 
   specify "should cache data by default" do
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       [[:a, {}]]
     end
     @db.schema(:x).should equal(@db.schema(:x))
   end
 
   specify "should not cache data if :reload=>true is given" do
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       [[:a, {}]]
     end
     @db.schema(:x).should_not equal(@db.schema(:x, :reload=>true))
@@ -1364,7 +1364,7 @@ describe "Schema Parser" do
 
   specify "should not cache schema metadata if cache_schema is false" do
     @db.cache_schema = false
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       [[:a, {}]]
     end
     @db.schema(:x).should_not equal(@db.schema(:x))
@@ -1372,7 +1372,7 @@ describe "Schema Parser" do
 
   specify "should provide options if given a table name" do
     c = nil
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       c = [t, opts]
       [[:a, {:db_type=>t.to_s}]]
     end
@@ -1388,7 +1388,7 @@ describe "Schema Parser" do
   specify "should parse the schema correctly for a single table" do
     sqls = @sqls
     proc{@db.schema(:x)}.should raise_error(Sequel::Error)
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       sqls << t
       [[:a, {:db_type=>t.to_s}]]
     end
@@ -1401,7 +1401,7 @@ describe "Schema Parser" do
   end
 
   specify "should convert various types of table name arguments" do
-    @db.meta_def(:schema_parse_table) do |t, opts|
+    meta_def(@db, :schema_parse_table) do |t, opts|
       [[t, opts]]
     end
     s1 = @db.schema(:x)

data/spec/core/spec_helper.rb

@@ -11,7 +11,11 @@ unless Object.const_defined?('Sequel')
   require 'sequel/core'
 end
 
-Sequel.extension :meta_def
+(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
+  def meta_def(obj, name, &block)
+    (class << obj; self end).send(:define_method, name, &block)
+  end
+end
 
 if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel.extension :columns_introspection

data/spec/extensions/association_dependencies_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "AssociationDependencies plugin" do
   before do
-    mods = @mods = []
+    @mods = []
     @c = Class.new(Sequel::Model)
     @c.plugin :association_dependencies
     @Artist = Class.new(@c).set_dataset(:artists)

data/spec/extensions/association_proxies_spec.rb

@@ -23,7 +23,7 @@ describe "Sequel::Plugins::AssociationProxies" do
     @i.associations.has_key?(:tags).should == true
   end
   
-  it "should send method calls to the association dataset sent another method" do
+  it "should send method calls to the association dataset if sent a non-array method" do
     @i.associations.has_key?(:tags).should == false
     @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
     @i.associations.has_key?(:tags).should == false

data/spec/extensions/auto_validations_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::AutoValidations" do
+  before do
+    db = Sequel.mock(:fetch=>{:v=>1})
+    def db.schema_parse_table(*) true; end
+    def db.schema(t, *)
+      t = t.first_source if t.is_a?(Sequel::Dataset)
+      return [] if t != :test
+      [[:id, {:primary_key=>true, :type=>:integer}],
+       [:name, {:primary_key=>false, :type=>:string, :allow_null=>false}],
+       [:num, {:primary_key=>false, :type=>:integer, :allow_null=>true}],
+       [:d, {:primary_key=>false, :type=>:date, :allow_null=>false}]]
+    end
+    def db.indexes(t, *)
+      return [] if t != :test
+      {:a=>{:columns=>[:name, :num], :unique=>true}, :b=>{:columns=>[:num], :unique=>false}}
+    end
+    @c = Class.new(Sequel::Model(db[:test]))
+    @c.send(:def_column_accessor, :id, :name, :num, :d)
+    @c.raise_on_typecast_failure = false
+    @c.plugin :auto_validations
+    @m = @c.new
+    db.sqls
+  end
+
+  it "should have automatically created validations" do
+    @m.valid?.should be_false
+    @m.errors.should == {:d=>["is not present"], :name=>["is not present"]}
+
+    @m.name = ''
+    @m.valid?.should be_false
+    @m.errors.should == {:d=>["is not present"]}
+
+    @m.set(:d=>'/', :num=>'a', :name=>'1')
+    @m.valid?.should be_false
+    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+
+    @m.set(:d=>Date.today, :num=>1)
+    @m.valid?.should be_false
+    @m.errors.should == {[:name, :num]=>["is already taken"]}
+  end
+
+  it "should allow skipping validations by type" do
+    @c = Class.new(@c)
+    @m = @c.new
+    @c.skip_auto_validations(:presence)
+    @m.valid?.should be_true
+
+    @m.set(:d=>'/', :num=>'a', :name=>'1')
+    @m.valid?.should be_false
+    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+
+    @c.skip_auto_validations(:types)
+    @m.valid?.should be_false
+    @m.errors.should == {[:name, :num]=>["is already taken"]}
+
+    @c.skip_auto_validations(:unique)
+    @m.valid?.should be_true
+  end
+
+  it "should allow skipping all auto validations" do
+    @c = Class.new(@c)
+    @m = @c.new
+    @c.skip_auto_validations(:all)
+    @m.valid?.should be_true
+    @m.set(:d=>'/', :num=>'a', :name=>'1')
+    @m.valid?.should be_true
+  end
+
+  it "should work correctly in subclasses" do
+    @c = Class.new(@c)
+    @m = @c.new
+    @m.valid?.should be_false
+    @m.errors.should == {:d=>["is not present"], :name=>["is not present"]}
+
+    @m.set(:d=>'/', :num=>'a', :name=>'1')
+    @m.valid?.should be_false
+    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+
+    @m.set(:d=>Date.today, :num=>1)
+    @m.valid?.should be_false
+    @m.errors.should == {[:name, :num]=>["is already taken"]}
+  end
+
+  it "should work correctly when changing the dataset" do
+    @c.set_dataset(@c.db[:foo])
+    @c.new.valid?.should be_true
+  end
+end

data/spec/extensions/caching_spec.rb

@@ -14,6 +14,7 @@ describe Sequel::Model, "caching" do
       attr_accessor :ttl
       def set(k, v, ttl); self[k] = v; @ttl = ttl; end
       def get(k); if self[k] then return self[k]; else raise ArgumentError; end end
+      def delete(k); if self[k] then super; else raise ArgumentError; end end
     end
     cache2 = @memcached_class.new
     @memcached = cache2
@@ -225,10 +226,15 @@ describe Sequel::Model, "caching" do
   
   it "should raise an exception if cache_store is memcached and ignore_exception is not enabled" do
     proc{@c3[1]}.should raise_error
+    m = @c3.new.save
+    proc{m.update({:name=>'blah'})}.should raise_error
   end
   
   it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
     @c4[1].values.should == {:name => 'sharon', :id => 1}
+    m = @c4.new.save
+    proc{m.update({:name=>'blah'})}.should_not raise_error
+    m.values.should == {:name => 'blah', :id => 1, :x => 1}
   end
   
   it "should support Model.cache_get_pk for getting a value from the cache by primary key" do

data/spec/extensions/class_table_inheritance_spec.rb

@@ -9,7 +9,7 @@ describe "class_table_inheritance plugin" do
        :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
        :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
        }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
-     end
+    end
     @db.extend_datasets do
       def columns
         {[:employees]=>[:id, :name, :kind],
@@ -162,6 +162,13 @@ describe "class_table_inheritance plugin" do
     @db.sqls.should == ["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 = Executive.load(:id=>1)
+    o.freeze
+    proc{o.delete}.should raise_error(Sequel::Error)
+    @db.sqls.should == []
+  end
+
   it "should insert the correct rows into all tables when inserting" do
     Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
     sqls = @db.sqls

data/spec/extensions/composition_spec.rb

@@ -91,28 +91,28 @@ describe "Composition plugin" do
   end
 
   it "should clear compositions cache when using set_values" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @o.date = Date.new(3, 4, 5)
     @o.set_values(:id=>1)
     @o.compositions.should == {}
   end
 
   it "should clear compositions cache when refreshing" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @o.date = Date.new(3, 4, 5)
     @o.refresh
     @o.compositions.should == {}
   end
 
   it "should clear compositions cache when refreshing after save" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {}
   end
 
   it "should clear compositions cache when saving with insert_select" do
     def (@c.instance_dataset).supports_insert_select?() true end
     def (@c.instance_dataset).insert_select(*) {:id=>1} end
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {}
   end
 
@@ -125,7 +125,7 @@ describe "Composition plugin" do
 
   it "should cache value of composition" do
     times = 0
-    @c.composition :date, :composer=>proc{times+=1}, :decomposer=>proc{called = true}
+    @c.composition :date, :composer=>proc{times+=1}, :decomposer=>proc{}
     times.should == 0
     @o.date
     times.should == 1
@@ -201,6 +201,13 @@ describe "Composition plugin" do
     sql.should include("day = NULL")
   end
 
+  it "should work with frozen instances" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.freeze
+    @o.date.should == Date.new(1, 2, 3)
+    proc{@o.date = Date.today}.should raise_error
+  end
+
   it "should work correctly with subclasses" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     c = Class.new(@c)