database_cleaner 1.7.0 → 1.8.5

data/lib/database_cleaner/base.rb

@@ -1,166 +1,153 @@
+require 'database_cleaner/deprecation'
 require 'database_cleaner/null_strategy'
 require 'database_cleaner/safeguard'
+require 'database_cleaner/orm_autodetector'
+require 'forwardable'
+
 module DatabaseCleaner
   class Base
     include Comparable
 
     def <=>(other)
-      (self.orm <=> other.orm) == 0 ? self.db <=> other.db : self.orm <=> other.orm
+      [orm, db] <=> [other.orm, other.db]
     end
 
-    def initialize(desired_orm = nil,opts = {})
-      if [:autodetect, nil, "autodetect"].include?(desired_orm)
-        autodetect
-      else
-        self.orm = desired_orm
-      end
+    def initialize(desired_orm = nil, opts = {})
+      @orm_autodetector = ORMAutodetector.new
+      self.orm = desired_orm
       self.db = opts[:connection] || opts[:model] if opts.has_key?(:connection) || opts.has_key?(:model)
-      set_default_orm_strategy
+      self.strategy = orm_module && orm_module.default_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
+      @db = self.strategy_db = desired_db
     end
 
     def db
       @db ||= :default
     end
 
-    def create_strategy(*args)
+    def strategy=(args)
       strategy, *strategy_args = args
-      orm_strategy(strategy).new(*strategy_args)
-    end
+      @strategy = if strategy.is_a?(Symbol)
+        create_strategy(*args)
+      elsif strategy_args.empty?
+        strategy
+      else
+        raise ArgumentError, "You must provide a strategy object, or a symbol for a known strategy along with initialization params."
+      end
 
-    def clean_with(*args)
-      strategy = create_strategy(*args)
-      set_strategy_db strategy, self.db
+      set_strategy_db @strategy, db
+    end
 
-      strategy.clean
-      strategy
+    def strategy
+      @strategy ||= NullStrategy.new
     end
 
-    alias clean_with! clean_with
+    attr_reader :orm
 
-    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
+    def orm=(desired_orm)
+      @orm = (desired_orm || :autodetect).to_sym
+      @orm = @orm_autodetector.orm if @orm == :autodetect
     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
+    extend Forwardable
+    delegate [:start, :clean, :cleaning] => :strategy
 
-       set_strategy_db @strategy, self.db
-
-       @strategy
+    def clean_with(*args)
+      strategy = create_strategy(*args)
+      set_strategy_db strategy, db
+      strategy.clean
+      strategy
     end
 
-    def strategy
-      @strategy ||= NullStrategy
-    end
+    # TODO remove the following methods in 2.0
 
-    def orm=(desired_orm)
-      @orm = desired_orm.to_sym
+    def auto_detected?
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].auto_detected?` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      @orm_autodetector.autodetected?
     end
 
-    def orm
-      @orm || autodetect
+    def autodetect_orm
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].autodetect_orm` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      @orm_autodetector.orm
     end
 
-    def start
-      strategy.start
+    def clean!
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].clean!` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner[...].clean instead."
+      clean
     end
 
-    def clean
-      strategy.clean
+    def clean_with!
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].clean_with!` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner[...].clean_with instead."
+      clean_with
     end
 
-    alias clean! clean
+    # TODO privatize the following methods in 2.0
 
-    def cleaning(&block)
-      strategy.cleaning(&block)
+    def strategy_db=(desired_db)
+      if DatabaseCleaner.called_externally?(__FILE__, caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].strategy_db=` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner[...].db=` instead."
+      end
+      set_strategy_db(strategy, desired_db)
     end
 
-    def auto_detected?
-      !!@autodetected
+    def set_strategy_db(strategy, desired_db)
+      if DatabaseCleaner.called_externally?(__FILE__, caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].set_strategy_db=` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner[...].db=` instead."
+      end
+      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 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
+    def create_strategy(*args)
+      if DatabaseCleaner.called_externally?(__FILE__, caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner[...].create_strategy` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner[...].strategy=` instead."
       end
+      strategy, *strategy_args = args
+      orm_strategy(strategy).new(*strategy_args)
     end
 
     private
 
     def orm_module
-      ::DatabaseCleaner.orm_module(orm)
+      return unless [:active_record, :data_mapper, :mongo, :mongoid, :mongo_mapper, :moped, :couch_potato, :sequel, :ohm, :redis, :neo4j].include?(orm)
+      load_adapter(orm) if !adapter_loaded?(orm)
+      orm_module_name = ORMAutodetector::ORMS[orm]
+      DatabaseCleaner.const_get(orm_module_name, false)
     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
+    def adapter_loaded? orm
+      $LOADED_FEATURES.grep(%r{/lib/database_cleaner/#{orm}\.rb$}).any?
     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?")
+    def load_adapter orm
+      $LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../../adapters/database_cleaner-#{orm}/lib")
+      require "database_cleaner/#{orm}"
     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
+    def orm_strategy(strategy)
+      strategy_module_name = strategy.to_s.capitalize
+      orm_module.const_get(strategy_module_name, false)
+    rescue NameError
+      if orm != :active_record
+        DatabaseCleaner.deprecate <<-TEXT
+          The #{orm_module} adapter has been extracted to its own gem: database_cleaner-#{orm}, and will be removed from database_cleaner in 2.0. To silence this message, please replace `gem "database_cleaner"` with `gem "database_cleaner-#{orm}"` in your Gemfile.
+        TEXT
       end
+      require_orm_strategy(orm, strategy)
+      retry
+    end
+
+    def require_orm_strategy(orm, strategy)
+      $LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../../adapters/database_cleaner-#{orm}/lib")
+      require "database_cleaner/#{orm}/#{strategy}"
+    rescue LoadError
+      raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{orm_module.available_strategies.join(', ')}"
     end
   end
 end

data/lib/database_cleaner/configuration.rb

@@ -1,74 +1,77 @@
 require 'database_cleaner/base'
+require 'database_cleaner/deprecation'
+require 'forwardable'
 
 module DatabaseCleaner
 
-  class NoORMDetected < StandardError;   end
-  class UnknownStrategySpecified < ArgumentError;   end
+  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 = {})
+  class Cleaners < Hash
+    # FIXME this method conflates creation with lookup... both a command and a query. yuck.
+    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
+      fetch([orm, opts]) { add_cleaner(orm, opts) }
+    end 
 
-    def add_cleaner(orm,opts = {})
-      init_cleaners
-      cleaner = DatabaseCleaner::Base.new(orm,opts)
-      @cleaners[[orm, opts]] = cleaner
-      @connections << cleaner
-      cleaner
+    def strategy=(strategy)
+      add_cleaner(:autodetect) if none?
+      values.each { |cleaner| cleaner.strategy = strategy }
+      remove_duplicates
     end
 
-    def app_root=(desired_root)
-      @app_root = desired_root
+    def orm=(orm)
+      add_cleaner(:autodetect) if none?
+      values.each { |cleaner| cleaner.orm = orm }
+      remove_duplicates
     end
 
-    def app_root
-      @app_root ||= Dir.pwd
+    # TODO privatize the following methods in 2.0
+
+    def add_cleaner(orm, opts = {})
+      self[[orm, opts]] = ::DatabaseCleaner::Base.new(orm, opts)
     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
+    def remove_duplicates
+      replace(reduce(Cleaners.new) do |cleaners, (key, value)|
+        cleaners[key] = value unless cleaners.values.include?(value)
+        cleaners
+      end)
     end
+  end
 
-    def logger=(log_source)
-      @logger = log_source
+  class Configuration
+    def initialize
+      @cleaners ||= Cleaners.new
     end
 
-    def logger
-      return @logger if @logger
+    extend Forwardable
+    delegate [
+      :[],
+      :strategy=,
+      :orm=,
+    ] => :cleaners
 
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::ERROR
-      @logger
+    attr_accessor :cleaners
+
+    def app_root
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.app_root` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner::ActiveRecord.config_file_location`, instead."
+      @app_root ||= Dir.pwd
     end
 
-    def strategy=(stratagem)
-      connections.each { |connect| connect.strategy = stratagem }
-      remove_duplicates
+    def app_root= value
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.app_root=` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner::ActiveRecord.config_file_location=`, instead."
+      @app_root = value
     end
 
-    def orm=(orm)
-      connections.each { |connect| connect.orm = orm }
-      remove_duplicates
+    def logger
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.logger` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      @logger ||= Logger.new(STDOUT).tap { |l| l.level = Logger::ERROR }
+    end
+
+    def logger= value
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.logger=` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      @logger = value
     end
 
     def start
@@ -79,8 +82,6 @@ module DatabaseCleaner
       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) }
@@ -91,41 +92,44 @@ module DatabaseCleaner
       connections.each { |connection| connection.clean_with(*args) }
     end
 
-    alias clean_with! clean_with
+    # TODO remove the following methods in 2.0
 
-    def remove_duplicates
-      temp = []
-      connections.each do |connect|
-        temp.push connect unless temp.include? connect
+    def clean!
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.clean!` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.clean`, instead."
+      clean
+    end
+
+    def clean_with!(*args)
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.clean_with!` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.clean_with`, instead."
+      clean_with(*args)
+    end
+
+    def init_cleaners
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.init_cleaners` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+    end
+
+    def connections
+      if DatabaseCleaner.called_externally?(__FILE__, caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner.connections` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.cleaners`, instead."
+      end
+      add_cleaner(:autodetect) if @cleaners.none?
+      @cleaners.values
+    end
+
+    # TODO privatize the following methods in 2.0
+
+    def add_cleaner(orm, opts = {})
+      if DatabaseCleaner.called_externally?(__FILE__, caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner.add_cleaner` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.[]`, instead."
       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
+      @cleaners.add_cleaner(orm, opts = {})
+    end
+
+    def remove_duplicates
+      if DatabaseCleaner.called_externally?(__FILE__, caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner.remove_duplicates` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
       end
+      @cleaners.remove_duplicates
     end
   end
 end