database_cleaner 1.99.0 → 2.0.0.beta

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

@@ -1,5 +0,0 @@
-module DatabaseCleaner
-  module Sequel
-    VERSION = "1.99.0"
-  end
-end

data/cucumber.yml

@@ -1 +0,0 @@
-default: features

data/lib/database_cleaner/base.rb

@@ -1,169 +0,0 @@
-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)
-      [orm, db] <=> [other.orm, other.db]
-    end
-
-    def initialize(desired_orm = nil, opts = {})
-      @orm_autodetector = ORMAutodetector.new
-      self.orm = desired_orm
-      if opts.has_key?(:model)
-        DatabaseCleaner.deprecate "Using the `:model` key in `DatabaseCleaner[:orm, model: ...]` is deprecated, and will be removed in database_cleaner 2.0. Please use the new `:db` key, instead, which has identical behavior: `DatabaseCleaner[:orm, db: ...]`."
-      end
-      if opts.has_key?(:connection)
-        DatabaseCleaner.deprecate "Using the `:connection` key in `DatabaseCleaner[:orm, connection: ...]` is deprecated, and will be removed in database_cleaner 2.0. Please use the new `:db` key, instead, which has identical behavior: `DatabaseCleaner[:orm, db: ...]`."
-      end
-      self.db = opts[:db] || opts[:connection] || opts[:model] if opts.has_key?(:db) || opts.has_key?(:connection) || opts.has_key?(:model)
-      self.strategy = orm_module && orm_module.default_strategy
-      Safeguard.new.run
-    end
-
-    def db=(desired_db)
-      @db = self.strategy_db = desired_db
-    end
-
-    def db
-      @db ||= :default
-    end
-
-    def strategy=(args)
-      strategy, *strategy_args = args
-
-      if DatabaseCleaner.called_externally?(__FILE__, caller) \
-        && [:redis, :mongo, :mongoid].include?(orm) \
-        && strategy == :truncation
-        DatabaseCleaner.deprecate "The #{orm} adapter's :truncation strategy will be renamed to :deletion in database_cleaner-#{orm} 2.0. Please specify the :deletion adapter to resolve this deprecation notice."
-      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
-
-      set_strategy_db @strategy, db
-    end
-
-    def strategy
-      @strategy ||= NullStrategy.new
-    end
-
-    attr_reader :orm
-
-    def orm=(desired_orm)
-      if DatabaseCleaner.called_externally?(__FILE__, caller)
-        DatabaseCleaner.deprecate "Calling `DatabaseCleaner[:orm].orm=` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
-      end
-      @orm = (desired_orm || :autodetect).to_sym
-      @orm = @orm_autodetector.orm if @orm == :autodetect
-    end
-
-    extend Forwardable
-    delegate [:start, :clean, :cleaning] => :strategy
-
-    def clean_with(*args)
-      strategy = create_strategy(*args)
-      set_strategy_db strategy, db
-      strategy.clean
-      strategy
-    end
-
-    # TODO remove the following methods in 2.0
-
-    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 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 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!
-      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
-
-    # TODO privatize the following methods in 2.0
-
-    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 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 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
-      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 adapter_loaded? orm
-      $LOADED_FEATURES.grep(%r{/lib/database_cleaner/#{orm}\.rb$}).any?
-    end
-
-    def load_adapter orm
-      $LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../../adapters/database_cleaner-#{orm}/lib")
-      require "database_cleaner/#{orm}"
-    end
-
-    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,136 +0,0 @@
-require 'database_cleaner/base'
-require 'database_cleaner/deprecation'
-require 'forwardable'
-
-module DatabaseCleaner
-
-  class NoORMDetected < StandardError; end
-  class UnknownStrategySpecified < ArgumentError; end
-
-  class Cleaners < Hash
-    # FIXME this method conflates creation with lookup... both a command and a query. yuck.
-    def [](orm, opts = {})
-      raise NoORMDetected unless orm
-      fetch([orm, opts]) { add_cleaner(orm, opts) }
-    end 
-
-    def strategy=(strategy)
-      add_cleaner(:autodetect) if none?
-      values.each { |cleaner| cleaner.strategy = strategy }
-      remove_duplicates
-    end
-
-    def orm=(orm)
-      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.orm=` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
-      add_cleaner(:autodetect) if none?
-      values.each { |cleaner| cleaner.orm = orm }
-      remove_duplicates
-    end
-
-    # TODO privatize the following methods in 2.0
-
-    def add_cleaner(orm, opts = {})
-      self[[orm, opts]] = ::DatabaseCleaner::Base.new(orm, opts)
-    end
-
-    def remove_duplicates
-      replace(reduce(Cleaners.new) do |cleaners, (key, value)|
-        cleaners[key] = value unless cleaners.values.include?(value)
-        cleaners
-      end)
-    end
-  end
-
-  class Configuration
-    def initialize
-      @cleaners ||= Cleaners.new
-    end
-
-    extend Forwardable
-    delegate [
-      :[],
-      :strategy=,
-      :orm=,
-    ] => :cleaners
-
-    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 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 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
-      connections.each { |connection| connection.start }
-    end
-
-    def clean
-      connections.each { |connection| connection.clean }
-    end
-
-    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
-
-    # TODO remove the following methods in 2.0
-
-    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.values`, 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
-      @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/cucumber.rb

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

data/lib/database_cleaner/deprecation.rb

@@ -1,26 +0,0 @@
-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/generic/base.rb

@@ -1,29 +0,0 @@
-module ::DatabaseCleaner
-  module Generic
-    module Base
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      def db
-        :default
-      end
-
-      def cleaning(&block)
-        begin
-          start
-          yield
-        ensure
-          clean
-        end
-      end
-
-      module ClassMethods
-        def available_strategies
-          %W[]
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/generic/transaction.rb

@@ -1,11 +0,0 @@
-module DatabaseCleaner
-  module Generic
-    module Transaction
-      def initialize(opts = {})
-        if !opts.empty?
-          raise ArgumentError, "Options are not available for transaction strategies."
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/generic/truncation.rb

@@ -1,40 +0,0 @@
-module DatabaseCleaner
-  module Generic
-    module Truncation
-      def initialize(opts={})
-        if !opts.empty? && !(opts.keys - [:only, :except, :pre_count, :reset_ids, :cache_tables]).empty?
-          raise ArgumentError, "The only valid options are :only, :except, :pre_count, :reset_ids or :cache_tables. You specified #{opts.keys.join(',')}."
-        end
-        if opts.has_key?(:only) && opts.has_key?(:except)
-          raise ArgumentError, "You may only specify either :only or :except.  Doing both doesn't really make sense does it?"
-        end
-
-        @only = opts[:only]
-        @tables_to_exclude = Array( (opts[:except] || []).dup ).flatten
-        @tables_to_exclude += migration_storage_names
-        @pre_count = opts[:pre_count]
-        @reset_ids = opts[:reset_ids]
-        @cache_tables = opts.has_key?(:cache_tables) ? !!opts[:cache_tables] : true
-      end
-
-      def start
-        #included for compatability reasons, do nothing if you don't need to
-      end
-
-      def clean
-        raise NotImplementedError
-      end
-
-      private
-      def tables_to_truncate
-        raise NotImplementedError
-      end
-
-      # overwrite in subclasses
-      # default implementation given because migration storage need not be present
-      def migration_storage_names
-        %w[]
-      end
-    end
-  end
-end

data/lib/database_cleaner/null_strategy.rb

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