database_cleaner 0.5.2 → 0.6.0.rc.1

data/lib/database_cleaner/configuration.rb

@@ -1,129 +1,77 @@
+require 'database_cleaner/base'
+
 module DatabaseCleaner
 
   class NoStrategySetError < StandardError;   end
   class NoORMDetected < StandardError;   end
   class UnknownStrategySpecified < ArgumentError;   end
 
-  module ActiveRecord
-    def self.available_strategies
-      %w[truncation transaction]
+  class << self
+    def [](orm,opts = {})
+      raise NoORMDetected if orm.nil?
+      @connections ||= []
+      cleaner = DatabaseCleaner::Base.new(orm,opts)
+      connections.push cleaner
+      cleaner
     end
-  end
 
-  module DataMapper
-    def self.available_strategies
-      %w[truncation transaction]
+    def app_root=(desired_root)
+      @app_root = desired_root
     end
-  end
-  
 
-  module MongoMapper
-    def self.available_strategies
-      %w[truncation]
+    def app_root
+      @app_root || Dir.pwd
     end
-  end
 
-  module Mongoid
-    def self.available_strategies
-      %w[truncation]
+    def connections
+      @connections ||= [::DatabaseCleaner::Base.new]
     end
-  end
 
-  module CouchPotato
-    def self.available_strategies
-      %w[truncation]
+    def strategy=(stratagem)
+      self.connections.each { |connect| connect.strategy = stratagem }
+      remove_duplicates
     end
-  end
 
-  class << self
-
-    def create_strategy(*args)
-      strategy, *strategy_args = args
-      orm_strategy(strategy).new(*strategy_args)
-    end
-
-    def clean_with(*args)
-      strategy = create_strategy(*args)
-      strategy.clean
-      strategy
-    end
-
-    alias clean_with! clean_with
-
-    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 know strategy along with initialization params."
-       end
-    end
-
-    def orm=(orm_string)
-      @orm = orm_string
+    def orm=(orm)
+      self.connections.each { |connect| connect.orm = orm }
+      remove_duplicates
     end
 
     def start
-      strategy.start
+      self.connections.each { |connection| connection.start }
     end
 
     def clean
-      strategy.clean
-    end
-
-    alias clean! clean
-
-    private
-
-    def strategy
-      return @strategy if @strategy
-      raise NoStrategySetError, "Please set a strategy with DatabaseCleaner.strategy=."
+      self.connections.each { |connection| connection.clean }
     end
 
-    def orm_strategy(strategy)
-  		require "database_cleaner/#{orm}/#{strategy}"
-      orm_module.const_get(strategy.to_s.capitalize)
-    rescue LoadError => e
-      raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{orm_module.available_strategies.join(', ')}"
+    def clean_with(stratagem)
+      self.connections.each { |connection| connection.clean_with stratagem }
     end
 
-
-    def orm
-      @orm ||=begin
-        if defined? ::ActiveRecord
-          'active_record'
-        elsif defined? ::DataMapper
-          'data_mapper'
-        elsif defined? ::MongoMapper
-          'mongo_mapper'
-        elsif defined? ::Mongoid
-          'mongoid'
-        elsif defined? ::CouchPotato
-          'couch_potato'
-        else
-          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, MongoMapper, Mongoid, or CouchPotato loaded?"
-        end
+    def remove_duplicates
+      temp = []
+      self.connections.each do |connect|
+        temp.push connect unless temp.include? connect
       end
+      @connections = temp
     end
-
-
-    def orm_module
-      case orm
-      when 'active_record'
-        DatabaseCleaner::ActiveRecord
-      when 'data_mapper'
-        DatabaseCleaner::DataMapper
-      when 'mongo_mapper'
-        DatabaseCleaner::MongoMapper
-      when 'mongoid'
-        DatabaseCleaner::Mongoid
-      when 'couch_potato'
-        DatabaseCleaner::CouchPotato
+    
+    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 :couch_potato
+          DatabaseCleaner::CouchPotato
       end
     end
-
   end
-
 end

data/lib/database_cleaner/couch_potato/base.rb

@@ -0,0 +1,7 @@
+module DatabaseCleaner
+  module CouchPotato
+    def self.available_strategies
+      %w[truncation]
+    end
+  end
+end

data/lib/database_cleaner/couch_potato/truncation.rb

@@ -1,8 +1,10 @@
-require 'database_cleaner/truncation_base'
+require 'database_cleaner/generic/truncation'
 
 module DatabaseCleaner
   module CouchPotato
-    class Truncation < DatabaseCleaner::TruncationBase
+    class Truncation
+      include ::DatabaseCleaner::Generic::Truncation
+
       def initialize(options = {})
         if options.has_key?(:only) || options.has_key?(:except)
           raise ArgumentError, "The :only and :except options are not available for use with CouchPotato/CouchDB."

data/lib/database_cleaner/cucumber.rb

@@ -1,4 +1,3 @@
-
 Before do
   DatabaseCleaner.start
 end

data/lib/database_cleaner/data_mapper/base.rb

@@ -0,0 +1,21 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module DataMapper
+    def self.available_strategies
+      %w[truncation transaction]
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      def db=(desired_db)
+        @db = desired_db
+      end
+
+      def db
+        @db || :default
+      end
+
+    end
+  end
+end

data/lib/database_cleaner/data_mapper/transaction.rb

@@ -1,16 +1,21 @@
+require 'database_cleaner/data_mapper/base'
+
 module DatabaseCleaner::DataMapper
   class Transaction
-
-    def start(repo = :default)
-      DataMapper.repository(repo) do |r|
+    include ::DatabaseCleaner::DataMapper::Base
+    #TODO Figure out repositories, may have to refactor connection_klass to something more sensible
+    def start(repository = nil)
+      repository = self.db if repository.nil?
+      ::DataMapper.repository(repository) do |r|
         transaction = DataMapper::Transaction.new(r)
         transaction.begin
         r.adapter.push_transaction(transaction)
       end
     end
 
-    def clean(repo = :default)
-      DataMapper.repository(repo) do |r|
+    def clean(repository = nil)
+      repository = self.db if repository.nil?
+      ::DataMapper.repository(repository) do |r|
         adapter = r.adapter
         while adapter.current_transaction
           adapter.current_transaction.rollback

data/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,4 +1,5 @@
-require "database_cleaner/truncation_base"
+require "database_cleaner/generic/truncation"
+require 'database_cleaner/data_mapper/base'
 
 module DataMapper
   module Adapters
@@ -29,12 +30,13 @@ module DataMapper
           execute("SET FOREIGN_KEY_CHECKS = 0;")
           yield
         ensure
-          execute("SET FOREIGN_KEY_CHECKS = #{old};")
+          execute("SET FOREIGN_KEY_CHECKS = #{old.first};")
         end
       end
 
     end
 
+
     class Sqlite3Adapter < DataObjectsAdapter
 
       # taken from http://github.com/godfat/dm-mapping/tree/master
@@ -46,7 +48,7 @@ module DataMapper
           WHERE type = 'table' AND NOT name = 'sqlite_sequence'
         SQL
         # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
-        select sql
+        select(sql)
       end
 
       def truncate_table(table_name)
@@ -61,7 +63,32 @@ module DataMapper
       end
 
     end
+    
+    class SqliteAdapter < DataObjectsAdapter
+      # taken from http://github.com/godfat/dm-mapping/tree/master
+      def storage_names(repository = :default)
+        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 177
+        sql = <<-SQL.compress_lines
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+        SQL
+        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
+        select(sql)
+      end
 
+      def truncate_table(table_name)
+        execute("DELETE FROM #{quote_name(table_name)};")
+      end
+
+      # this is a no-op copied from activerecord
+      # i didn't find out if/how this is possible
+      # activerecord also doesn't do more here
+      def disable_referential_integrity
+        yield
+      end
+
+    end
 
     # FIXME
     # i don't know if this works
@@ -115,28 +142,34 @@ module DataMapper
 end
 
 
-module DatabaseCleaner::DataMapper
-  class Truncation < ::DatabaseCleaner::TruncationBase
+module DatabaseCleaner
+  module DataMapper
+    class Truncation
+      include ::DatabaseCleaner::DataMapper::Base
+      include ::DatabaseCleaner::Generic::Truncation
 
-    def clean(repository = :default)
-      adapter = DataMapper.repository(repository).adapter
-      adapter.disable_referential_integrity do
-        tables_to_truncate.each do |table_name|
-          adapter.truncate_table table_name
+      def clean(repository = nil)
+        repository = self.db if repository.nil?
+        adapter = ::DataMapper.repository(repository).adapter
+        adapter.disable_referential_integrity do
+          tables_to_truncate(repository).each do |table_name|
+            adapter.truncate_table table_name
+          end
         end
       end
-    end
 
-    private
+      private
 
-    def tables_to_truncate(repository = :default)
-      (@only || DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
-    end
+      def tables_to_truncate(repository = nil)
+        repository = self.db if repository.nil?
+        (@only || ::DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
+      end
 
-    # overwritten
-    def migration_storage_name
-      'migration_info'
-    end
+      # overwritten
+      def migration_storage_name
+        'migration_info'
+      end
 
+    end
   end
 end

data/lib/database_cleaner/generic/base.rb

@@ -0,0 +1,23 @@
+module ::DatabaseCleaner
+   module Generic
+     module Base
+
+       def self.included(base)
+         base.extend(ClassMethods)
+         base.send(:include, InstanceMethods)
+       end
+
+       module InstanceMethods
+         def db
+           :default
+         end
+       end
+
+       module ClassMethods
+         def available_strategies
+           %W[]
+         end
+       end
+     end
+   end
+end

data/lib/database_cleaner/generic/truncation.rb

@@ -0,0 +1,43 @@
+module DatabaseCleaner
+  module Generic
+    module Truncation
+      def self.included(base)
+       base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def initialize(opts={})
+          if !opts.empty? && !(opts.keys - [:only, :except]).empty?
+            raise ArgumentError, "The only valid options are :only and :except. You specified #{opts.keys.join(',')}."
+          end
+          if opts.has_key?(:only) && opts.has_key?(:except)
+            raise ArgumentError, "You may only specify either :only or :either.  Doing both doesn't really make sense does it?"
+          end
+
+          @only = opts[:only]
+          @tables_to_exclude = (opts[:except] || [])
+          @tables_to_exclude << migration_storage_name unless migration_storage_name.nil?
+        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_name
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/database_cleaner/mongo_mapper/base.rb

@@ -0,0 +1,20 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module MongoMapper
+    def self.available_strategies
+      %w[truncation]
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      def db=(desired_db)
+        @db = desired_db
+      end
+
+      def db
+        @db || :default
+      end
+    end
+  end
+end