acts-as-taggable-on 12.0.0 → 13.0.0

data/spec/acts_as_taggable_on/dirty_spec.rb

@@ -1,142 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-describe 'Dirty behavior of taggable objects' do
-  context 'with un-contexted tags' do
-    before(:each) do
-      @taggable = TaggableModel.create(tag_list: 'awesome, epic')
-    end
-
-    context 'when tag_list changed' do
-      before(:each) do
-        expect(@taggable.changes).to be_empty
-        @taggable.tag_list = 'one'
-      end
-
-      it 'should show changes of dirty object' do
-        expect(@taggable.changes).to eq({'tag_list' => [['awesome', 'epic'], ['one']]})
-      end
-
-      it 'should show changes of freshly initialized dirty object' do
-        taggable = TaggableModel.find(@taggable.id)
-        taggable.tag_list = 'one'
-        expect(taggable.changes).to eq({'tag_list' => [['awesome', 'epic'], ['one']]})
-      end
-
-      if Rails.version >= "5.1"
-        it 'flags tag_list as changed' do
-          expect(@taggable.will_save_change_to_tag_list?).to be_truthy
-        end
-      end
-
-      it 'preserves original value' do
-        expect(@taggable.tag_list_was).to eq(['awesome', 'epic'])
-      end
-
-      it 'shows what the change was' do
-        expect(@taggable.tag_list_change).to eq([['awesome', 'epic'], ['one']])
-      end
-
-      context 'without order' do
-        it 'should not mark attribute if order change ' do
-          taggable = TaggableModel.create(name: 'Dirty Harry', tag_list: %w(d c b a))
-          taggable.tag_list =  %w(a b c d)
-          expect(taggable.tag_list_changed?).to be_falsey
-        end
-      end
-
-      context 'with order' do
-        it 'should mark attribute if order change' do
-          taggable = OrderedTaggableModel.create(name: 'Clean Harry', tag_list: 'd,c,b,a')
-          taggable.save
-          taggable.tag_list =  %w(a b c d)
-          expect(taggable.tag_list_changed?).to be_truthy
-        end
-      end
-    end
-
-    context 'when tag_list is the same' do
-      before(:each) do
-        @taggable.tag_list = 'awesome, epic'
-      end
-
-      it 'is not flagged as changed' do
-        expect(@taggable.tag_list_changed?).to be_falsy
-      end
-
-      it 'does not show any changes to the taggable item' do
-        expect(@taggable.changes).to be_empty
-      end
-
-      context "and using a delimiter different from a ','" do
-        before do
-          @old_delimiter = ActsAsTaggableOn.delimiter
-          ActsAsTaggableOn.delimiter = ';'
-        end
-
-        after do
-          ActsAsTaggableOn.delimiter = @old_delimiter
-        end
-
-        it 'does not show any changes to the taggable item when using array assignments' do
-          @taggable.tag_list = %w(awesome epic)
-          expect(@taggable.changes).to be_empty
-        end
-      end
-    end
-  end
-
-  context 'with context tags' do
-    before(:each) do
-      @taggable = TaggableModel.create('language_list' => 'awesome, epic')
-    end
-
-    context 'when language_list changed' do
-      before(:each) do
-        expect(@taggable.changes).to be_empty
-        @taggable.language_list = 'one'
-      end
-
-      it 'should show changes of dirty object' do
-        expect(@taggable.changes).to eq({'language_list' => [['awesome', 'epic'], ['one']]})
-      end
-
-      it 'flags language_list as changed' do
-        expect(@taggable.language_list_changed?).to be_truthy
-      end
-
-      it 'preserves original value' do
-        expect(@taggable.language_list_was).to eq(['awesome', 'epic'])
-      end
-
-      it 'shows what the change was' do
-        expect(@taggable.language_list_change).to eq([['awesome', 'epic'], ['one']])
-      end
-    end
-
-    context 'when language_list is the same' do
-      before(:each) do
-        @taggable.language_list = 'awesome, epic'
-      end
-
-      it 'is not flagged as changed' do
-        expect(@taggable.language_list_changed?).to be_falsy
-      end
-
-      it 'does not show any changes to the taggable item' do
-        expect(@taggable.changes).to be_empty
-      end
-    end
-
-    context 'when language_list changed by association' do
-      let(:tag) { ActsAsTaggableOn::Tag.new(name: 'one') }
-
-      it 'flags language_list as changed' do
-        expect(@taggable.changes).to be_empty
-        @taggable.languages << tag
-        expect(@taggable.language_list_changed?).to be_truthy
-      end
-    end
-
-  end
-end

data/spec/acts_as_taggable_on/generic_parser_spec.rb

@@ -1,14 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-describe ActsAsTaggableOn::GenericParser do
-  it '#parse should return empty array if empty tag string is passed' do
-    tag_list = ActsAsTaggableOn::GenericParser.new('')
-    expect(tag_list.parse).to be_empty
-  end
-
-  it '#parse should separate tags by comma' do
-    tag_list = ActsAsTaggableOn::GenericParser.new('cool,data,,I,have')
-    expect(tag_list.parse).to eq(%w(cool data I have))
-  end
-end

data/spec/acts_as_taggable_on/related_spec.rb

@@ -1,99 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-describe 'Acts As Taggable On' do
-
-  describe 'Related Objects' do
-
-    #TODO, shared example
-    it 'should find related objects based on tag names on context' do
-      taggable1 = TaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
-      taggable2 = TaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four')
-      taggable3 = TaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
-
-      expect(taggable1.find_related_tags).to include(taggable3)
-      expect(taggable1.find_related_tags).to_not include(taggable2)
-    end
-
-    it 'finds related tags for ordered taggable on' do
-      taggable1 = OrderedTaggableModel.create!(name: 'Taggable 1',colour_list: 'one, two')
-      taggable2 = OrderedTaggableModel.create!(name: 'Taggable 2',colour_list: 'three, four')
-      taggable3 = OrderedTaggableModel.create!(name: 'Taggable 3',colour_list: 'one, four')
-
-      expect(taggable1.find_related_colours).to include(taggable3)
-      expect(taggable1.find_related_colours).to_not include(taggable2)
-    end
-
-    it 'should find related objects based on tag names on context - non standard id' do
-      taggable1 = NonStandardIdTaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
-      taggable2 = NonStandardIdTaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four')
-      taggable3 = NonStandardIdTaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
-
-      expect(taggable1.find_related_tags).to include(taggable3)
-      expect(taggable1.find_related_tags).to_not include(taggable2)
-    end
-
-    it 'should find other related objects based on tag names on context' do
-      taggable1 = TaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
-      taggable2 = OtherTaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four')
-      taggable3 = OtherTaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
-
-      expect(taggable1.find_related_tags_for(OtherTaggableModel)).to include(taggable3)
-      expect(taggable1.find_related_tags_for(OtherTaggableModel)).to_not include(taggable2)
-    end
-
-    it 'should find other related objects based on tags only from particular context' do
-      taggable1 = TaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
-      taggable2 = TaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four', skill_list: 'one, two')
-      taggable3 = TaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
-
-      expect(taggable1.find_related_tags).to include(taggable3)
-      expect(taggable1.find_related_tags).to_not include(taggable2)
-    end
-
-
-    shared_examples "a collection" do
-      it do
-        taggable1 = described_class.create!(name: 'Taggable 1', tag_list: 'one')
-        taggable2 = described_class.create!(name: 'Taggable 2', tag_list: 'one, two')
-
-        expect(taggable1.find_related_tags).to include(taggable2)
-        expect(taggable1.find_related_tags).to_not include(taggable1)
-      end
-    end
-
-    # it 'should not include the object itself in the list of related objects' do
-    describe TaggableModel do
-      it_behaves_like "a collection"
-    end
-
-    # it 'should not include the object itself in the list of related objects - non standard id' do
-    describe NonStandardIdTaggableModel do
-      it_behaves_like "a collection"
-    end
-
-    context 'Ignored Tags' do
-      let(:taggable1) { TaggableModel.create!(name: 'Taggable 1', tag_list: 'one, two, four') }
-      let(:taggable2) { TaggableModel.create!(name: 'Taggable 2', tag_list: 'two, three') }
-      let(:taggable3) { TaggableModel.create!(name: 'Taggable 3', tag_list: 'one, three') }
-
-      it 'should not include ignored tags in related search' do
-        expect(taggable1.find_related_tags(ignore: 'two')).to_not include(taggable2)
-        expect(taggable1.find_related_tags(ignore: 'two')).to include(taggable3)
-      end
-
-      it 'should accept array of ignored tags' do
-        taggable4 = TaggableModel.create!(name: 'Taggable 4', tag_list: 'four')
-
-
-        expect(taggable1.find_related_tags(ignore: ['two', 'four'])).to_not include(taggable2)
-        expect(taggable1.find_related_tags(ignore: ['two', 'four'])).to_not include(taggable4)
-      end
-
-      it 'should accept symbols as ignored tags' do
-        expect(taggable1.find_related_tags(ignore: :two)).to_not include(taggable2)
-      end
-    end
-
-  end
-end

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -1,231 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-describe 'Single Table Inheritance' do
-  let(:taggable) { TaggableModel.new(name: 'taggable model') }
-
-  let(:inheriting_model) { InheritingTaggableModel.new(name: 'Inheriting Taggable Model') }
-  let(:altered_inheriting) { AlteredInheritingTaggableModel.new(name: 'Altered Inheriting Model') }
-
-  1.upto(4) do |n|
-    let(:"inheriting_#{n}") { InheritingTaggableModel.new(name: "Inheriting Model #{n}") }
-  end
-
-  let(:student) { Student.create! }
-
-  describe 'tag contexts' do
-    it 'should pass on to STI-inherited models' do
-      expect(inheriting_model).to respond_to(:tag_list, :skill_list, :language_list)
-      expect(altered_inheriting).to respond_to(:tag_list, :skill_list, :language_list)
-    end
-
-    it 'should pass on to altered STI models' do
-      expect(altered_inheriting).to respond_to(:part_list)
-    end
-  end
-
-  context 'matching contexts' do
-
-    before do
-      inheriting_1.offering_list = 'one, two'
-      inheriting_1.need_list = 'one, two'
-      inheriting_1.save!
-
-      inheriting_2.need_list = 'one, two'
-      inheriting_2.save!
-
-      inheriting_3.offering_list = 'one, two'
-      inheriting_3.save!
-
-      inheriting_4.tag_list = 'one, two, three, four'
-      inheriting_4.save!
-
-      taggable.need_list = 'one, two'
-      taggable.save!
-    end
-
-    it 'should find objects with tags of matching contexts' do
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to include(inheriting_2)
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_3)
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_4)
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(taggable)
-
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(inheriting_2)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_3)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_4)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable)
-    end
-
-    it 'should not include the object itself in the list of related objects with tags of matching contexts' do
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_1)
-      expect(inheriting_1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs)).to_not include(inheriting_1)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_1)
-    end
-  end
-
-  context 'find related tags' do
-    before do
-      inheriting_1.tag_list = 'one, two'
-      inheriting_1.save
-
-      inheriting_2.tag_list = 'three, four'
-      inheriting_2.save
-
-      inheriting_3.tag_list = 'one, four'
-      inheriting_3.save
-
-      taggable.tag_list = 'one, two, three, four'
-      taggable.save
-    end
-
-    it 'should find related objects based on tag names on context' do
-      expect(inheriting_1.find_related_tags).to include(inheriting_3)
-      expect(inheriting_1.find_related_tags).to_not include(inheriting_2)
-      expect(inheriting_1.find_related_tags).to_not include(taggable)
-
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(inheriting_3)
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_2)
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(taggable)
-    end
-
-    it 'should not include the object itself in the list of related objects' do
-      expect(inheriting_1.find_related_tags).to_not include(inheriting_1)
-      expect(inheriting_1.find_related_tags_for(InheritingTaggableModel)).to_not include(inheriting_1)
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_1)
-    end
-  end
-
-  describe 'tag list' do
-    before do
-      @inherited_same = InheritingTaggableModel.new(name: 'inherited same')
-      @inherited_different = AlteredInheritingTaggableModel.new(name: 'inherited different')
-    end
-
-    #TODO, shared example
-    it 'should be able to save tags for inherited models' do
-      inheriting_model.tag_list = 'bob, kelso'
-      inheriting_model.save
-      expect(InheritingTaggableModel.tagged_with('bob').first).to eq(inheriting_model)
-    end
-
-    it 'should find STI tagged models on the superclass' do
-      inheriting_model.tag_list = 'bob, kelso'
-      inheriting_model.save
-      expect(TaggableModel.tagged_with('bob').first).to eq(inheriting_model)
-    end
-
-    it 'should be able to add on contexts only to some subclasses' do
-      altered_inheriting.part_list = 'fork, spoon'
-      altered_inheriting.save
-      expect(InheritingTaggableModel.tagged_with('fork', on: :parts)).to be_empty
-      expect(AlteredInheritingTaggableModel.tagged_with('fork', on: :parts).first).to eq(altered_inheriting)
-    end
-
-    it 'should have different tag_counts_on for inherited models' do
-      inheriting_model.tag_list = 'bob, kelso'
-      inheriting_model.save!
-      altered_inheriting.tag_list = 'fork, spoon'
-      altered_inheriting.save!
-
-      expect(InheritingTaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso))
-      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(fork spoon))
-      expect(TaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso fork spoon))
-    end
-
-    it 'should have different tags_on for inherited models' do
-      inheriting_model.tag_list = 'bob, kelso'
-      inheriting_model.save!
-      altered_inheriting.tag_list = 'fork, spoon'
-      altered_inheriting.save!
-
-      expect(InheritingTaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso))
-      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(fork spoon))
-      expect(TaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso fork spoon))
-    end
-
-    it 'should store same tag without validation conflict' do
-      taggable.tag_list = 'one'
-      taggable.save!
-
-      inheriting_model.tag_list = 'one'
-      inheriting_model.save!
-
-      inheriting_model.update! name: 'foo'
-    end
-
-    it "should only join with taggable's table to check type for inherited models" do
-      expect(TaggableModel.tag_counts_on(:tags).to_sql).to_not match /INNER JOIN taggable_models ON/
-      expect(InheritingTaggableModel.tag_counts_on(:tags).to_sql).to match /INNER JOIN taggable_models ON/
-    end
-  end
-
-  describe 'ownership' do
-    it 'should have taggings' do
-      student.tag(taggable, with: 'ruby,scheme', on: :tags)
-      expect(student.owned_taggings.count).to eq(2)
-    end
-
-    it 'should have tags' do
-      student.tag(taggable, with: 'ruby,scheme', on: :tags)
-      expect(student.owned_tags.count).to eq(2)
-    end
-
-    it 'should return tags for the inheriting tagger' do
-      student.tag(taggable, with: 'ruby, scheme', on: :tags)
-      expect(taggable.tags_from(student)).to eq(%w(ruby scheme))
-    end
-
-    it 'returns all owner tags on the taggable' do
-      student.tag(taggable, with: 'ruby, scheme', on: :tags)
-      student.tag(taggable, with: 'skill_one', on: :skills)
-      student.tag(taggable, with: 'english, spanish', on: :language)
-      expect(taggable.owner_tags(student).count).to eq(5)
-      expect(taggable.owner_tags(student).sort == %w(english ruby scheme skill_one spanish))
-    end
-
-
-    it 'returns owner tags on the tagger' do
-      student.tag(taggable, with: 'ruby, scheme', on: :tags)
-      expect(taggable.owner_tags_on(student, :tags).count).to eq(2)
-    end
-
-    it 'returns owner tags on the taggable for an array of contexts' do
-      student.tag(taggable, with: 'ruby, scheme', on: :tags)
-      student.tag(taggable, with: 'skill_one, skill_two', on: :skills)
-      expect(taggable.owner_tags_on(student, [:tags, :skills]).count).to eq(4)
-      expect(taggable.owner_tags_on(student, [:tags, :skills]).sort == %w(ruby scheme skill_one skill_two))
-    end
-
-    it 'should scope objects returned by tagged_with by owners' do
-      student.tag(taggable, with: 'ruby, scheme', on: :tags)
-      expect(TaggableModel.tagged_with(%w(ruby scheme), owned_by: student).count).to eq(1)
-    end
-  end
-
-  describe 'a subclass of Tag' do
-    let(:company) { Company.new(:name => 'Dewey, Cheatham & Howe') }
-    let(:user) { User.create! }
-
-    subject { Market.create! :name => 'finance' }
-
-    its(:type) { should eql 'Market' }
-
-    it 'sets STI type through string list' do
-      company.market_list = 'law, accounting'
-      company.save!
-      expect(Market.count).to eq(2)
-    end
-
-    it 'does not interfere with a normal Tag context on the same model' do
-      company.location_list = 'cambridge'
-      company.save!
-      expect(ActsAsTaggableOn::Tag.where(name: 'cambridge', type: nil)).to_not be_empty
-    end
-
-    it 'is returned with proper type through ownership' do
-      user.tag(company, :with => 'ripoffs, rackets', :on => :markets)
-      tags = company.owner_tags_on(user, :markets)
-      expect(tags.all? { |tag| tag.is_a? Market }).to be_truthy
-    end
-  end
-end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -1,176 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require 'spec_helper'
-
-describe ActsAsTaggableOn::TagList do
-  let(:tag_list) { ActsAsTaggableOn::TagList.new('awesome', 'radical') }
-  let(:another_tag_list) { ActsAsTaggableOn::TagList.new('awesome','crazy', 'alien') }
-
-  it { should be_kind_of Array }
-
-
-
-  describe '#add' do
-    it 'should be able to be add a new tag word' do
-      tag_list.add('cool')
-      expect(tag_list.include?('cool')).to be_truthy
-    end
-
-    it 'should be able to add delimited lists of words' do
-      tag_list.add('cool, wicked', parse: true)
-      expect(tag_list).to include('cool', 'wicked')
-    end
-
-    it 'should be able to add delimited list of words with quoted delimiters' do
-      tag_list.add("'cool, wicked', \"really cool, really wicked\"", parse: true)
-      expect(tag_list).to include('cool, wicked', 'really cool, really wicked')
-    end
-
-    it 'should be able to handle other uses of quotation marks correctly' do
-      tag_list.add("john's cool car, mary's wicked toy", parse: true)
-      expect(tag_list).to include("john's cool car", "mary's wicked toy")
-    end
-
-    it 'should be able to add an array of words' do
-      tag_list.add(%w(cool wicked), parse: true)
-      expect(tag_list).to include('cool', 'wicked')
-    end
-
-    it 'should quote escape tags with commas in them' do
-      tag_list.add('cool', 'rad,bodacious')
-      expect(tag_list.to_s).to eq("awesome, radical, cool, \"rad,bodacious\"")
-    end
-
-  end
-
-  describe '#remove' do
-    it 'should be able to remove words' do
-      tag_list.remove('awesome')
-      expect(tag_list).to_not include('awesome')
-    end
-
-    it 'should be able to remove delimited lists of words' do
-      tag_list.remove('awesome, radical', parse: true)
-      expect(tag_list).to be_empty
-    end
-
-    it 'should be able to remove an array of words' do
-      tag_list.remove(%w(awesome radical), parse: true)
-      expect(tag_list).to be_empty
-    end
-  end
-
-  describe '#+' do
-    it 'should not have duplicate tags' do
-      new_tag_list = tag_list + another_tag_list
-      expect(tag_list).to eq(%w[awesome radical])
-      expect(another_tag_list).to eq(%w[awesome crazy alien])
-      expect(new_tag_list).to eq(%w[awesome radical crazy alien])
-    end
-
-    it 'should have class : ActsAsTaggableOn::TagList' do
-      new_tag_list = tag_list + another_tag_list
-      expect(new_tag_list.class).to eq(ActsAsTaggableOn::TagList)
-    end
-  end
-
-  describe '#concat' do
-    it 'should not have duplicate tags' do
-      expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
-    end
-
-    it 'should have class : ActsAsTaggableOn::TagList' do
-      new_tag_list = tag_list.concat(another_tag_list)
-      expect(new_tag_list.class).to eq(ActsAsTaggableOn::TagList)
-    end
-
-    context 'without duplicates' do
-      let(:arr) { ['crazy', 'alien'] }
-      let(:another_tag_list) { ActsAsTaggableOn::TagList.new(*arr) }
-      it 'adds other list' do
-        expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
-      end
-
-      it 'adds other array' do
-        expect(tag_list.concat(arr)).to eq(%w[awesome radical crazy alien])
-      end
-    end
-  end
-
-  describe '#to_s' do
-    it 'should give a delimited list of words when converted to string' do
-      expect(tag_list.to_s).to eq('awesome, radical')
-    end
-
-    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
-    end
-  end
-
-  describe 'cleaning' do
-    it 'should parameterize if force_parameterize is set to true' do
-      ActsAsTaggableOn.force_parameterize = true
-      tag_list = ActsAsTaggableOn::TagList.new('awesome()', 'radical)(cc')
-
-      expect(tag_list.to_s).to eq('awesome, radical-cc')
-      ActsAsTaggableOn.force_parameterize = false
-    end
-
-    it 'should lowercase if force_lowercase is set to true' do
-      ActsAsTaggableOn.force_lowercase = true
-
-      tag_list = ActsAsTaggableOn::TagList.new('aweSomE', 'RaDicaL', 'Entrée')
-      expect(tag_list.to_s).to eq('awesome, radical, entrée')
-
-      ActsAsTaggableOn.force_lowercase = false
-    end
-
-    it 'should ignore case when removing duplicates if strict_case_match is false' do
-      tag_list = ActsAsTaggableOn::TagList.new('Junglist', 'JUNGLIST', 'Junglist', 'Massive', 'MASSIVE', 'MASSIVE')
-
-      expect(tag_list.to_s).to eq('Junglist, Massive')
-    end
-
-    it 'should not ignore case when removing duplicates if strict_case_match is true' do
-      ActsAsTaggableOn.strict_case_match = true
-      tag_list = ActsAsTaggableOn::TagList.new('Junglist', 'JUNGLIST', 'Junglist', 'Massive', 'MASSIVE', 'MASSIVE')
-
-      expect(tag_list.to_s).to eq('Junglist, JUNGLIST, Massive, MASSIVE')
-      ActsAsTaggableOn.strict_case_match = false
-    end
-  end
-
-  describe 'custom parser' do
-    let(:parser)       { double(parse: %w(cool wicked)) }
-    let(:parser_class) { stub_const('MyParser', Class) }
-
-    it 'should use a the default parser if none is set as parameter' do
-      allow(ActsAsTaggableOn.default_parser).to receive(:new).and_return(parser)
-      ActsAsTaggableOn::TagList.new('cool, wicked', parse: true)
-
-      expect(parser).to have_received(:parse)
-    end
-
-    it 'should use the custom parser passed as parameter' do
-      allow(parser_class).to receive(:new).and_return(parser)
-
-      ActsAsTaggableOn::TagList.new('cool, wicked', parser: parser_class)
-
-      expect(parser).to have_received(:parse)
-    end
-
-    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')
-      tag_list.parser = parser_class
-      tag_list.add('new, tag', parse: true)
-
-      expect(parser).to have_received(:parse)
-    end
-  end
-
-
-end