database_cleaner 1.7.0 → 2.0.2

data/lib/database_cleaner/mongoid/base.rb

@@ -1,20 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module Mongoid
-    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

data/lib/database_cleaner/mongoid/truncation.rb

@@ -1,49 +0,0 @@
-require 'database_cleaner/mongoid/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/mongo/truncation_mixin'
-require 'database_cleaner/mongo2/truncation_mixin'
-require 'database_cleaner/moped/truncation_base'
-require 'mongoid/version'
-
-module DatabaseCleaner
-  module Mongoid
-    class Truncation
-      include ::DatabaseCleaner::Mongoid::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      if ::Mongoid::VERSION < '3'
-
-        include ::DatabaseCleaner::Mongo::TruncationMixin
-
-        private
-
-        def database
-          ::Mongoid.database
-        end
-
-      elsif ::Mongoid::VERSION < '5'
-
-        include ::DatabaseCleaner::Moped::TruncationBase
-
-        private
-
-        def session
-          ::Mongoid::VERSION > "5.0.0" ? ::Mongoid.default_client : ::Mongoid.default_session
-        end
-
-        def database
-          if not(@db.nil? or @db == :default)
-            ::Mongoid.databases[@db]
-          else
-            ::Mongoid.database
-          end
-        end
-
-      else
-
-        include ::DatabaseCleaner::Mongo2::TruncationMixin
-
-      end
-    end
-  end
-end

data/lib/database_cleaner/moped/base.rb

@@ -1,39 +0,0 @@
-require 'database_cleaner/generic/base'
-
-module DatabaseCleaner
-  module Moped
-    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
-
-      def host_port=(desired_host)
-        @host = desired_host
-      end
-
-      def host
-        @host ||= '127.0.0.1:27017'
-      end
-
-      def db_version
-        @db_version ||= session.command('buildinfo' => 1)['version']
-      end
-
-      private
-
-      def session
-        ::Moped::Session.new([host], database: db)
-      end
-    end
-  end
-end

data/lib/database_cleaner/moped/truncation.rb

@@ -1,9 +0,0 @@
-require 'database_cleaner/moped/truncation_base'
-
-module DatabaseCleaner
-  module Moped
-    class Truncation
-      include ::DatabaseCleaner::Moped::TruncationBase
-    end
-  end
-end

data/lib/database_cleaner/moped/truncation_base.rb

@@ -1,40 +0,0 @@
-require 'database_cleaner/moped/base'
-require 'database_cleaner/generic/truncation'
-
-module DatabaseCleaner
-  module Moped
-    module TruncationBase
-      include ::DatabaseCleaner::Moped::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean
-        if @only
-          collections.each { |c| session[c].find.remove_all if @only.include?(c) }
-        else
-          collections.each { |c| session[c].find.remove_all unless @tables_to_exclude.include?(c) }
-        end
-        true
-      end
-
-      private
-
-      def collections
-        if db != :default
-          session.use(db)
-        end
-
-        if db_version.split('.').first.to_i >= 3
-          session.command(listCollections: 1, filter: { 'name' => { '$not' => /.?system\.|\$/ } })['cursor']['firstBatch'].map do |collection|
-            collection['name']
-          end
-        else
-          session['system.namespaces'].find(name: { '$not' => /\.system\.|\$/ }).to_a.map do |collection|
-            _, name = collection['name'].split('.', 2)
-            name
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/neo4j/base.rb

@@ -1,62 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module Neo4j
-    def self.available_strategies
-      %w[transaction truncation deletion]
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      def db=(desired_db)
-        @db = desired_db == :default ? nil : desired_db
-      end
-
-      def db
-        @db ||= nil
-      end
-
-      def start
-        if db_type == :embedded_db and not session.running?
-          session.start
-        else
-          session
-        end
-      end
-
-      def database
-        db && default_db.merge(db) || default_db
-      end
-
-      private
-
-      def default_db
-        {:type => default_db_type, :path => default_db_path}
-      end
-
-      def default_db_type
-        :server_db
-      end
-
-      def default_db_path(type = default_db_type)
-        type == :server_db ? 'http://localhost:7475/' : './db/test'
-      end
-
-      def db_type
-        database[:type]
-      end
-
-      def db_path
-        database[:path]
-      end
-
-      def db_params
-        database.reject!{|key, value| [:type, :path].include? key }
-      end
-
-      def session
-        @session ||= ::Neo4j::Session.open(db_type, db_path, db_params)
-      end
-    end
-  end
-end

data/lib/database_cleaner/neo4j/deletion.rb

@@ -1,16 +0,0 @@
-require 'database_cleaner/neo4j/base'
-require 'neo4j-core'
-
-module DatabaseCleaner
-  module Neo4j
-    class Deletion
-      include ::DatabaseCleaner::Neo4j::Base
-
-      def clean
-        ::Neo4j::Transaction.run do
-          session._query('MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r')
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/neo4j/transaction.rb

@@ -1,35 +0,0 @@
-require 'database_cleaner/neo4j/base'
-require 'database_cleaner/generic/transaction'
-require 'neo4j-core'
-
-module DatabaseCleaner
-  module Neo4j
-    class Transaction
-      include ::DatabaseCleaner::Generic::Transaction
-      include ::DatabaseCleaner::Neo4j::Base
-
-      attr_accessor :tx
-
-      def start
-        super
-        rollback
-        self.tx = ::Neo4j::Transaction.new
-      end
-
-      def clean
-        rollback
-      end
-
-      private
-
-      def rollback
-        if tx
-          tx.failure
-          tx.close
-        end
-      ensure
-        self.tx = nil
-      end
-    end
-  end
-end

data/lib/database_cleaner/neo4j/truncation.rb

@@ -1,9 +0,0 @@
-require 'database_cleaner/neo4j/base'
-require 'database_cleaner/neo4j/deletion'
-
-module DatabaseCleaner
-  module Neo4j
-    class Truncation < DatabaseCleaner::Neo4j::Deletion
-    end
-  end
-end

data/lib/database_cleaner/null_strategy.rb

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

data/lib/database_cleaner/ohm/truncation.rb

@@ -1,15 +0,0 @@
-require 'database_cleaner/redis/truncation'
-
-module DatabaseCleaner
-  module Ohm
-    class Truncation < ::DatabaseCleaner::Redis::Truncation
-
-      private
-
-      def default_redis
-        ::Ohm.redis
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/redis/base.rb

@@ -1,37 +0,0 @@
-require 'database_cleaner/generic/base'
-
-module DatabaseCleaner
-  module Redis
-    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
-
-      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/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/lib/database_cleaner/safeguard.rb

@@ -1,72 +0,0 @@
-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
-    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)
-          url && !LOCAL.any? { |str| url.include?(str) }
-        end
-
-        def skip?
-          ENV['DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL'] ||
-            DatabaseCleaner.allow_remote_database_url
-        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
-    ]
-
-    def run
-      CHECKS.each { |const| const.new.run }
-    end
-  end
-end

data/lib/database_cleaner/sequel/base.rb

@@ -1,22 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module Sequel
-    def self.available_strategies
-      %w(truncation transaction deletion)
-    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/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/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/lib/database_cleaner/sequel/truncation.rb

@@ -1,78 +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?
-
-        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};"
-          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
-        end
-      end
-
-      private
-
-      def pre_count_truncate_tables(db, tables)
-        tables = tables.reject { |table| db[table.to_sym].count == 0 }
-        truncate_tables(db, tables)
-      end
-
-      def truncate_tables(db, tables)
-        tables.each do |table|
-          db[table.to_sym].truncate
-        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