database_cleaner 1.8.5 → 2.0.2

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/transaction.rb

@@ -1,59 +0,0 @@
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/generic/transaction'
-
-module DatabaseCleaner::ActiveRecord
-  class Transaction
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::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
-      end
-    end
-
-
-    def clean
-      connection_class.connection_pool.connections.each do |connection|
-        next unless connection.open_transactions > 0
-
-        if connection.respond_to?(:rollback_transaction)
-          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
-
-    def connection_maintains_transaction_count?
-      ActiveRecord::VERSION::MAJOR < 4
-    end
-
-  end
-end

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/truncation.rb

@@ -1,280 +0,0 @@
-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 mysql_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
-        ::ActiveRecord::VERSION::MAJOR >= 5 ? data_sources : tables
-      end
-
-      def truncate_table(table_name)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(tables)
-        tables.each do |table_name|
-          self.truncate_table(table_name)
-        end
-      end
-    end
-
-    module AbstractMysqlAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
-
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      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))
-      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
-      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
-
-      # 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 has_rows?(table)
-        row_count(table) > 0
-      end
-    end
-
-    module IBM_DBAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
-      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}';")
-        end
-      end
-      alias truncate_table delete_table
-
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      end
-
-      private
-
-      # 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
-
-    module TruncateOrDelete
-      def truncate_table(table_name)
-        begin
-          execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-        rescue ::ActiveRecord::StatementInvalid
-          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)}")
-      end
-    end
-
-    module PostgreSQLAdapter
-      def db_version
-        @db_version ||= postgresql_version
-      end
-
-      def cascade
-        @cascade ||= db_version >=  80200 ? 'CASCADE' : ''
-      end
-
-      def restart_identity
-        @restart_identity ||= db_version >=  80400 ? 'RESTART IDENTITY' : ''
-      end
-
-      def truncate_table(table_name)
-        truncate_tables([table_name])
-      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
-
-      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))
-      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
-
-      private
-
-      # 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 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
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    #Apply adapter decoraters where applicable (adapter should be loaded)
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractAdapter }
-
-    if defined?(JdbcAdapter)
-      if defined?(OracleJdbcConnection)
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter }
-      else
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete }
-      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
-
-    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))
-        end
-      end
-    end
-
-    private
-
-    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
-        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 cache_tables?
-      !!@cache_tables
-    end
-
-    def pre_count?
-      @pre_count == true
-    end
-
-    def reset_ids?
-      @reset_ids != false
-    end
-  end
-end

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record/version.rb

@@ -1,5 +0,0 @@
-module DatabaseCleaner
-  module ActiveRecord
-    VERSION = "1.8.0"
-  end
-end

data/adapters/database_cleaner-active_record/lib/database_cleaner/active_record.rb

@@ -1,6 +0,0 @@
-require 'database_cleaner/active_record/version'
-require 'database_cleaner'
-require 'database_cleaner/active_record/deletion'
-require 'database_cleaner/active_record/transaction'
-require 'database_cleaner/active_record/truncation'
-

data/adapters/database_cleaner-active_record/lib/database_cleaner-active_record.rb

@@ -1 +0,0 @@
-require "database_cleaner/active_record"

data/adapters/database_cleaner-couch_potato/lib/database_cleaner/couch_potato/base.rb

@@ -1,7 +0,0 @@
-module DatabaseCleaner
-  module CouchPotato
-    def self.available_strategies
-      %w[truncation]
-    end
-  end
-end

data/adapters/database_cleaner-couch_potato/lib/database_cleaner/couch_potato/truncation.rb

@@ -1,28 +0,0 @@
-require 'database_cleaner/generic/truncation'
-
-module DatabaseCleaner
-  module CouchPotato
-    class Truncation
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def initialize(options = {})
-        if options.has_key?(:only) || options.has_key?(:except)
-          raise ArgumentError, "The :only and :except options are not available for use with CouchPotato/CouchDB."
-        elsif !options.empty?
-          raise ArgumentError, "Unsupported option. You specified #{options.keys.join(',')}."
-        end
-        super
-      end
-
-      def clean
-        database.recreate!
-      end
-
-      private
-
-      def database
-        ::CouchPotato.couchrest_database
-      end
-    end
-  end
-end

data/adapters/database_cleaner-couch_potato/lib/database_cleaner/couch_potato/version.rb

@@ -1,5 +0,0 @@
-module DatabaseCleaner
-  module CouchPotato
-    VERSION = "1.8.0"
-  end
-end

data/adapters/database_cleaner-couch_potato/lib/database_cleaner/couch_potato.rb

@@ -1,11 +0,0 @@
-require "database_cleaner/couch_potato/version"
-require "database_cleaner"
-require "database_cleaner/couch_potato/base"
-require "database_cleaner/couch_potato/truncation"
-
-module DatabaseCleaner::CouchPotato
-  def self.default_strategy
-    :truncation
-  end
-end
-

data/adapters/database_cleaner-couch_potato/lib/database_cleaner-couch_potato.rb

@@ -1 +0,0 @@
-require "database_cleaner/couch_potato"

data/adapters/database_cleaner-data_mapper/lib/database_cleaner/data_mapper/base.rb

@@ -1,25 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module DataMapper
-    def self.available_strategies
-      %w[truncation transaction]
-    end
-
-    def self.default_strategy
-      :transaction
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db ||= :default
-      end
-
-    end
-  end
-end

data/adapters/database_cleaner-data_mapper/lib/database_cleaner/data_mapper/transaction.rb

@@ -1,28 +0,0 @@
-require 'database_cleaner/data_mapper/base'
-require 'database_cleaner/generic/transaction'
-
-module DatabaseCleaner::DataMapper
-  class Transaction
-    include ::DatabaseCleaner::DataMapper::Base
-    include ::DatabaseCleaner::Generic::Transaction
-
-    def start(repository = self.db)
-      ::DataMapper.repository(repository) do |r|
-        transaction = DataMapper::Transaction.new(r)
-        transaction.begin
-        r.adapter.push_transaction(transaction)
-      end
-    end
-
-    def clean(repository = self.db)
-      ::DataMapper.repository(repository) do |r|
-        adapter = r.adapter
-        while adapter.current_transaction
-          adapter.current_transaction.rollback
-          adapter.pop_transaction
-        end
-      end
-    end
-
-  end
-end

data/adapters/database_cleaner-data_mapper/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,173 +0,0 @@
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/data_mapper/base'
-require 'data_mapper'
-
-module DataMapper
-  module Adapters
-
-    class DataObjectsAdapter
-
-      def storage_names(repository = :default)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(table_names)
-        table_names.each do |table_name|
-          truncate_table table_name
-        end
-      end
-
-    end
-
-    class MysqlAdapter < DataObjectsAdapter
-
-      # taken from https://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        select 'SHOW TABLES'
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)};")
-      end
-
-      # copied from activerecord
-      def disable_referential_integrity
-        old = select("SELECT @@FOREIGN_KEY_CHECKS;")
-        begin
-          execute("SET FOREIGN_KEY_CHECKS = 0;")
-          yield
-        ensure
-          execute("SET FOREIGN_KEY_CHECKS = ?", *old)
-        end
-      end
-
-    end
-
-    module SqliteAdapterMethods
-
-      # taken from https://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 177
-        sql = <<-SQL
-          SELECT name
-          FROM sqlite_master
-          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-        SQL
-        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("DELETE FROM #{quote_name(table_name)};")
-        if uses_sequence?
-          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
-        end
-      end
-
-      # this is a no-op copied from activerecord
-      # i didn't find out if/how this is possible
-      # activerecord also doesn't do more here
-      def disable_referential_integrity
-        yield
-      end
-
-      private
-
-      # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
-      def uses_sequence?
-        sql = <<-SQL
-          SELECT name FROM sqlite_master
-          WHERE type='table' AND name='sqlite_sequence'
-        SQL
-        select(sql).first
-      end
-    end
-
-    class SqliteAdapter; include SqliteAdapterMethods; end
-    class Sqlite3Adapter; include SqliteAdapterMethods; end
-
-    # FIXME
-    # i don't know if this works
-    # i basically just copied activerecord code to get a rough idea what they do.
-    # i don't have postgres available, so i won't be the one to write this.
-    # maybe codes below gets some postgres/datamapper user going, though.
-    class PostgresAdapter < DataObjectsAdapter
-
-      # taken from https://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        sql = <<-SQL
-          SELECT table_name FROM "information_schema"."tables"
-          WHERE table_schema = current_schema() and table_type = 'BASE TABLE'
-        SQL
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)} RESTART IDENTITY CASCADE;")
-      end
-
-      # override to use a single statement
-      def truncate_tables(table_names)
-        quoted_names = table_names.collect { |n| quote_name(n) }.join(', ')
-        execute("TRUNCATE TABLE #{quoted_names} RESTART IDENTITY;")
-      end
-
-      # FIXME
-      # copied from activerecord
-      def supports_disable_referential_integrity?
-        version = select("SHOW server_version")[0][0].split('.')
-        (version[0].to_i >= 8 && version[1].to_i >= 1) ? true : false
-      rescue
-        return false
-      end
-
-      # FIXME
-      # copied unchanged from activerecord
-      def disable_referential_integrity(repository = :default)
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} DISABLE TRIGGER ALL"
-          end.join(";"))
-        end
-        yield
-      ensure
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} ENABLE TRIGGER ALL"
-          end.join(";"))
-        end
-      end
-
-    end
-
-  end
-end
-
-
-module DatabaseCleaner
-  module DataMapper
-    class Truncation
-      include ::DatabaseCleaner::DataMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean(repository = self.db)
-        adapter = ::DataMapper.repository(repository).adapter
-        adapter.disable_referential_integrity do
-          adapter.truncate_tables(tables_to_truncate(repository))
-        end
-      end
-
-      private
-
-      def tables_to_truncate(repository = self.db)
-        (@only || ::DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
-      end
-
-      # overwritten
-      def migration_storage_names
-        %w[migration_info]
-      end
-
-    end
-  end
-end

data/adapters/database_cleaner-data_mapper/lib/database_cleaner/data_mapper/version.rb

@@ -1,5 +0,0 @@
-module DatabaseCleaner
-  module DataMapper
-    VERSION = "1.8.0"
-  end
-end

data/adapters/database_cleaner-data_mapper/lib/database_cleaner/data_mapper.rb

@@ -1,4 +0,0 @@
-require "database_cleaner/data_mapper/version"
-require "database_cleaner"
-require "database_cleaner/data_mapper/transaction"
-require "database_cleaner/data_mapper/truncation"

data/adapters/database_cleaner-data_mapper/lib/database_cleaner-data_mapper.rb

@@ -1 +0,0 @@
-require "database_cleaner/data_mapper"

data/adapters/database_cleaner-mongo/lib/database_cleaner/mongo/base.rb

@@ -1,16 +0,0 @@
-module DatabaseCleaner
-  module Mongo
-    def self.available_strategies
-      %w[truncation]
-    end
-    module Base
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db || raise("You have not specified a database.  (see Mongo::Database)")
-      end
-    end
-  end
-end