sequel 4.5.0 → 4.6.0

data/spec/extensions/pagination_spec.rb

@@ -62,20 +62,20 @@ describe "A paginated dataset" do
   end
 
   specify "should know if current page is last page" do
-    @paginated.last_page?.should be_false
-    @d.paginate(2, 20).last_page?.should be_false
-    @d.paginate(5, 30).last_page?.should be_false
-    @d.paginate(6, 30).last_page?.should be_true
+    @paginated.last_page?.should == false
+    @d.paginate(2, 20).last_page?.should == false
+    @d.paginate(5, 30).last_page?.should == false
+    @d.paginate(6, 30).last_page?.should == true
 
     @d.meta_def(:count) {0}
-    @d.paginate(1, 30).last_page?.should be_true
-    @d.paginate(2, 30).last_page?.should be_false
+    @d.paginate(1, 30).last_page?.should == true
+    @d.paginate(2, 30).last_page?.should == false
   end
 
   specify "should know if current page is first page" do
-    @paginated.first_page?.should be_true
-    @d.paginate(1, 20).first_page?.should be_true
-    @d.paginate(2, 20).first_page?.should be_false
+    @paginated.first_page?.should == true
+    @d.paginate(1, 20).first_page?.should == true
+    @d.paginate(2, 20).first_page?.should == false
   end
 
   specify "should work with fixed sql" do

data/spec/extensions/pg_array_associations_spec.rb

@@ -225,8 +225,8 @@ describe Sequel::Model, "pg_array_associations" do
   end
   
   it "reflection remove_before_destroy? should return correct values" do
-    @c1.association_reflection(:tags).remove_before_destroy?.should be_true
-    @c2.association_reflection(:artists).remove_before_destroy?.should be_false
+    @c1.association_reflection(:tags).remove_before_destroy?.should == true
+    @c2.association_reflection(:artists).remove_before_destroy?.should == false
   end
   
   it "reflection reciprocal should be correct" do

data/spec/extensions/pg_array_spec.rb

@@ -327,7 +327,7 @@ describe "pg_array extension" do
     @db.fetch = [{:name=>'id', :db_type=>'banana[]'}]
     @db.schema(:items).map{|e| e[1][:type]}.should == [:banana_array]
     @db.conversion_procs.should have_key(7865)
-    @db.respond_to?(:typecast_value_banana_array, true).should be_true
+    @db.respond_to?(:typecast_value_banana_array, true).should == true
 
     db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
@@ -335,7 +335,7 @@ describe "pg_array extension" do
     db.fetch = [{:name=>'id', :db_type=>'banana[]'}]
     db.schema(:items).map{|e| e[1][:type]}.should == [nil]
     db.conversion_procs.should_not have_key(7865)
-    db.respond_to?(:typecast_value_banana_array, true).should be_false
+    db.respond_to?(:typecast_value_banana_array, true).should == false
   end
 
   it "should automatically look up the array and scalar oids when registering per-Database types" do

data/spec/extensions/pg_hstore_spec.rb

@@ -78,14 +78,14 @@ describe "pg_hstore extension" do
     Sequel.hstore('foo2'=>'bar').fetch(:foo){|key| k = key }.should == 'foo'
     k.should == 'foo'
     
-    Sequel.hstore('foo'=>'bar').has_key?(:foo).should be_true
-    Sequel.hstore('foo'=>'bar').has_key?(:bar).should be_false
-    Sequel.hstore('foo'=>'bar').key?(:foo).should be_true
-    Sequel.hstore('foo'=>'bar').key?(:bar).should be_false
-    Sequel.hstore('foo'=>'bar').member?(:foo).should be_true
-    Sequel.hstore('foo'=>'bar').member?(:bar).should be_false
-    Sequel.hstore('foo'=>'bar').include?(:foo).should be_true
-    Sequel.hstore('foo'=>'bar').include?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').has_key?(:foo).should == true
+    Sequel.hstore('foo'=>'bar').has_key?(:bar).should == false
+    Sequel.hstore('foo'=>'bar').key?(:foo).should == true
+    Sequel.hstore('foo'=>'bar').key?(:bar).should == false
+    Sequel.hstore('foo'=>'bar').member?(:foo).should == true
+    Sequel.hstore('foo'=>'bar').member?(:bar).should == false
+    Sequel.hstore('foo'=>'bar').include?(:foo).should == true
+    Sequel.hstore('foo'=>'bar').include?(:bar).should == false
 
     Sequel.hstore('foo'=>'bar', '1'=>'2').values_at(:foo3, :foo, :foo2, 1).should == [nil, 'bar', nil, '2']
 
@@ -96,16 +96,16 @@ describe "pg_hstore extension" do
   end
 
   it "should convert has_value?/value? lookups to string" do
-    Sequel.hstore('foo'=>'bar').has_value?(:bar).should be_true
-    Sequel.hstore('foo'=>'bar').has_value?(:foo).should be_false
-    Sequel.hstore('foo'=>'bar').value?(:bar).should be_true
-    Sequel.hstore('foo'=>'bar').value?(:foo).should be_false
+    Sequel.hstore('foo'=>'bar').has_value?(:bar).should == true
+    Sequel.hstore('foo'=>'bar').has_value?(:foo).should == false
+    Sequel.hstore('foo'=>'bar').value?(:bar).should == true
+    Sequel.hstore('foo'=>'bar').value?(:foo).should == false
   end
 
   it "should handle nil values in has_value?/value? lookups" do
-    Sequel.hstore('foo'=>'').has_value?('').should be_true
-    Sequel.hstore('foo'=>'').has_value?(nil).should be_false
-    Sequel.hstore('foo'=>nil).has_value?(nil).should be_true
+    Sequel.hstore('foo'=>'').has_value?('').should == true
+    Sequel.hstore('foo'=>'').has_value?(nil).should == false
+    Sequel.hstore('foo'=>nil).has_value?(nil).should == true
   end
 
   it "should have underlying hash convert lookups by key to string" do

data/spec/extensions/pg_interval_spec.rb

@@ -49,18 +49,18 @@ describe "pg_interval extension" do
     d = ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
     @db.typecast_value(:interval, d).object_id.should == d.object_id
 
-    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").is_a?(ActiveSupport::Duration).should be_true
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").is_a?(ActiveSupport::Duration).should == true
     @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").should == d
     @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
     @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07.0").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
 
-    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").is_a?(ActiveSupport::Duration).should be_true
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").is_a?(ActiveSupport::Duration).should == true
     @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").should == d
     @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
     @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7.0 secs").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
 
     d2 = ActiveSupport::Duration.new(1, [[:seconds, 1]])
-    @db.typecast_value(:interval, 1).is_a?(ActiveSupport::Duration).should be_true
+    @db.typecast_value(:interval, 1).is_a?(ActiveSupport::Duration).should == true
     @db.typecast_value(:interval, 1).should == d2
     @db.typecast_value(:interval, 1).parts.sort_by{|k,v| k.to_s}.should == d2.parts.sort_by{|k,v| k.to_s}
 

data/spec/extensions/pg_range_spec.rb

@@ -285,8 +285,8 @@ describe "pg_range extension" do
 
     it "should quack like a range" do
       if RUBY_VERSION >= '1.9'
-        @r1.cover?(1.5).should be_true
-        @r1.cover?(2.5).should be_false
+        @r1.cover?(1.5).should == true
+        @r1.cover?(2.5).should == false
         @r1.first(1).should == [1]
         @r1.last(1).should == [2]
       end
@@ -357,12 +357,12 @@ describe "pg_range extension" do
     end
 
     it "should have #exclude_begin? and #exclude_end indicate whether the beginning or ending of the range is excluded" do
-      @r1.exclude_begin?.should be_false
-      @r1.exclude_end?.should be_false
-      @r2.exclude_begin?.should be_true
-      @r2.exclude_end?.should be_false
-      @r3.exclude_begin?.should be_false
-      @r3.exclude_end?.should be_true
+      @r1.exclude_begin?.should == false
+      @r1.exclude_end?.should == false
+      @r2.exclude_begin?.should == true
+      @r2.exclude_end?.should == false
+      @r3.exclude_begin?.should == false
+      @r3.exclude_end?.should == true
     end
 
     it "should have #to_range raise an exception if the PGRange cannot be represented by a Range" do
@@ -381,24 +381,24 @@ describe "pg_range extension" do
     end
 
     it "should have #unbounded_begin? and #unbounded_end indicate whether the beginning or ending of the range is unbounded" do
-      @r1.unbounded_begin?.should be_false
-      @r1.unbounded_end?.should be_false
-      @r2.unbounded_begin?.should be_false
-      @r2.unbounded_end?.should be_true
-      @r3.unbounded_begin?.should be_true
-      @r3.unbounded_end?.should be_false
+      @r1.unbounded_begin?.should == false
+      @r1.unbounded_end?.should == false
+      @r2.unbounded_begin?.should == false
+      @r2.unbounded_end?.should == true
+      @r3.unbounded_begin?.should == true
+      @r3.unbounded_end?.should == false
     end
 
     it "should have #valid_ruby_range? return true if the PGRange can be represented as a Range" do
-      @r1.valid_ruby_range?.should be_true
-      @R.new(1, 2, :exclude_end=>true).valid_ruby_range?.should be_true
+      @r1.valid_ruby_range?.should == true
+      @R.new(1, 2, :exclude_end=>true).valid_ruby_range?.should == true
     end
 
     it "should have #valid_ruby_range? return false if the PGRange cannot be represented as a Range" do
-      @R.new(nil, 1).valid_ruby_range?.should be_false
-      @R.new(1, nil).valid_ruby_range?.should be_false
-      @R.new(0, 1, :exclude_begin=>true).valid_ruby_range?.should be_false
-      @R.empty.valid_ruby_range?.should be_false
+      @R.new(nil, 1).valid_ruby_range?.should == false
+      @R.new(1, nil).valid_ruby_range?.should == false
+      @R.new(0, 1, :exclude_begin=>true).valid_ruby_range?.should == false
+      @R.empty.valid_ruby_range?.should == false
     end
   end
 end

data/spec/extensions/pg_row_spec.rb

@@ -272,7 +272,7 @@ describe "pg_row extension" do
     @db.conversion_procs[4] = proc{|s| called = true; s}
     @db.register_row_type(:foo)
     @db.conversion_procs[1].call('()').should == {:bar=>nil}
-    called.should be_false
+    called.should == false
   end
 
   it "should registering array type for row type if type has an array oid" do

data/spec/extensions/schema_caching_spec.rb

@@ -12,9 +12,9 @@ describe "schema_caching extension" do
   end
 
   it "Database#dump_schema_cache should dump cached schema to the given file" do
-    File.exist?(@filename).should be_false
+    File.exist?(@filename).should == false
     @db.dump_schema_cache(@filename)
-    File.exist?(@filename).should be_true
+    File.exist?(@filename).should == true
     File.size(@filename).should > 0
   end
 
@@ -34,7 +34,7 @@ describe "schema_caching extension" do
 
   it "Database#load_schema_cache? should load cached schema from the given file if it exists" do
     db = Sequel::Database.new.extension(:schema_caching)
-    File.exist?(@filename).should be_false
+    File.exist?(@filename).should == false
     db.load_schema_cache?(@filename)
     db.instance_variable_get(:@schemas).should == {}
   end

data/spec/extensions/spec_helper.rb

@@ -37,7 +37,9 @@ def skip_warn(s)
   warn "Skipping test of #{s}" if ENV["SKIPPED_TEST_WARN"]
 end
 
-(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
+require File.join(File.dirname(File.expand_path(__FILE__)), "../rspec_helper.rb")
+
+RSPEC_EXAMPLE_GROUP.class_eval do
   if ENV['SEQUEL_DEPRECATION_WARNINGS']
     class << self
       alias qspecify specify

data/spec/extensions/static_cache_spec.rb

@@ -78,7 +78,7 @@ describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
     end
 
     it "should have map without a block not return a frozen object" do
-      @c.map.frozen?.should be_false
+      @c.map.frozen?.should == false
     end
 
     it "should have map with a block and argument raise" do
@@ -100,7 +100,7 @@ describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
     end
 
     it "should have all not return a frozen object" do
-      @c.all.frozen?.should be_false
+      @c.all.frozen?.should == false
     end
 
     it "should have all return things in dataset order" do
@@ -135,7 +135,7 @@ describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
     end
 
     it "should have to_hash not return a frozen object" do
-      @c.to_hash.frozen?.should be_false
+      @c.to_hash.frozen?.should == false
     end
 
     it "should have to_hash_groups without arguments return the cached objects without a query" do
@@ -201,7 +201,7 @@ describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
     end
 
     it "all of the static cache values (model instances) should be frozen" do
-      @c.all.all?{|o| o.frozen?}.should be_true
+      @c.all.all?{|o| o.frozen?}.should == true
     end
 
     it "should make .[] method with primary key return cached instances" do
@@ -286,47 +286,47 @@ describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
     it_should_behave_like "Sequel::Plugins::StaticCache"
 
     it "record retrieved by primary key should not be frozen" do
-      @c[1].frozen?.should be_false
-      @c.cache_get_pk(1).frozen?.should be_false
+      @c[1].frozen?.should == false
+      @c.cache_get_pk(1).frozen?.should == false
     end
 
     it "none of values returned in #all should be frozen" do
-      @c.all.all?{|o| !o.frozen?}.should be_true
+      @c.all.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values yielded by each should be frozen" do
       a = []
       @c.each{|o| a << o}
-      a.all?{|o| !o.frozen?}.should be_true
+      a.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values yielded by Enumerable method should be frozen" do
-      @c.sort_by{|o| o.id}.all?{|o| !o.frozen?}.should be_true
+      @c.sort_by{|o| o.id}.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values returned by map without an argument or block should be frozen" do
-      @c.map{|o| o}.all?{|o| !o.frozen?}.should be_true
-      @c.map.all?{|o| !o.frozen?}.should be_true
+      @c.map{|o| o}.all?{|o| !o.frozen?}.should == true
+      @c.map.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values in the hash returned by to_hash without an argument should be frozen" do
-      @c.to_hash.values.all?{|o| !o.frozen?}.should be_true
+      @c.to_hash.values.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values in the hash returned by to_hash with a single argument should be frozen" do
-      @c.to_hash(:id).values.all?{|o| !o.frozen?}.should be_true
+      @c.to_hash(:id).values.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values in the hash returned by to_hash with a single array argument should be frozen" do
-      @c.to_hash([:id, :id]).values.all?{|o| !o.frozen?}.should be_true
+      @c.to_hash([:id, :id]).values.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values in the hash returned by to_hash_groups with a single argument should be frozen" do
-      @c.to_hash_groups(:id).values.flatten.all?{|o| !o.frozen?}.should be_true
+      @c.to_hash_groups(:id).values.flatten.all?{|o| !o.frozen?}.should == true
     end
 
     it "none of values in the hash returned by to_hash_groups with a single array argument should be frozen" do
-      @c.to_hash_groups([:id, :id]).values.flatten.all?{|o| !o.frozen?}.should be_true
+      @c.to_hash_groups([:id, :id]).values.flatten.all?{|o| !o.frozen?}.should == true
     end
 
     it "should not automatically update the cache when creating new model objects" do

data/spec/extensions/tree_spec.rb

@@ -89,12 +89,12 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have root? return true for a root node and false for a child node" do
-    @c.load(:parent_id => nil).root?.should be_true
-    @c.load(:parent_id => 1).root?.should be_false
+    @c.load(:parent_id => nil).root?.should == true
+    @c.load(:parent_id => 1).root?.should == false
   end
 
   it "should have root? return false for an new node" do
-    @c.new.root?.should be_false
+    @c.new.root?.should == false
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
@@ -207,14 +207,14 @@ describe Sequel::Model, "tree plugin with composite keys" do
   end
 
   it "should have root? return true for a root node and false for a child node" do
-    @c.load(:parent_id => nil, :parent_id2=>nil).root?.should be_true
-    @c.load(:parent_id => 1, :parent_id2=>nil).root?.should be_true
-    @c.load(:parent_id => nil, :parent_id2=>2).root?.should be_true
-    @c.load(:parent_id => 1, :parent_id2=>2).root?.should be_false
+    @c.load(:parent_id => nil, :parent_id2=>nil).root?.should == true
+    @c.load(:parent_id => 1, :parent_id2=>nil).root?.should == true
+    @c.load(:parent_id => nil, :parent_id2=>2).root?.should == true
+    @c.load(:parent_id => 1, :parent_id2=>2).root?.should == false
   end
 
   it "should have root? return false for an new node" do
-    @c.new.root?.should be_false
+    @c.new.root?.should == false
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do

data/spec/extensions/validation_class_methods_spec.rb

@@ -142,9 +142,9 @@ describe Sequel::Model do
   specify "should have the validates block have appropriate respond_to?" do
     c = nil
     @c.validates{c = respond_to?(:foo)}
-    c.should be_false
+    c.should == false
     @c.validates{c = respond_to?(:length_of)}
-    c.should be_true
+    c.should == true
   end if RUBY_VERSION >= '1.9'
 end
 
@@ -616,7 +616,7 @@ describe "Superclass validations" do
     o.errors.full_messages.should == ['value is too short', 'value is invalid']
 
     o.value = 'abcde'
-    o.valid?.should be_true
+    o.valid?.should == true
   end
   
   specify "should have skip_superclass_validations? return whether superclass validations were skipped" do
@@ -630,14 +630,14 @@ describe "Superclass validations" do
 
     o = @c2.new
     o.value = 'ab'
-    o.valid?.should be_true
+    o.valid?.should == true
 
     o.value = '12'
     o.valid?.should == false
     o.errors.full_messages.should == ['value is invalid']
 
     o.value = 'abcde'
-    o.valid?.should be_true
+    o.valid?.should == true
   end
 end
 
@@ -733,9 +733,9 @@ describe Sequel::Model, "Validations" do
     end
 
     @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.should be_false
+    @person.valid?.should == false
     @person = Person.new :first_name => "Anita"
-    @person.valid?.should be_true
+    @person.valid?.should == true
   end
   
   it "should validate length of column" do
@@ -943,10 +943,10 @@ describe Sequel::Model, "Validations" do
     Person.validations[:first_name].size.should == 2
     
     @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.should be_false
+    @person.valid?.should == false
     
     @person2 = Person.new :first_name => "Wayne"
-    @person2.valid?.should be_true
+    @person2.valid?.should == true
   end
 
   it "should allow 'longhand' validations direcly within the model." do
@@ -1008,7 +1008,7 @@ describe "Model#save" do
     
     @m.x = 7
     @m.should be_valid
-    @m.save.should_not be_false
+    @m.save.should_not == false
     DB.sqls.should == ['UPDATE people SET x = 7 WHERE (id = 4)']
   end
   

data/spec/integration/database_test.rb

@@ -78,7 +78,7 @@ describe Sequel::Database do
       @db << "SELECT"
     rescue Sequel::DatabaseError=>e
       if defined?(Java::JavaLang::Exception)
-        (e.wrapped_exception.is_a?(Exception) || e.wrapped_exception.is_a?(Java::JavaLang::Exception)).should be_true
+        (e.wrapped_exception.is_a?(Exception) || e.wrapped_exception.is_a?(Java::JavaLang::Exception)).should == true
       else
         e.wrapped_exception.should be_a_kind_of(Exception)
       end
@@ -98,8 +98,8 @@ describe Sequel::Database do
 
   cspecify "should provide ability to check connections for validity", [:do, :postgres] do
     conn = @db.synchronize{|c| c}
-    @db.valid_connection?(conn).should be_true
+    @db.valid_connection?(conn).should == true
     @db.disconnect
-    @db.valid_connection?(conn).should be_false
+    @db.valid_connection?(conn).should == false
   end
 end