database_cleaner 1.7.0 → 2.0.1

data/lib/database_cleaner/base.rb

@@ -1,166 +0,0 @@
-require 'database_cleaner/null_strategy'
-require 'database_cleaner/safeguard'
-module DatabaseCleaner
-  class Base
-    include Comparable
-
-    def <=>(other)
-      (self.orm <=> other.orm) == 0 ? self.db <=> other.db : self.orm <=> other.orm
-    end
-
-    def initialize(desired_orm = nil,opts = {})
-      if [:autodetect, nil, "autodetect"].include?(desired_orm)
-        autodetect
-      else
-        self.orm = desired_orm
-      end
-      self.db = opts[:connection] || opts[:model] if opts.has_key?(:connection) || opts.has_key?(:model)
-      set_default_orm_strategy
-      Safeguard.new.run
-    end
-
-    def db=(desired_db)
-       self.strategy_db = desired_db
-       @db = desired_db
-    end
-
-    def strategy_db=(desired_db)
-      if strategy.respond_to? :db=
-        strategy.db = desired_db
-      elsif desired_db!= :default
-        raise ArgumentError, "You must provide a strategy object that supports non default databases when you specify a database"
-      end
-    end
-
-    def db
-      @db ||= :default
-    end
-
-    def create_strategy(*args)
-      strategy, *strategy_args = args
-      orm_strategy(strategy).new(*strategy_args)
-    end
-
-    def clean_with(*args)
-      strategy = create_strategy(*args)
-      set_strategy_db strategy, self.db
-
-      strategy.clean
-      strategy
-    end
-
-    alias clean_with! clean_with
-
-    def set_strategy_db(strategy, desired_db)
-      if strategy.respond_to? :db=
-        strategy.db = desired_db
-      elsif desired_db != :default
-        raise ArgumentError, "You must provide a strategy object that supports non default databases when you specify a database"
-      end
-    end
-
-    def strategy=(args)
-      strategy, *strategy_args = args
-       if strategy.is_a?(Symbol)
-          @strategy = create_strategy(*args)
-       elsif strategy_args.empty?
-         @strategy = strategy
-       else
-         raise ArgumentError, "You must provide a strategy object, or a symbol for a known strategy along with initialization params."
-       end
-
-       set_strategy_db @strategy, self.db
-
-       @strategy
-    end
-
-    def strategy
-      @strategy ||= NullStrategy
-    end
-
-    def orm=(desired_orm)
-      @orm = desired_orm.to_sym
-    end
-
-    def orm
-      @orm || autodetect
-    end
-
-    def start
-      strategy.start
-    end
-
-    def clean
-      strategy.clean
-    end
-
-    alias clean! clean
-
-    def cleaning(&block)
-      strategy.cleaning(&block)
-    end
-
-    def auto_detected?
-      !!@autodetected
-    end
-
-    def autodetect_orm
-      if defined? ::ActiveRecord
-        :active_record
-      elsif defined? ::DataMapper
-        :data_mapper
-      elsif defined? ::MongoMapper
-        :mongo_mapper
-      elsif defined? ::Mongoid
-        :mongoid
-      elsif defined? ::CouchPotato
-        :couch_potato
-      elsif defined? ::Sequel
-        :sequel
-      elsif defined? ::Moped
-        :moped
-      elsif defined? ::Ohm
-        :ohm
-      elsif defined? ::Redis
-        :redis
-      elsif defined? ::Neo4j
-        :neo4j
-      end
-    end
-
-    private
-
-    def orm_module
-      ::DatabaseCleaner.orm_module(orm)
-    end
-
-    def orm_strategy(strategy)
-      require "database_cleaner/#{orm.to_s}/#{strategy.to_s}"
-      orm_module.const_get(strategy.to_s.capitalize)
-    rescue LoadError
-      if orm_module.respond_to? :available_strategies
-        raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{orm_module.available_strategies.join(', ')}"
-      else
-        raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!"
-      end
-    end
-
-    def autodetect
-      @autodetected = true
-
-      @orm ||= autodetect_orm ||
-               raise(NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, Sequel, MongoMapper, Mongoid, Moped, or CouchPotato, Redis or Ohm loaded?")
-    end
-
-    def set_default_orm_strategy
-      case orm
-      when :active_record, :data_mapper, :sequel
-        self.strategy = :transaction
-      when :mongo_mapper, :mongoid, :couch_potato, :moped, :ohm, :redis
-        self.strategy = :truncation
-      when :neo4j
-        self.strategy = :transaction
-      end
-    end
-  end
-end

data/lib/database_cleaner/configuration.rb

@@ -1,131 +0,0 @@
-require 'database_cleaner/base'
-
-module DatabaseCleaner
-
-  class NoORMDetected < StandardError;   end
-  class UnknownStrategySpecified < ArgumentError;   end
-
-  class << self
-    def init_cleaners
-      @cleaners ||= {}
-      # ghetto ordered hash.. maintains 1.8 compat and old API
-      @connections ||= []
-    end
-
-    def [](orm,opts = {})
-      raise NoORMDetected unless orm
-      init_cleaners
-      # TODO: deprecate
-      # this method conflates creation with lookup.  Both a command and a query. Yuck.
-      if @cleaners.has_key? [orm, opts]
-        @cleaners[[orm, opts]]
-      else
-        add_cleaner(orm, opts)
-      end
-    end
-
-    def add_cleaner(orm,opts = {})
-      init_cleaners
-      cleaner = DatabaseCleaner::Base.new(orm,opts)
-      @cleaners[[orm, opts]] = cleaner
-      @connections << cleaner
-      cleaner
-    end
-
-    def app_root=(desired_root)
-      @app_root = desired_root
-    end
-
-    def app_root
-      @app_root ||= Dir.pwd
-    end
-
-    def connections
-      # double yuck.. can't wait to deprecate this whole class...
-      unless defined?(@cleaners) && @cleaners
-        autodetected = ::DatabaseCleaner::Base.new
-        add_cleaner(autodetected.orm)
-      end
-      @connections
-    end
-
-    def logger=(log_source)
-      @logger = log_source
-    end
-
-    def logger
-      return @logger if @logger
-
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::ERROR
-      @logger
-    end
-
-    def strategy=(stratagem)
-      connections.each { |connect| connect.strategy = stratagem }
-      remove_duplicates
-    end
-
-    def orm=(orm)
-      connections.each { |connect| connect.orm = orm }
-      remove_duplicates
-    end
-
-    def start
-      connections.each { |connection| connection.start }
-    end
-
-    def clean
-      connections.each { |connection| connection.clean }
-    end
-
-    alias clean! clean
-
-    def cleaning(&inner_block)
-      connections.inject(inner_block) do |curr_block, connection|
-        proc { connection.cleaning(&curr_block) }
-      end.call
-    end
-
-    def clean_with(*args)
-      connections.each { |connection| connection.clean_with(*args) }
-    end
-
-    alias clean_with! clean_with
-
-    def remove_duplicates
-      temp = []
-      connections.each do |connect|
-        temp.push connect unless temp.include? connect
-      end
-      @connections = temp
-    end
-
-    def orm_module(symbol)
-      case symbol
-        when :active_record
-          DatabaseCleaner::ActiveRecord
-        when :data_mapper
-          DatabaseCleaner::DataMapper
-        when :mongo
-          DatabaseCleaner::Mongo
-        when :mongoid
-          DatabaseCleaner::Mongoid
-        when :mongo_mapper
-          DatabaseCleaner::MongoMapper
-        when :moped
-          DatabaseCleaner::Moped
-        when :couch_potato
-          DatabaseCleaner::CouchPotato
-        when :sequel
-          DatabaseCleaner::Sequel
-        when :ohm
-          DatabaseCleaner::Ohm
-        when :redis
-          DatabaseCleaner::Redis
-        when :neo4j
-          DatabaseCleaner::Neo4j
-      end
-    end
-  end
-end

data/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/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/lib/database_cleaner/cucumber.rb

@@ -1,3 +0,0 @@
-Around do |scenario, block|
-  DatabaseCleaner.cleaning(&block)
-end

data/lib/database_cleaner/data_mapper/base.rb

@@ -1,21 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module DataMapper
-    def self.available_strategies
-      %w[truncation 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/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/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,172 +0,0 @@
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/data_mapper/base'
-
-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 http://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 http://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 http://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