database_cleaner 1.7.0 → 1.8.0.beta

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

@@ -0,0 +1,5 @@
+module DatabaseCleaner
+  module Moped
+    VERSION = "1.8.0.beta"
+  end
+end

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

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

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

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

data/{lib → adapters/database_cleaner-neo4j/lib}/database_cleaner/neo4j/base.rb

@@ -5,6 +5,10 @@ module DatabaseCleaner
       %w[transaction truncation deletion]
     end
 
+    def self.default_strategy
+      :transaction
+    end
+
     module Base
       include ::DatabaseCleaner::Generic::Base
 

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

@@ -0,0 +1,5 @@
+module DatabaseCleaner
+  module Neo4j
+    VERSION = "1.8.0.beta"
+  end
+end

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

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

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

@@ -0,0 +1,10 @@
+require "database_cleaner/ohm/version"
+require "database_cleaner"
+require "database_cleaner/ohm/truncation"
+
+module DatabaseCleaner::Ohm
+  def self.default_strategy
+    :truncation
+  end
+end
+

data/{lib → adapters/database_cleaner-ohm/lib}/database_cleaner/ohm/truncation.rb

@@ -2,6 +2,10 @@ require 'database_cleaner/redis/truncation'
 
 module DatabaseCleaner
   module Ohm
+    def self.available_strategies
+      %w(truncation)
+    end
+
     class Truncation < ::DatabaseCleaner::Redis::Truncation
 
       private

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

@@ -0,0 +1,5 @@
+module DatabaseCleaner
+  module Ohm
+    VERSION = "1.8.0.beta"
+  end
+end

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

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

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

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

data/{lib → adapters/database_cleaner-redis/lib}/database_cleaner/redis/base.rb

@@ -6,6 +6,10 @@ module DatabaseCleaner
       %w{truncation}
     end
 
+    def self.default_strategy
+      :truncation
+    end
+
     module Base
       include ::DatabaseCleaner::Generic::Base
 

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

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

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

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

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

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

data/{lib → adapters/database_cleaner-sequel/lib}/database_cleaner/sequel/base.rb

@@ -5,6 +5,10 @@ module DatabaseCleaner
       %w(truncation transaction deletion)
     end
 
+    def self.default_strategy
+      :transaction
+    end
+
     module Base
       include ::DatabaseCleaner::Generic::Base
 

data/{lib → adapters/database_cleaner-sequel/lib}/database_cleaner/sequel/truncation.rb

@@ -14,39 +14,40 @@ module DatabaseCleaner
       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 = tables_to_truncate(db)).empty?
-            all_tables = tables.map { |t| %("#{t}") }.join(',')
-            db.run "TRUNCATE TABLE #{all_tables};"
+          unless tables.empty?
+            tables_sql = tables.map { |t| %("#{t}") }.join(',')
+            db.run "TRUNCATE TABLE #{tables_sql} RESTART IDENTITY;"
           end
         else
-          tables = tables_to_truncate(db)
-
-          if pre_count?
-            # Count rows before truncating
-            pre_count_truncate_tables(db, tables)
-          else
-            # Truncate each table normally
-            truncate_tables(db, tables)
-          end
+          truncate_tables(db, tables)
         end
       end
 
       private
 
-      def pre_count_truncate_tables(db, tables)
-        tables = tables.reject { |table| db[table.to_sym].count == 0 }
-        truncate_tables(db, tables)
+      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
 

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

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

data/lib/database_cleaner.rb

@@ -1,12 +1,47 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+require 'database_cleaner/version'
 require 'database_cleaner/configuration'
+require 'database_cleaner/deprecation'
+require 'forwardable'
 
 module DatabaseCleaner
   class << self
-    attr_accessor :allow_remote_database_url, :allow_production
+    extend Forwardable
+    delegate [
+      :[],
+      :app_root=,
+      :app_root,
+      :logger=,
+      :logger,
+      :cleaners,
+      :cleaners=,
+      :strategy=,
+      :orm=,
+      :start,
+      :clean,
+      :clean_with,
+      :cleaning,
+
+      # TODO remove in 2.0
+      :clean!,
+      :clean_with!,
+      :init_cleaners,
+      :add_cleaner,
+      :connections,
+      :remove_duplicates,
+    ] => :configuration
+
+    attr_accessor :allow_remote_database_url, :allow_production, :url_whitelist
 
     def can_detect_orm?
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.can_detect_orm?` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
       DatabaseCleaner::Base.autodetect_orm
     end
+
+    private
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
   end
 end

data/lib/database_cleaner/base.rb

@@ -1,166 +1,148 @@
+require 'database_cleaner/deprecation'
 require 'database_cleaner/null_strategy'
 require 'database_cleaner/safeguard'
+require 'database_cleaner/orm_autodetector'
+require 'active_support/core_ext/string/inflections'
+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 called_externally?(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 called_externally?(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 called_externally?(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_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../../adapters/database_cleaner-#{orm}/lib")
+      require "database_cleaner/#{orm}"
+      DatabaseCleaner.const_get(orm.to_s.camelize)
     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!"
+    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 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 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
 
-    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
+    def called_externally?(caller)
+      __FILE__ != caller.first.split(":").first
     end
   end
 end