sequel_core 1.5.1 → 2.0.0

data/spec/migration_spec.rb

@@ -258,4 +258,4 @@ context "Sequel::Migrator" do
 
     Sequel::Migrator.apply(@db, '.').should == 5
   end
-end
+end

data/spec/object_graph_spec.rb

@@ -62,21 +62,15 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#graph should pass all join_conditions to join_table" do
-    ds = @ds1.graph(@ds2, :x=>:id, :y=>:id)
-    ['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)',
-    '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.y = points.id) AND (lines.x = points.id)'
-    ].should(include(ds.sql))
+    ds = @ds1.graph(@ds2, [[:x, :id], [:y, :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
 
   it "#graph should not add columns if graph is called after set_graph_aliases" do
-    ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-    ['SELECT points.x, lines.y FROM points',
-    'SELECT lines.y, points.x FROM points'
-    ].should(include(ds.sql))
+    ds = @ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])
+    ds.sql.should == 'SELECT points.x, lines.y FROM points'
     ds = ds.graph(:lines, :x=>:id)
-    ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-    'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ].should(include(ds.sql))
+    ds.sql.should == 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
   end
 
   it "#graph should allow graphing of multiple datasets" do

data/spec/rcov.opts

@@ -3,4 +3,4 @@ gems
 --exclude
 spec
 --exclude
-00*
+00*

data/spec/schema_generator_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe Sequel::Schema::Generator do
-  before :all do
+  before do
     @generator = Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
       string :title
       column :body, :text
@@ -11,6 +11,7 @@ describe Sequel::Schema::Generator do
       constraint(:xxx) {:yyy == :zzz}
       index :title
       index [:title, :body]
+      foreign_key :node_id, :nodes
     end
     @columns, @indexes = @generator.create_info
   end
@@ -22,7 +23,7 @@ describe Sequel::Schema::Generator do
   end
   
   it "counts primary key, column and constraint definitions as columns" do
-    @columns.size.should == 6
+    @columns.size.should == 7
   end
   
   it "places primary key first" do
@@ -45,6 +46,13 @@ describe Sequel::Schema::Generator do
   it "creates foreign key column" do
     @columns[3][:name].should == :parent_id
     @columns[3][:type].should == :integer
+    @columns[6][:name].should == :node_id
+    @columns[6][:type].should == :integer
+  end
+  
+  it "uses table for foreign key columns, if specified" do
+    @columns[6][:table].should == :nodes
+    @columns[3][:table].should == nil
   end
   
   it "finds columns" do
@@ -72,7 +80,7 @@ describe Sequel::Schema::Generator do
 end
 
 describe Sequel::Schema::AlterTableGenerator do
-  before :all do
+  before do
     @generator = Sequel::Schema::AlterTableGenerator.new(SchemaDummyDatabase.new) do
       add_column :aaa, :text
       drop_column :bbb
@@ -87,6 +95,8 @@ describe Sequel::Schema::AlterTableGenerator do
       add_index :blah, :where => {:something => true}
       add_constraint :con1, ':fred > 100'
       drop_constraint :con2
+      add_primary_key :id
+      add_foreign_key :node_id, :nodes
     end
   end
   
@@ -104,7 +114,9 @@ describe Sequel::Schema::AlterTableGenerator do
       {:op => :add_index, :columns => [:blah], :type => :hash},
       {:op => :add_index, :columns => [:blah], :where => {:something => true}},
       {:op => :add_constraint, :type => :check, :name => :con1, :check => [':fred > 100']},
-      {:op => :drop_constraint, :name => :con2}
+      {:op => :drop_constraint, :name => :con2},
+      {:op => :add_column, :name => :id, :type => :integer, :primary_key=>true, :auto_increment=>true},
+      {:op => :add_column, :name => :node_id, :type => :integer, :table=>:nodes}
     ]
   end
 end

data/spec/schema_spec.rb

@@ -110,12 +110,26 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (name varchar(102))"]
   end
 
-  specify "should accept foreign keys" do
+  specify "should accept foreign keys without options" do
+    @db.create_table(:cats) do
+      foreign_key :project_id
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer)"]
+  end
+
+  specify "should accept foreign keys with options" do
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects)"]
   end
+
+  specify "should accept foreign keys with separate table argument" do
+    @db.create_table(:cats) do
+      foreign_key :project_id, :projects, :default=>3
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer DEFAULT 3 REFERENCES projects)"]
+  end
   
   specify "should accept foreign keys with arbitrary keys" do
     @db.create_table(:cats) do
@@ -264,14 +278,15 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name)"]
   end
   
-  specify "should accept unnamed constraint definitions" do
+  pt_specify "should accept unnamed constraint definitions with blocks" do
     @db.create_table(:cats) do
       integer :score
       check {:x > 0 && :y < 1}
     end
-    @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK (((x > 0) AND (y < 1))))"]
-    @db.sqls.clear
+    @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK ((x > 0) AND (y < 1)))"]
+  end
 
+  specify "should accept unnamed constraint definitions" do
     @db.create_table(:cats) do
       check 'price < ?', 100
     end
@@ -284,12 +299,13 @@ context "DB#create_table" do
       constraint :valid_score, 'score <= 100'
     end
     @db.sqls.should == ["CREATE TABLE cats (score integer, CONSTRAINT valid_score CHECK (score <= 100))"]
-    @db.sqls.clear
+  end
 
+  pt_specify "should accept named constraint definitions with block" do
     @db.create_table(:cats) do
       constraint(:blah_blah) {:x > 0 && :y < 1}
     end
-    @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK (((x > 0) AND (y < 1))))"]
+    @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1)))"]
   end
 end
 
@@ -320,24 +336,87 @@ context "DB#alter_table" do
     @db = SchemaDummyDatabase.new
   end
 
-  specify "should accept add constraint definitions" do
+  specify "should support add_column" do
+    @db.alter_table(:cats) do
+      add_column :score, :integer
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN score integer"]
+  end
+
+  specify "should support add_constraint" do
     @db.alter_table(:cats) do
       add_constraint :valid_score, 'score <= 100'
     end
     @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT valid_score CHECK (score <= 100)"]
-    @db.sqls.clear
+  end
 
+  pt_specify "should support add_constraint with block" do
     @db.alter_table(:cats) do
       add_constraint(:blah_blah) {:x > 0 && :y < 1}
     end
-    @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT blah_blah CHECK (((x > 0) AND (y < 1)))"]
+    @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1))"]
   end
 
-  specify "should accept drop constraint definitions" do
+  specify "should support add_foreign_key" do
+    @db.alter_table(:cats) do
+      add_foreign_key :node_id, :nodes
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN node_id integer REFERENCES nodes"]
+  end
+
+  specify "should support add_index" do
+    @db.alter_table(:cats) do
+      add_index :name
+    end
+    @db.sqls.should == ["CREATE INDEX cats_name_index ON cats (name)"]
+  end
+
+  specify "should support add_primary_key" do
+    @db.alter_table(:cats) do
+      add_primary_key :id
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN id integer PRIMARY KEY AUTOINCREMENT"]
+  end
+
+  specify "should support drop_column" do
+    @db.alter_table(:cats) do
+      drop_column :score
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP COLUMN score"]
+  end
+
+  specify "should support drop_constraint" do
     @db.alter_table(:cats) do
       drop_constraint :valid_score
     end
     @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score"]
   end
 
+  specify "should support drop_index" do
+    @db.alter_table(:cats) do
+      drop_index :name
+    end
+    @db.sqls.should == ["DROP INDEX cats_name_index"]
+  end
+
+  specify "should support rename_column" do
+    @db.alter_table(:cats) do
+      rename_column :name, :old_name
+    end
+    @db.sqls.should == ["ALTER TABLE cats RENAME COLUMN name TO old_name"]
+  end
+
+  specify "should support set_column_default" do
+    @db.alter_table(:cats) do
+      set_column_default :score, 3
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET DEFAULT 3"]
+  end
+
+  specify "should support set_column_type" do
+    @db.alter_table(:cats) do
+      set_column_type :score, :real
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score TYPE real"]
+  end
 end

data/spec/sequelizer_spec.rb

@@ -53,7 +53,7 @@ context "Sequelizer without Ruby2Ruby" do
     $VERBOSE = old_verbose
   end
   
-  specify "should raise error only when using external expressions" do
+  pt_specify "should raise error only when using external expressions" do
     proc {proc {:x > 1}.to_sql(@ds)}.should_not raise_error(Sequel::Error)
     proc {proc {1 + 1}.to_sql(@ds)}.should raise_error(Sequel::Error)
   end
@@ -84,7 +84,7 @@ context "Proc#to_sql" do
     end
   end
   
-  specify "should support <sym> <op> <lit>" do
+  pt_specify "should support <sym> <op> <lit>" do
     proc {:x > 100}.sql.should == '(x > 100)'
     proc {:x < 100}.sql.should == '(x < 100)'
     proc {:x >= 100}.sql.should == '(x >= 100)'
@@ -92,27 +92,27 @@ context "Proc#to_sql" do
     proc {:x == 100}.sql.should == '(x = 100)'
   end
   
-  specify "should support number literals" do
+  pt_specify "should support number literals" do
     proc {:x > 123.45}.sql.should == '(x > 123.45)'
     proc {:x > -30_000}.sql.should == '(x > -30000)'
   end
 
-  specify "should support string literals" do
+  pt_specify "should support string literals" do
     proc {:x == 'abc'}.sql.should == "(x = 'abc')"
     proc {:y == "ab'cd"}.sql.should == "(y = 'ab''cd')"
   end
   
-  specify "should support boolean literals" do
+  pt_specify "should support boolean literals" do
     proc {:x == false}.sql.should == "(x = 'f')"
     proc {:x == true}.sql.should == "(x = 't')"
   end
   
-  specify "should support nil literal and nil?" do
+  pt_specify "should support nil literal and nil?" do
     proc {:x == nil}.sql.should == "(x IS NULL)"
     proc {:x.nil?}.sql.should == "(x IS NULL)"
   end
   
-  specify "should support local vars or method references" do
+  pt_specify "should support local vars or method references" do
     proc {proc {:x == a}.sql}.should raise_error(NameError)
     b = 123
     proc {:x == b}.sql.should == "(x = 123)"
@@ -127,13 +127,13 @@ context "Proc#to_sql" do
     proc {:x == y2}.sql.should == "(x = 111)"
   end
   
-  specify "sould support subscript access on symbols" do
+  pt_specify "sould support subscript access on symbols" do
     proc {:x|1 > 0}.sql.should == "(x[1] > 0)"
     proc {:x|2|3 > 0}.sql.should == "(x[2, 3] > 0)"
     proc {:x|[4, 5] > 0}.sql.should == "(x[4, 5] > 0)"
   end
   
-  specify "should support constants" do
+  pt_specify "should support constants" do
     ZZZ = 444
     proc {:x == ZZZ}.sql.should == "(x = 444)"
     
@@ -142,33 +142,33 @@ context "Proc#to_sql" do
     proc {:x == CCCD::DDD}.sql.should == "(x = 'hi')"
   end
   
-  specify "should support instance attributes" do
+  pt_specify "should support instance attributes" do
     @abc = 123
     proc {:x == @abc}.sql.should == "(x = 123)"
   end
   
-  specify "should support class attributes" do
+  pt_specify "should support class attributes" do
     @@abc = 321
     proc {:x == @@abc}.sql.should == "(x = 321)"
   end
   
-  specify "should support like? pattern" do
+  pt_specify "should support like? pattern" do
     proc {:x.like? '%abc'}.sql.should == "(x LIKE '%abc')"
   end
   
-  specify "should support like? pattern with multiple choices" do
+  pt_specify "should support like? pattern with multiple choices" do
     proc {:x.like? ['%abc', '%def', '%ghi']}.sql.should == \
       "((x LIKE '%abc') OR (x LIKE '%def') OR (x LIKE '%ghi'))"
   end
   
-  specify "should support =~ operator" do
+  pt_specify "should support =~ operator" do
     # stock SQL version does not know about regexps
     proc {:x =~ '123'}.sql.should == "(x LIKE '123')"
 
     proc {:x =~ /^123/}.sql.should == "(x ~ '^123')"
   end
   
-  specify "should support =~ operator with multiple choices" do
+  pt_specify "should support =~ operator with multiple choices" do
     # stock SQL version does not know about regexps
     proc {:x =~ ['123', '456', '789']}.sql.should == "((x LIKE '123') OR (x LIKE '456') OR (x LIKE '789'))"
 
@@ -177,101 +177,101 @@ context "Proc#to_sql" do
     proc {:x =~ [/^123/, '456%', /^789/]}.sql.should == "((x ~ '^123') OR (x LIKE '456%') OR (x ~ '^789'))"
   end
   
-  specify "should raise on =~ operator for unsupported types" do
+  pt_specify "should raise on =~ operator for unsupported types" do
     proc {proc {:x =~ 123}.sql}.should raise_error(Sequel::Error)
   end
   
-  specify "should support != operator" do
+  pt_specify "should support != operator" do
     proc {:x != 100}.sql.should == "(NOT (x = 100))"
   end
 
-  specify "should support != operator with multiple choices" do
+  pt_specify "should support != operator with multiple choices" do
     proc {:x != [100, 200, 300]}.sql.should == "(NOT (x IN (100, 200, 300)))"
   end
 
-  specify "should support !~ operator" do
+  pt_specify "should support !~ operator" do
     proc {:x !~ '123'}.sql.should == "(NOT (x LIKE '123'))"
   end
   
-  specify "should support !~ operator with multiple choices" do
+  pt_specify "should support !~ operator with multiple choices" do
     proc {:x !~ ['123', '456']}.sql.should == "(NOT ((x LIKE '123') OR (x LIKE '456')))"
   end
   
-  specify "should support ! operator" do
+  pt_specify "should support ! operator" do
     proc {!:x}.sql.should == "(x = 'f')"
     proc {!(:x > 100)}.sql.should == "(NOT (x > 100))"
   end
   
-  specify "should support && operator" do
+  pt_specify "should support && operator" do
     proc {1 && 2}.sql.should == "(1 AND 2)"
     proc {:x > 100 && :y < 100}.sql.should == "((x > 100) AND (y < 100))"
     proc {:x && :y && :z}.sql.should == "(x AND (y AND z))"
   end
   
-  specify "should support << operator for assignment" do
+  pt_specify "should support << operator for assignment" do
     proc {:x << 1}.sql.should == "x = 1"
   end
   
-  specify "should concatenate separate statements using AND" do
+  pt_specify "should concatenate separate statements using AND" do
     proc {:x == 20; :y == 30}.sql.should == "((x = 20) AND (y = 30))"
     proc {:x != 1; :y != 2; :z != 3}.sql.should == \
       "((NOT (x = 1)) AND (NOT (y = 2)) AND (NOT (z = 3)))"
   end
   
-  specify "should concatenate separate statements using custom join argument" do
+  pt_specify "should concatenate separate statements using custom join argument" do
     proc {:x << 20; :y << 30}.sql_comma_separated.should == "x = 20, y = 30"
     z = 333
     proc {:x << :x + 1; :y << z}.sql_comma_separated.should == "x = (x + 1), y = 333"
   end
   
-  specify "should support || operator" do
+  pt_specify "should support || operator" do
     proc {1 || 2}.sql.should == "(1 OR 2)"
     proc {:x > 100 || :y < 100}.sql.should == "((x > 100) OR (y < 100))"
     proc {:x || :y || :z}.sql.should == "(x OR (y OR z))"
   end
   
-  specify "should support operator combinations" do
+  pt_specify "should support operator combinations" do
     proc {(:x > 1 || :y > 2) && (:z > 3)}.sql.should == "(((x > 1) OR (y > 2)) AND (z > 3))"
     proc {(1 && 2) || (3 || 4)}.sql.should == "((1 AND 2) OR (3 OR 4))"
     proc {(:x != 2) || (:y == 3) || !(:z == 4)}.sql.should == \
       "((NOT (x = 2)) OR ((y = 3) OR (NOT (z = 4))))"
   end
   
-  specify "should support late bound column references" do
+  pt_specify "should support late bound column references" do
     def abc; :tttt; end
     proc {abc > 2}.sql.should == "(tttt > 2)"
   end
   
-  specify "should support qualified column references" do
+  pt_specify "should support qualified column references" do
     proc {:x__y > 3}.sql.should == "(x.y > 3)"
   end
   
-  specify "should support functions on columns" do
+  pt_specify "should support functions on columns" do
     proc {:max[:x] > 100}.sql.should == "(max(x) > 100)"
     proc {:count[:x] > 100}.sql.should == "(count(x) > 100)"
   end
   
-  specify "should support SQL functions" do
+  pt_specify "should support SQL functions" do
     proc {:MAX[:x] > 100}.sql.should == "(MAX(x) > 100)"
 
     proc {:MAX[:x__y] > 100}.sql.should == "(MAX(x.y) > 100)"
   end
   
-  specify "should support SQL functions with multiple arguments" do
+  pt_specify "should support SQL functions with multiple arguments" do
     proc {:sum[1, 2, 3] > 100}.sql.should == "(sum(1, 2, 3) > 100)"
     
     proc {:x[1, DB[:y].select(:z), "a'b"] > 100}.sql.should == \
       "(x(1, (SELECT z FROM y), 'a''b') > 100)"
   end
   
-  specify "should support SQL functions without arguments" do
+  pt_specify "should support SQL functions without arguments" do
     proc {:abc[] > 100}.sql.should == "(abc() > 100)"
     
     proc {:now[] - :last_stamp > 100}.sql.should == \
       "((now() - last_stamp) > 100)"
   end
   
-  specify "should do stuff like..." do
+  pt_specify "should do stuff like..." do
     proc {:price < 100 || :category != 'ruby'}.sql.should == \
       "((price < 100) OR (NOT (category = 'ruby')))"
     t = Time.now
@@ -281,13 +281,13 @@ context "Proc#to_sql" do
     proc {1 < :x}.sql.should == "(1 < x)"
   end
   
-  specify "should complain if someone is crazy" do
+  pt_specify "should complain if someone is crazy" do
     proc {proc {def x; 1; end}.sql}.should raise_error(Sequel::Error::InvalidExpression)
     a = 1
     proc {proc {a = 1}.sql}.should raise_error(Sequel::Error::InvalidExpression)
   end
   
-  specify "should support comparison to Range objects" do
+  pt_specify "should support comparison to Range objects" do
     proc {:x == (1..10)}.sql.should == \
       "(x >= 1 AND x <= 10)"
 
@@ -308,7 +308,7 @@ context "Proc#to_sql" do
       "(stamp >= #{DS.literal(t1)} AND stamp <= #{DS.literal(t2)})"
   end
 
-  specify "should support comparison to sub-queries" do
+  pt_specify "should support comparison to sub-queries" do
     @ds2 = DB[:test].select(:node_id)
     
     proc {:id == @ds2}.sql.should == \
@@ -324,17 +324,17 @@ context "Proc#to_sql" do
       "(price >= (SELECT price FROM items))"
   end
 
-  specify "should support comparison to arrays" do
+  pt_specify "should support comparison to arrays" do
     proc {:id == [1, 3, 7, 15]}.sql.should == \
       "(id IN (1, 3, 7, 15))"
   end
   
-  specify "should not literalize String#expr and String#lit" do
+  pt_specify "should not literalize String#expr and String#lit" do
     proc {'x'.lit == 1}.sql.should == "(x = 1)"
     proc {'x.y'.expr == 1}.sql.should == "(x.y = 1)"
   end
 
-  specify "should support in/in? operator" do
+  pt_specify "should support in/in? operator" do
     proc {:x.in [3, 4, 5]}.sql.should == "(x IN (3, 4, 5))"
     proc {:x.in?(3, 4, 5)}.sql.should == "(x IN (3, 4, 5))"
 
@@ -345,7 +345,7 @@ context "Proc#to_sql" do
     proc {:x.in @ds2}.sql.should == "(x IN (SELECT node_id FROM test))"
   end
   
-  specify "should support nested procs" do
+  pt_specify "should support nested procs" do
     proc {:x > 10 || proc{:y > 20}}.sql.should == \
       "((x > 10) OR (y > 20))"
     
@@ -357,7 +357,7 @@ context "Proc#to_sql" do
       "((x > 10) OR (y > 20))"
   end
   
-  specify "should support unfolding of calls to #each" do
+  pt_specify "should support unfolding of calls to #each" do
     # from http://groups.google.com/group/sequel-talk/browse_thread/thread/54a660568515fbb7
     periods = [:day, :week, :month, :year, :alltime]
     idx = 1
@@ -371,7 +371,7 @@ context "Proc#to_sql" do
       "day[1] = (day[1] + 2), week[1] = (week[1] + 2), month[1] = (month[1] + 2), year[1] = (year[1] + 2), alltime[1] = (alltime[1] + 2)"
   end
   
-  specify "should support unfolding of calls to Hash#each" do
+  pt_specify "should support unfolding of calls to Hash#each" do
     periods = {:month => 3}
     idx = 1
     pr = proc do
@@ -382,14 +382,14 @@ context "Proc#to_sql" do
     pr.sql_comma_separated.should == "month = (month + 3)"
   end
   
-  specify "should support local arguments" do
+  pt_specify "should support local arguments" do
     def t(x)
       proc {x > 10}.sql
     end
     t(:y).should == "(y > 10)"
   end
   
-  specify "should support binary operators on local context" do
+  pt_specify "should support binary operators on local context" do
     XXX = 1
     YYY = 2
     proc {XXX || YYY}.sql.should == "(1 OR 2)"
@@ -399,7 +399,7 @@ context "Proc#to_sql" do
     proc {xxx && yyy}.sql.should == "(1 AND 2)"
   end
   
-  specify "should support arithmetics" do
+  pt_specify "should support arithmetics" do
     zzz = 300
     proc {(:x + 100) > zzz}.sql.should == "((x + 100) > 300)"
     
@@ -408,22 +408,22 @@ context "Proc#to_sql" do
     proc {:units * :price}.sql.should == "(units * price)"
   end
   
-  specify "should support | operator" do
+  pt_specify "should support | operator" do
     proc {(:x | 1) > 0}.sql.should == "(x[1] > 0)"
     proc {10 | 1}.sql.should == 11
   end
   
-  specify "should support globals" do
+  pt_specify "should support globals" do
     $aaaa_zzzz = 400
     proc {:x > $aaaa_zzzz}.sql.should == "(x > 400)"
   end
   
-  specify "should support Regexp macros" do
+  pt_specify "should support Regexp macros" do
     "abc" =~ /(ab)/
     proc {:x == $1}.sql.should == "(x = 'ab')"
   end
   
-  specify "should evaluate expression not referring to symbols or literal strings." do
+  pt_specify "should evaluate expression not referring to symbols or literal strings." do
     proc {:x > 2 * 3}.sql.should == "(x > 6)"
     y = 3
     proc {:x > y * 4}.sql.should == "(x > 12)"
@@ -435,14 +435,14 @@ context "Proc#to_sql" do
     proc {:y == (1 > 2)}.sql.should == "(y = 'f')"
   end
   
-  specify "should support ternary operator" do
+  pt_specify "should support ternary operator" do
     y = true
     proc {:x > (y ? 1 : 2)}.sql.should == "(x > 1)"
     
     proc {((1 > 2) ? :x : :y) > 3}.sql.should == "(y > 3)"
   end
   
-  specify "should support strings with embedded Ruby code in them and literalize them" do
+  pt_specify "should support strings with embedded Ruby code in them and literalize them" do
     proc {:n == "#{1+2}"}.sql.should == "(n = '3')"
     
     y = "12'34"
@@ -450,14 +450,14 @@ context "Proc#to_sql" do
     proc {:x > "#{y}"}.sql.should == "(x > '12''34')"
   end
   
-  specify "should support format strings and literalize the result" do
+  pt_specify "should support format strings and literalize the result" do
     prod = 1
     proc {:x == "abc%d" % prod}.sql.should == "(x = 'abc1')"
     
     proc {:x == ("%d" % prod).lit}.sql.should == "(x = 1)"
   end
   
-  specify "should support conditional filters" do
+  pt_specify "should support conditional filters" do
     @criteria = nil
     proc {if @criteria; :x.like @criteria; end}.sql.should == nil
     
@@ -468,7 +468,7 @@ context "Proc#to_sql" do
     proc {if @criteria; :x.like @criteria; else; :x.like 'ddd'; end}.sql.should == "(x LIKE 'ddd')"
   end
   
-  specify "should support more complex conditional filters" do
+  pt_specify "should support more complex conditional filters" do
     x, y = true, false
     proc {
       if x || y
@@ -502,7 +502,7 @@ context "Proc#to_sql" do
 end
 
 context "Proc#to_sql stock" do
-  specify "should not support regexps" do
+  pt_specify "should not support regexps" do
     db = Sequel::Database.new
     ds = db[:items]
 

data/spec/spec.opts

@@ -1,5 +0,0 @@
---colour
---backtrace
---format
-specdoc
---diff