acts-as-taggable-on 9.0.0 → 11.0.0

data/lib/acts-as-taggable-on.rb

@@ -1,43 +1,21 @@
 require 'active_record'
 require 'active_record/version'
 require 'active_support/core_ext/module'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect "acts-as-taggable-on" => "ActsAsTaggableOn"
+loader.setup
 
 begin
   require 'rails/engine'
-  require 'acts_as_taggable_on/engine'
+  require 'acts-as-taggable-on/engine'
   rescue LoadError
-
 end
 
 require 'digest/sha1'
 
 module ActsAsTaggableOn
-  extend ActiveSupport::Autoload
-
-  autoload :Tag
-  autoload :TagList
-  autoload :GenericParser
-  autoload :DefaultParser
-  autoload :Taggable
-  autoload :Tagger
-  autoload :Tagging
-  autoload :TagsHelper
-  autoload :VERSION
-
-  autoload_under 'taggable' do
-    autoload :Cache
-    autoload :Collection
-    autoload :Core
-    autoload :Dirty
-    autoload :Ownership
-    autoload :Related
-    autoload :TagListType
-  end
-
-  autoload :Utils
-  autoload :Compatibility
-
-
   class DuplicateTagError < StandardError
   end
 
@@ -66,7 +44,7 @@ module ActsAsTaggableOn
                   :remove_unused_tags, :default_parser,
                   :tags_counter, :tags_table,
                   :taggings_table
-    attr_reader :delimiter, :strict_case_match
+    attr_reader :delimiter, :strict_case_match, :base_class
 
     def initialize
       @delimiter = ','
@@ -79,6 +57,7 @@ module ActsAsTaggableOn
       @force_binary_collation = false
       @tags_table = :tags
       @taggings_table = :taggings
+      @base_class = '::ActiveRecord::Base'
     end
 
     def strict_case_match=(force_cs)
@@ -119,6 +98,11 @@ WARNING
       end
     end
 
+    def base_class=(base_class)
+      raise "base_class must be a String" unless base_class.is_a?(String)
+      @base_class = base_class
+    end
+
   end
 
   setup
@@ -128,6 +112,7 @@ ActiveSupport.on_load(:active_record) do
   extend ActsAsTaggableOn::Taggable
   include ActsAsTaggableOn::Tagger
 end
+
 ActiveSupport.on_load(:action_view) do
   include ActsAsTaggableOn::TagsHelper
 end

data/lib/tasks/example/acts-as-taggable-on.rb.example

@@ -0,0 +1,8 @@
+ActsAsTaggableOn.setup do |config|
+  # This works because the classes where the base class is a concern, Tag and Tagging
+  # are autoloaded, and won't be started until after the initializers run. The value
+  # must be a String, as the Rails Zeitwerk autoloader will not allow models to be
+  # referenced at initialization time.
+  #
+  # config.base_class = 'ApplicationRecord'
+end

data/lib/tasks/install_initializer.rake

@@ -0,0 +1,23 @@
+namespace :acts_as_taggable_on do
+
+  namespace :sharded_db do
+
+    desc "Install initializer setting custom base class"
+    task :install_initializer => [:environment, "config/initializers/foo"] do
+      source = File.join(
+        Gem.loaded_specs["acts-as-taggable-on"].full_gem_path,
+        "lib",
+        "tasks",
+        "examples",
+        "acts-as-taggable-on.rb.example"
+      )
+
+      destination = "config/initializers/acts-as-taggable-on.rb"
+
+      cp source, destination
+    end
+
+    directory "config/initializers"
+  end
+
+end

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -197,7 +197,7 @@ describe 'Acts As Taggable On' do
 
         its(:language_list)        { should == ['ruby', '.net']}
         its(:cached_language_list) { should == 'ruby, .net' }           # passes
-        its(:instance_variables)   { should     include((RUBY_VERSION < '1.9' ? '@language_list' : :@language_list)) }
+        its(:instance_variables)   { should     include(:@language_list) }
       end
 
       context 'status taggings cache after update' do
@@ -207,8 +207,8 @@ describe 'Acts As Taggable On' do
         its(:status_list)        { should     == ['happy', 'married'] }
         its(:cached_status_list) { should     == 'happy, married'     } # fails
         its(:cached_status_list) { should_not == ''                   } # fails, is blank
-        its(:instance_variables) { should     include((RUBY_VERSION < '1.9' ? '@status_list' : :@status_list)) }
-        its(:instance_variables) { should_not include((RUBY_VERSION < '1.9' ? '@statu_list' : :@statu_list))  } # fails, note: one "s"
+        its(:instance_variables) { should     include(:@status_list) }
+        its(:instance_variables) { should_not include(:@statu_list)  } # fails, note: one "s"
 
       end
 
@@ -221,13 +221,8 @@ describe 'Acts As Taggable On' do
         its(:glass_list)         { should     == ['rectangle', 'aviator'] }
         its(:cached_glass_list)  { should     == 'rectangle, aviator'     } # fails
         its(:cached_glass_list)  { should_not == ''                       } # fails, is blank
-        if RUBY_VERSION < '1.9'
-          its(:instance_variables) { should     include('@glass_list')      }
-          its(:instance_variables) { should_not include('@glas_list')       } # fails, note: one "s"
-        else
-          its(:instance_variables) { should     include(:@glass_list)      }
-          its(:instance_variables) { should_not include(:@glas_list)       } # fails, note: one "s"
-        end
+        its(:instance_variables) { should     include(:@glass_list)      }
+        its(:instance_variables) { should_not include(:@glas_list)       } # fails, note: one "s"
 
       end
     end

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -70,9 +70,9 @@ describe 'acts_as_tagger' do
 
       it 'should throw an exception when the default is over-ridden' do
         expect(@taggable.tag_list_on(:foo_boo)).to be_empty
-        expect(-> {
+        expect {
           @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false)
-        }).to raise_error(RuntimeError)
+        }.to raise_error(RuntimeError)
       end
 
       it 'should not create the tag context on-the-fly when the default is over-ridden' do

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -16,10 +16,6 @@ describe 'Acts As Taggable On' do
       expect(@taggable).to respond_to(:save_tags)
     end
 
-    it 'should add cached tag lists to the instance if cached column is not present' do
-      expect(TaggableModel.new(name: 'Art Kram')).to_not respond_to(:save_cached_tag_list)
-    end
-
     it 'should generate a cached column checker for each tag type' do
       expect(CachedModel).to respond_to(:caching_tag_list?)
       expect(OtherCachedModel).to respond_to(:caching_language_list?)

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -104,8 +104,8 @@ describe ActsAsTaggableOn::TagList do
 
     it 'should be able to call to_s on a frozen tag list' do
       tag_list.freeze
-      expect(-> { tag_list.add('cool', 'rad,bodacious') }).to raise_error(RuntimeError)
-      expect(-> { tag_list.to_s }).to_not raise_error
+      expect { tag_list.add('cool', 'rad,bodacious') }.to raise_error(RuntimeError)
+      expect { tag_list.to_s }.to_not raise_error
     end
   end
 
@@ -161,7 +161,7 @@ describe ActsAsTaggableOn::TagList do
       expect(parser).to have_received(:parse)
     end
 
-    it 'should use the parser setted as attribute' do
+    it 'should use the parser set as attribute' do
       allow(parser_class).to receive(:new).with('new, tag').and_return(parser)
 
       tag_list = ActsAsTaggableOn::TagList.new('example')

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -100,9 +100,9 @@ describe ActsAsTaggableOn::Tag do
     end
 
     it 'should create by name' do
-      expect(-> {
+      expect {
         ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('epic')
-      }).to change(ActsAsTaggableOn::Tag, :count).by(1)
+      }.to change(ActsAsTaggableOn::Tag, :count).by(1)
     end
   end
 
@@ -182,6 +182,25 @@ describe ActsAsTaggableOn::Tag do
     it 'should return an empty array if no tags are specified' do
       expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name([])).to be_empty
     end
+
+    context 'another tag is created concurrently', :database_cleaner_delete, if: supports_concurrency?  do
+      it 'retries and finds tag if tag with same name created concurrently' do
+        tag_name = 'super'
+
+        expect(ActsAsTaggableOn::Tag).to receive(:create).with(name: tag_name) do
+          # Simulate concurrent tag creation
+          Thread.new do
+            ActsAsTaggableOn::Tag.new(name: tag_name).save!
+          end.join
+
+          raise ActiveRecord::RecordNotUnique
+        end
+
+        expect {
+          ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_name)
+        }.to change(ActsAsTaggableOn::Tag, :count).by(1)
+      end
+    end
   end
 
   it 'should require a name' do
@@ -352,4 +371,28 @@ describe ActsAsTaggableOn::Tag do
     end
   end
 
+  describe 'base_class' do
+    before do
+      class Foo < ActiveRecord::Base; end
+    end
+
+    context "default" do
+      it "inherits from ActiveRecord::Base" do
+
+        expect(ActsAsTaggableOn::Tag.ancestors).to include(ActiveRecord::Base)
+        expect(ActsAsTaggableOn::Tag.ancestors).to_not include(Foo)
+      end
+    end
+
+    context "custom" do
+      it "inherits from custom class" do
+
+        ActsAsTaggableOn.base_class = 'Foo'
+        hide_const("ActsAsTaggableOn::Tag")
+        load("lib/acts-as-taggable-on/tag.rb")
+
+        expect(ActsAsTaggableOn::Tag.ancestors).to include(Foo)
+      end
+    end
+  end
 end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -27,9 +27,9 @@ describe 'Taggable To Preserve Order' do
     @taggable.tag_list = 'rails, ruby, css'
     expect(@taggable.instance_variable_get('@tag_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-    expect(-> {
+    expect{
       @taggable.save
-    }).to change(ActsAsTaggableOn::Tag, :count).by(3)
+    }.to change(ActsAsTaggableOn::Tag, :count).by(3)
 
     @taggable.reload
     expect(@taggable.tag_list).to eq(%w(rails ruby css))
@@ -61,9 +61,9 @@ describe 'Taggable To Preserve Order' do
     @taggable.tag_list = 'pow, ruby, rails'
     expect(@taggable.instance_variable_get('@tag_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-    expect(-> {
+    expect {
       @taggable.save
-    }).to change(ActsAsTaggableOn::Tag, :count).by(3)
+    }.to change(ActsAsTaggableOn::Tag, :count).by(3)
 
     @taggable.reload
     expect(@taggable.tags.map { |t| t.name }).to eq(%w(pow ruby rails))
@@ -157,9 +157,9 @@ describe 'Taggable' do
     @taggable.skill_list = 'ruby, rails, css'
     expect(@taggable.instance_variable_get('@skill_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-    expect(-> {
+    expect{
       @taggable.save
-    }).to change(ActsAsTaggableOn::Tag, :count).by(3)
+    }.to change(ActsAsTaggableOn::Tag, :count).by(3)
 
     @taggable.reload
     expect(@taggable.skill_list.sort).to eq(%w(ruby rails css).sort)
@@ -480,6 +480,10 @@ describe 'Taggable' do
       jim = TaggableModel.create(name: 'Jim', tag_list: 'jim, steve')
 
       expect(TaggableModel.tagged_with(%w(bob tricia), wild: true, any: true).to_a.sort_by { |o| o.id }).to eq([bob, frank, steve])
+      expect(TaggableModel.tagged_with(%w(bob tricia), wild: :prefix, any: true).to_a.sort_by { |o| o.id }).to eq([bob, steve])
+      expect(TaggableModel.tagged_with(%w(bob tricia), wild: :suffix, any: true).to_a.sort_by { |o| o.id }).to eq([bob, frank])
+      expect(TaggableModel.tagged_with(%w(cia), wild: :prefix, any: true).to_a.sort_by { |o| o.id }).to eq([bob, steve])
+      expect(TaggableModel.tagged_with(%w(j), wild: :suffix, any: true).to_a.sort_by { |o| o.id }).to eq([frank, steve, jim])
       expect(TaggableModel.tagged_with(%w(bob tricia), wild: true, exclude: true).to_a).to eq([jim])
       expect(TaggableModel.tagged_with('ji', wild: true, any: true).to_a).to match_array([frank, jim])
     end
@@ -555,39 +559,39 @@ describe 'Taggable' do
       let(:bob) { TaggableModel.create(name: 'Bob') }
       context 'case sensitive' do
         it '#add' do
-          expect(lambda {
+          expect {
             bob.tag_list.add 'happier'
             bob.tag_list.add 'happier'
             bob.tag_list.add 'happier', 'rich', 'funny'
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(3)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(3)
         end
         it '#<<' do
-          expect(lambda {
+          expect {
             bob.tag_list << 'social'
             bob.tag_list << 'social'
             bob.tag_list << 'social' << 'wow'
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(2)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(2)
 
         end
 
         it 'unicode' do
 
-          expect(lambda {
+          expect {
             bob.tag_list.add 'ПРИВЕТ'
             bob.tag_list.add 'ПРИВЕТ'
             bob.tag_list.add 'ПРИВЕТ', 'ПРИВЕТ'
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(1)
 
         end
 
         it '#=' do
-          expect(lambda {
+          expect {
             bob.tag_list = ['Happy', 'Happy']
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(1)
         end
       end
       context 'case insensitive' do
@@ -595,39 +599,39 @@ describe 'Taggable' do
         after(:all) { ActsAsTaggableOn.force_lowercase = false }
 
         it '#<<' do
-          expect(lambda {
+          expect {
             bob.tag_list << 'Alone'
             bob.tag_list << 'AloNe'
             bob.tag_list << 'ALONE' << 'In The dark'
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(2)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(2)
 
         end
 
         it '#add' do
-          expect(lambda {
+          expect {
             bob.tag_list.add 'forever'
             bob.tag_list.add 'ForEver'
             bob.tag_list.add 'FOREVER', 'ALONE'
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(2)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(2)
         end
 
         it 'unicode' do
 
-          expect(lambda {
+          expect {
             bob.tag_list.add 'ПРИВЕТ'
             bob.tag_list.add 'привет', 'Привет'
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(1)
 
         end
 
         it '#=' do
-          expect(lambda {
+          expect {
             bob.tag_list = ['Happy', 'HAPPY']
             bob.save
-          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+          }.to change(ActsAsTaggableOn::Tagging, :count).by(1)
         end
 
 
@@ -636,26 +640,29 @@ describe 'Taggable' do
 
     end
 
-    xit 'should not duplicate tags added on different threads', if: supports_concurrency?, skip: 'FIXME, Deadlocks in travis' do
-      #TODO, try with more threads and fix deadlock
-      thread_count = 4
-      barrier = Barrier.new thread_count
+    it 'should not duplicate tags' do
+      connor = TaggableModel.new(name: 'Connor', tag_list: 'There, can, be, only, one')
 
-      expect {
-        thread_count.times.map do |idx|
-          Thread.start do
-            connor = TaggableModel.first_or_create(name: 'Connor')
-            connor.tag_list = 'There, can, be, only, one'
-            barrier.wait
-            begin
-              connor.save
-            rescue ActsAsTaggableOn::DuplicateTagError
-              # second save should succeed
-              connor.save
-            end
-          end
-        end.map(&:join)
-      }.to change(ActsAsTaggableOn::Tag, :count).by(5)
+      allow(ActsAsTaggableOn::Tag).to receive(:create).and_call_original
+      expect(ActsAsTaggableOn::Tag).to receive(:create).with(name: 'can') do
+        # Simulate concurrent tag creation
+        ActsAsTaggableOn::Tag.new(name: 'can').save!
+
+        raise ActiveRecord::RecordNotUnique
+      end
+
+      expect(ActsAsTaggableOn::Tag).to receive(:create).with(name: 'be') do
+        # Simulate concurrent tag creation
+        ActsAsTaggableOn::Tag.new(name: 'be').save!
+
+        raise ActiveRecord::RecordNotUnique
+      end
+
+      expect { connor.save! }.to change(ActsAsTaggableOn::Tag, :count).by(5)
+
+      %w[There can only be one].each do |tag|
+        expect(TaggableModel.tagged_with(tag).count).to eq(1)
+      end
     end
   end
 
@@ -726,9 +733,9 @@ describe 'Taggable' do
       @taggable.skill_list = 'ruby, rails, css'
       expect(@taggable.instance_variable_get('@skill_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-      expect(-> {
+      expect {
         @taggable.save
-      }).to change(ActsAsTaggableOn::Tag, :count).by(3)
+      }.to change(ActsAsTaggableOn::Tag, :count).by(3)
 
       @taggable.reload
       expect(@taggable.skill_list.sort).to eq(%w(ruby rails css).sort)
@@ -754,7 +761,7 @@ describe 'Taggable' do
   end
 
   # See https://github.com/mbleigh/acts-as-taggable-on/pull/457 for details
-  context 'tag_counts and aggreating scopes, compatability with MySQL ' do
+  context 'tag_counts and aggreating scopes, compatibility with MySQL ' do
     before(:each) do
       TaggableModel.new(:name => 'Barb Jones').tap { |t| t.tag_list = %w(awesome fun) }.save
       TaggableModel.new(:name => 'John Doe').tap { |t| t.tag_list = %w(cool fun hella) }.save

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -61,10 +61,10 @@ describe 'Tagger' do
 
   it 'should not overlap tags from different taggers' do
     @user2 = User.new
-    expect(-> {
+    expect {
       @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
       @user2.tag(@taggable, with: 'java, python, lisp, ruby', on: :tags)
-    }).to change(ActsAsTaggableOn::Tagging, :count).by(6)
+    }.to change(ActsAsTaggableOn::Tagging, :count).by(6)
 
     [@user, @user2, @taggable].each(&:reload)
 
@@ -83,9 +83,9 @@ describe 'Tagger' do
     @user2.tag(@taggable, with: 'java, python, lisp, ruby', on: :tags)
     @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
 
-    expect(-> {
+    expect {
       @user2.tag(@taggable, with: 'java, python, lisp', on: :tags)
-    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
+    }.to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     [@user, @user2, @taggable].each(&:reload)
 
@@ -102,9 +102,9 @@ describe 'Tagger' do
     @user.tag(@taggable, with: 'awesome', on: :tags)
     @user2.tag(@taggable, with: 'awesome, epic', on: :tags)
 
-    expect(-> {
+    expect {
       @user2.tag(@taggable, with: 'epic', on: :tags)
-    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
+    }.to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     @taggable.reload
     expect(@taggable.all_tags_list).to include('awesome')
@@ -119,9 +119,9 @@ describe 'Tagger' do
     expect(@taggable.tag_list).to eq(%w(ruby))
     expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)
 
-    expect(-> {
+    expect {
       @taggable.update(tag_list: '')
-    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
+    }.to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     expect(@taggable.tag_list).to be_empty
     expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -20,9 +20,9 @@ describe ActsAsTaggableOn::Tagging do
     @taggable = TaggableModel.create(name: 'Bob Jones')
     @tag = ActsAsTaggableOn::Tag.create(name: 'awesome')
 
-    expect(-> {
+    expect {
       2.times { ActsAsTaggableOn::Tagging.create(taggable: @taggable, tag: @tag, context: 'tags') }
-    }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+    }.to change(ActsAsTaggableOn::Tagging, :count).by(1)
   end
 
   it 'should not delete tags of other records' do
@@ -140,4 +140,30 @@ describe ActsAsTaggableOn::Tagging do
       end
     end
   end
+
+  describe 'base_class' do
+    before do
+      class Foo < ActiveRecord::Base; end
+    end
+
+    context "default" do
+      it "inherits from ActiveRecord::Base" do
+
+        expect(ActsAsTaggableOn::Tagging.ancestors).to include(ActiveRecord::Base)
+        expect(ActsAsTaggableOn::Tagging.ancestors).to_not include(Foo)
+      end
+    end
+
+    context "custom" do
+      it "inherits from custom class" do
+
+        ActsAsTaggableOn.base_class = 'Foo'
+        hide_const("ActsAsTaggableOn::Tagging")
+        load("lib/acts-as-taggable-on/tagging.rb")
+
+        expect(ActsAsTaggableOn::Tagging.ancestors).to include(Foo)
+      end
+    end
+  end
+
 end

data/spec/support/database.rb

@@ -13,23 +13,15 @@ ActiveRecord::Base.configurations = YAML.load_file(database_yml)
 ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), '../debug.log'))
 ActiveRecord::Base.logger.level = ENV['CI'] ? ::Logger::ERROR : ::Logger::DEBUG
 ActiveRecord::Migration.verbose = false
-if ActiveRecord.version >= Gem::Version.new('7.0.0.alpha2')
-  ActiveRecord.default_timezone = :utc
-else
-  ActiveRecord::Base.default_timezone = :utc
-end
-config = if ActiveRecord.version >= Gem::Version.new('6.1.0')
-           ActiveRecord::Base.configurations.configs_for(env_name: db_name)
-         else
-           ActiveSupport::HashWithIndifferentAccess.new(ActiveRecord::Base.configurations[db_name])
-         end
+ActiveRecord.default_timezone = :utc
+config = ActiveRecord::Base.configurations.configs_for(env_name: db_name)
 
 begin
   ActiveRecord::Base.establish_connection(db_name.to_sym)
   ActiveRecord::Base.connection
 rescue StandardError
   case db_name
-  when /mysql/
+  when /(mysql)/
     ActiveRecord::Base.establish_connection(config.merge('database' => nil))
     ActiveRecord::Base.connection.create_database(config['database'],
                                                   { charset: 'utf8', collation: 'utf8_unicode_ci' })

data/spec/support/database_cleaner.rb

@@ -6,6 +6,10 @@ RSpec.configure do |config|
     DatabaseCleaner.clean
   end
 
+  config.before(:each, :database_cleaner_delete) do
+    DatabaseCleaner.strategy = :truncation
+  end
+
   config.after(:suite) do
     DatabaseCleaner.clean
   end