raffle_v1 0.0.5 → 1.0.4

data/lib/database_cleaner-0.7.2/lib/database_cleaner/base.rb

@@ -1,138 +0,0 @@
-require 'database_cleaner/null_strategy'
-module DatabaseCleaner
-  class Base
-
-    def initialize(desired_orm = nil,opts = {})
-      if [:autodetect, nil, "autodetect"].include?(desired_orm)
-        autodetect
-      else
-        self.orm = desired_orm
-      end
-      self.db = opts[:connection] if opts.has_key? :connection
-      set_default_orm_strategy
-    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
-    end
-
-    def db
-      @db || :default
-    end
-
-    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 known strategy along with initialization params."
-       end
-
-       self.strategy_db = self.db
-
-       @strategy
-    end
-
-    def strategy
-      @strategy || NullStrategy
-    end
-
-    def orm=(desired_orm)
-      @orm = desired_orm.to_sym
-    end
-
-    def orm
-      @orm || autodetect
-    end
-
-    def start
-      strategy.start
-    end
-
-    def clean
-      strategy.clean
-    end
-
-    alias clean! clean
-
-    def auto_detected?
-      !!@autodetected
-    end
-
-    #TODO make strategies directly comparable
-    def ==(other)
-      self.orm == other.orm && self.db == other.db && self.strategy.class == other.strategy.class
-    end
-
-    private
-
-    def orm_module
-      ::DatabaseCleaner.orm_module(orm)
-    end
-
-    def orm_strategy(strategy)
-      require "database_cleaner/#{orm.to_s}/#{strategy.to_s}"
-      orm_module.const_get(strategy.to_s.capitalize)
-    rescue LoadError => e
-      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!"
-      end
-    end
-
-    def autodetect
-      @orm ||= begin
-        @autodetected = true
-        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
-        else
-          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, Sequel, MongoMapper, Mongoid, or CouchPotato loaded?"
-        end
-      end
-    end
-
-    def set_default_orm_strategy
-      case orm
-      when :active_record, :data_mapper, :sequel
-        self.strategy = :transaction
-      when :mongo_mapper, :mongoid, :couch_potato
-        self.strategy = :truncation
-      end
-    end
-  end
-end

data/lib/database_cleaner-0.7.2/lib/database_cleaner/configuration.rb

@@ -1,94 +0,0 @@
-require 'database_cleaner/base'
-
-module DatabaseCleaner
-
-  class NoORMDetected < StandardError;   end
-  class UnknownStrategySpecified < ArgumentError;   end
-
-  class << self
-    def [](orm,opts = {})
-      raise NoORMDetected unless orm
-      @connections ||= []
-      cleaner = DatabaseCleaner::Base.new(orm,opts)
-      connections.push cleaner
-      cleaner
-    end
-
-    def app_root=(desired_root)
-      @app_root = desired_root
-    end
-
-    def app_root
-      @app_root || Dir.pwd
-    end
-
-    def connections
-      @connections ||= [::DatabaseCleaner::Base.new]
-    end
-
-    def logger=(log_source)
-      @logger = log_source
-    end
-
-    def logger
-      return @logger if @logger
-
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::ERROR
-      @logger
-    end
-
-    def strategy=(stratagem)
-      connections.each { |connect| connect.strategy = stratagem }
-      remove_duplicates
-    end
-
-    def orm=(orm)
-      connections.each { |connect| connect.orm = orm }
-      remove_duplicates
-    end
-
-    def start
-      connections.each { |connection| connection.start }
-    end
-
-    def clean
-      connections.each { |connection| connection.clean }
-    end
-
-    alias clean! clean
-
-    def clean_with(*args)
-      connections.each { |connection| connection.clean_with(*args) }
-    end
-
-    alias clean_with! clean_with
-
-    def remove_duplicates
-      temp = []
-      connections.each do |connect|
-        temp.push connect unless temp.include? connect
-      end
-      @connections = temp
-    end
-
-    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
-        when :sequel
-          DatabaseCleaner::Sequel
-      end
-    end
-  end
-end

data/lib/database_cleaner-0.7.2/lib/database_cleaner/couch_potato/base.rb

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

data/lib/database_cleaner-0.7.2/lib/database_cleaner/couch_potato/truncation.rb

@@ -1,28 +0,0 @@
-require 'database_cleaner/generic/truncation'
-
-module DatabaseCleaner
-  module CouchPotato
-    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."
-        elsif !options.empty?
-          raise ArgumentError, "Unsupported option. You specified #{options.keys.join(',')}."
-        end
-        super
-      end
-
-      def clean
-        database.recreate!
-      end
-
-      private
-
-      def database
-        ::CouchPotato.couchrest_database
-      end
-    end
-  end
-end

data/lib/database_cleaner-0.7.2/lib/database_cleaner/cucumber.rb

@@ -1,11 +0,0 @@
-Before do
-  DatabaseCleaner.start
-end
-
-After do
-  begin
-    DatabaseCleaner.clean
-  rescue Exception =>  e
-    DatabaseCleaner.logger.error "Exception encountered by DatabaseCleaner in Cucumber After block: #{e}"
-  end
-end

data/lib/database_cleaner-0.7.2/lib/database_cleaner/data_mapper/base.rb

@@ -1,21 +0,0 @@
-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-0.7.2/lib/database_cleaner/data_mapper/transaction.rb

@@ -1,26 +0,0 @@
-require 'database_cleaner/data_mapper/base'
-
-module DatabaseCleaner::DataMapper
-  class Transaction
-    include ::DatabaseCleaner::DataMapper::Base
-
-    def start(repository = self.db)
-      ::DataMapper.repository(repository) do |r|
-        transaction = DataMapper::Transaction.new(r)
-        transaction.begin
-        r.adapter.push_transaction(transaction)
-      end
-    end
-
-    def clean(repository = self.db)
-      ::DataMapper.repository(repository) do |r|
-        adapter = r.adapter
-        while adapter.current_transaction
-          adapter.current_transaction.rollback
-          adapter.pop_transaction
-        end
-      end
-    end
-
-  end
-end

data/lib/database_cleaner-0.7.2/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,175 +0,0 @@
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/data_mapper/base'
-
-module DataMapper
-  module Adapters
-
-    class DataObjectsAdapter
-
-      def storage_names(repository = :default)
-        raise NotImplementedError
-      end
-
-    end
-
-    class MysqlAdapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        select 'SHOW TABLES'
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)};")
-      end
-
-      # copied from activerecord
-      def disable_referential_integrity
-        old = select("SELECT @@FOREIGN_KEY_CHECKS;")
-        begin
-          execute("SET FOREIGN_KEY_CHECKS = 0;")
-          yield
-        ensure
-          execute("SET FOREIGN_KEY_CHECKS = ?", *old)
-        end
-      end
-
-    end
-
-
-    class Sqlite3Adapter < 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
-          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)};")
-        execute("DELETE FROM sqlite_sequence where 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
-
-    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
-          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)};")
-        execute("DELETE FROM sqlite_sequence where 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
-    # i basically just copied activerecord code to get a rough idea what they do.
-    # i don't have postgres available, so i won't be the one to write this.
-    # maybe codes below gets some postgres/datamapper user going, though.
-    class PostgresAdapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        sql = <<-SQL
-          SELECT table_name FROM "information_schema"."tables"
-          WHERE table_schema = current_schema() and table_type = 'BASE TABLE'
-        SQL
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)} RESTART IDENTITY CASCADE;")
-      end
-
-      # FIXME
-      # copied from activerecord
-      def supports_disable_referential_integrity?
-        version = select("SHOW server_version")[0][0].split('.')
-        (version[0].to_i >= 8 && version[1].to_i >= 1) ? true : false
-      rescue
-        return false
-      end
-
-      # FIXME
-      # copied unchanged from activerecord
-      def disable_referential_integrity(repository = :default)
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} DISABLE TRIGGER ALL"
-          end.join(";"))
-        end
-        yield
-      ensure
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} ENABLE TRIGGER ALL"
-          end.join(";"))
-        end
-      end
-
-    end
-
-  end
-end
-
-
-module DatabaseCleaner
-  module DataMapper
-    class Truncation
-      include ::DatabaseCleaner::DataMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean(repository = self.db)
-        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
-
-      private
-
-      def tables_to_truncate(repository = self.db)
-        (@only || ::DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
-      end
-
-      # overwritten
-      def migration_storage_name
-        'migration_info'
-      end
-
-    end
-  end
-end