sequel 4.22.0 → 4.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bcc145a56d7aca254c6a4298678e07ea3cbd4f0
-  data.tar.gz: 8c90dbb6ef553ddb4995b70f9ac3d0cf03d4dd76
+  metadata.gz: b30c79c77e61381e85de13c0490b3e5cba437b25
+  data.tar.gz: daf911babab2bc31fb6e255d0a0219a4536f373f
 SHA512:
-  metadata.gz: 5b0214c84c88c09f8c3130a75a1e0f3cacf55584f3f3fc310907cd4e08cfdc39147ea4fca90475917db55ac054bcfc8778ea8df2648b2edff8ca9282f4348c72
-  data.tar.gz: b6efbc0bdd00bd6e5d668960b085e5fd26b6da7fa6592c4621c5f3505d221b1988243af9fbd27ba8075541de6d3a2c24a13c73f36240761416f2c7c7ba10db47
+  metadata.gz: b360c247c80f905380b13ac37ff319339127a09860ddcf13288378be326f8dea51c0e56b9880ae0f488253f32e46bf0752d5b4bf4abe4bd7f9200ddcbe563702
+  data.tar.gz: 15a84132c8caa90c4dad81998a6a060f931cd2bc77145345e5de5cadbf378c545b3e7f8bbab1a0900341be5a6dd1cf0e9121d35bfea5cfeb85f9ac45a6f42bf0

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 4.23.0 (2015-06-01)
+
+* Make dataset.call_sproc(:insert) work in the jdbc adapter (flash-gordon) (#1013)
+
+* Add update_refresh plugin, for refreshing a model instance when updating (jeremyevans)
+
+* Add delay_add_association plugin, for delaying add_* method calls on new objects until after saving the object (jeremyevans)
+
+* Add validate_associated plugin, for validating associated objects when validating the current object (jeremyevans)
+
+* Make Postgres::JSONBOp#[] and #get_text return JSONBOp instances (jeremyevans) (#1005)
+
+* Remove the fdbsql, jdbc/fdbsql, and openbase adapters (jeremyevans)
+
+* Database#transaction now returns block return value if :rollback=>:always is used (jeremyevans)
+
+* Allow postgresql:// connection strings as aliases to postgres://, for compatibility with libpq (jeremyevans) (#1004)
+
+* Make Model#move_to in the list plugin handle out-of-range targets without raising an exception (jeremyevans) (#1003)
+
+* Make Database#add_named_conversion_proc on PostgreSQL handle conversion procs for enum types (celsworth) (#1002)
+
 === 4.22.0 (2015-05-01)
 
 * Deprecate the db2, dbi, fdbsql, firebird, jdbc/fdbsql, informix, and openbase adapters (jeremyevans)

data/README.rdoc

@@ -430,6 +430,12 @@ You can then do anything you like with the dataset:
   # ON order_items.item_id = items.id
   # WHERE order_items.order_id = 1234
   
+Note that the default selection in Sequel is <tt>*</tt>, which includes all columns
+in all joined tables.  Because Sequel returns results as a hash keyed by column name
+symbols, if any tables have columns with the same name, this will clobber the columns
+in the returned hash.  So when joining you are usually going to want to change the
+selection using +select+, +select_all+, and/or +select_append+.
+
 == Column references in Sequel
 
 Sequel expects column names to be specified using symbols. In addition, returned hashes always use symbols as their keys. This allows you to freely mix literal values and column references in many cases. For example, the two following lines produce equivalent SQL:

data/Rakefile

@@ -82,98 +82,76 @@ end
 
 ### Specs
 
-begin
-  begin
-    raise LoadError if ENV['RSPEC1']
-    # RSpec 2
-    require "rspec/core/rake_task"
-    spec_class = RSpec::Core::RakeTask
-    spec_files_meth = :pattern=
-    spec_opts_meth = :rspec_opts=
-  rescue LoadError
-    # RSpec 1
-    require "spec/rake/spectask"
-    spec_class = Spec::Rake::SpecTask
-    spec_files_meth = :spec_files=
-    spec_opts_meth = :spec_opts=
+run_spec = proc do |patterns|
+  lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
+  rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
+  if RUBY_PLATFORM =~ /mingw32/
+    patterns = patterns.split.map{|pat| Dir[pat].to_a}.flatten.join(' ')
   end
+  sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| require f}\" #{patterns}"
+  ENV['RUBYLIB'] = rubylib
+end
 
-  spec = lambda do |name, files, d|
-    lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
-    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
-
-    desc "#{d} with -w, some warnings filtered"
-    task "#{name}_w" do
-      ENV['RUBYOPT'] ? (ENV['RUBYOPT'] += " -w") : (ENV['RUBYOPT'] = '-w')
-      rake = ENV['RAKE'] || "#{FileUtils::RUBY} -S rake"
-      sh "#{rake} #{name} 2>&1 | egrep -v \"(spec/.*: warning: (possibly )?useless use of == in void context|: warning: instance variable @.* not initialized|: warning: method redefined; discarding old|: warning: previous definition of)|rspec\""
-    end
-
-    desc d
-    spec_class.new(name) do |t|
-      t.send spec_files_meth, files
-      t.send spec_opts_meth, ENV['SEQUEL_SPEC_OPTS'].split if ENV['SEQUEL_SPEC_OPTS']
-    end
+spec_task = proc do |description, name, files|
+  desc description
+  task name do
+    run_spec.call(files)
   end
 
-  spec_with_cov = lambda do |name, files, d, &b|
-    spec.call(name, files, d)
-    if RUBY_VERSION < '1.9'
-      t = spec.call("#{name}_cov", files, "#{d} with coverage")
-      t.rcov = true
-      t.rcov_opts = File.file?("spec/rcov.opts") ? File.read("spec/rcov.opts").split("\n") : []
-      b.call(t) if b
-    else
-      desc "#{d} with coverage"
-      task "#{name}_cov" do
-        ENV['COVERAGE'] = '1'
-        Rake::Task[name].invoke
-      end
-    end
-    t
+  desc "#{description} with warnings, some warnings filtered"
+  task :"#{name}_w" do
+    ENV['RUBYOPT'] ? (ENV['RUBYOPT'] += " -w") : (ENV['RUBYOPT'] = '-w')
+    rake = ENV['RAKE'] || "#{FileUtils::RUBY} -S rake"
+    sh "#{rake} #{name} 2>&1 | egrep -v \"(: warning: instance variable @.* not initialized|: warning: method redefined; discarding old|: warning: previous definition of)\""
   end
 
-  desc "Run the core, model, and extension/plugin specs"
-  task :default => [:spec, :spec_plugin]
+  desc "#{description} with coverage"
+  task :"#{name}_cov" do
+    ENV['COVERAGE'] = '1'
+    run_spec.call(files)
+    ENV.delete('COVERAGE')
+  end
+end
 
-  spec_with_cov.call("spec", Dir["spec/{core,model}/*_spec.rb"], "Run core and model specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/(adapters/([a-ln-z]|m[a-np-z])|extensions/core_extensions)"')}
-  spec.call("spec_bin", ["spec/bin_spec.rb"], "Run bin/sequel specs")
-  spec.call("spec_core", Dir["spec/core/*_spec.rb"], "Run core specs")
-  spec.call("spec_model", Dir["spec/model/*_spec.rb"], "Run model specs")
-  spec.call("_spec_model_no_assoc", Dir["spec/model/*_spec.rb"].delete_if{|f| f =~ /association|eager_loading/}, '')
-  spec_with_cov.call("spec_core_ext", ["spec/core_extensions_spec.rb"], "Run core extensions specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|adapters|connection_pool|database|dataset|model)"')}
-  spec_with_cov.call("spec_plugin", Dir["spec/extensions/*_spec.rb"].sort_by{rand}, "Run extension/plugin specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|adapters|connection_pool|database|dataset|model)"')}
-  spec_with_cov.call("spec_integration", Dir["spec/integration/*_test.rb"], "Run integration tests")
+desc "Run the core, model, and extension/plugin specs"
+task :default => :spec
+desc "Run the core, model, and extension/plugin specs"
+task :spec => [:spec_core, :spec_model, :spec_plugin]
+
+spec_task.call("Run core and model specs together", :spec_core_model, './spec/core/*_spec.rb ./spec/model/*_spec.rb')
+spec_task.call("Run core specs", :spec_core, './spec/core/*_spec.rb')
+spec_task.call("Run model specs", :spec_model, './spec/model/*_spec.rb')
+spec_task.call("Run plugin/extension specs", :spec_plugin, './spec/extensions/*_spec.rb')
+spec_task.call("Run bin/sequel specs", :spec_bin, './spec/bin_spec.rb')
+spec_task.call("Run core extensions specs", :spec_core_ext, './spec/core_extensions_spec.rb')
+spec_task.call("Run integration tests", :spec_integration, './spec/integration/*_test.rb')
+
+%w'postgres sqlite mysql informix oracle firebird mssql db2 sqlanywhere'.each do |adapter|
+  spec_task.call("Run #{adapter} tests", :"spec_#{adapter}", "./spec/adapters/#{adapter}_spec.rb ./spec/integration/*_test.rb")
+end
 
-  %w'postgres sqlite mysql informix oracle fdbsql firebird mssql db2 sqlanywhere'.each do |adapter|
-    spec_with_cov.call("spec_#{adapter}", ["spec/adapters/#{adapter}_spec.rb"] + Dir["spec/integration/*_test.rb"], "Run #{adapter} specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|connection_pool|database|dataset|model|extensions|plugins)"')}
-  end
+spec_task.call("Run model specs without the associations code", :_spec_model_no_assoc, Dir["./spec/model/*_spec.rb"].delete_if{|f| f =~ /association|eager_loading/}.join(' '))
+desc "Run model specs without the associations code"
+task :spec_model_no_assoc do
+  ENV['SEQUEL_NO_ASSOCIATIONS'] = '1'
+  Rake::Task['_spec_model_no_assoc'].invoke
+end
 
-  task :spec_travis=>[:spec, :spec_plugin, :spec_core_ext] do
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      ENV['SEQUEL_SQLITE_URL'] = "jdbc:sqlite::memory:"
-      ENV['SEQUEL_POSTGRES_URL'] = "jdbc:postgresql://localhost/sequel_test?user=postgres"
-      ENV['SEQUEL_MYSQL_URL'] = "jdbc:mysql://localhost/sequel_test?user=root"
-    else
-      ENV['SEQUEL_SQLITE_URL'] = "sqlite:/"
-      ENV['SEQUEL_POSTGRES_URL'] = "postgres://localhost/sequel_test?user=postgres"
-      ENV['SEQUEL_MYSQL_URL'] = "mysql2://localhost/sequel_test?user=root"
-    end
-
-    Rake::Task['spec_sqlite'].invoke
-    Rake::Task['spec_postgres'].invoke
-    Rake::Task['spec_mysql'].invoke
+task :spec_travis=>[:spec_core, :spec_model, :spec_plugin, :spec_core_ext] do
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    ENV['SEQUEL_SQLITE_URL'] = "jdbc:sqlite::memory:"
+    ENV['SEQUEL_POSTGRES_URL'] = "jdbc:postgresql://localhost/sequel_test?user=postgres"
+    ENV['SEQUEL_MYSQL_URL'] = "jdbc:mysql://localhost/sequel_test?user=root"
+  else
+    ENV['SEQUEL_SQLITE_URL'] = "sqlite:/"
+    ENV['SEQUEL_POSTGRES_URL'] = "postgres://localhost/sequel_test?user=postgres"
+    ENV['SEQUEL_MYSQL_URL'] = "mysql2://localhost/sequel_test?user=root"
   end
 
-  desc "Run model specs without the associations code"
-  task :spec_model_no_assoc do
-    ENV['SEQUEL_NO_ASSOCIATIONS'] = '1'
-    Rake::Task['_spec_model_no_assoc'].invoke
-  end
-rescue LoadError
-  task :default do
-    puts "Must install rspec to run the default task (which runs specs)"
-  end
+  Rake::Task['spec_sqlite'].invoke
+  Rake::Task['spec_postgres'].invoke
+  Rake::Task['spec_mysql'].invoke
 end
 
 desc "Print Sequel version"

data/doc/migration.rdoc

@@ -72,6 +72,8 @@ reverse the given migration.  The +change+ block can usually correctly reverse
 the following methods:
 
 * +create_table+
+* +create_join_table+
+* +create_view+
 * +add_column+
 * +add_index+
 * +rename_column+

data/doc/release_notes/4.23.0.txt

@@ -0,0 +1,65 @@
+= New Features
+
+* An update_refresh plugin has been added, for refreshing a model
+  instance when updating.  The default behavior is to only refresh
+  when inserting.  However, if you have triggers on the model's table,
+  it's a good idea to refresh when updating to pick up the possibly
+  changed values.  On databases that support UPDATE RETURNING, such as
+  PostgreSQL, the update and refresh are done in a single query.
+
+* A delay_add_association plugin has been added, for delaying add_*
+  method calls for associations until after the receiver has been
+  saved, if the receiver is a new object. Example:
+
+    artist = Artist.new(:name=>'Foo')
+    artist.add_album(Album.new(:name=>'Bar'))
+    # No database queries yet
+
+    artist.save # Saves artist, then album
+
+* A validate_associated plugin has been added, for validating
+  associated objects when validating the current object.  This
+  was extracted from the nested_attributes plugin, and is also
+  used by the delay_add_association plugin.  For example,
+  if you have an albums association and you want to validate all
+  associated objects before saving the current object, you can
+  cal validate_associated_object for each object:
+
+    def validate
+      super
+      reflection = association_reflection(:albums)
+      associations[:albums].each do |obj|
+        validate_associated_object(reflection, obj)
+      end
+    end
+
+= Other Improvements
+
+* Database#transaction now returns the block return value if
+  :rollback=>:always is used.  Previously, it would return nil in
+  that case.
+
+* Postgres::JSONBOp#[] and #get_text now return JSONBOp instances
+  instead of JSONOp instances.
+
+* Model#move_to, #move_up, and #move_down in the list plugin now
+  automatically handle out-of-range targets by defaulting to the first
+  or last position in the list.  Previously, using an out of range
+  target would raise an exception.
+
+* Database#add_named_conversion_proc on PostgreSQL now works for enum
+  types.
+
+* dataset.call_sproc(:insert, ...) now works correctly on JDBC.
+
+* postgresql:// connection strings are now supported, since that is
+  the protocol name supported by libpq.
+
+* Sequel has switched from rspec to minitest/spec for testing, and
+  now uses random test order when testing. During the conversion
+  process, many test order dependency bugs were fixed.
+
+= Backwards Compatibility
+
+* The deprecated fdbsql, jdbc/fdbsql, and openbase adapters have been
+  removed.

data/doc/sharding.rdoc

@@ -56,12 +56,13 @@ the symbol name defined in the connect options. For example:
 Let's say you have 4 slave database servers with names slave_server0,
 slave_server1, slave_server2, and slave_server3.
 
-  DB=Sequel.connect('postgres://master_server/database', \
-    :servers=>{:read_only=>proc{|db| {:host=>db.get_slave_host}}})
-  def DB.get_slave_host
-    @current_host ||= -1
-    "slave_server#{(@current_host+=1)%4}"
+  num_read_only = 4
+  read_only_host = rand(num_read_only)
+  read_only_proc = proc do |db|
+    {:host=>"slave_server#{(read_only_host+=1) % num_read_only}"}
   end
+  DB=Sequel.connect('postgres://master_server/database', \
+    :servers=>{:read_only=>read_only_proc})
 
 This will use one of the slave servers for SELECT queries and use the
 master_server for other queries.  It's also possible to pick a random host
@@ -74,17 +75,18 @@ This involves the same basic idea as the multiple slaves, single master, but
 it shows that the master database is named :default.  So for 4 masters and
 4 slaves:
 
-  DB=Sequel.connect('postgres://master_server/database', \
-    :servers=>{:read_only=>proc{|db| {:host=>db.get_slave_host}}, \
-      :default=>proc{|db| {:host=>db.get_master_host}}})
-  def DB.get_slave_host
-    @current_slave_host ||= -1
-    "slave_server#{(@current_slave_host+=1)%4}"
+  num_read_only = 4
+  read_only_host = rand(num_read_only)
+  read_only_proc = proc do |db|
+    {:host=>"slave_server#{(read_only_host+=1) % num_read_only}"}
   end
-  def DB.get_master_host
-    @current_master_host ||= -1
-    "master_server#{(@current_master_host+=1)%4}"
+  num_default = 4
+  default_host = rand(num_default)
+  default_proc = proc do |db|
+    {:host=>"master_server#{(default_host+=1) % num_default}"}
   end
+  DB=Sequel.connect('postgres://master_server/database', \
+    :servers=>{:default=>default_proc, :read_only=>read_only_proc})
   
 == Sharding
 

data/doc/testing.rdoc

@@ -6,84 +6,39 @@ Whether or not you use Sequel in your application, you are usually going to want
 
 These run each test in its own transaction, the recommended way to test.
 
-=== RSpec 1
+=== minitest/spec
 
-  class Spec::Example::ExampleGroup
-    def execute(*args, &block)
-      result = nil
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){result = super(*args, &block)}
-      result
-    end
-  end
-
-=== RSpec 2, <2.8
-
-  class RSpec::Core::ExampleGroup
-    # Setting an around filter globally doesn't appear to work in <2.8,
-    # so set one up for each subclass.
-    def self.inherited(subclass)
-      super
-      subclass.around do |example|
-        Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){example.call}
-      end
-    end
-  end
-
-=== RSpec >=2.8
-
-  # Global around filters should work
-  RSpec.configure do |c|
-    c.around(:each) do |example|
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
-    end
-  end
-
-=== Test::Unit
+==== with minitest-hooks
 
-  # Must use this class as the base class for your tests
-  class SequelTestCase < Test::Unit::TestCase
-    def run(*args, &block)
-      result = nil
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){result = super}
-      result
+  require 'minitest/hooks/default'
+  class Minitest::HooksSpec
+    def around
+      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
-  # Or you could override the base implementation like this
-  class Test::Unit::TestCase
-    alias_method :_original_run, :run
+==== without minitest-hooks
 
+  class Minitest::Spec
     def run(*args, &block)
-      result = nil
-      Sequel::Model.db.transaction(:rollback => :always, :auto_savepoint=>true) do
-        result = _original_run(*args, &block)
-      end
-      result
+      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
-=== MiniTest::Unit
+=== minitest/test
 
-  # Add a subclass
-  # Must use this class as the base class for your tests
-  class SequelTestCase < MiniTest::Unit::TestCase
+  # Use this class as the base class for your tests
+  class SequelTestCase < Minitest::Test
     def run(*args, &block)
-      result = nil
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){result = super}
-      result
+      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
-  # Or you could override the base implementation like this
-  class MiniTest::Unit::TestCase
-    alias_method :_original_run, :run
+=== rspec >= 2.8
 
-    def run(*args, &block)
-      result = nil
-      Sequel::Model.db.transaction(:rollback => :always, :auto_savepoint=>true) do
-        result = _original_run(*args, &block)
-      end
-      result
+  RSpec.configure do |c|
+    c.around(:each) do |example|
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
     end
   end
 
@@ -97,15 +52,43 @@ Use Sequel.transaction with an array of databases:
 
   Sequel.transaction([DB1, DB2, DB3], :rollback=>:always)
 
+== Transactional testing with savepoints
+
+Using minitest/spec and minitest-hooks, and assuming your database supports it, you can use
+transactions around entire test suites, using savepoints around each test.  This can sigificantly
+speed up any test suite where there is a lot of shared setup in a before all hook.  By using
+savepoints per test, each test is isolated from each other, rolling back changes after it
+completes, and by using transactions per test suite, you only pay the cost to load the data once
+for the test suite, and it is automatically rolled back after the test suite completes.
+
+Example:
+
+  require 'minitest/hooks/default'
+  class Minitest::HooksSpec
+    def around
+      Sequel::Model.db.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
+    end
+
+    def around_all
+      Sequel::Model.db.transaction(:rollback=>:always){super}
+    end
+  end
+
+  describe "some large test suite" do
+    before(:all) do
+      DB[:table].import # Large number of rows
+    end
+  end
+
 == Nontransactional tests
 
 In some cases, it is not possible to use transactions.  For example, if you are testing a web application that is running in a separate process, you don't have access to that process's database connections, so you can't run your examples in transactions.  In that case, the best way to handle things is to cleanup after each test by deleting or truncating the database tables used in the test.
 
 The order in which you delete/truncate the tables is important if you are using referential integrity in your database (which you should be doing).  If you are using referential integrity, you need to make sure to delete in tables referencing other tables before the tables that are being referenced.  For example, if you have an +albums+ table with an +artist_id+ field referencing the +artists+ table, you want to delete/truncate the +albums+ table before the +artists+ table.  Note that if you have cyclic references in your database, you will probably need to write your own custom cleaning code.
 
-=== RSpec
+=== minitest/spec or rspec
 
-  class Spec::Example::ExampleGroup
+  describe "some test suite" do
     after do
       [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
       # or
@@ -113,10 +96,9 @@ The order in which you delete/truncate the tables is important if you are using
     end
   end
 
-=== Test::Unit
+=== minitest/test
 
-  # Must use this class as the base class for your tests
-  class SequelTestCase < Test::Unit::TestCase
+  class SomeTestClass < Minitest::Test
     def teardown
       [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
       # or
@@ -126,15 +108,19 @@ The order in which you delete/truncate the tables is important if you are using
 
 = Testing Sequel Itself
 
-Sequel has multiple separate test suites.  All test suites run under rspec >=1.3.
+Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks and minitest-shared_description extensions.
 
 == rake
 
-The default rake task runs Sequel's core, model, plugin, and extension specs, the same as <tt>rake spec spec_plugin</tt>.
+The default rake task runs Sequel's core, model, plugin, and extension specs, the same as <tt>rake spec</tt> or <tt>rake spec_core spec_model spec_plugin</tt>.
+
+== rake spec_core
+
+The +spec_core+ rake task runs Sequel's core specs.  These specs use a mocked database connection, and test for specific SQL used and for generally correct behavior.
 
-== rake spec
+== rake spec_model
 
-The +spec+ rake task runs Sequel's core and model specs.  These specs use a mocked database connection, and test for specific SQL used and for generally correct behavior.
+The +spec_model+ rake task runs Sequel's model specs.  These specs also use a mocked database connection, and operate similar to the core tests.
 
 == rake spec_plugin
 
@@ -152,13 +138,13 @@ The +spec_bin+ rake task runs the specs for bin/sequel.  These use an SQLite3 da
 
 The <tt>spec_<i>adapter</i></tt> specs run against a real database connection with nothing mocked, and test for correct results.  They are slower than the standard specs, but they will catch errors that are mocked out by the default specs, as well as show issues that only occur on a certain database, adapter, or a combination of the two.
 
-These specs are broken down into two parts.  For each database, there are specific specs that only apply to that database, and these are called the adapter specs.  There are also shared specs that apply to all (or almost all) databases, these are called the integration specs. For database types that don't have specific adapter tests, you can use rake spec_integration to just run the shared integration tests.
+These specs are broken down into two parts.  For each database, there are specific specs that only apply to that database, and these are called the adapter specs.  There are also shared specs that apply to all (or almost all) databases, these are called the integration specs. For database types that don't have specific adapter tests, you can use <tt>rake spec_integration</tt> to just run the shared integration tests.
 
 == Environment variables
 
-Sequel uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying spec/spec_config.rb.example to spec/spec_config.rb and modifying it.  See that file for details.  It may be necessary to use spec_config.rb as opposed to an environment variable if your database connection cannot be specified by a connection string.
+Sequel uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying <tt>spec/spec_config.rb.example</tt> to <tt>spec/spec_config.rb</tt> and modifying it.  See that file for details.  It may be necessary to use +spec_config.rb+ as opposed to an environment variable if your database connection cannot be specified by a connection string.
 
-Sequel does not create test databases automatically, except for file-based databases such as SQLite/H2/HSQLDB/Derby.  It's up to the user to create the test databases manually and give Sequel a valid connection string in an environment variable (or setup the connection object in spec_config.rb).
+Sequel does not create test databases automatically, except for file-based databases such as SQLite/H2/HSQLDB/Derby.  It's up to the user to create the test databases manually and give Sequel a valid connection string in an environment variable (or setup the connection object in +spec_config.rb+).
 
 === Connection Strings
 
@@ -166,12 +152,10 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 === Other
 
-RSPEC1 :: Use RSpec 1 to run the tests even if a newer version is installed
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
-SEQUEL_NO_PENDING :: Don't mark any specs as pending, try running all specs (note, can cause lockups for some adapters)
-SEQUEL_NO_SKIP_PENDING :: On RSpec 3, run specs marked as pending, and fail the pending spec if it passes (note, can cause lockups for some adapters)
+SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SKIPPED_TEST_WARN :: Warn when skipping any tests because libraries aren't available