sequel 3.37.0 → 3.38.0

data/spec/core/object_graph_spec.rb

@@ -51,17 +51,17 @@ describe Sequel::Dataset, " graphing" do
     ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
     ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(:id.identifier, :x.qualify(:points)).graph(@ds2, :x=>:id)
+    ds = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
     ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(:id.identifier.qualify(:points), :x.identifier.as(:y)).graph(@ds2, :x=>:id)
+    ds = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
     ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(:id, :x.identifier.qualify(:points.identifier).as(:y.identifier)).graph(@ds2, :x=>:id)
+    ds = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
     ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
@@ -140,7 +140,7 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#graph should accept a block instead of conditions and pass it to join_table" do
-    ds = @ds1.graph(@ds2){|ja, lja, js| [[:x.qualify(ja), :id.qualify(lja)], [:y.qualify(ja), :id.qualify(lja)]]}
+    ds = @ds1.graph(@ds2){|ja, lja, js| [[Sequel.qualify(ja, :x), Sequel.qualify(lja, :id)], [Sequel.qualify(ja, :y), Sequel.qualify(lja, :id)]]}
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
   end
 
@@ -197,7 +197,7 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#set_graph_aliases should allow a third entry to specify an expression to use other than the default" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, :random.sql_function])
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)])
     ['SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
     'SELECT random() AS y, 1 AS x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     ].should(include(ds.sql))
@@ -280,7 +280,7 @@ describe Sequel::Dataset, " graphing" do
 
   it "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
     @db.fetch = [nil, {:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, :random.sql_function]).all.should == [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, Sequel.function(:random)]).all.should == [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
   end
 
   it "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do

data/spec/core/schema_spec.rb

@@ -13,14 +13,14 @@ describe "DB#create_table" do
   specify "should accept the table name in multiple formats" do
     @db.create_table(:cats__cats) {}
     @db.create_table("cats__cats1") {}
-    @db.create_table(:cats__cats2.identifier) {}
-    @db.create_table(:cats.qualify(:cats3)) {}
+    @db.create_table(Sequel.identifier(:cats__cats2)) {}
+    @db.create_table(Sequel.qualify(:cats3, :cats)) {}
     @db.sqls.should == ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
   end
 
   specify "should raise an error if the table name argument is not valid" do
     proc{@db.create_table(1) {}}.should raise_error(Sequel::Error)
-    proc{@db.create_table(:cats.as(:c)) {}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(Sequel.as(:cats, :c)) {}}.should raise_error(Sequel::Error)
   end
 
   specify "should remove cached schema entry" do
@@ -391,7 +391,7 @@ describe "DB#create_table" do
   specify "should accept functional indexes" do
     @db.create_table(:cats) do
       integer :id
-      index :lower.sql_function(:name)
+      index Sequel.function(:lower, :name)
     end
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_lower_name__index ON cats (lower(name))"]
   end
@@ -399,7 +399,7 @@ describe "DB#create_table" do
   specify "should accept indexes with identifiers" do
     @db.create_table(:cats) do
       integer :id
-      index :lower__name.identifier
+      index Sequel.identifier(:lower__name)
     end
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_lower__name_index ON cats (lower__name)"]
   end
@@ -431,7 +431,7 @@ describe "DB#create_table" do
   specify "should accept unnamed constraint definitions with blocks" do
     @db.create_table(:cats) do
       integer :score
-      check {(:x.sql_number > 0) & (:y.sql_number < 1)}
+      check{(x.sql_number > 0) & (y.sql_number < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK ((x > 0) AND (y < 1)))"]
   end
@@ -460,7 +460,7 @@ describe "DB#create_table" do
 
   specify "should accept named constraint definitions with block" do
     @db.create_table(:cats) do
-      constraint(:blah_blah) {(:x.sql_number > 0) & (:y.sql_number < 1)}
+      constraint(:blah_blah){(x.sql_number > 0) & (y.sql_number < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1)))"]
   end
@@ -787,7 +787,7 @@ describe "DB#alter_table" do
 
   specify "should support add_constraint with block" do
     @db.alter_table(:cats) do
-      add_constraint(:blah_blah) {(:x.sql_number > 0) & (:y.sql_number < 1)}
+      add_constraint(:blah_blah){(x.sql_number > 0) & (y.sql_number < 1)}
     end
     @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1))"]
   end
@@ -1122,7 +1122,7 @@ describe "Database#create_view" do
   specify "should construct proper SQL with raw SQL" do
     @db.create_view :test, "SELECT * FROM xyz"
     @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
-    @db.create_view :test.identifier, "SELECT * FROM xyz"
+    @db.create_view Sequel.identifier(:test), "SELECT * FROM xyz"
     @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
   end
   
@@ -1136,7 +1136,7 @@ describe "Database#create_view" do
   specify "should construct proper SQL with dataset" do
     @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
     @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
-    @db.create_or_replace_view :test.identifier, @db[:items].select(:a, :b).order(:c)
+    @db.create_or_replace_view Sequel.identifier(:test), @db[:items].select(:a, :b).order(:c)
     @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
   end
 end
@@ -1148,9 +1148,9 @@ describe "Database#drop_view" do
   
   specify "should construct proper SQL" do
     @db.drop_view :test
-    @db.drop_view :test.identifier
+    @db.drop_view Sequel.identifier(:test)
     @db.drop_view :sch__test
-    @db.drop_view :test.qualify(:sch)
+    @db.drop_view Sequel.qualify(:sch, :test)
     @db.sqls.should == ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test', 'DROP VIEW sch.test']
   end
 
@@ -1243,11 +1243,11 @@ describe "Schema Parser" do
     s1 = @db.schema(:x)
     s1.should == [['x', {:db_type=>'x', :ruby_default=>nil}]]
     @db.schema(:x).object_id.should == s1.object_id
-    @db.schema(:x.identifier).object_id.should == s1.object_id
+    @db.schema(Sequel.identifier(:x)).object_id.should == s1.object_id
     s2 = @db.schema(:x__y)
     s2.should == [['y', {:db_type=>'y', :ruby_default=>nil}]]
     @db.schema(:x__y).object_id.should == s2.object_id
-    @db.schema(:y.qualify(:x)).object_id.should == s2.object_id
+    @db.schema(Sequel.qualify(:x, :y)).object_id.should == s2.object_id
   end
 
   specify "should correctly parse all supported data types" do

data/spec/core/spec_helper.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+  SEQUEL_NO_CORE_EXTENSIONS = true
   require 'sequel/core'
 end
 

data/spec/{extensions/core_extensions_spec.rb → core_extensions_spec.rb}

@@ -1,24 +1,25 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+require 'rubygems'
 
-describe "Sequel core extensions" do
-  specify "should not be used inside Sequel, to insure Sequel works without them" do
-    usage = []
-    match_re = /(\.(sql_value_list|sql_array|sql_expr|sql_negate|sql_or|sql_string_join|lit|to_sequel_blob|case)\W)|:\w+\.(qualify|identifier|as|cast|asc|desc|sql_subscript|\*|sql_function)\W/
-    comment_re = /^\s*#|# core_sql/
-    Dir['lib/sequel/**/*.rb'].each do |f|
-      lines = File.read(f).split("\n").grep(match_re).delete_if{|l| l =~ comment_re}
-      usage << [f, lines] unless lines.empty?
-    end
-    puts usage unless usage.empty?
-    usage.should be_empty
-  end
+unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
+  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+  require 'sequel/no_core_ext'
+end
+
+Sequel.quote_identifiers = false
+Sequel.identifier_input_method = nil
+Sequel.identifier_output_method = nil
+
+Regexp.send(:include, Sequel::SQL::StringMethods)
+String.send(:include, Sequel::SQL::StringMethods)
+Sequel.extension :core_extensions
 
+describe "Sequel core extensions" do
   specify "should have Sequel.core_extensions? be true if enabled" do
     Sequel.core_extensions?.should be_true
   end
 end
 
-describe "Array and Hash extensions" do
+describe "Core extensions" do
   before do
     db = Sequel::Database.new
     @d = db[:items]
@@ -30,6 +31,150 @@ describe "Array and Hash extensions" do
     end
   end
   
+  if RUBY_VERSION < '1.9.0'
+    it "should not allow inequality operations on true, false, or nil" do
+      @d.lit(:x > 1).should == "(x > 1)"
+      @d.lit(:x < true).should == "(x < 't')"
+      @d.lit(:x >= false).should == "(x >= 'f')"
+      @d.lit(:x <= nil).should == "(x <= NULL)"
+    end
+
+    it "should not allow inequality operations on boolean complex expressions" do
+      @d.lit(:x > (:y > 5)).should == "(x > (y > 5))"
+      @d.lit(:x < (:y < 5)).should == "(x < (y < 5))"
+      @d.lit(:x >= (:y >= 5)).should == "(x >= (y >= 5))"
+      @d.lit(:x <= (:y <= 5)).should == "(x <= (y <= 5))"
+      @d.lit(:x > {:y => nil}).should == "(x > (y IS NULL))"
+      @d.lit(:x < ~{:y => nil}).should == "(x < (y IS NOT NULL))"
+      @d.lit(:x >= {:y => 5}).should == "(x >= (y = 5))"
+      @d.lit(:x <= ~{:y => 5}).should == "(x <= (y != 5))"
+      @d.lit(:x >= {:y => [1,2,3]}).should == "(x >= (y IN (1, 2, 3)))"
+      @d.lit(:x <= ~{:y => [1,2,3]}).should == "(x <= (y NOT IN (1, 2, 3)))"
+    end
+    
+    it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
+      @d.l(:x > 100).should == '(x > 100)'
+      @d.l(:x < 100.01).should == '(x < 100.01)'
+      @d.l(:x >= 100000000000000000000000000000000000).should == '(x >= 100000000000000000000000000000000000)'
+      @d.l(:x <= 100).should == '(x <= 100)'
+    end
+    
+    it "should support negation of >, <, >=, and <= via Symbol#~" do
+      @d.l(~(:x > 100)).should == '(x <= 100)'
+      @d.l(~(:x < 100.01)).should == '(x >= 100.01)'
+      @d.l(~(:x >= 100000000000000000000000000000000000)).should == '(x < 100000000000000000000000000000000000)'
+      @d.l(~(:x <= 100)).should == '(x > 100)'
+    end
+    
+    it "should support double negation via ~" do
+      @d.l(~~(:x > 100)).should == '(x > 100)'
+    end
+  end
+  it "should support NOT via Symbol#~" do
+    @d.l(~:x).should == 'NOT x'
+    @d.l(~:x__y).should == 'NOT x.y'
+  end
+  
+  it "should support + - * / via Symbol#+,-,*,/" do
+    @d.l(:x + 1 > 100).should == '((x + 1) > 100)'
+    @d.l((:x * :y) < 100.01).should == '((x * y) < 100.01)'
+    @d.l((:x - :y/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
+    @d.l((((:x - :y)/(:x + :y))*:z) <= 100).should == '((((x - y) / (x + y)) * z) <= 100)'
+    @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
+  end
+  
+  it "should support LIKE via Symbol#like" do
+    @d.l(:x.like('a')).should == '(x LIKE \'a\')'
+    @d.l(:x.like(/a/)).should == '(x ~ \'a\')'
+    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\') OR (x LIKE \'b\'))'
+    @d.l(:x.like(/a/, /b/i)).should == '((x ~ \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\') OR (x ~ \'b\'))'
+
+    @d.l('a'.like(:x)).should == "('a' LIKE x)"
+    @d.l('a'.like(:x, 'b')).should == "(('a' LIKE x) OR ('a' LIKE 'b'))"
+    @d.l('a'.like(:x, /b/)).should == "(('a' LIKE x) OR ('a' ~ 'b'))"
+    @d.l('a'.like(:x, /b/i)).should == "(('a' LIKE x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/.like(:x)).should == "('a' ~ x)"
+    @d.l(/a/.like(:x, 'b')).should == "(('a' ~ x) OR ('a' ~ 'b'))"
+    @d.l(/a/.like(:x, /b/)).should == "(('a' ~ x) OR ('a' ~ 'b'))"
+    @d.l(/a/.like(:x, /b/i)).should == "(('a' ~ x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/i.like(:x)).should == "('a' ~* x)"
+    @d.l(/a/i.like(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.like(:x, /b/)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.like(:x, /b/i)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+  end
+
+  it "should support NOT LIKE via Symbol#like and Symbol#~" do
+    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\')'
+    @d.l(~:x.like(/a/)).should == '(x !~ \'a\')'
+    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\') AND (x NOT LIKE \'b\'))'
+    @d.l(~:x.like(/a/, /b/i)).should == '((x !~ \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\') AND (x !~ \'b\'))'
+
+    @d.l(~'a'.like(:x)).should == "('a' NOT LIKE x)"
+    @d.l(~'a'.like(:x, 'b')).should == "(('a' NOT LIKE x) AND ('a' NOT LIKE 'b'))"
+    @d.l(~'a'.like(:x, /b/)).should == "(('a' NOT LIKE x) AND ('a' !~ 'b'))"
+    @d.l(~'a'.like(:x, /b/i)).should == "(('a' NOT LIKE x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/.like(:x)).should == "('a' !~ x)"
+    @d.l(~/a/.like(:x, 'b')).should == "(('a' !~ x) AND ('a' !~ 'b'))"
+    @d.l(~/a/.like(:x, /b/)).should == "(('a' !~ x) AND ('a' !~ 'b'))"
+    @d.l(~/a/.like(:x, /b/i)).should == "(('a' !~ x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/i.like(:x)).should == "('a' !~* x)"
+    @d.l(~/a/i.like(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.like(:x, /b/)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.like(:x, /b/i)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+  end
+
+  it "should support ILIKE via Symbol#ilike" do
+    @d.l(:x.ilike('a')).should == '(x ILIKE \'a\')'
+    @d.l(:x.ilike(/a/)).should == '(x ~* \'a\')'
+    @d.l(:x.ilike('a', 'b')).should == '((x ILIKE \'a\') OR (x ILIKE \'b\'))'
+    @d.l(:x.ilike(/a/, /b/i)).should == '((x ~* \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.ilike('a', /b/)).should == '((x ILIKE \'a\') OR (x ~* \'b\'))'
+
+    @d.l('a'.ilike(:x)).should == "('a' ILIKE x)"
+    @d.l('a'.ilike(:x, 'b')).should == "(('a' ILIKE x) OR ('a' ILIKE 'b'))"
+    @d.l('a'.ilike(:x, /b/)).should == "(('a' ILIKE x) OR ('a' ~* 'b'))"
+    @d.l('a'.ilike(:x, /b/i)).should == "(('a' ILIKE x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/.ilike(:x)).should == "('a' ~* x)"
+    @d.l(/a/.ilike(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/.ilike(:x, /b/)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/.ilike(:x, /b/i)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+
+    @d.l(/a/i.ilike(:x)).should == "('a' ~* x)"
+    @d.l(/a/i.ilike(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.ilike(:x, /b/)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+    @d.l(/a/i.ilike(:x, /b/i)).should == "(('a' ~* x) OR ('a' ~* 'b'))"
+  end
+
+  it "should support NOT ILIKE via Symbol#ilike and Symbol#~" do
+    @d.l(~:x.ilike('a')).should == '(x NOT ILIKE \'a\')'
+    @d.l(~:x.ilike(/a/)).should == '(x !~* \'a\')'
+    @d.l(~:x.ilike('a', 'b')).should == '((x NOT ILIKE \'a\') AND (x NOT ILIKE \'b\'))'
+    @d.l(~:x.ilike(/a/, /b/i)).should == '((x !~* \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.ilike('a', /b/)).should == '((x NOT ILIKE \'a\') AND (x !~* \'b\'))'
+
+    @d.l(~'a'.ilike(:x)).should == "('a' NOT ILIKE x)"
+    @d.l(~'a'.ilike(:x, 'b')).should == "(('a' NOT ILIKE x) AND ('a' NOT ILIKE 'b'))"
+    @d.l(~'a'.ilike(:x, /b/)).should == "(('a' NOT ILIKE x) AND ('a' !~* 'b'))"
+    @d.l(~'a'.ilike(:x, /b/i)).should == "(('a' NOT ILIKE x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/.ilike(:x)).should == "('a' !~* x)"
+    @d.l(~/a/.ilike(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/.ilike(:x, /b/)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/.ilike(:x, /b/i)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+
+    @d.l(~/a/i.ilike(:x)).should == "('a' !~* x)"
+    @d.l(~/a/i.ilike(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.ilike(:x, /b/)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+    @d.l(~/a/i.ilike(:x, /b/i)).should == "(('a' !~* x) AND ('a' !~* 'b'))"
+  end
+
   it "should support sql_expr on arrays with all two pairs" do
     @d.l([[:x, 100],[:y, 'a']].sql_expr).should == '((x = 100) AND (y = \'a\'))'
     @d.l([[:x, true], [:y, false]].sql_expr).should == '((x IS TRUE) AND (y IS FALSE))'
@@ -429,3 +574,52 @@ describe "Symbol" do
     :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)"
   end
 end
+
+describe "Postgres extensions integration" do
+  before do
+    @db = Sequel.mock
+    Sequel.extension(:pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops, :pg_json, :pg_range, :pg_range_ops, :pg_row, :pg_row_ops)
+  end
+
+  it "Symbol#pg_array should return an ArrayOp" do
+    @db.literal(:a.pg_array.unnest).should == "unnest(a)"
+  end
+
+  it "Symbol#pg_row should return a PGRowOp" do
+    @db.literal(:a.pg_row[:a]).should == "(a).a"
+  end
+
+  it "Symbol#hstore should return an HStoreOp" do
+    @db.literal(:a.hstore['a']).should == "(a -> 'a')"
+  end
+
+  it "Symbol#pg_range should return a RangeOp" do
+    @db.literal(:a.pg_range.lower).should == "lower(a)"
+  end
+
+  it "Array#pg_array should return a PGArray" do
+    @db.literal([1].pg_array.op.unnest).should == "unnest(ARRAY[1])"
+    @db.literal([1].pg_array(:int4).op.unnest).should == "unnest(ARRAY[1]::int4[])"
+  end
+
+  it "Array#pg_json should return a JSONArray" do
+    @db.literal([1].pg_json).should == "'[1]'::json"
+  end
+
+  it "Array#pg_row should return a ArrayRow" do
+    @db.literal([1].pg_row).should == "ROW(1)"
+  end
+
+  it "Hash#hstore should return an HStore" do
+    @db.literal({'a'=>1}.hstore.op['a']).should == '(\'"a"=>"1"\'::hstore -> \'a\')'
+  end
+
+  it "Hash#pg_json should return an JSONHash" do
+    @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
+  end
+
+  it "Range#pg_range should return an PGRange" do
+    @db.literal((1..2).pg_range).should == "'[1,2]'"
+    @db.literal((1..2).pg_range(:int4range)).should == "'[1,2]'::int4range"
+  end
+end

data/spec/extensions/columns_introspection_spec.rb

@@ -58,19 +58,19 @@ describe "columns_introspection extension" do
   end
 
   specify "should handle SQL::Identifiers " do
-    @ds.select(:x.identifier).columns.should == [:x]
+    @ds.select(Sequel.identifier(:x)).columns.should == [:x]
     @db.sqls.length.should == 0
   end
 
   specify "should handle SQL::QualifiedIdentifiers" do
-    @ds.select(:x.qualify(:t)).columns.should == [:x]
-    @ds.select(:x.identifier.qualify(:t)).columns.should == [:x]
+    @ds.select(Sequel.qualify(:t, :x)).columns.should == [:x]
+    @ds.select(Sequel.identifier(:x).qualify(:t)).columns.should == [:x]
     @db.sqls.length.should == 0
   end
 
   specify "should handle SQL::AliasedExpressions" do
-    @ds.select(:x.as(:a)).columns.should == [:a]
-    @ds.select(:x.as(:a.identifier)).columns.should == [:a]
+    @ds.select(Sequel.as(:x, :a)).columns.should == [:a]
+    @ds.select(Sequel.as(:x, Sequel.identifier(:a))).columns.should == [:a]
     @db.sqls.length.should == 0
   end
 

data/spec/extensions/hook_class_methods_spec.rb

@@ -1,14 +1,20 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-describe "Model hooks" do
+model_class = proc do |klass, &block|
+  c = Class.new(klass)
+  c.plugin :hook_class_methods
+  c.class_eval(&block) if block
+  c
+end
+
+describe Sequel::Model, "hook_class_methods plugin" do
   before do
     MODEL_DB.reset
   end
   
   specify "should be definable using a block" do
     adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
+    c = model_class.call Sequel::Model do
       before_save{adds << 'hi'}
     end
     
@@ -18,8 +24,7 @@ describe "Model hooks" do
   
   specify "should be definable using a method name" do
     adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
+    c = model_class.call Sequel::Model do
       define_method(:bye){adds << 'bye'}
       before_save :bye
     end
@@ -30,8 +35,7 @@ describe "Model hooks" do
 
   specify "should be additive" do
     adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
+    c = model_class.call Sequel::Model do
       after_save{adds << 'hyiyie'}
       after_save{adds << 'byiyie'}
     end
@@ -42,8 +46,7 @@ describe "Model hooks" do
   
   specify "before hooks should run in reverse order" do
     adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
+    c = model_class.call Sequel::Model do
       before_save{adds << 'hyiyie'}
       before_save{adds << 'byiyie'}
     end
@@ -54,8 +57,7 @@ describe "Model hooks" do
 
   specify "should not be additive if the method or tag already exists" do
     adds = []
-    c = Class.new(Sequel::Model)
-    c.class_eval do
+    c = model_class.call Sequel::Model do
       define_method(:bye){adds << 'bye'}
       before_save :bye
       before_save :bye
@@ -65,8 +67,7 @@ describe "Model hooks" do
     adds.should == ['bye']
 
     adds = []
-    d = Class.new(Sequel::Model)
-    d.class_eval do
+    d = model_class.call Sequel::Model do
       before_save(:bye){adds << 'hyiyie'}
       before_save(:bye){adds << 'byiyie'}
     end
@@ -75,8 +76,7 @@ describe "Model hooks" do
     adds.should == ['byiyie']
 
     adds = []
-    e = Class.new(Sequel::Model)
-    e.class_eval do
+    e = model_class.call Sequel::Model do
       define_method(:bye){adds << 'bye'}
       before_save :bye
       before_save(:bye){adds << 'byiyie'}
@@ -86,8 +86,7 @@ describe "Model hooks" do
     adds.should == ['byiyie']
 
     adds = []
-    e = Class.new(Sequel::Model)
-    e.class_eval do
+    e = model_class.call Sequel::Model do
       define_method(:bye){adds << 'bye'}
       before_save(:bye){adds << 'byiyie'}
       before_save :bye
@@ -99,8 +98,7 @@ describe "Model hooks" do
   
   specify "should be inheritable" do
     adds = []
-    a = Class.new(Sequel::Model)
-    a.class_eval do
+    a = model_class.call Sequel::Model do
       after_save{adds << '123'}
     end
     
@@ -116,8 +114,7 @@ describe "Model hooks" do
   
   specify "should be overridable in descendant classes" do
     adds = []
-    a = Class.new(Sequel::Model)
-    a.class_eval do
+    a = model_class.call Sequel::Model do
       before_save{adds << '123'}
     end
     
@@ -137,8 +134,7 @@ describe "Model hooks" do
     flag = true
     adds = []
     
-    a = Class.new(Sequel::Model)
-    a.class_eval do
+    a = model_class.call Sequel::Model do
       before_save{adds << 'cruel'; flag}
       before_save{adds << 'blah'; flag}
     end
@@ -173,8 +169,7 @@ describe "Model#after_initialize" do
     values1 = nil
     reached_after_initialized = false
     
-    a = Class.new(Sequel::Model)
-    a.class_eval do
+    a = model_class.call Sequel::Model do
       columns :x, :y
       after_initialize do
         values1 = @values.clone
@@ -192,8 +187,7 @@ describe "Model#before_create && Model#after_create" do
   before do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = model_class.call Sequel::Model(:items)  do
       columns :x
       no_primary_key
       
@@ -226,8 +220,7 @@ describe "Model#before_update && Model#after_update" do
   before do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = model_class.call(Sequel::Model(:items)) do
       after_update {MODEL_DB << "BLAH after"}
     end
   end
@@ -258,8 +251,7 @@ describe "Model#before_save && Model#after_save" do
   before do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = model_class.call(Sequel::Model(:items)) do
       columns :x
       after_save {MODEL_DB << "BLAH after"}
     end
@@ -298,8 +290,7 @@ describe "Model#before_destroy && Model#after_destroy" do
   before do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = model_class.call(Sequel::Model(:items)) do
       after_destroy {MODEL_DB << "BLAH after"}
     end
   end
@@ -329,8 +320,8 @@ describe "Model#before_validation && Model#after_validation" do
   before do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = model_class.call(Sequel::Model(:items)) do
+      plugin :validation_class_methods
       after_validation{MODEL_DB << "BLAH after"}
 
       def self.validate(o)
@@ -382,7 +373,7 @@ end
 
 describe "Model.has_hooks?" do
   before do
-    @c = Class.new(Sequel::Model(:items))
+    @c = model_class.call(Sequel::Model(:items))
   end
   
   specify "should return false if no hooks are defined" do
@@ -403,6 +394,7 @@ end
 describe "Model#add_hook_type" do
   before do
     class ::Foo < Sequel::Model(:items)
+      plugin :hook_class_methods
       add_hook_type :before_bar, :after_bar
 
       def bar