database_cleaner 1.8.4 → 2.0.0

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
-

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

data/lib/database_cleaner/orm_autodetector.rb

@@ -1,40 +0,0 @@
-module DatabaseCleaner
-  class ORMAutodetector
-    ORMS = {
-      active_record: "ActiveRecord",
-      data_mapper: "DataMapper",
-      mongo_mapper: "MongoMapper",
-      mongoid: "Mongoid",
-      couch_potato: "CouchPotato",
-      sequel: "Sequel",
-      moped: "Moped",
-      ohm: "Ohm",
-      redis: "Redis",
-      neo4j: "Neo4j",
-    }
-
-    def orm
-      @autodetected = true
-      autodetected_orm or raise no_orm_detected_error
-      ORMS.key(autodetected_orm.to_s)
-    end
-
-    def autodetected?
-      !!@autodetected
-    end
-
-    private
-
-    def autodetected_orm
-      ORMS.values.find do |orm|
-        Kernel.const_get(orm) rescue next
-      end
-    end
-
-    def no_orm_detected_error
-      orm_list = ORMS.values.join(", ").sub(ORMS.values.last, "or #{ORMS.values.last}")
-      NoORMDetected.new("No known ORM was detected!  Is #{orm_list} loaded?")
-    end
-  end
-  private_constant :ORMAutodetector
-end

data/lib/database_cleaner/safeguard.rb

@@ -1,107 +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
-
-      class NotWhitelistedUrl < Error
-        def initialize
-          super("ENV['DATABASE_URL'] is set to a URL that is not on the whitelist. Please refer to https://github.com/DatabaseCleaner/database_cleaner#safeguards")
-        end
-      end
-    end
-
-    class WhitelistedUrl
-      def run
-        return if skip?
-        raise Error::NotWhitelistedUrl if database_url_not_whitelisted?
-      end
-
-      private
-
-        def database_url_not_whitelisted?
-          !DatabaseCleaner.url_whitelist.include?(ENV['DATABASE_URL'])
-        end
-
-        def skip?
-          !DatabaseCleaner.url_whitelist
-        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)
-          return false unless url
-
-          parsed = URI.parse(url)
-          return false if parsed.scheme == 'sqlite3:'
-
-          host = parsed.host
-          return false unless host
-          return false if LOCAL.include?(host)
-          return false if host.end_with? '.local'
-          true
-        end
-
-        def skip?
-          ENV['DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL'] ||
-            DatabaseCleaner.allow_remote_database_url ||
-            DatabaseCleaner.url_whitelist
-        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,
-      WhitelistedUrl
-    ]
-
-    def run
-      CHECKS.each { |const| const.new.run }
-    end
-  end
-end

data/lib/database_cleaner/spec.rb

@@ -1,2 +0,0 @@
-require "database_cleaner/spec/database_helper"
-require "database_cleaner/spec/shared_examples"

data/lib/database_cleaner/spec/database_helper.rb

@@ -1,82 +0,0 @@
-require 'yaml'
-
-module DatabaseCleaner
-  module Spec
-    class DatabaseHelper < Struct.new(:db)
-      def self.with_all_dbs &block
-        %w[mysql mysql2 sqlite3 postgres].map(&:to_sym).each do |db|
-          yield new(db)
-        end
-      end
-
-      def setup
-        create_db
-        establish_connection
-        load_schema
-      end
-
-      attr_reader :connection
-
-      def teardown
-        drop_db
-      end
-
-      private
-
-      def establish_connection(config = default_config)
-        raise NotImplementedError
-      end
-
-      def create_db
-        if db == :sqlite3
-          # NO-OP
-        elsif db == :postgres
-          establish_connection default_config.merge('database' => 'postgres')
-          connection.execute "CREATE DATABASE #{default_config['database']}" rescue nil
-        else
-          establish_connection default_config.merge("database" => nil)
-          connection.execute "CREATE DATABASE IF NOT EXISTS #{default_config['database']}"
-        end
-      end
-
-      def load_schema
-        connection.execute <<-SQL
-          CREATE TABLE IF NOT EXISTS users (
-            id SERIAL PRIMARY KEY,
-            name INTEGER
-          );
-        SQL
-
-        connection.execute <<-SQL
-          CREATE TABLE IF NOT EXISTS agents (
-            name INTEGER
-          );
-        SQL
-      end
-
-      def drop_db
-        if db == :sqlite3
-          begin
-            File.unlink(db_config['sqlite3']['database'])
-          rescue Errno::ENOENT
-          end
-        elsif db == :postgres
-          # FIXME
-          connection.execute "DROP TABLE IF EXISTS users"
-          connection.execute "DROP TABLE IF EXISTS agents"
-        else
-          connection.execute "DROP DATABASE IF EXISTS #{default_config['database']}"
-        end
-      end
-
-      def db_config
-        config_path = 'spec/support/config.yml'
-        @db_config ||= YAML.load(IO.read(config_path))
-      end
-
-      def default_config
-        db_config[db.to_s]
-      end
-    end
-  end
-end