database_cleaner-core 2.0.0.beta

data/lib/database_cleaner-core.rb

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

data/lib/database_cleaner/base.rb

@@ -0,0 +1,101 @@
+require 'database_cleaner/deprecation'
+require 'database_cleaner/null_strategy'
+require 'database_cleaner/safeguard'
+require 'forwardable'
+
+module DatabaseCleaner
+  class Base
+    include Comparable
+
+    def <=>(other)
+      [orm, db] <=> [other.orm, other.db]
+    end
+
+    def initialize(orm = :null, opts = {})
+      self.orm = orm
+      self.db = opts[:connection] || opts[:model] if opts.has_key?(:connection) || opts.has_key?(:model)
+      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= orm
+      raise ArgumentError if orm.nil?
+      @orm = orm.to_sym
+    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
+
+    private
+
+    def strategy_db=(desired_db)
+      set_strategy_db(strategy, desired_db)
+    end
+
+    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
+    end
+
+    def create_strategy(*args)
+      strategy, *strategy_args = args
+      orm_strategy(strategy).new(*strategy_args)
+    end
+
+    def orm_strategy(strategy)
+      strategy_module_name = strategy.to_s.capitalize
+      orm_module.const_get(strategy_module_name)
+    rescue NameError
+      raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{orm_module.available_strategies.join(', ')}"
+    end
+
+    def orm_module
+      orm_module_name = camelize(orm)
+      DatabaseCleaner.const_get(orm_module_name)
+    end
+
+    def camelize(term)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!("/", "::")
+      string
+    end
+  end
+end

data/lib/database_cleaner/configuration.rb

@@ -0,0 +1,86 @@
+require 'database_cleaner/base'
+require 'database_cleaner/deprecation'
+require 'forwardable'
+
+module DatabaseCleaner
+
+  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 ArgumentError if orm.nil?
+      fetch([orm, opts]) { add_cleaner(orm, opts) }
+    end 
+
+    def strategy=(strategy)
+      values.each { |cleaner| cleaner.strategy = strategy }
+      remove_duplicates
+    end
+
+    def orm=(orm)
+      values.each { |cleaner| cleaner.orm = orm }
+      remove_duplicates
+    end
+
+    private
+
+    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 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
+
+    private
+
+    def connections
+      @cleaners.values
+    end
+
+    def add_cleaner(orm, opts = {})
+      @cleaners.add_cleaner(orm, opts = {})
+    end
+
+    def remove_duplicates
+      @cleaners.remove_duplicates
+    end
+  end
+end

data/lib/database_cleaner/core.rb

@@ -0,0 +1,29 @@
+require 'database_cleaner/version'
+require 'database_cleaner/configuration'
+require 'database_cleaner/deprecation'
+require 'forwardable'
+
+module DatabaseCleaner
+  class << self
+    extend Forwardable
+    delegate [
+      :[],
+      :cleaners,
+      :cleaners=,
+      :strategy=,
+      :orm=,
+      :start,
+      :clean,
+      :clean_with,
+      :cleaning,
+    ] => :configuration
+
+    attr_accessor :allow_remote_database_url, :allow_production, :url_whitelist
+
+    private
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+end

data/lib/database_cleaner/cucumber.rb

@@ -0,0 +1,3 @@
+Around do |scenario, block|
+  DatabaseCleaner.cleaning(&block)
+end

data/lib/database_cleaner/deprecation.rb

@@ -0,0 +1,20 @@
+module DatabaseCleaner
+  def deprecate message
+    method = caller.first[/\d+:in `(.*)'$/, 1].to_sym
+    @@deprecator ||= Deprecator.new
+    @@deprecator.deprecate method, message
+  end
+  module_function :deprecate
+
+  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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,20 @@
+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/safeguard.rb

@@ -0,0 +1,107 @@
+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