sequel 4.22.0 → 4.23.0

data/spec/extensions/eager_each_spec.rb

@@ -15,12 +15,12 @@ describe "Sequel::Plugins::EagerEach" do
     ds._fetch = [{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}]
     @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}]
     ds.each{|c| a << c}
-    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
     sqls = @c.db.sqls
-    sqls.shift.should == 'SELECT * FROM items'
+    sqls.shift.must_equal 'SELECT * FROM items'
     ['SELECT * FROM items WHERE (items.parent_id IN (1, 2))', 
-     'SELECT * FROM items WHERE (items.parent_id IN (2, 1))'].should include(sqls.pop)
+     'SELECT * FROM items WHERE (items.parent_id IN (2, 1))'].must_include(sqls.pop)
   end
 
   it "should make #each on an eager_graph dataset do eager loading" do
@@ -29,14 +29,14 @@ describe "Sequel::Plugins::EagerEach" do
     ds._fetch = []
     ds._fetch = [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}]
     ds.each{|c| a << c}
-    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
-    @c.db.sqls.should == ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
   end
 
   it "should not attempt to eager load when getting the columns" do
     ds = @c.eager(:children)
     def ds.all; raise; end
-    proc{ds.columns!}.should_not raise_error
+    ds.columns!
   end
 end

data/spec/extensions/empty_array_ignore_nulls_spec.rb

@@ -5,20 +5,20 @@ describe "filter_having extension" do
     @dataset = Sequel.mock[:test].extension(:empty_array_ignore_nulls)
   end
 
-  specify "should handle all types of IN/NOT IN queries with empty arrays" do
-    @dataset.filter(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 0)"
-    @dataset.filter([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 0)"
-    @dataset.exclude(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
-    @dataset.exclude([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+  it "should handle all types of IN/NOT IN queries with empty arrays" do
+    @dataset.filter(:id => []).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.filter([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.exclude(:id => []).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.exclude([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
   end
 
-  specify "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
+  it "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
     @dataset.meta_def(:supports_multiple_column_in?){false}
     db = Sequel.mock
     d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
-    @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 0)"
-    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
-    @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 1)"
-    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
+    db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    @dataset.exclude([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
+    db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
   end
 end

data/spec/extensions/error_splitter_spec.rb

@@ -11,8 +11,8 @@ describe "Sequel::Plugins::ErrorSplitter" do
   end
 
   it "should split errors for multiple columns and assign them to each column" do
-    @m.valid?.should == false
-    @m.errors.should == {:a=>['is bad'], :b=>['is bad']}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:a=>['is bad'], :b=>['is bad'])
   end
 end
 

data/spec/extensions/error_sql_spec.rb

@@ -5,16 +5,16 @@ describe "error_sql extension" do
     @db = Sequel.mock(:fetch=>proc{|sql| @db.log_yield(sql){raise StandardError}}).extension(:error_sql)
   end
 
-  specify "should have Sequel::DatabaseError#sql give the SQL causing the error" do
+  it "should have Sequel::DatabaseError#sql give the SQL causing the error" do
     @db["SELECT"].all rescue (e = $!)
-    e.sql.should == "SELECT"
+    e.sql.must_equal "SELECT"
   end
 
-  specify "should have Sequel::DatabaseError#sql give the SQL causing the error when using a logger" do
+  it "should have Sequel::DatabaseError#sql give the SQL causing the error when using a logger" do
     l = Object.new
     def l.method_missing(*) end
     @db.loggers = [l]
     @db["SELECT"].all rescue (e = $!)
-    e.sql.should == "SELECT"
+    e.sql.must_equal "SELECT"
   end
 end

data/spec/extensions/eval_inspect_spec.rb

@@ -9,7 +9,7 @@ describe "eval_inspect extension" do
     @ds.meta_def(:literal_blob_append){|sql, s| sql << "X'#{s}'"}
   end
 
-  specify "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do
+  it "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do
     [
       # Objects with components where eval(inspect) == self
       Sequel::SQL::AliasedExpression.new(:b, :a),
@@ -66,8 +66,8 @@ describe "eval_inspect extension" do
       Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_TIMESTAMP, :a),
     ].each do |o|
       v = eval(o.inspect)
-      v.should == o
-      @ds.literal(v).should == @ds.literal(o)
+      v.must_equal o
+      @ds.literal(v).must_equal @ds.literal(o)
     end
   end
 end

data/spec/extensions/filter_having_spec.rb

@@ -7,34 +7,34 @@ describe "filter_having extension" do
   end
 
   it "should make filter operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.filter(:b).sql.should == 'SELECT * FROM t HAVING (a AND b)'
+    @dsh.filter(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND b)'
   end
 
   it "should make filter operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.filter(:b).sql.should == 'SELECT * FROM t WHERE b'
+    @ds.filter(:b).sql.must_equal 'SELECT * FROM t WHERE b'
   end
 
   it "should make and operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.and(:b).sql.should == 'SELECT * FROM t HAVING (a AND b)'
+    @dsh.and(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND b)'
   end
 
   it "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.where(:a).and(:b).sql.should == 'SELECT * FROM t WHERE (a AND b)'
+    @ds.where(:a).and(:b).sql.must_equal 'SELECT * FROM t WHERE (a AND b)'
   end
 
   it "should make or operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.or(:b).sql.should == 'SELECT * FROM t HAVING (a OR b)'
+    @dsh.or(:b).sql.must_equal 'SELECT * FROM t HAVING (a OR b)'
   end
 
   it "should make or operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.where(:a).or(:b).sql.should == 'SELECT * FROM t WHERE (a OR b)'
+    @ds.where(:a).or(:b).sql.must_equal 'SELECT * FROM t WHERE (a OR b)'
   end
 
   it "should make exclude operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.exclude(:b).sql.should == 'SELECT * FROM t HAVING (a AND NOT b)'
+    @dsh.exclude(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND NOT b)'
   end
 
   it "should make exclude operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.exclude(:b).sql.should == 'SELECT * FROM t WHERE NOT b'
+    @ds.exclude(:b).sql.must_equal 'SELECT * FROM t WHERE NOT b'
   end
 end

data/spec/extensions/force_encoding_spec.rb

@@ -9,79 +9,79 @@ describe "force_encoding plugin" do
     @e1 = Encoding.find('UTF-8')
   end
 
-  specify "should force encoding to given encoding on load" do
+  it "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
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal @e1
   end
   
-  specify "should force encoding to given encoding when setting column values" do
+  it "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
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal @e1
   end
   
-  specify "should work correctly when given a frozen string" do
+  it "should work correctly when given a frozen string" do
     s = 'blah'
     s.force_encoding('US-ASCII')
     s.freeze
     o = @c.new(:x=>s)
-    o.x.should == 'blah'
-    o.x.encoding.should == @e1
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal @e1
   end
   
-  specify "should have a forced_encoding class accessor" do
+  it "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')
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal Encoding.find('Windows-1258')
   end
   
-  specify "should not force encoding if forced_encoding is nil" do
+  it "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')
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal Encoding.find('US-ASCII')
   end
   
-  specify "should work correctly when subclassing" do
+  it "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
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal @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')
+    o.x.must_equal ''
+    o.x.encoding.must_equal 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')
+    o.x.must_equal ''
+    o.x.encoding.must_equal 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')
+    o.x.must_equal ''
+    o.x.encoding.must_equal Encoding.find('UTF-16LE')
   end
   
-  specify "should work when saving new model instances" do
+  it "should work when saving new model instances" do
     o = @c.new
     ds = DB[:a]
     def ds.first
@@ -91,11 +91,11 @@ describe "force_encoding plugin" do
     end
     @c.dataset = ds
     o.save
-    o.x.should == 'blah'
-    o.x.encoding.should == @e1
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal @e1
   end
   
-  specify "should work when refreshing model instances" do
+  it "should work when refreshing model instances" do
     o = @c.load(:id=>1, :x=>'as')
     ds = DB[:a]
     def ds.first
@@ -105,8 +105,8 @@ describe "force_encoding plugin" do
     end
     @c.dataset = ds
     o.refresh
-    o.x.should == 'blah'
-    o.x.encoding.should == @e1
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal @e1
   end
 end 
 else

data/spec/extensions/from_block_spec.rb

@@ -6,16 +6,16 @@ describe "from_block extension" do
     @db.extension(:from_block)
   end
 
-  specify "should make Database#from blocks apply to FROM" do
-    @db.from{f}.sql.should == 'SELECT * FROM f'
-    @db.from{[f, g(f)]}.sql.should == 'SELECT * FROM f, g(f)'
+  it "should make Database#from blocks apply to FROM" do
+    @db.from{f}.sql.must_equal 'SELECT * FROM f'
+    @db.from{[f, g(f)]}.sql.must_equal 'SELECT * FROM f, g(f)'
   end
 
-  specify "should handle from blocks with method arguments" do
-    @db.from(:f){g(f)}.sql.should == 'SELECT * FROM f, g(f)'
+  it "should handle from blocks with method arguments" do
+    @db.from(:f){g(f)}.sql.must_equal 'SELECT * FROM f, g(f)'
   end
 
-  specify "should handle from without block" do
-    @db.from(:f).sql.should == 'SELECT * FROM f'
+  it "should handle from without block" do
+    @db.from(:f).sql.must_equal 'SELECT * FROM f'
   end
 end

data/spec/extensions/graph_each_spec.rb

@@ -22,23 +22,23 @@ describe Sequel::Dataset, " graphing" do
   it "#graph_each should handle graph using currently selected columns as the basis for the selected columns in a new graph" do
     ds = @ds1.select(:id).graph(@ds2, :x=>:id)
     ds._fetch = {:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5}
-    ds.all.should == [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+    ds.all.must_equal [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(:id, :x).graph(@ds2, :x=>: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.all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>: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.all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>: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.all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>: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.all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
   end
 
   it "#graph_each should split the result set into component tables" do
@@ -46,9 +46,9 @@ describe Sequel::Dataset, " graphing" do
       [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
       [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
 
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
+    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
   end
 
   it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
@@ -58,8 +58,8 @@ describe Sequel::Dataset, " graphing" do
       {:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11},
       {:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}]]
 
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil},
+    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil},
       {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil},
       {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}},
       {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}]
@@ -67,43 +67,43 @@ describe Sequel::Dataset, " graphing" do
 
   it "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
     @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil}
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
+    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
   end
 
   it "#graph_each should not included tables graphed with the :select => false option in the result set" do
     @db.fetch = {:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12}
-    @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
+    @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
   end
 
   it "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
     @db.fetch = [nil, [{:x=>2,:y=>3}], nil, [{:x=>2}], [{:x=>2, :q=>18}]]
 
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.must_equal [{:points=>{:x=>2}, :lines=>{:y=>3}}]
     ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x])
-    ds.all.should == [{:points=>{:x=>2}, :lines=>nil}]
+    ds.all.must_equal [{:points=>{:x=>2}, :lines=>nil}]
     ds = ds.add_graph_aliases(:q=>[:points, :r, 18])
-    ds.all.should == [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
+    ds.all.must_equal [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
   end
 
   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, Sequel.function(:random)]).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.must_equal [{: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
     @db.fetch = [nil, {:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.must_equal [{:points=>{:x=>2}, :lines=>{:y=>3}}]
   end
 
   it "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
     @db.fetch = [nil, {:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.must_equal [{:points=>{:x=>2}, :lines=>{:y=>3}}]
   end
 
   it "#graph_each should run the row_proc for graphed datasets" do
     @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
     @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
     @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
+    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
   end
 end

data/spec/extensions/hash_aliases_spec.rb

@@ -6,19 +6,19 @@ describe "hash_aliases extension" do
   end
 
   it "should make from treat hash arguments as alias specifiers" do
-    @ds.from(:a=>:b).sql.should == "SELECT * FROM a AS b"
+    @ds.from(:a=>:b).sql.must_equal "SELECT * FROM a AS b"
   end
 
   it "should not affect other arguments to from" do
-    @ds.from(:a, :b).sql.should == "SELECT * FROM a, b"
+    @ds.from(:a, :b).sql.must_equal "SELECT * FROM a, b"
   end
 
   it "should make select treat hash arguments as alias specifiers" do
-    @ds.select(:a=>:b).sql.should == "SELECT a AS b"
-    @ds.select{{:a=>:b}}.sql.should == "SELECT a AS b"
+    @ds.select(:a=>:b).sql.must_equal "SELECT a AS b"
+    @ds.select{{:a=>:b}}.sql.must_equal "SELECT a AS b"
   end
 
   it "should not affect other arguments to select" do
-    @ds.select(:a, :b).sql.should == "SELECT a, b"
+    @ds.select(:a, :b).sql.must_equal "SELECT a, b"
   end
 end