database_cleaner-active_record 2.0.0.beta → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 476fea7e84362519c14f1413c9af334688b3634f1b93eb337b35e52ca0c6aaea
-  data.tar.gz: e9022df4c0c38d5cb422c2f2daca8b5427c6a95ea452c0cddc46367fecfcc616
+  metadata.gz: 53199df54296cd17b30bf241e2ca431323b7bef7c4361240f63a682be6d02ee9
+  data.tar.gz: 668c5fbe4726841ff27034bcf81de0f98c6ba9494aa2a0cb3fcbade1bfb63d74
 SHA512:
-  metadata.gz: c27d71a958fedeb6391c3218a92bdaed05049f0feafe6402ca2dce691b6d159504f147053ce322f64d05f08216d882d040ea97fce14e39721ee4710da52f4175
-  data.tar.gz: 32e627ff45a35adc27bcbcc08af228f497fcec093ff869c73f3c5ff4febcafa8b216a200b86ff7ece3b2a36882e2d9fe896b83a69aa58deca6239bc19b3118b2
+  metadata.gz: 253bced62511194095bef9671ed30602be05d2c417ba39e79dd7b2df7b58f5f602551ccd53c91ad451746bfb9e6086e107818d089c0b37256e4035098bb10fdf
+  data.tar.gz: 5a4b22a83f03b8064b77e966c277ae9ebc98ff9ca44c0bb229df817a6b21fc0853b454f7307ae195e4184281f0f6e4d2bfc207b2845fe95e358488c90de70f92

data/.travis.yml

@@ -3,7 +3,6 @@ services:
   - mysql
   - postgresql
 rvm:
-  - 2.4
   - 2.5
   - 2.6
   - 2.7
@@ -11,11 +10,7 @@ gemfile:
   - gemfiles/rails_5.1.gemfile
   - gemfiles/rails_5.2.gemfile
   - gemfiles/rails_6.0.gemfile
-jobs:
-  exclude:
-  - rvm: 2.4
-    gemfile: gemfiles/rails_6.0.gemfile
 before_install:
-  - gem install bundler -v 1.17.2
   - bin/setup
-
+cache:
+  bundler: true

data/Gemfile

@@ -1,12 +1,13 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in database_cleaner-active_record.gemspec
 gemspec
 
-gem "byebug"
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
 
 gem "rails", "~>5.2"
+gem "byebug"
 
-gem "database_cleaner-core", branch: "master", github: "DatabaseCleaner/database_cleaner"
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end

data/README.md

@@ -2,11 +2,14 @@
 
 [![Build Status](https://travis-ci.org/DatabaseCleaner/database_cleaner-active_record.svg?branch=master)](https://travis-ci.org/DatabaseCleaner/database_cleaner-active_record)
 [![Code Climate](https://codeclimate.com/github/DatabaseCleaner/database_cleaner-active_record/badges/gpa.svg)](https://codeclimate.com/github/DatabaseCleaner/database_cleaner-active_record)
+[![codecov](https://codecov.io/gh/DatabaseCleaner/database_cleaner-active_record/branch/master/graph/badge.svg)](https://codecov.io/gh/DatabaseCleaner/database_cleaner-active_record)
 
 Clean your ActiveRecord databases with Database Cleaner.
 
 See https://github.com/DatabaseCleaner/database_cleaner for more information.
 
+For support or to discuss development please use the [Google Group](https://groups.google.com/group/database_cleaner).
+
 ## Installation
 
 ```ruby
@@ -18,26 +21,11 @@ end
 
 ## Supported Strategies
 
-Here is an overview of the supported strategies:
-
-<table>
-  <tbody>
-    <tr>
-      <th>Truncation</th>
-      <th>Transaction</th>
-      <th>Deletion</th>
-    </tr>
-    <tr>
-      <td> Yes</td>
-      <td> <b>Yes</b></td>
-      <td> Yes</td>
-    </tr>
-  </tbody>
-</table>
-
-(Default strategy is denoted in bold)
+Three strategies are supported:
 
-For support or to discuss development please use the [Google Group](https://groups.google.com/group/database_cleaner).
+* Transaction (default)
+* Truncation
+* Deletion
 
 ## What strategy is fastest?
 
@@ -53,36 +41,41 @@ So what is fastest out of `:deletion` and `:truncation`? Well, it depends on you
 
 Some people report much faster speeds with `:deletion` while others say `:truncation` is faster for them. The best approach therefore is it try all options on your test suite and see what is faster.
 
-If you are using ActiveRecord then take a look at the [additional options](#additional-activerecord-options-for-truncation) available for `:truncation`.
+## Strategy configuration options
 
-## Configuration options
+The transaction strategy accepts no options.
 
-<table>
-  <tbody>
-    <tr>
-      <th>ORM</th>
-      <th>How to access</th>
-      <th>Notes</th>
-    </tr>
-    <tr>
-      <td> Active Record </td>
-      <td> <code>DatabaseCleaner[:active_record]</code></td>
-      <td> Connection specified as <code>:symbol</code> keys, loaded from <code>config/database.yml</code>. You may also pass in the ActiveRecord model under the <code>:model</code> key.</td>
-    </tr>
-  </tbody>
-</table>
+The truncation and deletion strategies may accept the following options:
 
-### Additional ActiveRecord options for Truncation
+* `:only` and `:except` may take a list of table names:
 
-The following options are available for ActiveRecord's `:truncation` strategy _only_ for MySQL and Postgres.
+```ruby
+# Only truncate the "users" table.
+DatabaseCleaner[:active_record].strategy = :truncation, { only: ["users"] }
 
-* `:pre_count` - When set to `true` this will check each table for existing rows before truncating it.  This can speed up test suites when many of the tables to be truncated are never populated. Defaults to `:false`. (Also, see the section on [What strategy is fastest?](#what-strategy-is-fastest))
-* `:reset_ids` - This only matters when `:pre_count` is used, and it will make sure that a tables auto-incrementing id is reset even if there are no rows in the table (e.g. records were created in the test but also removed before DatabaseCleaner gets to it). Defaults to `true`.
+# Delete all tables except the "users" table.
+DatabaseCleaner[:active_record].strategy = :deletion, { except: ["users"] }
+```
 
-The following option is available for ActiveRecord's `:truncation` and `:deletion` strategy for any DB.
+* `:pre_count` - When set to `true` this will check each table for existing rows before truncating or deleting it.  This can speed up test suites when many of the tables are never populated. Defaults to `false`. (Also, see the section on [What strategy is fastest?](#what-strategy-is-fastest))
 
 * `:cache_tables` - When set to `true` the list of tables to truncate or delete from will only be read from the DB once, otherwise it will be read before each cleanup run. Set this to `false` if (1) you create and drop tables in your tests, or (2) you change Postgres schemas (`ActiveRecord::Base.connection.schema_search_path`) in your tests (for example, in a multitenancy setup with each tenant in a different Postgres schema). Defaults to `true`.
 
+## Adapter configuration options
+
+`#db` defaults to the default ActiveRecord database, but can be specified manually in a few ways:
+
+```ruby
+# ActiveRecord connection key
+DatabaseCleaner[:active_record].db = :logs
+
+# Back to default:
+DatabaseCleaner[:active_record].db = :default
+
+# Multiple databases can be specified:
+DatabaseCleaner[:active_record, connection: :default]
+DatabaseCleaner[:active_record, connection: :logs]
+```
 
 ## Common Errors
 
@@ -92,11 +85,11 @@ If you are using Postgres and have foreign key constraints, the truncation strat
 
 To silence these warnings set the following log level in your `postgresql.conf` file:
 
-```ruby
+```
 client_min_messages = warning
 ```
 
-For ActiveRecord, you add the following parameter in your database.yml file:
+You can also add this parameter to your database.yml file:
 
 <pre>
 test:

data/database_cleaner-active_record.gemspec

@@ -1,7 +1,4 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "database_cleaner/active_record/version"
+require_relative "./lib/database_cleaner/active_record/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "database_cleaner-active_record"
@@ -21,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "database_cleaner-core", "2.0.0.beta"
+  spec.add_dependency "database_cleaner-core", "~>2.0.0.beta2"
   spec.add_dependency "activerecord"
 
   spec.add_development_dependency "bundler"

data/gemfiles/rails_5.1.gemfile

@@ -2,8 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "byebug"
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
 gem "rails", "~>5.1.0"
-gem "database_cleaner-core", branch: "master", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
 
 gemspec path: "../"

data/gemfiles/rails_5.2.gemfile

@@ -2,8 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "byebug"
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
 gem "rails", "~>5.2.0"
-gem "database_cleaner-core", branch: "master", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
 
 gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -2,8 +2,13 @@
 
 source "https://rubygems.org"
 
-gem "byebug"
+gem "database_cleaner-core", git: "https://github.com/DatabaseCleaner/database_cleaner"
 gem "rails", "~>6.0.0"
-gem "database_cleaner-core", branch: "master", git: "https://github.com/DatabaseCleaner/database_cleaner"
+gem "byebug"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end
 
 gemspec path: "../"

data/lib/database_cleaner/active_record.rb

@@ -1,7 +1,7 @@
 require 'database_cleaner/active_record/version'
 require 'database_cleaner/core'
-require 'database_cleaner/active_record/deletion'
 require 'database_cleaner/active_record/transaction'
 require 'database_cleaner/active_record/truncation'
+require 'database_cleaner/active_record/deletion'
 
 DatabaseCleaner[:active_record].strategy = :transaction

data/lib/database_cleaner/active_record/base.rb

@@ -1,18 +1,10 @@
 require 'active_record'
-require 'database_cleaner/generic/base'
+require 'database_cleaner/strategy'
 require 'erb'
 require 'yaml'
 
 module DatabaseCleaner
   module ActiveRecord
-    def self.available_strategies
-      %w[truncation transaction deletion]
-    end
-
-    def self.default_strategy
-      :transaction
-    end
-
     def self.config_file_location=(path)
       @config_file_location = path
     end
@@ -21,64 +13,53 @@ module DatabaseCleaner
       @config_file_location ||= "#{Dir.pwd}/config/database.yml"
     end
 
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      attr_accessor :connection_hash
-
-      def db=(desired_db)
-        @db = desired_db
-        load_config
+    class Base < DatabaseCleaner::Strategy
+      def self.migration_table_name
+        ::ActiveRecord::SchemaMigration.table_name
       end
 
-      def db
-        @db ||= super
+      def self.exclusion_condition(column_name)
+        <<~SQL
+          #{column_name} <> '#{DatabaseCleaner::ActiveRecord::Base.migration_table_name}'
+            AND #{column_name} <> '#{::ActiveRecord::Base.internal_metadata_table_name}'
+        SQL
       end
 
-      def load_config
-        if self.db != :default && self.db.is_a?(Symbol) && File.file?(ActiveRecord.config_file_location)
-          connection_details = YAML::load(ERB.new(IO.read(ActiveRecord.config_file_location)).result)
-          @connection_hash   = valid_config(connection_details)[self.db.to_s]
-        end
+      def db=(*)
+        super
+        load_config
       end
 
-      def valid_config(connection_file)
-        if !::ActiveRecord::Base.configurations.nil? && !::ActiveRecord::Base.configurations.empty?
-          if connection_file != ::ActiveRecord::Base.configurations
-            return ::ActiveRecord::Base.configurations
-          end
-        end
-        connection_file
-      end
+      attr_accessor :connection_hash
 
       def connection_class
         @connection_class ||= if db && !db.is_a?(Symbol)
                                 db
                               elsif connection_hash
-                                lookup_from_connection_pool || establish_connection
+                                (lookup_from_connection_pool rescue nil) || establish_connection
                               else
                                 ::ActiveRecord::Base
                               end
       end
 
-      def self.migration_table_name
-        if ::ActiveRecord::VERSION::MAJOR < 5
-          ::ActiveRecord::Migrator.schema_migrations_table_name
-        else
-          ::ActiveRecord::SchemaMigration.table_name
+      private
+
+      def load_config
+        if self.db != :default && self.db.is_a?(Symbol) && File.file?(DatabaseCleaner::ActiveRecord.config_file_location)
+          connection_details = YAML::load(ERB.new(IO.read(DatabaseCleaner::ActiveRecord.config_file_location)).result)
+          @connection_hash   = valid_config(connection_details)[self.db.to_s]
         end
       end
 
-      def self.exclusion_condition(column_name)
-        result = " #{column_name} <> '#{::DatabaseCleaner::ActiveRecord::Base.migration_table_name}' "
-        if ::ActiveRecord::VERSION::MAJOR >= 5
-          result += " AND #{column_name} <> '#{::ActiveRecord::Base.internal_metadata_table_name}' "
+      def valid_config(connection_file)
+        if !::ActiveRecord::Base.configurations.nil? && !::ActiveRecord::Base.configurations.empty?
+          if connection_file != ::ActiveRecord::Base.configurations
+            return ::ActiveRecord::Base.configurations
+          end
         end
-        result
+        connection_file
       end
 
-      private
-
       def lookup_from_connection_pool
         if ::ActiveRecord::Base.respond_to?(:descendants)
           database_name = connection_hash["database"] || connection_hash[:database]

data/lib/database_cleaner/active_record/deletion.rb

@@ -1,107 +1,70 @@
 require 'active_record'
-require 'active_record/connection_adapters/abstract_adapter'
-require "database_cleaner/generic/truncation"
 require 'database_cleaner/active_record/truncation'
 
 module DatabaseCleaner
-  module ConnectionAdapters
-    module AbstractDeleteAdapter
-      def delete_table(table_name)
-        raise NotImplementedError
+  module ActiveRecord
+    class Deletion < Truncation
+      def clean
+        connection.disable_referential_integrity do
+          if pre_count? && connection.respond_to?(:pre_count_tables)
+            delete_tables(connection, connection.pre_count_tables(tables_to_truncate(connection)))
+          else
+            delete_tables(connection, tables_to_truncate(connection))
+          end
+        end
       end
-    end
 
-    module GenericDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
+      private
 
-    module OracleDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
+      def delete_tables(connection, table_names)
+        table_names.each do |table_name|
+          delete_table(connection, table_name)
+        end
       end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractDeleteAdapter }
-
-    JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(JdbcAdapter)
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(Mysql2Adapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleDeleteAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
 
-module DatabaseCleaner::ActiveRecord
-  module SelectiveTruncation
-    def tables_to_truncate(connection)
-      if information_schema_exists?(connection)
-        (@only || tables_with_new_rows(connection)) - @tables_to_exclude
-      else
-        super
+      def delete_table connection, table_name
+        connection.execute("DELETE FROM #{connection.quote_table_name(table_name)}")
       end
-    end
 
-    def tables_with_new_rows(connection)
-      stats = table_stats_query(connection)
-      if stats != ''
-        connection.select_values(stats)
-      else
-        []
+      def tables_to_truncate(connection)
+        if information_schema_exists?(connection)
+          @except += connection.database_cleaner_view_cache + migration_storage_names
+          (@only.any? ? @only : tables_with_new_rows(connection)) - @except
+        else
+          super
+        end
       end
-    end
 
-    def table_stats_query(connection)
-      @table_stats_query ||= build_table_stats_query(connection)
-    ensure
-      @table_stats_query = nil unless @cache_tables
-    end
+      def tables_with_new_rows(connection)
+        stats = table_stats_query(connection)
+        if stats != ''
+          connection.select_values(stats)
+        else
+          []
+        end
+      end
 
-    def build_table_stats_query(connection)
-      tables = connection.select_values(<<-SQL)
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = database()
-        AND #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('table_name')};
-      SQL
-      queries = tables.map do |table|
-        "(SELECT #{connection.quote(table)} FROM #{connection.quote_table_name(table)} LIMIT 1)"
+      def table_stats_query(connection)
+        @table_stats_query ||= build_table_stats_query(connection)
+      ensure
+        @table_stats_query = nil unless @cache_tables
       end
-      queries.join(' UNION ALL ')
-    end
 
-    def information_schema_exists? connection
-      return false unless connection.is_a? ActiveRecord::ConnectionAdapters::Mysql2Adapter
-      @information_schema_exists ||=
-        begin
-          connection.execute("SELECT 1 FROM information_schema.tables")
-          true
-        rescue
-          false
+      def build_table_stats_query(connection)
+        tables = connection.select_values(<<-SQL)
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = database()
+          AND #{self.class.exclusion_condition('table_name')};
+        SQL
+        queries = tables.map do |table|
+          "(SELECT #{connection.quote(table)} FROM #{connection.quote_table_name(table)} LIMIT 1)"
         end
-    end
-  end
-
-  class Deletion < Truncation
-    if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-      include SelectiveTruncation
-    end
+        queries.join(' UNION ALL ')
+      end
 
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        tables_to_truncate(connection).each do |table_name|
-          connection.delete_table table_name
-        end
+      def information_schema_exists? connection
+        connection.adapter_name == "Mysql2"
       end
     end
   end

data/lib/database_cleaner/active_record/transaction.rb

@@ -1,60 +1,22 @@
 require 'database_cleaner/active_record/base'
-require 'database_cleaner/generic/transaction'
 
-module DatabaseCleaner::ActiveRecord
-  class Transaction
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Transaction
+module DatabaseCleaner
+  module ActiveRecord
+    class Transaction < Base
+      def start
+        # Hack to make sure that the connection is properly set up before cleaning
+        connection_class.connection.transaction {}
 
-    def start
-      # Hack to make sure that the connection is properly setup for
-      # the clean code.
-      connection_class.connection.transaction{ }
-
-      if connection_maintains_transaction_count?
-        if connection_class.connection.respond_to?(:increment_open_transactions)
-          connection_class.connection.increment_open_transactions
-        else
-          connection_class.__send__(:increment_open_transactions)
-        end
-      end
-      if connection_class.connection.respond_to?(:begin_transaction)
-        connection_class.connection.begin_transaction :joinable => false
-      else
-        connection_class.connection.begin_db_transaction
+        connection_class.connection.begin_transaction joinable: false
       end
-    end
-
 
-    def clean
-      connection_class.connection_pool.connections.each do |connection|
-        next unless connection.open_transactions > 0
 
-        if connection.respond_to?(:rollback_transaction)
+      def clean
+        connection_class.connection_pool.connections.each do |connection|
+          next unless connection.open_transactions > 0
           connection.rollback_transaction
-        else
-          connection.rollback_db_transaction
-        end
-
-        # The below is for handling after_commit hooks.. see https://github.com/bmabey/database_cleaner/issues/99
-        if connection.respond_to?(:rollback_transaction_records, true)
-          connection.send(:rollback_transaction_records, true)
-        end
-
-        if connection_maintains_transaction_count?
-          if connection.respond_to?(:decrement_open_transactions)
-            connection.decrement_open_transactions
-          else
-            connection_class.__send__(:decrement_open_transactions)
-          end
         end
       end
     end
-
-    private
-
-    def connection_maintains_transaction_count?
-      ActiveRecord::VERSION::MAJOR < 4
-    end
   end
 end

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,284 +1,249 @@
+require "delegate"
 require 'active_record/base'
 require 'database_cleaner/active_record/base'
-require 'active_record/connection_adapters/abstract_adapter'
-
-#Load available connection adapters
-%w(
-  abstract_mysql_adapter postgresql_adapter sqlite3_adapter mysql2_adapter oracle_enhanced_adapter
-).each do |known_adapter|
-  begin
-    require "active_record/connection_adapters/#{known_adapter}"
-  rescue LoadError
-  end
-end
-
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/active_record/base'
 
 module DatabaseCleaner
-  module ConnectionAdapters
-
-    module AbstractAdapter
-      # used to be called views but that can clash with gems like schema_plus
-      # this gem is not meant to be exposing such an extra interface any way
-      def database_cleaner_view_cache
-        @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
-      end
-
-      def database_cleaner_table_cache
-        # the adapters don't do caching (#130) but we make the assumption that the list stays the same in tests
-        @database_cleaner_tables ||= database_tables
-      end
-
-      def database_tables
-        tables
-      end
-
-      def truncate_table(table_name)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(tables)
-        tables.each do |table_name|
-          self.truncate_table(table_name)
+  module ActiveRecord
+    class Truncation < Base
+      def initialize(opts={})
+        if !opts.empty? && !(opts.keys - [:only, :except, :pre_count, :cache_tables]).empty?
+          raise ArgumentError, "The only valid options are :only, :except, :pre_count, and :cache_tables. You specified #{opts.keys.join(',')}."
         end
-      end
-    end
 
-    module AbstractMysqlAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
+        @only = Array(opts[:only]).dup
+        @except = Array(opts[:except]).dup
 
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
+        @pre_count = opts[:pre_count]
+        @cache_tables = opts.has_key?(:cache_tables) ? !!opts[:cache_tables] : true
       end
 
-      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
-        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
-        truncate_tables(tables.select(&filter))
+      def clean
+        connection.disable_referential_integrity do
+          if pre_count? && connection.respond_to?(:pre_count_truncate_tables)
+            connection.pre_count_truncate_tables(tables_to_truncate(connection))
+          else
+            connection.truncate_tables(tables_to_truncate(connection))
+          end
+        end
       end
 
       private
 
-      def row_count(table)
-        # Patch for MysqlAdapter with ActiveRecord 3.2.7 later
-        # select_value("SELECT 1") #=> "1"
-        select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)").to_i
+      def connection
+        @connection ||= ConnectionWrapper.new(connection_class.connection)
       end
 
-      def auto_increment_value(table)
-        select_value(<<-SQL).to_i
-          SELECT auto_increment
-          FROM information_schema.tables
-          WHERE table_name = '#{table}'
-          AND table_schema = database()
-        SQL
+      def tables_to_truncate(connection)
+        if @only.none?
+          all_tables = cache_tables? ? connection.database_cleaner_table_cache : connection.database_tables
+          @only = all_tables.map { |table| table.split(".").last }
+        end
+        @except += connection.database_cleaner_view_cache + migration_storage_names
+        @only - @except
       end
 
-      # This method tells us if the given table has been inserted into since its
-      # last truncation. Note that the table might have been populated, which
-      # increased the auto-increment counter, but then cleaned again such that
-      # it appears empty now.
-      def has_been_used?(table)
-        has_rows?(table) || auto_increment_value(table) > 1
+      def migration_storage_names
+        [
+          DatabaseCleaner::ActiveRecord::Base.migration_table_name,
+          ::ActiveRecord::Base.internal_metadata_table_name,
+        ]
       end
 
-      def has_rows?(table)
-        row_count(table) > 0
+      def cache_tables?
+        !!@cache_tables
       end
-    end
 
-    module IBM_DBAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
+      def pre_count?
+        @pre_count == true
       end
     end
 
-    module SQLiteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-        if uses_sequence
-          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+    class ConnectionWrapper < SimpleDelegator
+      def initialize(connection)
+        extend AbstractAdapter
+        case connection.adapter_name
+        when "Mysql2"
+          extend AbstractMysqlAdapter
+        when "SQLite"
+          extend AbstractMysqlAdapter
+          extend SQLiteAdapter
+        when "PostgreSQL"
+          extend AbstractMysqlAdapter
+          extend PostgreSQLAdapter
         end
+        super(connection)
       end
-      alias truncate_table delete_table
 
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      end
+      module AbstractAdapter
+        # used to be called views but that can clash with gems like schema_plus
+        # this gem is not meant to be exposing such an extra interface any way
+        def database_cleaner_view_cache
+          @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
+        end
 
-      private
+        def database_cleaner_table_cache
+          # the adapters don't do caching (#130) but we make the assumption that the list stays the same in tests
+          @database_cleaner_tables ||= database_tables
+        end
 
-      # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
-      def uses_sequence
-        select_value("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';")
-      end
-    end
+        def database_tables
+          tables
+        end
 
-    module TruncateOrDelete
-      def truncate_table(table_name)
-        begin
-          execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+        def truncate_table(table_name)
+          execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
         rescue ::ActiveRecord::StatementInvalid
-          execute("DELETE FROM #{quote_table_name(table_name)};")
+          execute("DELETE FROM #{quote_table_name(table_name)}")
         end
-      end
-    end
 
-    module OracleAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
+        def truncate_tables(tables)
+          tables.each { |t| truncate_table(t) }
+        end
       end
-    end
 
-    module PostgreSQLAdapter
-      def db_version
-        @db_version ||= postgresql_version
-      end
+      module AbstractMysqlAdapter
+        def pre_count_truncate_tables(tables)
+          truncate_tables(pre_count_tables(tables))
+        end
 
-      def cascade
-        @cascade ||= db_version >=  80200 ? 'CASCADE' : ''
-      end
+        def pre_count_tables(tables)
+          tables.select { |table| has_been_used?(table) }
+        end
 
-      def restart_identity
-        @restart_identity ||= db_version >=  80400 ? 'RESTART IDENTITY' : ''
-      end
+        private
 
-      def database_tables
-        tables_with_schema
-      end
+        def row_count(table)
+          select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)")
+        end
 
-      def truncate_table(table_name)
-        truncate_tables([table_name])
-      end
+        def auto_increment_value(table)
+          select_value(<<-SQL).to_i
+            SELECT auto_increment
+            FROM information_schema.tables
+            WHERE table_name = '#{table}'
+            AND table_schema = database()
+          SQL
+        end
 
-      def truncate_tables(table_names)
-        return if table_names.nil? || table_names.empty?
-        execute("TRUNCATE TABLE #{table_names.map{|name| quote_table_name(name)}.join(', ')} #{restart_identity} #{cascade};")
-      end
+        # This method tells us if the given table has been inserted into since its
+        # last truncation. Note that the table might have been populated, which
+        # increased the auto-increment counter, but then cleaned again such that
+        # it appears empty now.
+        def has_been_used?(table)
+          has_rows?(table) || auto_increment_value(table) > 1
+        end
 
-      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
-        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
-        truncate_tables(tables.select(&filter))
+        def has_rows?(table)
+          row_count(table) > 0
+        end
       end
 
-      def database_cleaner_table_cache
-        # AR returns a list of tables without schema but then returns a
-        # migrations table with the schema. There are other problems, too,
-        # with using the base list. If a table exists in multiple schemas
-        # within the search path, truncation without the schema name could
-        # result in confusing, if not unexpected results.
-        @database_cleaner_tables ||= tables_with_schema
-      end
+      module SQLiteAdapter
+        def truncate_table(table_name)
+          super
+          if uses_sequence?
+            execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
+          end
+        end
 
-      private
+        def truncate_tables(tables)
+          tables.each { |t| truncate_table(t) }
+        end
 
-      # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
-      # Note, this is different than an empty table since an table may populated, the index increased,
-      # but then the table is cleaned.  In other words, this function tells us if the given table
-      # was ever inserted into.
-      def has_been_used?(table)
-        return has_rows?(table) unless has_sequence?(table)
+        def pre_count_truncate_tables(tables)
+          truncate_tables(pre_count_tables(tables))
+        end
 
-        cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
-        cur_val > 0
-      end
+        def pre_count_tables(tables)
+          sequences = fetch_sequences
+          tables.select { |table| has_been_used?(table, sequences) }
+        end
 
-      def has_sequence?(table)
-        select_value("SELECT true FROM pg_class WHERE relname = '#{table}_id_seq';")
-      end
+        private
 
-      def has_rows?(table)
-        select_value("SELECT true FROM #{table} LIMIT 1;")
-      end
+        def fetch_sequences
+          return {} unless uses_sequence?
+          results = select_all("SELECT * FROM sqlite_sequence")
+          Hash[results.rows]
+        end
 
-      def tables_with_schema
-        rows = select_rows <<-_SQL
-          SELECT schemaname || '.' || tablename
-          FROM pg_tables
-          WHERE
-            tablename !~ '_prt_' AND
-            #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('tablename')} AND
-            schemaname = ANY (current_schemas(false))
-        _SQL
-        rows.collect { |result| result.first }
-      end
-    end
-  end
-end
+        def has_been_used?(table, sequences)
+          count = sequences.fetch(table) { row_count(table) }
+          count > 0
+        end
 
-module ActiveRecord
-  module ConnectionAdapters
-    #Apply adapter decoraters where applicable (adapter should be loaded)
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractAdapter }
+        def row_count(table)
+          select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)")
+        end
 
-    if defined?(JdbcAdapter)
-      if defined?(OracleJdbcConnection)
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter }
-      else
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete }
+        # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
+        def uses_sequence?
+          select_value("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';")
+        end
       end
-    end
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(Mysql2Adapter)
-    MysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(MysqlAdapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::PostgreSQLAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::IBM_DBAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
 
-module DatabaseCleaner::ActiveRecord
-  class Truncation
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Truncation
+      module PostgreSQLAdapter
+        def database_tables
+          tables_with_schema
+        end
 
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        if pre_count? && connection.respond_to?(:pre_count_truncate_tables)
-          connection.pre_count_truncate_tables(tables_to_truncate(connection), {:reset_ids => reset_ids?})
-        else
-          connection.truncate_tables(tables_to_truncate(connection))
+        def truncate_tables(table_names)
+          return if table_names.nil? || table_names.empty?
+          execute("TRUNCATE TABLE #{table_names.map{|name| quote_table_name(name)}.join(', ')} RESTART IDENTITY CASCADE;")
         end
-      end
-    end
 
-    private
+        def pre_count_truncate_tables(tables)
+          truncate_tables(pre_count_tables(tables))
+        end
 
-    def tables_to_truncate(connection)
-      tables_in_db = cache_tables? ? connection.database_cleaner_table_cache : connection.database_tables
-      to_reject = (@tables_to_exclude + connection.database_cleaner_view_cache)
-      (@only || tables_in_db).reject do |table|
-        if ( m = table.match(/([^.]+)$/) )
-          to_reject.include?(m[1])
-        else
-          false
+        def pre_count_tables(tables)
+          tables.select { |table| has_been_used?(table) }
         end
-      end
-    end
 
-    # overwritten
-    def migration_storage_names
-      result = [::DatabaseCleaner::ActiveRecord::Base.migration_table_name]
-      result << ::ActiveRecord::Base.internal_metadata_table_name if ::ActiveRecord::VERSION::MAJOR >= 5
-      result
-    end
+        def database_cleaner_table_cache
+          # AR returns a list of tables without schema but then returns a
+          # migrations table with the schema. There are other problems, too,
+          # with using the base list. If a table exists in multiple schemas
+          # within the search path, truncation without the schema name could
+          # result in confusing, if not unexpected results.
+          @database_cleaner_tables ||= tables_with_schema
+        end
 
-    def cache_tables?
-      !!@cache_tables
-    end
+        private
 
-    def pre_count?
-      @pre_count == true
-    end
+        # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
+        # Note, this is different than an empty table since an table may populated, the index increased,
+        # but then the table is cleaned.  In other words, this function tells us if the given table
+        # was ever inserted into.
+        def has_been_used?(table)
+          return has_rows?(table) unless has_sequence?(table)
+
+          cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
+          cur_val > 0
+        end
+
+        def has_sequence?(table)
+          select_value("SELECT true FROM pg_class WHERE relname = '#{table}_id_seq';")
+        end
 
-    def reset_ids?
-      @reset_ids != false
+        def has_rows?(table)
+          select_value("SELECT true FROM #{table} LIMIT 1;")
+        end
+
+        def tables_with_schema
+          rows = select_rows <<-_SQL
+            SELECT schemaname || '.' || tablename
+            FROM pg_tables
+            WHERE
+              tablename !~ '_prt_' AND
+              #{DatabaseCleaner::ActiveRecord::Base.exclusion_condition('tablename')} AND
+              schemaname = ANY (current_schemas(false))
+          _SQL
+          rows.collect { |result| result.first }
+        end
+      end
     end
+    private_constant :ConnectionWrapper
   end
 end
+

data/lib/database_cleaner/active_record/version.rb

@@ -1,5 +1,5 @@
 module DatabaseCleaner
   module ActiveRecord
-    VERSION = "2.0.0.beta"
+    VERSION = "2.0.0.beta2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: database_cleaner-active_record
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Ernesto Tagwerker
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-05 00:00:00.000000000 Z
+date: 2020-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: database_cleaner-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.beta
+        version: 2.0.0.beta2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.beta
+        version: 2.0.0.beta2
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement