database_cleaner 1.8.5 → 2.0.2

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

@@ -1,24 +0,0 @@
-begin # when database_cleaner-ohm is loaded as a gem
-  require 'database_cleaner/redis/truncation'
-rescue LoadError # when database_cleaner is loaded as a gem
-  $LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../../../../../adapters/database_cleaner-redis/lib")
-  require 'database_cleaner/redis/truncation'
-end
-
-module DatabaseCleaner
-  module Ohm
-    def self.available_strategies
-      %w(truncation)
-    end
-
-    class Truncation < ::DatabaseCleaner::Redis::Truncation
-
-      private
-
-      def default_redis
-        ::Ohm.redis
-      end
-
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module DatabaseCleaner
-  module Ohm
-    VERSION = "1.8.1"
-  end
-end

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

@@ -1,12 +0,0 @@
-require "database_cleaner/ohm/version"
-require "database_cleaner"
-require "database_cleaner/ohm/truncation"
-
-DatabaseCleaner.deprecate "The Ohm adapter for DatabaseCleaner is deprecated, and will be removed in v2.0. Please use the Redis adapter instead."
-
-module DatabaseCleaner::Ohm
-  def self.default_strategy
-    :truncation
-  end
-end
-

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

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

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

@@ -1,41 +0,0 @@
-require 'database_cleaner/generic/base'
-
-module DatabaseCleaner
-  module Redis
-    def self.available_strategies
-      %w{truncation}
-    end
-
-    def self.default_strategy
-      :truncation
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db ||= :default
-      end
-
-      alias url db
-
-      private
-
-      def connection
-        @connection ||= begin
-          if url == :default
-            ::Redis.new
-          elsif db.is_a?(::Redis) # pass directly the connection
-            db
-          else
-            ::Redis.new(:url => url)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'database_cleaner/redis/base'
-require 'database_cleaner/generic/truncation'
-
-module DatabaseCleaner
-  module Redis
-    class Truncation
-      include ::DatabaseCleaner::Redis::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean
-        if @only
-          @only.each do |term|
-            connection.keys(term).each { |k| connection.del k }
-          end
-        elsif @tables_to_exclude
-          keys_except = []
-          @tables_to_exclude.each { |term| keys_except += connection.keys(term) }
-          connection.keys.each { |k| connection.del(k) unless keys_except.include?(k) }
-        else
-          connection.flushdb
-        end
-        connection.quit unless url == :default
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module Sequel
-    def self.available_strategies
-      %w(truncation transaction deletion)
-    end
-
-    def self.default_strategy
-      :transaction
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        return @db if @db && @db != :default
-        raise "As you have more than one active sequel database you have to specify the one to use manually!" if ::Sequel::DATABASES.count > 1
-        ::Sequel::DATABASES.first || :default
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'database_cleaner/sequel/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/sequel/truncation'
-
-module DatabaseCleaner::Sequel
-  class Deletion < Truncation
-    def disable_referential_integrity(tables)
-      case db.database_type
-      when :postgres
-        db.run('SET CONSTRAINTS ALL DEFERRED')
-        tables_to_truncate(db).each do |table|
-          db.run("ALTER TABLE \"#{table}\" DISABLE TRIGGER ALL")
-        end
-      when :mysql
-        old = db.fetch('SELECT @@FOREIGN_KEY_CHECKS').first[:@@FOREIGN_KEY_CHECKS]
-        db.run('SET FOREIGN_KEY_CHECKS = 0')
-      end
-      yield
-    ensure
-      case db.database_type
-      when :postgres
-        tables.each do |table|
-          db.run("ALTER TABLE \"#{table}\" ENABLE TRIGGER ALL")
-        end
-      when :mysql
-        db.run("SET FOREIGN_KEY_CHECKS = #{old}")
-      end
-    end
-
-    def delete_tables(db, tables)
-      tables.each do |table|
-        db[table.to_sym].delete
-      end
-    end
-
-    def clean
-      return unless dirty?
-
-      tables = tables_to_truncate(db)
-      db.transaction do
-        disable_referential_integrity(tables) do
-          delete_tables(db, tables)
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'database_cleaner/sequel/base'
-module DatabaseCleaner
-  module Sequel
-    class Transaction
-      include ::DatabaseCleaner::Sequel::Base
-
-      def self.check_fiber_brokenness
-        if !@checked_fiber_brokenness && Fiber.new { Thread.current }.resume != Thread.current
-          raise RuntimeError, "This ruby engine's Fibers are not compatible with Sequel's connection pool. " +
-            "To work around this, please use DatabaseCleaner.cleaning with a block instead of " +
-            "DatabaseCleaner.start and DatabaseCleaner.clean"
-        end
-        @checked_fiber_brokenness = true
-      end
-
-      def start
-        self.class.check_fiber_brokenness
-
-        @fibers ||= []
-        db = self.db
-        f = Fiber.new do
-          db.transaction(:rollback => :always, :savepoint => true) do
-            Fiber.yield
-          end
-        end
-        f.resume
-        @fibers << f
-      end
-
-      def clean
-        f = @fibers.pop
-        f.resume
-      end
-
-      def cleaning
-        self.db.transaction(:rollback => :always, :savepoint => true) { yield }
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/sequel/base'
-
-module DatabaseCleaner
-  module Sequel
-    class Truncation
-      include ::DatabaseCleaner::Sequel::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def start
-        @last_txid = txid
-      end
-
-      def clean
-        return unless dirty?
-
-        tables = tables_to_truncate(db)
-
-        # Count rows before truncating
-        if pre_count?
-          tables = pre_count_tables(tables)
-        end
-
-        case db.database_type
-        when :postgres
-          # PostgreSQL requires all tables with FKs to be truncates in the same command, or have the CASCADE keyword
-          # appended. Bulk truncation without CASCADE is:
-          # * Safer. Tables outside of tables_to_truncate won't be affected.
-          # * Faster. Less roundtrips to the db.
-          unless tables.empty?
-            tables_sql = tables.map { |t| %("#{t}") }.join(',')
-            db.run "TRUNCATE TABLE #{tables_sql} RESTART IDENTITY;"
-          end
-        else
-          truncate_tables(db, tables)
-        end
-      end
-
-      private
-
-      def pre_count_tables tables
-        tables.reject { |table| db[table.to_sym].count == 0 }
-      end
-
-      def truncate_tables(db, tables)
-        tables.each do |table|
-          db[table.to_sym].truncate
-          if db.database_type == :sqlite && db.table_exists?(:sqlite_sequence)
-            db[:sqlite_sequence].where(name: table).delete
-          end
-        end
-      end
-
-      def dirty?
-        @last_txid != txid || @last_txid.nil?
-      end
-
-      def txid
-        case db.database_type
-        when :postgres
-          db.fetch('SELECT txid_snapshot_xmax(txid_current_snapshot()) AS txid').first[:txid]
-        end
-      end
-
-      def tables_to_truncate(db)
-        (@only || db.tables.map(&:to_s)) - @tables_to_exclude
-      end
-
-      # overwritten
-      def migration_storage_names
-        %w(schema_info schema_migrations)
-      end
-
-      def pre_count?
-        @pre_count == true
-      end
-    end
-  end
-end

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

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

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

@@ -1,6 +0,0 @@
-require "database_cleaner/sequel/version"
-require "database_cleaner"
-require "database_cleaner/sequel/truncation"
-require "database_cleaner/sequel/transaction"
-require "database_cleaner/sequel/deletion"
-

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

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

data/cucumber.yml

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

data/lib/database_cleaner/base.rb

@@ -1,153 +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
-      self.db = opts[:connection] || opts[:model] if 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
-      @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)
-      @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,135 +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)
-      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`, 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
-