sequel 3.4.0 → 3.5.0

data/spec/extensions/force_encoding_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+if RUBY_VERSION >= '1.9.0'
+describe "force_encoding plugin" do
+  before do
+    @c = Class.new(Sequel::Model) do
+    end
+    @c.columns :id, :x
+    @c.plugin :force_encoding, 'UTF-8'
+    @e1 = Encoding.find('UTF-8')
+  end
+
+  specify "should force encoding to given encoding on load" do
+    s = 'blah'
+    s.force_encoding('US-ASCII')
+    o = @c.load(:id=>1, :x=>s)
+    o.x.should == 'blah'
+    o.x.encoding.should == @e1
+  end
+  
+  specify "should force encoding to given encoding when setting column values" do
+    s = 'blah'
+    s.force_encoding('US-ASCII')
+    o = @c.new(:x=>s)
+    o.x.should == 'blah'
+    o.x.encoding.should == @e1
+  end
+  
+  specify "should have a forced_encoding class accessor" do
+    s = 'blah'
+    s.force_encoding('US-ASCII')
+    @c.forced_encoding = 'Windows-1258'
+    o = @c.load(:id=>1, :x=>s)
+    o.x.should == 'blah'
+    o.x.encoding.should == Encoding.find('Windows-1258')
+  end
+  
+  specify "should not force encoding if forced_encoding is nil" do
+    s = 'blah'
+    s.force_encoding('US-ASCII')
+    @c.forced_encoding = nil
+    o = @c.load(:id=>1, :x=>s)
+    o.x.should == 'blah'
+    o.x.encoding.should == Encoding.find('US-ASCII')
+  end
+  
+  specify "should work correctly when subclassing" do
+    c = Class.new(@c)
+    s = 'blah'
+    s.force_encoding('US-ASCII')
+    o = c.load(:id=>1, :x=>s)
+    o.x.should == 'blah'
+    o.x.encoding.should == @e1
+    
+    c.plugin :force_encoding, 'UTF-16LE'
+    s = ''
+    s.force_encoding('US-ASCII')
+    o = c.load(:id=>1, :x=>s)
+    o.x.should == ''
+    o.x.encoding.should == Encoding.find('UTF-16LE')
+    
+    @c.plugin :force_encoding, 'UTF-32LE'
+    s = ''
+    s.force_encoding('US-ASCII')
+    o = @c.load(:id=>1, :x=>s)
+    o.x.should == ''
+    o.x.encoding.should == Encoding.find('UTF-32LE')
+    
+    s = ''
+    s.force_encoding('US-ASCII')
+    o = c.load(:id=>1, :x=>s)
+    o.x.should == ''
+    o.x.encoding.should == Encoding.find('UTF-16LE')
+  end
+end 
+end

data/spec/extensions/looser_typecasting_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+context "LooserTypecasting Extension" do
+  before do
+    @db = Sequel::Database.new({})
+    def @db.schema(*args)
+      [[:id, {}], [:y, {:type=>:float}], [:b, {:type=>:integer}]]
+    end 
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.instance_eval do
+      @columns = [:id, :b, :y] 
+      def columns; @columns; end 
+    end
+  end
+
+  specify "Should use to_i instead of Integer() for typecasting integers" do
+    proc{@c.new(:b=>'a')}.should raise_error(Sequel::InvalidValue)
+    @db.extend(Sequel::LooserTypecasting)
+    @c.new(:b=>'a').b.should == 0
+
+    o = Object.new
+    def o.to_i
+      1
+    end
+    @c.new(:b=>o).b.should == 1
+  end
+
+  specify "Should use to_f instead of Float() for typecasting floats" do
+    proc{@c.new(:y=>'a')}.should raise_error(Sequel::InvalidValue)
+    @db.extend(Sequel::LooserTypecasting)
+    @c.new(:y=>'a').y.should == 0.0
+
+    o = Object.new
+    def o.to_f
+      1.0
+    end
+    @c.new(:y=>o).y.should == 1.0
+  end
+end

data/spec/extensions/many_through_many_spec.rb

@@ -82,6 +82,16 @@ describe Sequel::Model, "many_through_many" do
     n.tags.should == [@c2.load(:id=>1)]
   end
   
+  it "should handle composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    n = @c1.load(:id => 1234)
+    n.yyy = 85
+    a = n.tags_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2) AND (albums_artists.b1 = 1234) AND (albums_artists.b2 = 85))'
+    n.tags.should == [@c2.load(:id=>1)]
+  end
+  
   it "should support a :conditions option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:a=>32}
     n = @c1.load(:id => 1234)
@@ -287,10 +297,20 @@ describe 'Sequel::Plugins::ManyThroughMany::ManyThroughManyAssociationReflection
     @ar.edges.should == [{:conditions=>[], :left=>:id, :right=>:artist_id, :table=>:albums_artists, :join_type=>:left_outer, :block=>nil}, {:conditions=>[], :left=>:album_id, :right=>:id, :table=>:albums, :join_type=>:left_outer, :block=>nil}, {:conditions=>[], :left=>:id, :right=>:album_id, :table=>:albums_tags, :join_type=>:left_outer, :block=>nil}]
   end
   
+  it "#edges should handle composite keys" do
+    Artist.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    Artist.association_reflection(:tags).edges.should == [{:conditions=>[], :left=>[:id, :yyy], :right=>[:b1, :b2], :table=>:albums_artists, :join_type=>:left_outer, :block=>nil}, {:conditions=>[], :left=>[:c1, :c2], :right=>[:d1, :d2], :table=>:albums, :join_type=>:left_outer, :block=>nil}, {:conditions=>[], :left=>[:e1, :e2], :right=>[:f1, :f2], :table=>:albums_tags, :join_type=>:left_outer, :block=>nil}]
+  end
+  
   it "#reverse_edges should be an array of joins to make when lazy loading or eager loading" do
     @ar.reverse_edges.should == [{:alias=>:albums_tags, :left=>:tag_id, :right=>:id, :table=>:albums_tags}, {:alias=>:albums, :left=>:id, :right=>:album_id, :table=>:albums}]
   end
   
+  it "#reverse_edges should handle composite keys" do
+    Artist.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    Artist.association_reflection(:tags).reverse_edges.should == [{:alias=>:albums_tags, :left=>[:g1, :g2], :right=>[:h1, :h2], :table=>:albums_tags}, {:alias=>:albums, :left=>[:e1, :e2], :right=>[:f1, :f2], :table=>:albums}]
+  end
+  
   it "#reciprocal should be nil" do
     @ar.reciprocal.should == nil
   end
@@ -339,6 +359,8 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
         h = {:id => 2}
         if sql =~ /albums_artists.artist_id IN \(([18])\)/
           h.merge!(:x_foreign_key_x=>$1.to_i)
+        elsif sql =~ /\(\(albums_artists.b1, albums_artists.b2\) IN \(\(1, 8\)\)\)/
+          h.merge!(:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>8)
         end
         h[:tag_id] = h.delete(:id) if sql =~ /albums_artists.artist_id IN \(8\)/
         yield h
@@ -453,7 +475,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = @c1.eager(:tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
-      'SELECT tags.id, tracks.id AS tracks_id, albums_artists.artist_id 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) AND (albums_artists.artist_id IN (1))) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']
+      'SELECT tags.id, tracks.id AS tracks_id, albums_artists.artist_id AS x_foreign_key_x FROM (SELECT tags.* 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) AND (albums_artists.artist_id IN (1)))) AS tags LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums ON (albums.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
@@ -473,7 +495,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:tracks
     a = @c1.load(:id=>1)
     a.tags
-    MODEL_DB.sqls.should == [ 'SELECT tags.id, tracks.id AS tracks_id 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) AND (albums_artists.artist_id = 1)) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']
+    MODEL_DB.sqls.should == [ 'SELECT tags.id, tracks.id AS tracks_id FROM (SELECT tags.* 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) AND (albums_artists.artist_id = 1))) AS tags LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums ON (albums.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']
     a.tags.should == [Tag.load(:id=>2)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
     MODEL_DB.sqls.length.should == 1
@@ -554,6 +576,26 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a.first.tags.should == [Tag.load(:tag_id=>2)]
     MODEL_DB.sqls.length.should == 2
   end
+  
+  it "should handle composite keys" do
+    @c1.send(:define_method, :yyy){values[:yyy]}
+    @c1.dataset.extend(Module.new {
+      def columns
+        [:id, :yyy]
+      end
+      def fetch_rows(sql)
+        @db << sql
+        yield({:id=>1, :yyy=>8})
+      end
+    })
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    a = @c1.eager(:tags).all
+    a.should == [@c1.load(:id=>1, :yyy=>8)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.b1 AS x_foreign_key_0_x, albums_artists.b2 AS x_foreign_key_1_x FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2) AND ((albums_artists.b1, albums_artists.b2) IN ((1, 8))))']
+    a.first.tags.should == [Tag.load(:id=>2)]
+    MODEL_DB.sqls.length.should == 2
+  end
 
   it "should respect :after_load callbacks on associations when eager loading" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :after_load=>lambda{|o, as| o[:id] *= 2; as.each{|a| a[:id] *= 3}}
@@ -725,6 +767,22 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a.first.tags.should == [Tag.load(:id=>2, :tag_id=>4)]
     MODEL_DB.sqls.length.should == 1
   end
+  
+  it "eager graphing should respect composite keys" do 
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:id, :tag_id], :left_primary_key=>[:id, :yyy]
+    @c1.dataset.meta_def(:columns){[:id, :yyy]}
+    Tag.dataset.meta_def(:columns){[:id, :tag_id]}
+    ds = @c1.eager_graph(:tags)
+    def ds.fetch_rows(sql)
+      @db << sql
+      yield({:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4})
+    end
+    a = ds.all
+    a.should == [@c1.load(:id=>1, :yyy=>8)]
+    MODEL_DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.b1 = artists.id) AND (albums_artists.b2 = artists.yyy)) LEFT OUTER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) LEFT OUTER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.g1) AND (tags.tag_id = albums_tags.g2))']
+    a.first.tags.should == [Tag.load(:id=>2, :tag_id=>4)]
+    MODEL_DB.sqls.length.should == 1
+  end
 
   it "should respect the association's :graph_select option" do 
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :graph_select=>:b

data/spec/extensions/named_timezones_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+if (begin
+  require 'tzinfo'
+  true
+  rescue LoadError
+  end) 
+
+Sequel.extension :named_timezones
+Sequel.datetime_class = Time
+
+describe "Sequel named_timezones extension" do
+  before do
+    @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
+    @tz_out = TZInfo::Timezone.get('America/New_York')
+    @db = MockDatabase.new
+    @dt = DateTime.civil(2009,6,1,10,20,30,0)
+    Sequel.application_timezone = 'America/Los_Angeles'
+    Sequel.database_timezone = 'America/New_York'
+    Sequel.datetime_class = DateTime
+  end
+  after do
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+  
+  it "should convert string arguments to *_timezone= to TZInfo::Timezone instances" do
+    Sequel.application_timezone.should == @tz_in
+    Sequel.database_timezone.should == @tz_out
+  end
+    
+  it "should accept TZInfo::Timezone instances in *_timezone=" do
+    Sequel.application_timezone = @tz_in
+    Sequel.database_timezone = @tz_out
+    Sequel.application_timezone.should == @tz_in
+    Sequel.database_timezone.should == @tz_out
+  end
+    
+  it "should convert datetimes going into the database to named database_timezone" do
+    ds = @db[:a]
+    def ds.supports_timestamp_timezones?; true; end
+    def ds.supports_timestamp_usecs?; false; end
+    ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,Rational(-7, 24)), DateTime.civil(2009,6,1,6,20,30,Rational(-1, 6))])
+    @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+  end
+  
+  it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
+    dt.should == @dt
+    dt.offset.should == Rational(-7, 24)
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
+    dt.should == @dt
+    dt.offset.should == Rational(-7, 24)
+  end
+    
+  it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
+    dt.should == @dt
+    dt.offset.should == Rational(-7, 24)
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30')
+    dt.should == @dt + Rational(1, 6)
+    dt.offset.should == Rational(-7, 24)
+  end
+  
+  it "should work with the thread_local_timezones extension" do
+    [Thread.new{Sequel.thread_application_timezone = 'America/New_York'; sleep 0.03; Sequel.application_timezone.should == @tz_out},
+     Thread.new{sleep 0.01; Sequel.thread_application_timezone = 'America/Los_Angeles'; sleep 0.01; Sequel.application_timezone.should == @tz_in}].each{|x| x.join}
+  end
+end
+end

data/spec/extensions/nested_attributes_spec.rb

@@ -220,7 +220,7 @@ describe "NestedAttributes plugin" do
     @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)']]
   end
   
-  it "should not save if nested attribute is not validate and should include nested attribute validation errors in the main object's validation errors" do
+  it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
     @Artist.class_eval do
       def validate
         super
@@ -234,6 +234,34 @@ describe "NestedAttributes plugin" do
     @mods.should == []
   end
   
+  it "should not attempt to validate nested attributes if the :validate=>false association option is used" do
+    @Album.many_to_one :artist, :class=>@Artist, :validate=>false
+    @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
+    @Artist.class_eval do
+      def validate
+        super
+        errors.add(:name, 'cannot be Ar') if name == 'Ar'
+      end
+    end
+    a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+  end
+  
+  it "should not attempt to validate nested attributes if the :validate=>false option is passed to save" do
+    @Artist.class_eval do
+      def validate
+        super
+        errors.add(:name, 'cannot be Ar') if name == 'Ar'
+      end
+    end
+    a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
+    @mods.should == []
+    a.save(:validate=>false)
+    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+  end
+  
   it "should not accept nested attributes unless explicitly specified" do
     @Artist.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
     proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.should raise_error(Sequel::Error)

data/spec/extensions/schema_dumper_spec.rb

@@ -246,6 +246,16 @@ END_MIG
     @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=>Time.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=>Time.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>\"'6 weeks'\".lit\nend"
   end
+  
+  it "should not use a '...'.lit 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}]]
+      s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
+      s
+    end
+    @d.dump_table_schema(:t5, :same_db=>true).should == "create_table(:t5) do\n  column :c10, \"interval\"\nend"
+  end
 
   it "should convert unknown database types to strings" do
     @d.dump_table_schema(:t5).should == "create_table(:t5) do\n  String :c1\nend"

data/spec/extensions/spec_helper.rb

@@ -8,7 +8,7 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
-Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper')
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones')
 {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
 
 class MockDataset < Sequel::Dataset

data/spec/extensions/sql_expr_spec.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Sequel sql_expr extension" do
+  specify "Object#sql_expr should wrap the object in a GenericComplexExpression" do
+    o = Object.new
+    s = o.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
+    s.op.should == :NOOP
+    s.args.should == [o]
+    (s+1).should be_a_kind_of(Sequel::SQL::NumericExpression)
+    (s & true).should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    (s < 1).should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.sql_subscript(1).should be_a_kind_of(Sequel::SQL::Subscript)
+    s.like('a').should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.as(:a).should be_a_kind_of(Sequel::SQL::AliasedExpression)
+    s.cast(Integer).should be_a_kind_of(Sequel::SQL::Cast)
+    s.desc.should be_a_kind_of(Sequel::SQL::OrderedExpression)
+    s.sql_string.should be_a_kind_of(Sequel::SQL::StringExpression)
+  end
+
+  specify "Numeric#sql_expr should wrap the object in a NumericExpression" do
+    [1, 2.0, 2^40, BigDecimal.new('1.0')].each do |o|
+      s = o.sql_expr
+      s.should be_a_kind_of(Sequel::SQL::NumericExpression)
+      s.op.should == :NOOP
+      s.args.should == [o]
+    end
+  end
+
+  specify "String#sql_expr should wrap the object in a StringExpression" do
+    o = ""
+    s = o.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::StringExpression)
+    s.op.should == :NOOP
+    s.args.should == [o]
+  end
+
+  specify "NilClass, TrueClass, and FalseClass#sql_expr should wrap the object in a BooleanExpression" do
+    [nil, true, false].each do |o|
+      s = o.sql_expr
+      s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
+      s.op.should == :NOOP
+      s.args.should == [o]
+    end
+  end
+
+  specify "Proc#sql_expr should should treat the object as a virtual row block" do
+    s = proc{a}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.value.should == :a
+
+    s = proc{a__b}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::QualifiedIdentifier)
+    s.table.should == "a"
+    s.column.should == "b"
+
+    s = proc{a(b)}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::Function)
+    s.f.should == :a
+    s.args.length.should == 1
+    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.first.value.should == :b
+  end
+
+  specify "Proc#sql_expr should should wrap the object in a GenericComplexExpression if the object is not already an expression" do
+    s = proc{1}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
+    s.op.should == :NOOP
+    s.args.should == [1]
+  end
+
+  specify "Proc#sql_expr should should convert a hash or array of two element arrays to a BooleanExpression" do
+    s = proc{{a=>b}}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.op.should == :"="
+    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.first.value.should == :a
+    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.last.value.should == :b
+
+    s = proc{[[a,b]]}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.op.should == :"="
+    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.first.value.should == :a
+    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.last.value.should == :b
+  end
+end