database_cleaner 1.6.2 → 1.8.5

data/lib/database_cleaner/base.rb

@@ -1,164 +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

data/lib/database_cleaner/deprecation.rb

@@ -0,0 +1,26 @@
+module DatabaseCleaner
+  def deprecate message
+    method = caller.first[/\d+:in `(.*)'$/, 1].to_sym
+    @@deprecator ||= Deprecator.new
+    @@deprecator.deprecate method, message
+  end
+  module_function :deprecate
+
+  def called_externally?(file, caller)
+    file != caller.first[/^(.+\.rb):\d+/, 1]
+  end
+  module_function :called_externally?
+
+  class Deprecator
+    def initialize
+      @methods_already_warned = {}
+    end
+
+    def deprecate method, message
+      return if @methods_already_warned.key?(method)
+      $stderr.puts message
+      @methods_already_warned[method] = true
+    end
+  end
+end
+

data/lib/database_cleaner/null_strategy.rb

@@ -1,18 +1,18 @@
 module DatabaseCleaner
   class NullStrategy
-    def self.start
+    def start
       # no-op
     end
     
-     def self.db=(connection)
-       # no-op
-     end
+    def db=(connection)
+      # no-op
+    end
      
-    def self.clean
+    def clean
       # no-op
     end
 
-    def self.cleaning(&block)
+    def cleaning(&block)
       # no-op
       yield
     end

data/lib/database_cleaner/orm_autodetector.rb

@@ -0,0 +1,41 @@
+module DatabaseCleaner
+  class ORMAutodetector
+    ORMS = {
+      active_record: "ActiveRecord",
+      data_mapper: "DataMapper",
+      mongo_mapper: "MongoMapper",
+      mongoid: "Mongoid",
+      mongo: "Mongo",
+      couch_potato: "CouchPotato",
+      sequel: "Sequel",
+      moped: "Moped",
+      ohm: "Ohm",
+      redis: "Redis",
+      neo4j: "Neo4j",
+    }
+
+    def orm
+      @autodetected = true
+      autodetected_orm or raise no_orm_detected_error
+      ORMS.key(autodetected_orm.to_s)
+    end
+
+    def autodetected?
+      !!@autodetected
+    end
+
+    private
+
+    def autodetected_orm
+      ORMS.values.find do |orm|
+        Kernel.const_get(orm) rescue next
+      end
+    end
+
+    def no_orm_detected_error
+      orm_list = ORMS.values.join(", ").sub(ORMS.values.last, "or #{ORMS.values.last}")
+      NoORMDetected.new("No known ORM was detected!  Is #{orm_list} loaded?")
+    end
+  end
+  private_constant :ORMAutodetector
+end

data/lib/database_cleaner/safeguard.rb

@@ -0,0 +1,107 @@
+module DatabaseCleaner
+  class Safeguard
+    class Error < Exception
+      class RemoteDatabaseUrl < Error
+        def initialize
+          super("ENV['DATABASE_URL'] is set to a remote URL. Please refer to https://github.com/DatabaseCleaner/database_cleaner#safeguards")
+        end
+      end
+
+      class ProductionEnv < Error
+        def initialize(env)
+          super("ENV['#{env}'] is set to production. Please refer to https://github.com/DatabaseCleaner/database_cleaner#safeguards")
+        end
+      end
+
+      class NotWhitelistedUrl < Error
+        def initialize
+          super("ENV['DATABASE_URL'] is set to a URL that is not on the whitelist. Please refer to https://github.com/DatabaseCleaner/database_cleaner#safeguards")
+        end
+      end
+    end
+
+    class WhitelistedUrl
+      def run
+        return if skip?
+        raise Error::NotWhitelistedUrl if database_url_not_whitelisted?
+      end
+
+      private
+
+        def database_url_not_whitelisted?
+          !DatabaseCleaner.url_whitelist.include?(ENV['DATABASE_URL'])
+        end
+
+        def skip?
+          !DatabaseCleaner.url_whitelist
+        end
+    end
+
+
+    class RemoteDatabaseUrl
+      LOCAL = %w(localhost 127.0.0.1)
+
+      def run
+        raise Error::RemoteDatabaseUrl if !skip? && given?
+      end
+
+      private
+
+        def given?
+          remote?(ENV['DATABASE_URL'])
+        end
+
+        def remote?(url)
+          return false unless url
+
+          parsed = URI.parse(url)
+          return false if parsed.scheme == 'sqlite3:'
+
+          host = parsed.host
+          return false unless host
+          return false if LOCAL.include?(host)
+          return false if host.end_with? '.local'
+          true
+        end
+
+        def skip?
+          ENV['DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL'] ||
+            DatabaseCleaner.allow_remote_database_url ||
+            DatabaseCleaner.url_whitelist
+        end
+    end
+
+    class Production
+      KEYS = %w(ENV RACK_ENV RAILS_ENV)
+
+      def run
+        raise Error::ProductionEnv.new(key) if !skip? && given?
+      end
+
+      private
+
+        def given?
+          !!key
+        end
+
+        def key
+          @key ||= KEYS.detect { |key| ENV[key] == 'production' }
+        end
+
+        def skip?
+          ENV['DATABASE_CLEANER_ALLOW_PRODUCTION'] ||
+            DatabaseCleaner.allow_production
+        end
+    end
+
+    CHECKS = [
+      RemoteDatabaseUrl,
+      Production,
+      WhitelistedUrl
+    ]
+
+    def run
+      CHECKS.each { |const| const.new.run }
+    end
+  end
+end