sequel 3.37.0 → 3.38.0

data/spec/extensions/pg_typecast_on_load_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe Sequel::Model, "PgTypecastOnLoad plugin" do
+  before do
+    @db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :b=>"t", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
+    def @db.schema(*args)
+      [[:id, {}], [:b, {:type=>:boolean, :oid=>16}], [:y, {:type=>:integer, :oid=>20}]]
+    end
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.plugin :pg_typecast_on_load, :b, :y
+  end 
+
+  specify "should call the database conversion proc for all given columns" do
+    @c.first.values.should == {:id=>1, :b=>true, :y=>0}
+  end
+
+  specify "should call the database conversion proc with value when reloading the object, for all given columns" do
+    @c.first.refresh.values.should == {:id=>1, :b=>true, :y=>0}
+  end
+
+  specify "should call the database conversion proc with value when automatically reloading the object on creation via insert_select" do
+    @c.dataset.meta_def(:insert_select){|h| insert(h); first}
+    @c.create.values.should == {:id=>1, :b=>true, :y=>0}
+  end
+
+  specify "should allowing setting columns separately via add_typecast_on_load_columns" do
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.plugin :pg_typecast_on_load
+    @c.first.values.should == {:id=>1, :b=>"t", :y=>"0"}
+    @c.add_pg_typecast_on_load_columns :b
+    @c.first.values.should == {:id=>1, :b=>true, :y=>"0"}
+    @c.add_pg_typecast_on_load_columns :y
+    @c.first.values.should == {:id=>1, :b=>true, :y=>0}
+  end
+
+  specify "should work with subclasses" do
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.plugin :pg_typecast_on_load
+    @c.first.values.should == {:id=>1, :b=>"t", :y=>"0"}
+
+    c1 = Class.new(@c)
+    @c.add_pg_typecast_on_load_columns :b
+    @c.first.values.should == {:id=>1, :b=>true, :y=>"0"}
+    c1.first.values.should == {:id=>1, :b=>"t", :y=>"0"}
+
+    c2 = Class.new(@c)
+    @c.add_pg_typecast_on_load_columns :y
+    @c.first.values.should == {:id=>1, :b=>true, :y=>0}
+    c2.first.values.should == {:id=>1, :b=>true, :y=>"0"}
+    
+    c1.add_pg_typecast_on_load_columns :y
+    c1.first.values.should == {:id=>1, :b=>"t", :y=>0}
+  end
+
+  specify "should not mark the object as modified" do
+    @c.first.modified?.should == false
+  end
+end

data/spec/extensions/query_literals_spec.rb

@@ -18,7 +18,7 @@ describe "query_literals extension" do
   end
 
   it "should have #select work the standard way if initial string is a literal string already" do
-    @ds.select('a, b, ?'.lit, 1).sql.should == 'SELECT a, b, ?, 1 FROM t'
+    @ds.select(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT a, b, ?, 1 FROM t'
   end
 
   it "should have #select work regularly if not given a string as the first argument" do
@@ -39,7 +39,7 @@ describe "query_literals extension" do
     end
 
     it "should have #select_more work the standard way if initial string is a literal string already" do
-      @ds.select_more('a, b, ?'.lit, 1).sql.should == 'SELECT d, a, b, ?, 1 FROM t'
+      @ds.select_more(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT d, a, b, ?, 1 FROM t'
     end
 
     it "should have #select_more work regularly if not given a string as the first argument" do
@@ -56,7 +56,7 @@ describe "query_literals extension" do
   end
 
   it "should have #select_append work the standard way if initial string is a literal string already" do
-    @ds.select_append('a, b, ?'.lit, 1).sql.should == 'SELECT *, a, b, ?, 1 FROM t'
+    @ds.select_append(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT *, a, b, ?, 1 FROM t'
   end
 
   it "should have #select_append work regularly if not given a string as the first argument" do
@@ -72,7 +72,7 @@ describe "query_literals extension" do
   end
 
   it "should have #select_group work the standard way if initial string is a literal string already" do
-    @ds.select_group('a, b, ?'.lit, 1).sql.should == 'SELECT a, b, ?, 1 FROM t GROUP BY a, b, ?, 1'
+    @ds.select_group(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT a, b, ?, 1 FROM t GROUP BY a, b, ?, 1'
   end
 
   it "should have #select_group work regularly if not given a string as the first argument" do
@@ -87,11 +87,11 @@ describe "query_literals extension" do
     @ds.group('a, b, ?', 1).sql.should == 'SELECT * FROM t GROUP BY a, b, 1'
   end
 
-  it "should have #select_group work the standard way if initial string is a literal string already" do
-    @ds.group('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t GROUP BY a, b, ?, 1'
+  it "should have #group work the standard way if initial string is a literal string already" do
+    @ds.group(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t GROUP BY a, b, ?, 1'
   end
 
-  it "should have #select_group work regularly if not given a string as the first argument" do
+  it "should have #group work regularly if not given a string as the first argument" do
     @ds.group(:a, 1).sql.should == 'SELECT * FROM t GROUP BY a, 1'
   end
 
@@ -104,7 +104,7 @@ describe "query_literals extension" do
   end
 
   it "should have #group_and_count work the standard way if initial string is a literal string already" do
-    @ds.group_and_count('a, b, ?'.lit, 1).sql.should == 'SELECT a, b, ?, 1, count(*) AS count FROM t GROUP BY a, b, ?, 1'
+    @ds.group_and_count(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT a, b, ?, 1, count(*) AS count FROM t GROUP BY a, b, ?, 1'
   end
 
   it "should have #group_and_count work regularly if not given a string as the first argument" do
@@ -120,7 +120,7 @@ describe "query_literals extension" do
   end
 
   it "should have #order work the standard way if initial string is a literal string already" do
-    @ds.order('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1'
+    @ds.order(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1'
   end
 
   it "should have #order work regularly if not given a string as the first argument" do
@@ -141,7 +141,7 @@ describe "query_literals extension" do
     end
 
     it "should have #order_more work the standard way if initial string is a literal string already" do
-      @ds.order_more('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t ORDER BY d, a, b, ?, 1'
+      @ds.order_more(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t ORDER BY d, a, b, ?, 1'
     end
 
     it "should have #order_more work regularly if not given a string as the first argument" do
@@ -157,7 +157,7 @@ describe "query_literals extension" do
     end
 
     it "should have #order_append work the standard way if initial string is a literal string already" do
-      @ds.order_prepend('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1, d'
+      @ds.order_prepend(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1, d'
     end
 
     it "should have #order_append work regularly if not given a string as the first argument" do

data/spec/extensions/query_spec.rb

@@ -41,13 +41,13 @@ describe "Dataset#query" do
   specify "should support #where" do
     q = @d.query do
       from :zzz
-      where(:x + 2 > :y + 3)
+      where{x + 2 > Sequel.expr(:y) + 3}
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))"
 
     q = @d.from(:zzz).query do
-      where((:x.sql_number > 1) & (:y.sql_number > 2))
+      where{(x > 1) & (Sequel.expr(:y) > 2)}
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))"
@@ -63,7 +63,7 @@ describe "Dataset#query" do
     q = @d.query do
       from :abc
       group_by :id
-      having(:x.sql_number >= 2)
+      having{x >= 2}
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"

data/spec/extensions/schema_dumper_spec.rb

@@ -67,7 +67,7 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:tables){|o| [:t1, :t2]}
     @d.meta_def(:schema) do |t, *o|
       case t
-      when :t1, 't__t1', :t__t1.identifier
+      when :t1, 't__t1', Sequel.identifier(:t__t1)
         [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
          [:c2, {:db_type=>'varchar(20)', :allow_null=>true}]]
       when :t2
@@ -88,7 +88,7 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should support dumping table schemas when given an identifier" do
-    @d.dump_table_schema(:t__t1.identifier).should == "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_table_schema(Sequel.identifier(:t__t1)).should == "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
   it "should dump non-Integer primary key columns with explicit :type" do
@@ -593,10 +593,10 @@ END_MIG
       s
     end
     @d.dump_table_schema(:t4).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.parse(\"2008-10-29\")\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30\"), :only_time=>true\n  String :c10\nend"
-    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.parse(\"2008-10-29\")\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>\"'6 weeks'\".lit\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.parse(\"2008-10-29\")\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\nend"
   end
   
-  it "should not use a '...'.lit as a fallback if using MySQL with the :same_db option" do
+  it "should not use a literal string as a fallback if using MySQL with the :same_db option" do
     @d.meta_def(:database_type){:mysql}
     @d.meta_def(:schema) do |t, *os|
       s = [[:c10, {:db_type=>'interval', :default=>"'6 weeks'", :type=>:interval, :allow_null=>true}]]
@@ -712,6 +712,22 @@ end
 END_MIG
   end
 
+  it "should convert mysql types to ruby types" do
+    types = ['double(15,2)', 'double(7,1) unsigned']
+    @d.meta_def(:schema) do |t, *o|
+      i = 0
+      types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+    end
+    @d.dump_table_schema(:x).should == (<<END_MIG).chomp
+create_table(:x) do
+  Float :c1
+  Float :c2
+  
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c2), 0)
+end
+END_MIG
+  end
+
   it "should use separate primary_key call with non autoincrementable types" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'varchar(8)', :primary_key=>true}]]}
     @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"

data/spec/extensions/schema_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe Sequel::Model, "dataset & schema" do
   before do
     @model = Class.new(Sequel::Model(:items))
+    @model.plugin :schema
   end 
 
   specify "sets schema with implicit table name" do
@@ -22,27 +23,17 @@ describe Sequel::Model, "dataset & schema" do
   end
 end
 
-describe Sequel::Model, "table_exists?" do
-  before do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
-  end
-
-  it "should get the table name and question the model's db if table_exists?" do
-    @model.db.should_receive(:table_exists?).and_return(false)
-    @model.table_exists?.should == false
-  end
-end
-
 describe Sequel::Model, "create_table and schema" do
   before do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model) do
+    @model = Class.new(Sequel::Model)
+    @model.class_eval do
+      plugin :schema
       set_schema(:items) do
         text :name
         float :price, :null => false
       end
     end
+    MODEL_DB.reset
   end
 
   it "should get the create table SQL list from the db and execute it line by line" do
@@ -74,61 +65,47 @@ describe Sequel::Model, "create_table and schema" do
 
   it "should return nil if no schema is present" do
     @model = Class.new(Sequel::Model)
+    @model.plugin :schema
     @model.schema.should == nil
     @submodel = Class.new(@model)
     @submodel.schema.should == nil
   end
 end
 
-describe Sequel::Model, "drop_table" do
+describe Sequel::Model, "schema methods" do
   before do
     @model = Class.new(Sequel::Model(:items))
+    @model.plugin :schema
     MODEL_DB.reset
   end
 
-  it "should drop the related table" do
-    @model.drop_table
-    MODEL_DB.sqls.should == ['DROP TABLE items']
+  it "table_exists? should get the table name and question the model's db if table_exists?" do
+    @model.db.should_receive(:table_exists?).and_return(false)
+    @model.table_exists?.should == false
   end
-end
 
-describe Sequel::Model, "drop_table?" do
-  before do
-    @model = Class.new(Sequel::Model(:items))
-    MODEL_DB.reset
+  it "drop_table should drop the related table" do
+    @model.drop_table
+    MODEL_DB.sqls.should == ['DROP TABLE items']
   end
 
-  it "should drop the table if it exists" do
+  it "drop_table? should drop the table if it exists" do
     @model.drop_table?
     MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items']
   end
-end
-
-describe Sequel::Model, "create_table!" do
-  before do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
-  end
   
-  it "should drop table if it exists and then create the table" do
+  it "create_table! should drop table if it exists and then create the table" do
     @model.create_table!
     MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items', 'CREATE TABLE items ()']
   end
-end
-
-describe Sequel::Model, "create_table?" do
-  before do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
-  end
   
-  it "should not create the table if it already exists" do
+  it "create_table? should not create the table if it already exists" do
     @model.should_receive(:table_exists?).and_return(true)
     @model.create_table?
     MODEL_DB.sqls.should == []
   end
 
-  it "should create the table if it doesn't exist" do
+  it "create_table? should create the table if it doesn't exist" do
     @model.should_receive(:table_exists?).and_return(false)
     @model.create_table?
     MODEL_DB.sqls.should == ['CREATE TABLE items ()']

data/spec/extensions/select_remove_spec.rb

@@ -24,15 +24,15 @@ describe "Dataset#select_remove" do
   end
 
   specify "should handle expressions where Sequel can't determine the alias by itself" do
-    d = @d.select(:a, :b.sql_function, :c.as(:b))
+    d = @d.select(:a, Sequel.function(:b), Sequel.as(:c, :b))
     d.columns :a, :"b()", :b
     d.select_remove(:"b()").sql.should == 'SELECT a, c AS b FROM test'
   end
 
   specify "should remove expressions if given exact expressions" do
-    d = @d.select(:a, :b.sql_function, :c.as(:b))
+    d = @d.select(:a, Sequel.function(:b), Sequel.as(:c, :b))
     d.columns :a, :"b()", :b
-    d.select_remove(:b.sql_function).sql.should == 'SELECT a, c AS b FROM test'
-    d.select_remove(:c.as(:b)).sql.should == 'SELECT a, b() FROM test'
+    d.select_remove(Sequel.function(:b)).sql.should == 'SELECT a, c AS b FROM test'
+    d.select_remove(Sequel.as(:c, :b)).sql.should == 'SELECT a, b() FROM test'
   end
 end

data/spec/extensions/spec_helper.rb

@@ -8,13 +8,9 @@ if defined?(RSpec)
   end
 end
 
-unless Object.const_defined?('Sequel')
+unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel/core'
-end
-unless Sequel.const_defined?('Model')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel/model'
+  require 'sequel/no_core_ext'
 end
 
 begin
@@ -26,8 +22,8 @@ rescue LoadError
   nil
 end
 
-Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers pg_auto_parameterize pg_statement_cache pg_array pg_array_ops pg_hstore pg_hstore_ops pg_range pg_range_ops pg_json pg_inet schema_caching null_dataset select_remove query_literals eval_inspect')
-{:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
+# Load most extensions by default, so that any conflicts are easily detectable.
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers pg_auto_parameterize pg_statement_cache pg_array pg_array_ops pg_hstore pg_hstore_ops pg_range pg_range_ops pg_json pg_inet pg_row pg_row_ops schema_caching null_dataset select_remove query_literals eval_inspect')
 
 Sequel::Dataset.introspect_all_columns if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 

data/spec/extensions/to_dot_spec.rb

@@ -100,19 +100,19 @@ END
   end
 
   it "should handle SQL::OrderedExpressions" do
-    dot(@ds.order(:a.desc(:nulls=>:last))).should == ["1 -> 2 [label=\"order\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"OrderedExpression: DESC NULLS LAST\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];"]
+    dot(@ds.order(Sequel.desc(:a, :nulls=>:last))).should == ["1 -> 2 [label=\"order\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"OrderedExpression: DESC NULLS LAST\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];"]
   end
 
   it "should handle SQL::AliasedExpressions" do
-    dot(@ds.from(:a.as(:b))).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];"]
+    dot(@ds.from(Sequel.as(:a, :b))).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];"]
   end
 
   it "should handle SQL::CaseExpressions" do
-    dot(@ds.select({:a=>:b}.case(:c, :d))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"CaseExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":d\"];", "3 -> 5 [label=\"conditions\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":a\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"default\"];", "9 [label=\":c\"];"]
+    dot(@ds.select(Sequel.case({:a=>:b}, :c, :d))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"CaseExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":d\"];", "3 -> 5 [label=\"conditions\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":a\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"default\"];", "9 [label=\":c\"];"]
   end
 
   it "should handle SQL::Cast" do
-    dot(@ds.select(:a.cast(Integer))).should ==  ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Cast\"];", "3 -> 4 [label=\"expr\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"type\"];", "5 [label=\"Integer\"];"]
+    dot(@ds.select(Sequel.cast(:a, Integer))).should ==  ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Cast\"];", "3 -> 4 [label=\"expr\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"type\"];", "5 [label=\"Integer\"];"]
   end
 
   it "should handle SQL::Function" do
@@ -120,7 +120,7 @@ END
   end
 
   it "should handle SQL::Subscript" do
-    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
+    dot(@ds.select(Sequel.subscript(:a, 1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
   end
 
   it "should handle SQL::WindowFunction" do

data/spec/extensions/validation_class_methods_spec.rb

@@ -1,8 +1,15 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+model_class = proc do |klass, &block|
+  c = Class.new(klass)
+  c.plugin :validation_class_methods
+  c.class_eval(&block) if block
+  c
+end
+
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model) do
+    @c = model_class.call Sequel::Model do
       def self.validates_coolness_of(attr)
         validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
       end
@@ -135,8 +142,7 @@ end
 
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model)
-    @c.class_eval do
+    @c = model_class.call Sequel::Model do
       columns :score
       validates_each :score do |o, a, v|
         o.errors[a] << 'too low' if v < 87
@@ -165,11 +171,11 @@ describe Sequel::Model do
   end
 end
 
-describe Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator do
+describe "Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator" do
   before do
     $testit = nil
     
-    @c = Class.new(Sequel::Model) do
+    @c = model_class.call Sequel::Model do
       def self.validates_blah
         $testit = 1324
       end
@@ -186,7 +192,7 @@ end
 
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model) do
+    @c = model_class.call Sequel::Model do
       columns :value
       
       def self.filter(*args)
@@ -579,8 +585,7 @@ end
 
 describe "Superclass validations" do
   before do
-    @c1 = Class.new(Sequel::Model)
-    @c1.class_eval do
+    @c1 = model_class.call Sequel::Model do
       columns :value
       validates_length_of :value, :minimum => 5
     end
@@ -624,8 +629,7 @@ end
 
 describe ".validates with block" do
   specify "should support calling .each" do
-    @c = Class.new(Sequel::Model)
-    @c.class_eval do
+    @c = model_class.call Sequel::Model do
       columns :vvv
       validates do
         each :vvv do |o, a, v|
@@ -646,24 +650,36 @@ describe Sequel::Model, "Validations" do
 
   before(:all) do
     class ::Person < Sequel::Model
+      plugin :validation_class_methods
       columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms
     end
 
     class ::Smurf < Person
     end
+
+    class ::Can < Sequel::Model
+      plugin :validation_class_methods
+      columns :id, :name
+    end
     
     class ::Cow < Sequel::Model
+      plugin :validation_class_methods
       columns :id, :name, :got_milk
     end
 
     class ::User < Sequel::Model
+      plugin :validation_class_methods
       columns :id, :username, :password
     end
     
     class ::Address < Sequel::Model
+      plugin :validation_class_methods
       columns :id, :zip_code
     end
   end
+  after(:all) do
+    [:Person, :Smurf, :Cow, :User, :Address].each{|c| Object.send(:remove_const, c)}
+  end
   
   it "should validate the acceptance of a column" do
     class ::Cow < Sequel::Model
@@ -741,8 +757,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate that a column doesn't have a string value" do
-    p = Class.new(Sequel::Model)
-    p.class_eval do
+    p = model_class.call Sequel::Model do
       columns :age, :price, :confirmed
       self.raise_on_typecast_failure = false
       validates_not_string :age
@@ -941,8 +956,6 @@ describe Sequel::Model, "Validations" do
 
   it "should validate correctly instances initialized with string keys" do
     class ::Can < Sequel::Model
-      columns :id, :name
-      
       validates_length_of :name, :minimum => 4
     end
     
@@ -954,8 +967,7 @@ end
 
 describe "Model#save" do
   before do
-    @c = Class.new(Sequel::Model(:people))
-    @c.class_eval do
+    @c = model_class.call Sequel::Model(:people) do
       columns :id, :x
 
       validates_each :x do |o, a, v|