acts-as-taggable-on 4.0.0.pre → 7.0.0

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,3 @@
 module ActsAsTaggableOn
-  VERSION = '4.0.0.pre'
+  VERSION = '7.0.0'
 end
-

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -73,14 +73,6 @@ describe 'Acts As Taggable On' do
     end
   end
 
-  describe 'Reloading' do
-    it 'should save a model instantiated by Model.find' do
-      taggable = TaggableModel.create!(name: 'Taggable')
-      found_taggable = TaggableModel.find(taggable.id)
-      found_taggable.save
-    end
-  end
-
   describe 'Matching Contexts' do
     it 'should find objects with tags of matching contexts' do
       taggable1 = TaggableModel.create!(name: 'Taggable 1')
@@ -142,7 +134,7 @@ describe 'Acts As Taggable On' do
       taggable1.save
 
       column = TaggableModel.connection.quote_column_name("context")
-      offer_alias = TaggableModel.connection.quote_table_name("taggings")
+      offer_alias = TaggableModel.connection.quote_table_name(ActsAsTaggableOn.taggings_table)
       need_alias = TaggableModel.connection.quote_table_name("need_taggings_taggable_models_join")
 
       expect(TaggableModel.joins(:offerings, :needs).to_sql).to include "#{offer_alias}.#{column}"
@@ -200,7 +192,7 @@ describe 'Acts As Taggable On' do
       its(:cached_glass_list)    { should be_blank }
 
       context 'language taggings cache after update' do
-        before  { @taggable.update_attributes(language_list: 'ruby, .net') }
+        before  { @taggable.update(language_list: 'ruby, .net') }
         subject { @taggable }
 
         its(:language_list)        { should == ['ruby', '.net']}
@@ -209,7 +201,7 @@ describe 'Acts As Taggable On' do
       end
 
       context 'status taggings cache after update' do
-        before  { @taggable.update_attributes(status_list: 'happy, married') }
+        before  { @taggable.update(status_list: 'happy, married') }
         subject { @taggable }
 
         its(:status_list)        { should     == ['happy', 'married'] }
@@ -222,7 +214,7 @@ describe 'Acts As Taggable On' do
 
       context 'glass taggings cache after update' do
         before do
-          @taggable.update_attributes(glass_list: 'rectangle, aviator')
+          @taggable.update(glass_list: 'rectangle, aviator')
         end
 
         subject { @taggable }

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -31,40 +31,40 @@ describe 'Acts As Taggable On' do
     end
 
     it 'should cache tags' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome, epic')
       expect(@taggable.cached_tag_list).to eq('awesome, epic')
 
-      @another_taggable.update_attributes(language_list: 'ruby, .net')
+      @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_attributes(tag_list: 'awesome, epic')
+      @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_attributes(tag_list: 'awesome, epic')
-      @taggable.update_attributes(tag_list: 'awesome')
+      @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_attributes(tag_list: 'awesome, epic')
-      @taggable.update_attributes(tag_list: '')
+      @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_attributes(tag_list: 'awesome, epic')
+      @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_attributes(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome, epic')
       @taggable = CachedModel.find(@taggable.id)
       @taggable.save!
       expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
@@ -75,6 +75,12 @@ describe 'Acts As Taggable On' do
       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
@@ -89,7 +95,7 @@ describe 'Acts As Taggable On' do
     end
 
     it 'should cache tags with custom delimiter' do
-      @taggable.update_attributes(tag_list: 'awesome; epic')
+      @taggable.update(tag_list: 'awesome; epic')
       expect(@taggable.tag_list).to eq(['awesome', 'epic'])
       expect(@taggable.cached_tag_list).to eq('awesome; epic')
 
@@ -99,6 +105,24 @@ describe 'Acts As Taggable On' do
     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

data/spec/acts_as_taggable_on/{taggable/dirty_spec.rb → dirty_spec.rb}

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 require 'spec_helper'
 
-describe ActsAsTaggableOn::Taggable::Dirty do
+describe 'Dirty behavior of taggable objects' do
   context 'with un-contexted tags' do
     before(:each) do
       @taggable = TaggableModel.create(tag_list: 'awesome, epic')
@@ -14,19 +14,27 @@ describe ActsAsTaggableOn::Taggable::Dirty do
       end
 
       it 'should show changes of dirty object' do
-        expect(@taggable.changes).to eq({'tag_list' => ['awesome, epic', ['one']]})
+        expect(@taggable.changes).to eq({'tag_list' => [['awesome', 'epic'], ['one']]})
       end
 
-      it 'flags tag_list as changed' do
-        expect(@taggable.tag_list_changed?).to be_truthy
+      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')
+        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']])
+        expect(@taggable.tag_list_change).to eq([['awesome', 'epic'], ['one']])
       end
 
       context 'without order' do
@@ -90,7 +98,7 @@ describe ActsAsTaggableOn::Taggable::Dirty do
       end
 
       it 'should show changes of dirty object' do
-        expect(@taggable.changes).to eq({'language_list' => ['awesome, epic', ['one']]})
+        expect(@taggable.changes).to eq({'language_list' => [['awesome', 'epic'], ['one']]})
       end
 
       it 'flags language_list as changed' do
@@ -98,15 +106,11 @@ describe ActsAsTaggableOn::Taggable::Dirty do
       end
 
       it 'preserves original value' do
-        expect(@taggable.language_list_was).to eq('awesome, epic')
+        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
-
-      it 'shows what the changes were' do
-        expect(@taggable.language_list_changes).to eq(['awesome, epic', ['one']])
+        expect(@taggable.language_list_change).to eq([['awesome', 'epic'], ['one']])
       end
     end
 
@@ -123,5 +127,16 @@ describe ActsAsTaggableOn::Taggable::Dirty 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/single_table_inheritance_spec.rb

@@ -127,9 +127,9 @@ describe 'Single Table Inheritance' do
       altered_inheriting.tag_list = 'fork, spoon'
       altered_inheriting.save!
 
-      expect(InheritingTaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso))
-      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(fork spoon))
-      expect(TaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso fork spoon))
+      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
@@ -138,9 +138,9 @@ describe 'Single Table Inheritance' do
       altered_inheriting.tag_list = 'fork, spoon'
       altered_inheriting.save!
 
-      expect(InheritingTaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso))
-      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(fork spoon))
-      expect(TaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso fork spoon))
+      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
@@ -150,7 +150,12 @@ describe 'Single Table Inheritance' do
       inheriting_model.tag_list = 'one'
       inheriting_model.save!
 
-      inheriting_model.update_attributes! name: 'foo'
+      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
 
@@ -170,11 +175,27 @@ describe 'Single Table Inheritance' do
       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)
@@ -208,4 +229,3 @@ describe 'Single Table Inheritance' do
     end
   end
 end
-

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -200,8 +200,8 @@ describe 'Taggable' do
     @taggables[1].skill_list = 'css'
     @taggables.each { |taggable| taggable.save }
 
-    @found_taggables_by_tag = TaggableModel.joins(:tags).where(tags: {name: ['bob']})
-    @found_taggables_by_skill = TaggableModel.joins(:skills).where(tags: {name: ['ruby']})
+    @found_taggables_by_tag = TaggableModel.joins(:tags).where(ActsAsTaggableOn.tags_table => {name: ['bob']})
+    @found_taggables_by_skill = TaggableModel.joins(:skills).where(ActsAsTaggableOn.tags_table => {name: ['ruby']})
 
     expect(@found_taggables_by_tag).to include @taggables[0]
     expect(@found_taggables_by_tag).to_not include @taggables[1]
@@ -247,7 +247,7 @@ describe 'Taggable' do
     expect(TaggableModel.tagged_with("ruby", :start_at => today, :end_at => tomorrow).count).to eq(1)
   end
 
-    it "shouldn't be able to find a tag outside date range" do
+  it "shouldn't be able to find a tag outside date range" do
     @taggable.skill_list = "ruby"
     @taggable.save
 
@@ -255,14 +255,17 @@ describe 'Taggable' do
   end
 
   it 'should be able to find by tag with context' do
-    @taggable.skill_list = 'ruby, rails, css'
-    @taggable.tag_list = 'bob, charlie'
+    @taggable.skill_list = 'ruby, rails, css, julia'
+    @taggable.tag_list = 'bob, charlie, julia'
     @taggable.save
 
     expect(TaggableModel.tagged_with('ruby').first).to eq(@taggable)
     expect(TaggableModel.tagged_with('ruby, css').first).to eq(@taggable)
     expect(TaggableModel.tagged_with('bob', on: :skills).first).to_not eq(@taggable)
     expect(TaggableModel.tagged_with('bob', on: :tags).first).to eq(@taggable)
+    expect(TaggableModel.tagged_with('julia', on: :skills).size).to eq(1)
+    expect(TaggableModel.tagged_with('julia', on: :tags).size).to eq(1)
+    expect(TaggableModel.tagged_with('julia', on: nil).size).to eq(2)
   end
 
   it 'should not care about case' do
@@ -335,7 +338,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
     expect(TaggableModel.all_tag_counts).to_not be_empty
-    expect(TaggableModel.all_tag_counts(order: 'tags.id').first.count).to eq(3) # ruby
+    expect(TaggableModel.all_tag_counts(order: "#{ActsAsTaggableOn.tags_table}.id").first.count).to eq(3) # ruby
   end
 
   it 'should be able to get all tags on model as whole' do
@@ -344,7 +347,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
     expect(TaggableModel.all_tags).to_not be_empty
-    expect(TaggableModel.all_tags(order: 'tags.id').first.name).to eq('ruby')
+    expect(TaggableModel.all_tags(order: "#{ActsAsTaggableOn.tags_table}.id").first.name).to eq('ruby')
   end
 
   it 'should be able to use named scopes to chain tag finds by any tags by context' do
@@ -366,7 +369,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    expect(TaggableModel.tagged_with('ruby').tag_counts(order: 'tags.id').first.count).to eq(2) # ruby
+    expect(TaggableModel.tagged_with('ruby').tag_counts(order: "#{ActsAsTaggableOn.tags_table}.id").first.count).to eq(2) # ruby
     expect(TaggableModel.tagged_with('ruby').skill_counts.first.count).to eq(1) # ruby
   end
 
@@ -375,7 +378,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    expect(TaggableModel.tagged_with('ruby').all_tag_counts(order: 'tags.id').first.count).to eq(3) # ruby
+    expect(TaggableModel.tagged_with('ruby').all_tag_counts(order: "#{ActsAsTaggableOn.tags_table}.id").first.count).to eq(3) # ruby
   end
 
   it 'should be able to get all scoped tags' do
@@ -383,7 +386,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    expect(TaggableModel.tagged_with('ruby').all_tags(order: 'tags.id').first.name).to eq('ruby')
+    expect(TaggableModel.tagged_with('ruby').all_tags(order: "#{ActsAsTaggableOn.tags_table}.id").first.name).to eq('ruby')
   end
 
   it 'should only return tag counts for the available scope' do
@@ -474,7 +477,7 @@ describe 'Taggable' do
 
       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: true, exclude: true).to_a).to eq([jim])
-      expect(TaggableModel.tagged_with('ji', wild: true, any: true).to_a =~ [frank, jim])
+      expect(TaggableModel.tagged_with('ji', wild: true, any: true).to_a).to match_array([frank, jim])
     end
   end
 
@@ -538,7 +541,7 @@ describe 'Taggable' do
 
   it 'should not delete tags if not updated' do
     model = TaggableModel.create(name: 'foo', tag_list: 'ruby, rails, programming')
-    model.update_attributes(name: 'bar')
+    model.update(name: 'bar')
     model.reload
     expect(model.tag_list.sort).to eq(%w(ruby rails programming).sort)
   end
@@ -669,7 +672,7 @@ describe 'Taggable' do
       # NOTE: type column supports an STI Tag subclass in the test suite, though
       # isn't included by default in the migration generator
       expect(@taggable.grouped_column_names_for(ActsAsTaggableOn::Tag))
-      .to eq('tags.id, tags.name, tags.taggings_count, tags.type')
+      .to eq("#{ActsAsTaggableOn.tags_table}.id, #{ActsAsTaggableOn.tags_table}.name, #{ActsAsTaggableOn.tags_table}.taggings_count, #{ActsAsTaggableOn.tags_table}.type")
     end
 
     it 'should return all column names joined for TaggableModel GROUP clause' do

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -112,7 +112,7 @@ describe 'Tagger' do
   end
 
   it 'should not lose tags' do
-    @taggable.update_attributes(tag_list: 'ruby')
+    @taggable.update(tag_list: 'ruby')
     @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
 
     [@taggable, @user].each(&:reload)
@@ -120,7 +120,7 @@ describe 'Tagger' do
     expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)
 
     expect(-> {
-      @taggable.update_attributes(tag_list: '')
+      @taggable.update(tag_list: '')
     }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     expect(@taggable.tag_list).to be_empty

data/spec/internal/app/models/altered_inheriting_taggable_model.rb

@@ -1,3 +1,5 @@
+require_relative 'taggable_model'
+
 class AlteredInheritingTaggableModel < TaggableModel
   acts_as_taggable_on :parts
 end

data/spec/internal/app/models/cached_model_with_array.rb

@@ -2,4 +2,10 @@ if using_postgresql?
   class CachedModelWithArray < ActiveRecord::Base
     acts_as_taggable
   end
+  if postgresql_support_json?
+    class TaggableModelWithJson < ActiveRecord::Base
+      acts_as_taggable
+      acts_as_taggable_on :skills
+    end
+  end
 end