database_cleaner-core 2.0.0.beta → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9467fc1cf16d24409f77e3abb20b76e95a78a51d0a0177e301ddf68a1082ce16
-  data.tar.gz: d32838e88873b2f0d68e525b556f2f2872af1b2371dbf99443f095ec2034b04c
+  metadata.gz: eacd8a1e863364bb678724f33c44ba361e1fbdc77066da69b4b92794e3528c14
+  data.tar.gz: 978fd0a42dd410ee1bb8282fdd29654582a88afe1a6709b4b23fa33c418ff0bc
 SHA512:
-  metadata.gz: c479db77842f06279475fceef8c102c94e2a22722d8ce3568ae1adf1d393fd91738ab7d619904a2c3dfaa2337b977b41876e4d80430d5f53ee842663fe0ac0d8
-  data.tar.gz: 882b8e42173a8d44f35a9021ab6b67ee5c5614ec9ac4a48973b3ebf51580d35b5eafe64da03b0958d9be8285b725aac1bee31e829283ec4ecc768205c841f59b
+  metadata.gz: 0eb27aff631629df80bcf9234c8fd923f8946727592688372233c101f9ae2c839b00d74c12dd3c847047d4fab95694a74d492378cc73aec1bb8cf55a5704fc04
+  data.tar.gz: aeb081d591c2619f37575b6b4e714cac728c0de01de73de416ecc641782e3ccf3a1b7d1abdf61a19983258cf95b47e719409154747a31a456ee5a6e85158567f

data/.travis.yml

@@ -1,11 +1,11 @@
+dist: bionic
 language: ruby
+services:
+  - redis
 rvm:
-  - 2.4
   - 2.5
   - 2.6
   - 2.7
-before_install:
-  - gem install bundler -v 1.17.3
 before_script:
   - bin/setup
 cache:

data/ADAPTERS.md

@@ -0,0 +1,126 @@
+# WORK IN PROGRESS - PLEASE DO NOT FOLLOW THESE INSTRUCTIONS UNTIL v2.0.0 FINAL IS RELEASED!
+
+## How to add a new adapter
+
+_Note the following tutorial is for database_cleaner version 2 and above_
+
+Every adapter is a separate gem, the first step in the creation of an adapter is to create a new gem.
+
+### Naming
+Please follow the [Rubygems convention for gem naming](https://guides.rubygems.org/name-your-gem/). The namespace you will be working within is `DatabaseCleaner::Namespace` where Namespace is the name of the ORM you are creation an adapter for.
+For example, `database_cleaner-active_record` provides `DatabaseCleaner::ActiveRecord`, and `database_cleaner-redis` provides `DatabaseCleaner::Redis`, etc.
+
+### Bootstrapping a gem
+We will use `bundle` to bootstrap the new gem. This will produce all the initial files needed.
+
+```
+bundle gem database_cleaner-orm_name
+```
+#### Modifying .gemspec
+You need to add a couple of dependecies to `.gemspec`:
+* `database_cleaner-core`
+* Adapter you're creating this gem for
+
+```
+  spec.add_dependency "database_cleaner-core"
+  spec.add_dependency "orm_name", "some version if required"
+```
+
+#### 
+
+### File structure
+
+Inside the `lib/database_cleaner/orm_name` directory, you will need to create a few files:
+
+* Separate files for each strategy you have
+
+The file structure you end up with will look something like this
+
+```
+\-lib
+  \-database_cleaner
+    \- orm_name
+      \- truncation.rb
+      \- deletion.rb
+      \- transaction.rb
+      \- version.rb
+    \- orm_name.rb
+```
+
+#### orm_name.rb
+
+File `orm_name.rb` **must** do the following:
+  * require `database_cleaner-core`
+  * require all the strategies
+  * configure `DatabaseCleaner` with the default strategy for the ORM.
+
+So, in the end you will end up with a file that might look something like this:
+
+```ruby
+# lib/database_cleaner/orm_name.rb
+
+require 'database_cleaner/orm_name/version'
+require 'database_cleaner/core'
+require 'database_cleaner/orm_name/transaction'
+require 'database_cleaner/orm_name/truncation'
+require 'database_cleaner/orm_name/deletion'
+
+DatabaseCleaner[:orm_name].strategy = :transaction
+```
+
+### Strategy classes
+
+Each strategy class **must** inherit from `DatabaseCleaner::Strategy`.
+
+Each strategy **must** have the following instance methods:
+  *  `#clean` -- where the cleaning happens
+
+Optionally, depending on how your strategy works you may also need to define
+  *  `#start` -- if your strategy is transactional, this is where you would start the database transaction that `#clean` later rolls back.
+
+Given that we're creating a strategy for truncation, you may end up with something like the following class:
+
+```ruby
+# lib/database_cleaner/orm_name/truncation.rb
+
+require 'database_cleaner/strategy'
+require 'orm'
+
+module DatabaseCleaner
+  module OrmName
+    class Truncation < Strategy
+      def clean
+        # actual database cleaning code goes here
+        ORM.truncate_all_tables!
+      end
+    end
+  end
+end
+```
+
+That's about it for the code needed to create your own adapter!
+
+### Testing
+
+To make sure that your new adapter adheres to the Database Cleaner API, database_cleaner-core provides an RSpec shared example. This shared example only checks to make sure all the right methods exist. You will still want to write tests to verify that the cleaning actually works as you expect!
+
+```ruby
+# spec/database_cleaner/orm_name_spec.rb
+
+require 'database_cleaner/orm_name'
+require 'database_cleaner/spec'
+
+RSpec.describe DatabaseCleaner::OrmName do
+  it_should_behave_like "a database_cleaner adapter"
+end
+```
+
+### What's next
+
+Now you should be all set up with your very own database_cleaner ORM adapter!
+Also, don't forget to take a look at the already created adapters, if you encounter any problems.
+
+When you are done with your adapter gem, only a few things left to do
+  * Create a repository with your code
+  * Push code to rubygems
+  * Open a PR to add your adapter to the [list](https://github.com/DatabaseCleaner/database_cleaner#list-of-adapters)

data/Gemfile

@@ -3,3 +3,10 @@ source "https://rubygems.org"
 gemspec name: "database_cleaner-core"
 
 gem "byebug"
+gem "database_cleaner-active_record", git: "https://github.com/DatabaseCleaner/database_cleaner-active_record"
+gem "database_cleaner-redis", git: "https://github.com/DatabaseCleaner/database_cleaner-redis"
+
+group :test do
+  gem "simplecov", require: false
+  gem "codecov", require: false
+end

data/History.rdoc

@@ -1,4 +1,55 @@
-== Development (master)
+== 2.0.0.beta2 2020-05-30
+
+=== Features
+  * New API for ORM Adapter gems: https://github.com/DatabaseCleaner/database_cleaner/pull/644
+
+=== Breaking changes
+  * Rename :connection configuration option to :db for consistency: https://github.com/DatabaseCleaner/database_cleaner/pull/650
+  * Remove all #orm= setter methods: https://github.com/DatabaseCleaner/database_cleaner/pull/643/files
+  * drop support for Ruby 2.4 which is EOL as of 2020-03-31: https://github.com/DatabaseCleaner/database_cleaner/pull/635
+
+== 2.0.0.beta 2020-04-05
+
+=== Breaking changes
+  * Replace old shared RSpec examples with new "database_cleaner adapter" example: https://github.com/DatabaseCleaner/database_cleaner/pull/629
+  * split gem into database_cleaner-core and database_cleaner metagem.
+  * Support Ruby versions 2.4, 2.5, 2.6, and 2.7, and drop support for older Rubies.
+  * remove all deprecated code and get the specs passing again.
+  * Split off all adapter gems into their own repos: https://github.com/DatabaseCleaner/database_cleaner/pull/620
+
+== 1.99.0.beta 2020-05-30
+
+== Changes
+  * Remove unnecessary dependency on database_cleaner-mongo from database_cleaner-mongoid: @botandrose
+  * Enable the :cache_tables option for the mongo truncation strategy, and default to true: https://github.com/DatabaseCleaner/database_cleaner/pull/646"
+  * Introduce deletion aliases for truncation strategies for mongo, mongoid, and redis adapters. https://github.com/DatabaseCleaner/database_cleaner/pull/654
+  * Add new :db orm configuration key, for consistency with #db and #db=. https://github.com/DatabaseCleaner/database_cleaner/pull/649
+
+== Deprecations
+  * Deprecate all #orm= setter methods: https://github.com/DatabaseCleaner/database_cleaner/pull/643
+  * Deprecate non-functional :reset_ids option in ActiveRecord truncation strategy: https://github.com/DatabaseCleaner/database_cleaner/issues/559
+  * Deprecate mongo truncation's `:cache_tables => true` option in favor of `false`, to prep for caching removal in v2.0: https://github.com/DatabaseCleaner/database_cleaner/pull/646"
+  * Deprecate redis truncation's #url method in favor of #db: @botandrose
+  * Deprecate mongo, mongoid, and redis truncation strategies in favor of deletion. https://github.com/DatabaseCleaner/database_cleaner/pull/654
+  * Deprecate :connection and :model configuration options in favor of :db for consistency: https://github.com/DatabaseCleaner/database_cleaner/pull/650
+
+== Bugfixes
+  * Fix deprecation warning about `DatabaseCleaner.connections` to recommend a better alternative: https://github.com/DatabaseCleaner/database_cleaner/pull/656
+
+== 1.8.5 2020-05-04
+
+=== Bug Fixes
+  * Fix :mongo strategy: https://github.com/DatabaseCleaner/database_cleaner/pull/645
+
+== 1.8.4 2020-04-02
+
+=== Bug Fixes
+  * Fix false positive deprecation warnings on Windows: https://github.com/DatabaseCleaner/database_cleaner/pull/633
+
+== 1.8.3 2020-02-18
+
+=== Bug Fixes
+  * Fix performance issue of DatabaseCleaner::Base#orm_module: https://github.com/DatabaseCleaner/database_cleaner/pull/625
 
 == 1.8.2 2020-02-01
 

data/README.markdown

@@ -1,12 +1,13 @@
 **If you're viewing this at https://github.com/DatabaseCleaner/database_cleaner,
 you're reading the documentation for the `master` branch.
 [View documentation for the latest release
-(1.8.2).](https://github.com/DatabaseCleaner/database_cleaner/blob/v1.8.2/README.markdown)**
+(1.8.5).](https://github.com/DatabaseCleaner/database_cleaner/blob/v1.8.5/README.markdown)**
 
 # Database Cleaner
 
 [![Build Status](https://travis-ci.org/DatabaseCleaner/database_cleaner.svg?branch=master)](https://travis-ci.org/DatabaseCleaner/database_cleaner)
 [![Code Climate](https://codeclimate.com/github/DatabaseCleaner/database_cleaner/badges/gpa.svg)](https://codeclimate.com/github/DatabaseCleaner/database_cleaner)
+[![codecov](https://codecov.io/gh/DatabaseCleaner/database_cleaner/branch/master/graph/badge.svg)](https://codecov.io/gh/DatabaseCleaner/database_cleaner)
 ![Gem Version](https://badge.fury.io/rb/database_cleaner.svg)
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=database_cleaner&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=database_cleaner&package-manager=bundler&version-scheme=semver)
 
@@ -51,21 +52,19 @@ MongoDB
 Redis
  * [database_cleaner-redis](https://github.com/DatabaseCleaner/database_cleaner-redis)
 
-Neo4j
- * [database_cleaner-neo4j](https://github.com/DatabaseCleaner/database_cleaner-neo4j)
-
 More details on available configuration options can be found in the README for the specific adapter gem that you're using.
 
 For support or to discuss development please use the [Google Group](https://groups.google.com/group/database_cleaner).
 
 ### Discontinued adapters
 
-The following adapters have been discontinued, as their libraries appear to be unmaintained. Please let us know on the [Google Group](https://groups.google.com/group/database_cleaner) if you think one of these should be resurrected!
+The following adapters have been discontinued. Please let us know on the [Google Group](https://groups.google.com/group/database_cleaner) if you think one of these should be resurrected!
 
  * [database_cleaner-data_mapper](https://github.com/DatabaseCleaner/database_cleaner-data_mapper)
  * [database_cleaner-couch_potato](https://github.com/DatabaseCleaner/database_cleaner-couch_potato)
  * [database_cleaner-mongo_mapper](https://github.com/DatabaseCleaner/database_cleaner-mongo_mapper)
  * [database_cleaner-moped](https://github.com/DatabaseCleaner/database_cleaner-moped)
+ * [database_cleaner-neo4j](https://github.com/DatabaseCleaner/database_cleaner-neo4j)
 
 ## How to use
 
@@ -295,7 +294,7 @@ For more examples see the section ["Why?"](#why).
 
 Sometimes you need to use multiple ORMs in your application.
 
-You can use DatabaseCleaner to clean multiple ORMs, and multiple connections for those ORMs.
+You can use DatabaseCleaner to clean multiple ORMs, and multiple databases for those ORMs.
 
 ```ruby
 require 'database_cleaner/active_record'
@@ -305,14 +304,14 @@ require 'database_cleaner/mongo_mapper'
 DatabaseCleaner[:active_record].strategy = :transaction
 DatabaseCleaner[:mongo_mapper].strategy = :truncation
 
-# How to specify particular connections
-DatabaseCleaner[:active_record, { :connection => :two }]
+# How to specify particular databases
+DatabaseCleaner[:active_record, { db: :two }]
 
 # You may also pass in the model directly:
-DatabaseCleaner[:active_record, { :model => ModelWithDifferentConnection }]
+DatabaseCleaner[:active_record, { db: ModelWithDifferentConnection }]
 ```
 
-Usage beyond that remains the same with `DatabaseCleaner.start` calling any setup on the different configured connections, and `DatabaseCleaner.clean` executing afterwards.
+Usage beyond that remains the same with `DatabaseCleaner.start` calling any setup on the different configured databases, and `DatabaseCleaner.clean` executing afterwards.
 
 ## Why?
 

data/Rakefile

@@ -1,7 +1,9 @@
 # testing
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
-task :default => :spec
+require "cucumber/rake/task"
+Cucumber::Rake::Task.new(:features)
+task :default => [:spec, :features]
 
 # releasing
 require "rake/clean"

data/database_cleaner-core.gemspec

@@ -1,6 +1,4 @@
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "database_cleaner/version"
+require_relative "./lib/database_cleaner/version"
 
 Gem::Specification.new do |spec|
   spec.name        = "database_cleaner-core"
@@ -25,5 +23,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'guard-rspec'
   spec.add_development_dependency "listen"
   spec.add_development_dependency "rspec"
+
   spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "database_cleaner-active_record"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "database_cleaner-redis"
 end

data/database_cleaner.gemspec

@@ -2,7 +2,9 @@ require_relative "./lib/database_cleaner/version"
 
 Gem::Specification.new do |spec|
   spec.name        = "database_cleaner"
-  spec.version     = DatabaseCleaner::VERSION
+# FIXME temporarily hardcode to different version since core is at 2.0.0.beta2, but this gem only is at 2.0.0.beta
+# spec.version     = DatabaseCleaner::VERSION
+  spec.version     = "2.0.0.beta"
   spec.authors     = ["Ben Mabey", "Ernesto Tagwerker", "Micah Geisel"]
   spec.email       = ["ernesto@ombulabs.com"]
 
@@ -11,8 +13,10 @@ Gem::Specification.new do |spec|
   spec.homepage    = "https://github.com/DatabaseCleaner/database_cleaner"
   spec.license     = "MIT"
 
+  spec.metadata["changelog_uri"] = "https://github.com/DatabaseCleaner/database_cleaner/blob/master/History.rdoc"
+
   spec.files       = ["lib/database_cleaner.rb"]
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "database_cleaner-active_record"
+  spec.add_dependency "database_cleaner-active_record", "~>2.0.0.beta2"
 end

data/lib/database_cleaner/{base.rb → cleaner.rb}

@@ -1,22 +1,38 @@
-require 'database_cleaner/deprecation'
 require 'database_cleaner/null_strategy'
 require 'database_cleaner/safeguard'
+require 'database_cleaner/strategy'
 require 'forwardable'
 
 module DatabaseCleaner
-  class Base
+  class UnknownStrategySpecified < ArgumentError; end
+
+  class Cleaner
+    def self.available_strategies(orm_module)
+      # introspect publically available constants for descendents of Strategy to get list of strategies
+      # ignore classes named Base, because its a common name for a shared base class that adds ORM access stuff to Strategy before being inherited by final concrete class
+      # if you're writing an adapter and this method is falsely returning an internal constant that isn't a valid strategy, consider making it private with Module#private_constant.
+      orm_module.constants.select do |constant_name|
+        ancestors = orm_module.const_get(constant_name).ancestors rescue []
+        ancestors.include?(DatabaseCleaner::Strategy)
+      end.map do |constant_name|
+        underscore(constant_name).to_sym
+      end - [:base]
+    end
+
     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)
+    def initialize(orm, db: nil)
+      @orm = orm
+      self.db = db
       Safeguard.new.run
     end
 
+    attr_reader :orm
+
     def db=(desired_db)
       @db = self.strategy_db = desired_db
     end
@@ -42,13 +58,6 @@ module DatabaseCleaner
       @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
 
@@ -82,7 +91,8 @@ module DatabaseCleaner
       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(', ')}"
+      available_strategies = self.class.available_strategies(orm_module)
+      raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{available_strategies.join(', ')}"
     end
 
     def orm_module
@@ -90,6 +100,8 @@ module DatabaseCleaner
       DatabaseCleaner.const_get(orm_module_name)
     end
 
+    # copied from ActiveSupport to avoid adding it as a dependency
+
     def camelize(term)
       string = term.to_s
       string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
@@ -97,5 +109,16 @@ module DatabaseCleaner
       string.gsub!("/", "::")
       string
     end
+
+    def self.underscore(camel_cased_word)
+      return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+    private_class_method :underscore
   end
 end

data/lib/database_cleaner/cleaners.rb

@@ -0,0 +1,51 @@
+require 'database_cleaner/cleaner'
+
+module DatabaseCleaner
+  class Cleaners < Hash
+    def initialize hash={}
+      super.replace(hash)
+    end
+
+    # 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 start
+      values.each { |cleaner| cleaner.start }
+    end
+
+    def clean
+      values.each { |cleaner| cleaner.clean }
+    end
+
+    def cleaning(&inner_block)
+      values.inject(inner_block) do |curr_block, cleaner|
+        proc { cleaner.cleaning(&curr_block) }
+      end.call
+    end
+
+    def clean_with(*args)
+      values.each { |cleaner| cleaner.clean_with(*args) }
+    end
+
+    private
+
+    def add_cleaner(orm, opts = {})
+      self[[orm, opts]] = Cleaner.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
+end

data/lib/database_cleaner/core.rb

@@ -1,6 +1,5 @@
 require 'database_cleaner/version'
-require 'database_cleaner/configuration'
-require 'database_cleaner/deprecation'
+require 'database_cleaner/cleaners'
 require 'forwardable'
 
 module DatabaseCleaner
@@ -8,22 +7,18 @@ module DatabaseCleaner
     extend Forwardable
     delegate [
       :[],
-      :cleaners,
-      :cleaners=,
       :strategy=,
-      :orm=,
       :start,
       :clean,
       :clean_with,
       :cleaning,
-    ] => :configuration
+    ] => :cleaners
 
     attr_accessor :allow_remote_database_url, :allow_production, :url_whitelist
 
-    private
-
-    def configuration
-      @configuration ||= Configuration.new
+    def cleaners
+      @cleaners ||= Cleaners.new
     end
+    attr_writer :cleaners
   end
 end

data/lib/database_cleaner/null_strategy.rb

@@ -4,7 +4,7 @@ module DatabaseCleaner
       # no-op
     end
     
-    def db=(connection)
+    def db=(db)
       # no-op
     end
      

data/lib/database_cleaner/spec/database_helper.rb

@@ -40,9 +40,17 @@ module DatabaseCleaner
       end
 
       def load_schema
+        id_column = case db
+          when :sqlite3
+            "id INTEGER PRIMARY KEY AUTOINCREMENT"
+          when :mysql2
+            "id INTEGER PRIMARY KEY AUTO_INCREMENT"
+          when :postgres
+            "id SERIAL PRIMARY KEY"
+          end
         connection.execute <<-SQL
           CREATE TABLE IF NOT EXISTS users (
-            id SERIAL PRIMARY KEY,
+            #{id_column},
             name INTEGER
           );
         SQL

data/lib/database_cleaner/spec/shared_examples.rb

@@ -1,3 +1,5 @@
+require "database_cleaner/cleaner"
+
 RSpec.shared_examples_for "a database_cleaner strategy" do
   it { is_expected.to respond_to(:db)  }
   it { is_expected.to respond_to(:db=)  }
@@ -7,15 +9,8 @@ RSpec.shared_examples_for "a database_cleaner strategy" do
 end
 
 RSpec.shared_examples_for "a database_cleaner adapter" do
-  it { expect(described_class).to respond_to(:available_strategies) }
-  it { expect(described_class).to respond_to(:default_strategy) }
-
-  it 'default_strategy should be part of available_strategies' do
-    expect(described_class.available_strategies).to include(described_class.default_strategy)
-  end
-
   describe 'all strategies should adhere to a database_cleaner strategy interface' do
-    described_class.available_strategies.each do |strategy|
+    DatabaseCleaner::Cleaner.available_strategies(described_class).each do |strategy|
       subject { described_class.const_get(strategy.to_s.capitalize).new }
 
       it_behaves_like 'a database_cleaner strategy'

data/lib/database_cleaner/strategy.rb

@@ -0,0 +1,36 @@
+# Abstract strategy class for orm adapter gems to subclass
+
+module DatabaseCleaner
+  class Strategy
+    # Override this method if the strategy accepts options
+    def initialize(options=nil)
+      if options
+        name = self.class.name.sub("DatabaseCleaner::","").sub("::"," ") # e.g. "ActiveRecord Transaction"
+        raise ArgumentError, "No options are available for the #{name} strategy."
+      end
+    end
+
+    def db
+      @db ||= :default
+    end
+    attr_writer :db
+
+    # Override this method to start a database transaction if the strategy uses them
+    def start
+    end
+
+    # Override this method with the actual cleaning procedure. Its the only mandatory method implementation.
+    def clean
+      raise NotImplementedError
+    end
+
+    def cleaning(&block)
+      begin
+        start
+        yield
+      ensure
+        clean
+      end
+    end
+  end
+end

data/lib/database_cleaner/version.rb

@@ -1,3 +1,3 @@
 module DatabaseCleaner
-  VERSION = "2.0.0.beta"
+  VERSION = "2.0.0.beta2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: database_cleaner-core
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Ben Mabey
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-05 00:00:00.000000000 Z
+date: 2020-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -95,6 +95,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Strategies for cleaning databases. Can be used to ensure a clean slate
   for testing.
 email:
@@ -107,6 +163,7 @@ files:
 - ".rspec"
 - ".ruby-version.sample"
 - ".travis.yml"
+- ADAPTERS.md
 - CONTRIBUTE.markdown
 - Gemfile
 - Guardfile
@@ -119,19 +176,17 @@ files:
 - database_cleaner-core.gemspec
 - database_cleaner.gemspec
 - lib/database_cleaner-core.rb
-- lib/database_cleaner/base.rb
-- lib/database_cleaner/configuration.rb
+- lib/database_cleaner/cleaner.rb
+- lib/database_cleaner/cleaners.rb
 - lib/database_cleaner/core.rb
 - lib/database_cleaner/cucumber.rb
 - lib/database_cleaner/deprecation.rb
-- lib/database_cleaner/generic/base.rb
-- lib/database_cleaner/generic/transaction.rb
-- lib/database_cleaner/generic/truncation.rb
 - lib/database_cleaner/null_strategy.rb
 - lib/database_cleaner/safeguard.rb
 - lib/database_cleaner/spec.rb
 - lib/database_cleaner/spec/database_helper.rb
 - lib/database_cleaner/spec/shared_examples.rb
+- lib/database_cleaner/strategy.rb
 - lib/database_cleaner/version.rb
 - tmp/.keep
 homepage: https://github.com/DatabaseCleaner/database_cleaner

data/lib/database_cleaner/configuration.rb

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