sb-acts-as-taggable-on 6.5.0

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -0,0 +1,112 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe 'acts_as_tagger' do
+
+  describe 'Tagger Method Generation' do
+    before(:each) do
+      @tagger = User.new
+    end
+
+    it 'should add #is_tagger? query method to the class-side' do
+      expect(User).to respond_to(:is_tagger?)
+    end
+
+    it 'should return true from the class-side #is_tagger?' do
+      expect(User.is_tagger?).to be_truthy
+    end
+
+    it 'should return false from the base #is_tagger?' do
+      expect(ActiveRecord::Base.is_tagger?).to be_falsy
+    end
+
+    it 'should add #is_tagger? query method to the singleton' do
+      expect(@tagger).to respond_to(:is_tagger?)
+    end
+
+    it 'should add #tag method on the instance-side' do
+      expect(@tagger).to respond_to(:tag)
+    end
+
+    it 'should generate an association for #owned_taggings and #owned_tags' do
+      expect(@tagger).to respond_to(:owned_taggings, :owned_tags)
+    end
+  end
+
+  describe '#tag' do
+    context 'when called with a non-existent tag context' do
+      before(:each) do
+        @tagger = User.new
+        @taggable = TaggableModel.new(name: 'Richard Prior')
+      end
+
+      it 'should by default not throw an exception ' do
+        expect(@taggable.tag_list_on(:foo)).to be_empty
+        expect(-> {
+          @tagger.tag(@taggable, with: 'this, and, that', on: :foo)
+        }).to_not raise_error
+      end
+
+      it 'should by default create the tag context on-the-fly' do
+        expect(@taggable.tag_list_on(:here_ond_now)).to be_empty
+        @tagger.tag(@taggable, with: 'that', on: :here_ond_now)
+        expect(@taggable.tag_list_on(:here_ond_now)).to_not include('that')
+        expect(@taggable.all_tags_list_on(:here_ond_now)).to include('that')
+      end
+
+      it 'should show all the tag list when both public and owned tags exist' do
+        @taggable.tag_list = 'ruby, python'
+        @tagger.tag(@taggable, with: 'java, lisp', on: :tags)
+        expect(@taggable.all_tags_on(:tags).map(&:name).sort).to eq(%w(ruby python java lisp).sort)
+      end
+
+      it 'should not add owned tags to the common list' do
+        @taggable.tag_list = 'ruby, python'
+        @tagger.tag(@taggable, with: 'java, lisp', on: :tags)
+        expect(@taggable.tag_list).to eq(%w(ruby python))
+        @tagger.tag(@taggable, with: '', on: :tags)
+        expect(@taggable.tag_list).to eq(%w(ruby python))
+      end
+
+      it 'should throw an exception when the default is over-ridden' do
+        expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+        expect(-> {
+          @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false)
+        }).to raise_error(RuntimeError)
+      end
+
+      it 'should not create the tag context on-the-fly when the default is over-ridden' do
+        expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+        @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false) rescue
+            expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+      end
+    end
+
+    describe "when called by multiple tagger's" do
+      before(:each) do
+        @user_x = User.create(name: 'User X')
+        @user_y = User.create(name: 'User Y')
+        @taggable = TaggableModel.create(name: 'acts_as_taggable_on', tag_list: 'plugin')
+
+        @user_x.tag(@taggable, with: 'ruby, rails', on: :tags)
+        @user_y.tag(@taggable, with: 'ruby, plugin', on: :tags)
+
+        @user_y.tag(@taggable, with: '', on: :tags)
+        @user_y.tag(@taggable, with: '', on: :tags)
+      end
+
+      it 'should delete owned tags' do
+        expect(@user_y.owned_tags).to be_empty
+      end
+
+      it 'should not delete other taggers tags' do
+        expect(@user_x.owned_tags.count).to eq(2)
+      end
+
+      it 'should not delete original tags' do
+        expect(@taggable.all_tags_list_on(:tags)).to include('plugin')
+      end
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -0,0 +1,129 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe 'Acts As Taggable On' do
+
+  describe 'Caching' do
+    before(:each) do
+      @taggable = CachedModel.new(name: 'Bob Jones')
+      @another_taggable = OtherCachedModel.new(name: 'John Smith')
+    end
+
+    it 'should add saving of tag lists and cached tag lists to the instance' do
+      expect(@taggable).to respond_to(:save_cached_tag_list)
+      expect(@another_taggable).to respond_to(:save_cached_tag_list)
+
+      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?)
+    end
+
+    it 'should not have cached tags' do
+      expect(@taggable.cached_tag_list).to be_blank
+      expect(@another_taggable.cached_language_list).to be_blank
+    end
+
+    it 'should cache tags' do
+      @taggable.update(tag_list: 'awesome, epic')
+      expect(@taggable.cached_tag_list).to eq('awesome, epic')
+
+      @another_taggable.update(language_list: 'ruby, .net')
+      expect(@another_taggable.cached_language_list).to eq('ruby, .net')
+    end
+
+    it 'should keep the cache' do
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.save!
+      expect(@taggable.cached_tag_list).to eq('awesome, epic')
+    end
+
+    it 'should update the cache' do
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome')
+      expect(@taggable.cached_tag_list).to eq('awesome')
+    end
+
+    it 'should remove the cache' do
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: '')
+      expect(@taggable.cached_tag_list).to be_blank
+    end
+
+    it 'should have a tag list' do
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
+    end
+
+    it 'should keep the tag list' do
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.save!
+      expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
+    end
+
+    it 'should clear the cache on reset_column_information' do
+      CachedModel.column_names
+      CachedModel.reset_column_information
+      expect(CachedModel.instance_variable_get(:@acts_as_taggable_on_cache_columns)).to eql(nil)
+    end
+
+    it 'should not override a user-defined columns method' do
+      expect(ColumnsOverrideModel.columns.map(&:name)).not_to include('ignored_column')
+      ColumnsOverrideModel.acts_as_taggable
+      expect(ColumnsOverrideModel.columns.map(&:name)).not_to include('ignored_column')
+    end
+  end
+
+  describe 'with a custom delimiter' do
+    before(:each) do
+      @taggable = CachedModel.new(name: 'Bob Jones')
+      @another_taggable = OtherCachedModel.new(name: 'John Smith')
+      ActsAsTaggableOn.delimiter = ';'
+    end
+
+    after(:all) do
+      ActsAsTaggableOn.delimiter = ','
+    end
+
+    it 'should cache tags with custom delimiter' do
+      @taggable.update(tag_list: 'awesome; epic')
+      expect(@taggable.tag_list).to eq(['awesome', 'epic'])
+      expect(@taggable.cached_tag_list).to eq('awesome; epic')
+
+      @taggable = CachedModel.find_by_name('Bob Jones')
+      expect(@taggable.tag_list).to eq(['awesome', 'epic'])
+      expect(@taggable.cached_tag_list).to eq('awesome; epic')
+    end
+  end
+
+  describe 'Cache methods initialization on new models' do
+    before(:all) do
+      ActiveRecord::Base.connection.execute(
+        'INSERT INTO cache_methods_injected_models (cached_tag_list) VALUES (\'ciao\')'
+      )
+      class CacheMethodsInjectedModel < ActiveRecord::Base
+        acts_as_taggable
+      end
+    end
+    after(:all) { Object.send(:remove_const, :CacheMethodsInjectedModel) }
+
+    it 'cached_tag_list_on? get injected correctly' do
+      expect do
+        CacheMethodsInjectedModel.first.tag_list
+      end.not_to raise_error
+    end
+  end
+
+  describe 'CachingWithArray' do
+    pending '#TODO'
+  end
+end

data/spec/acts_as_taggable_on/default_parser_spec.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::DefaultParser do
+  it '#parse should return empty array if empty array is passed' do
+    parser = ActsAsTaggableOn::DefaultParser.new([])
+    expect(parser.parse).to be_empty
+  end
+
+  describe 'Multiple Delimiter' do
+    before do
+      @old_delimiter = ActsAsTaggableOn.delimiter
+    end
+
+    after do
+      ActsAsTaggableOn.delimiter = @old_delimiter
+    end
+
+    it 'should separate tags by delimiters' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      parser = ActsAsTaggableOn::DefaultParser.new('cool, data|I have')
+      expect(parser.parse.to_s).to eq('cool, data, I, have')
+    end
+
+    it 'should escape quote' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      parser = ActsAsTaggableOn::DefaultParser.new("'I have'|cool, data")
+      expect(parser.parse.to_s).to eq('"I have", cool, data')
+
+      parser = ActsAsTaggableOn::DefaultParser.new('"I, have"|cool, data')
+      expect(parser.parse.to_s).to eq('"I, have", cool, data')
+    end
+
+    it 'should work for utf8 delimiter and long delimiter' do
+      ActsAsTaggableOn.delimiter = ['，', '的', '可能是']
+      parser = ActsAsTaggableOn::DefaultParser.new('我的东西可能是不见了，还好有备份')
+      expect(parser.parse.to_s).to eq('我， 东西， 不见了， 还好有备份')
+    end
+
+    it 'should work for multiple quoted tags' do
+      ActsAsTaggableOn.delimiter = [',']
+      parser = ActsAsTaggableOn::DefaultParser.new('"Ruby Monsters","eat Katzenzungen"')
+      expect(parser.parse.to_s).to eq('Ruby Monsters, eat Katzenzungen')
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/dirty_spec.rb

@@ -0,0 +1,142 @@
+# -*- 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

@@ -0,0 +1,14 @@
+# -*- 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

@@ -0,0 +1,99 @@
+# -*- 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