acts-as-taggable-on 3.1.1 → 3.2.1

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -1,137 +1,140 @@
 require 'spec_helper'
 
-describe "Tagger" do
+describe 'Tagger' do
   before(:each) do
-    clean_database!
     @user = User.create
-    @taggable = TaggableModel.create(:name => "Bob Jones")
+    @taggable = TaggableModel.create(name: 'Bob Jones')
   end
 
-  it "should have taggings" do
-    @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
-    @user.owned_taggings.size == 2
+
+
+  it 'should have taggings' do
+    @user.tag(@taggable, with: 'ruby,scheme', on: :tags)
+    expect(@user.owned_taggings.size).to eq(2)
   end
 
-  it "should have tags" do
-    @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
-    @user.owned_tags.size == 2
+  it 'should have tags' do
+    @user.tag(@taggable, with: 'ruby,scheme', on: :tags)
+    expect(@user.owned_tags.size).to eq(2)
   end
 
-  it "should scope objects returned by tagged_with by owners" do
-    @taggable2 = TaggableModel.create(:name => "Jim Jones")
-    @taggable3 = TaggableModel.create(:name => "Jane Doe")
+  it 'should scope objects returned by tagged_with by owners' do
+    @taggable2 = TaggableModel.create(name: 'Jim Jones')
+    @taggable3 = TaggableModel.create(name: 'Jane Doe')
 
     @user2 = User.new
-    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
-    @user2.tag(@taggable2, :with => 'ruby, scheme', :on => :tags)
-    @user2.tag(@taggable3, :with => 'ruby, scheme', :on => :tags)
+    @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
+    @user2.tag(@taggable2, with: 'ruby, scheme', on: :tags)
+    @user2.tag(@taggable3, with: 'ruby, scheme', on: :tags)
 
-    TaggableModel.tagged_with(%w(ruby scheme), :owned_by => @user).count.should == 1
-    TaggableModel.tagged_with(%w(ruby scheme), :owned_by => @user2).count.should == 2
+    expect(TaggableModel.tagged_with(%w(ruby scheme), owned_by: @user).count).to eq(1)
+    expect(TaggableModel.tagged_with(%w(ruby scheme), owned_by: @user2).count).to eq(2)
   end
 
-  it "only returns objects tagged by owned_by when any is true" do
+  it 'only returns objects tagged by owned_by when any is true' do
     @user2 = User.new
-    @taggable2 = TaggableModel.create(:name => "Jim Jones")
-    @taggable3 = TaggableModel.create(:name => "Jane Doe")
+    @taggable2 = TaggableModel.create(name: 'Jim Jones')
+    @taggable3 = TaggableModel.create(name: 'Jane Doe')
+
+    @user.tag(@taggable, with: 'ruby', on: :tags)
+    @user.tag(@taggable2, with: 'java', on: :tags)
+    @user2.tag(@taggable3, with: 'ruby', on: :tags)
 
-    @user.tag(@taggable, :with => 'ruby', :on => :tags)
-    @user.tag(@taggable2, :with => 'java', :on => :tags)
-    @user2.tag(@taggable3, :with => 'ruby', :on => :tags)
+    tags = TaggableModel.tagged_with(%w(ruby java), owned_by: @user, any: true)
+    expect(tags).to include(@taggable, @taggable2)
+    expect(tags.size).to eq(2)
 
-    tags = TaggableModel.tagged_with(%w(ruby java), :owned_by => @user, :any => true)
-    tags.should match_array [@taggable, @taggable2]
   end
 
-  it "only returns objects tagged by owned_by when exclude is true" do
+  it 'only returns objects tagged by owned_by when exclude is true' do
     @user2 = User.new
-    @taggable2 = TaggableModel.create(:name => "Jim Jones")
-    @taggable3 = TaggableModel.create(:name => "Jane Doe")
+    @taggable2 = TaggableModel.create(name: 'Jim Jones')
+    @taggable3 = TaggableModel.create(name: 'Jane Doe')
 
-    @user.tag(@taggable, :with => 'ruby', :on => :tags)
-    @user.tag(@taggable2, :with => 'java', :on => :tags)
-    @user2.tag(@taggable3, :with => 'java', :on => :tags)
+    @user.tag(@taggable, with: 'ruby', on: :tags)
+    @user.tag(@taggable2, with: 'java', on: :tags)
+    @user2.tag(@taggable3, with: 'java', on: :tags)
 
-    tags = TaggableModel.tagged_with(%w(ruby), :owned_by => @user, :exclude => true)
-    tags.should match_array [@taggable2]
+    tags = TaggableModel.tagged_with(%w(ruby), owned_by: @user, exclude: true)
+    expect(tags).to eq([@taggable2])
   end
 
-  it "should not overlap tags from different taggers" do
+  it 'should not overlap tags from different taggers' do
     @user2 = User.new
-    lambda{
-      @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
-      @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
-    }.should change(ActsAsTaggableOn::Tagging, :count).by(6)
+    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)
 
     [@user, @user2, @taggable].each(&:reload)
 
-    @user.owned_tags.map(&:name).sort.should == %w(ruby scheme).sort
-    @user2.owned_tags.map(&:name).sort.should == %w(java python lisp ruby).sort
+    expect(@user.owned_tags.map(&:name).sort).to eq(%w(ruby scheme).sort)
+    expect(@user2.owned_tags.map(&:name).sort).to eq(%w(java python lisp ruby).sort)
 
-    @taggable.tags_from(@user).sort.should == %w(ruby scheme).sort
-    @taggable.tags_from(@user2).sort.should == %w(java lisp python ruby).sort
+    expect(@taggable.tags_from(@user).sort).to eq(%w(ruby scheme).sort)
+    expect(@taggable.tags_from(@user2).sort).to eq(%w(java lisp python ruby).sort)
 
-    @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
-    @taggable.all_tags_on(:tags).size.should == 5
+    expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme java python lisp).sort)
+    expect(@taggable.all_tags_on(:tags).size).to eq(5)
   end
 
-  it "should not lose tags from different taggers" do
+  it 'should not lose tags from different taggers' do
     @user2 = User.create
-    @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
-    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
+    @user2.tag(@taggable, with: 'java, python, lisp, ruby', on: :tags)
+    @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
 
-    lambda {
-      @user2.tag(@taggable, :with => 'java, python, lisp', :on => :tags)
-    }.should change(ActsAsTaggableOn::Tagging, :count).by(-1)
+    expect(-> {
+      @user2.tag(@taggable, with: 'java, python, lisp', on: :tags)
+    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     [@user, @user2, @taggable].each(&:reload)
 
-    @taggable.tags_from(@user).sort.should == %w(ruby scheme).sort
-    @taggable.tags_from(@user2).sort.should == %w(java python lisp).sort
+    expect(@taggable.tags_from(@user).sort).to eq(%w(ruby scheme).sort)
+    expect(@taggable.tags_from(@user2).sort).to eq(%w(java python lisp).sort)
 
-    @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
-    @taggable.all_tags_on(:tags).length.should == 5
+    expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme java python lisp).sort)
+    expect(@taggable.all_tags_on(:tags).length).to eq(5)
   end
 
-  it "should not lose tags" do
+  it 'should not lose tags' do
     @user2 = User.create
 
-    @user.tag(@taggable, :with => 'awesome', :on => :tags)
-    @user2.tag(@taggable, :with => 'awesome, epic', :on => :tags)
+    @user.tag(@taggable, with: 'awesome', on: :tags)
+    @user2.tag(@taggable, with: 'awesome, epic', on: :tags)
 
-    lambda {
-      @user2.tag(@taggable, :with => 'epic', :on => :tags)
-    }.should change(ActsAsTaggableOn::Tagging, :count).by(-1)
+    expect(-> {
+      @user2.tag(@taggable, with: 'epic', on: :tags)
+    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     @taggable.reload
-    @taggable.all_tags_list.should include('awesome')
-    @taggable.all_tags_list.should include('epic')
+    expect(@taggable.all_tags_list).to include('awesome')
+    expect(@taggable.all_tags_list).to include('epic')
   end
 
-  it "should not lose tags" do
-    @taggable.update_attributes(:tag_list => 'ruby')
-    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
+  it 'should not lose tags' do
+    @taggable.update_attributes(tag_list: 'ruby')
+    @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
 
     [@taggable, @user].each(&:reload)
-    @taggable.tag_list.should == %w(ruby)
-    @taggable.all_tags_list.sort.should == %w(ruby scheme).sort
+    expect(@taggable.tag_list).to eq(%w(ruby))
+    expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)
 
-    lambda {
-      @taggable.update_attributes(:tag_list => "")
-    }.should change(ActsAsTaggableOn::Tagging, :count).by(-1)
+    expect(-> {
+      @taggable.update_attributes(tag_list: '')
+    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
-    @taggable.tag_list.should == []
-    @taggable.all_tags_list.sort.should == %w(ruby scheme).sort
+    expect(@taggable.tag_list).to be_empty
+    expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)
   end
 
-  it "is tagger" do
-    @user.is_tagger?.should(be_true)
+  it 'is tagger' do
+    expect(@user.is_tagger?).to be_truthy
   end
 
-  it "should skip save if skip_save is passed as option" do
-    lambda {
-      @user.tag(@taggable, :with => 'epic', :on => :tags, :skip_save => true)
-    }.should_not change(ActsAsTaggableOn::Tagging, :count)
+  it 'should skip save if skip_save is passed as option' do
+    expect(-> {
+      @user.tag(@taggable, with: 'epic', on: :tags, skip_save: true)
+    }).to_not change(ActsAsTaggableOn::Tagging, :count)
   end
 
 end

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -2,27 +2,26 @@ require 'spec_helper'
 
 describe ActsAsTaggableOn::Tagging do
   before(:each) do
-    clean_database!
     @tagging = ActsAsTaggableOn::Tagging.new
   end
 
-  it "should not be valid with a invalid tag" do
-    @tagging.taggable = TaggableModel.create(:name => "Bob Jones")
-    @tagging.tag = ActsAsTaggableOn::Tag.new(:name => "")
-    @tagging.context = "tags"
+  it 'should not be valid with a invalid tag' do
+    @tagging.taggable = TaggableModel.create(name: 'Bob Jones')
+    @tagging.tag = ActsAsTaggableOn::Tag.new(name: '')
+    @tagging.context = 'tags'
 
-    @tagging.should_not be_valid
-    
-    @tagging.errors[:tag_id].should == ["can't be blank"]
+    expect(@tagging).to_not be_valid
+
+    expect(@tagging.errors[:tag_id]).to eq(['can\'t be blank'])
   end
 
-  it "should not create duplicate taggings" do
-    @taggable = TaggableModel.create(:name => "Bob Jones")
-    @tag = ActsAsTaggableOn::Tag.create(:name => "awesome")
+  it 'should not create duplicate taggings' do
+    @taggable = TaggableModel.create(name: 'Bob Jones')
+    @tag = ActsAsTaggableOn::Tag.create(name: 'awesome')
 
-    lambda {
-      2.times { ActsAsTaggableOn::Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
-    }.should change(ActsAsTaggableOn::Tagging, :count).by(1)
+    expect(-> {
+      2.times { ActsAsTaggableOn::Tagging.create(taggable: @taggable, tag: @tag, context: 'tags') }
+    }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
   end
   
 end

data/spec/acts_as_taggable_on/tags_helper_spec.rb

@@ -2,43 +2,43 @@ require 'spec_helper'
 
 describe ActsAsTaggableOn::TagsHelper do
   before(:each) do
-    clean_database!
-
-    @bob = TaggableModel.create(:name => "Bob Jones",  :language_list => "ruby, php")
-    @tom = TaggableModel.create(:name => "Tom Marley", :language_list => "ruby, java")
-    @eve = TaggableModel.create(:name => "Eve Nodd",   :language_list => "ruby, c++")
-
-    @helper = class Helper
-      include ActsAsTaggableOn::TagsHelper
-    end.new
+    @bob = TaggableModel.create(name: 'Bob Jones', language_list: 'ruby, php')
+    @tom = TaggableModel.create(name: 'Tom Marley', language_list: 'ruby, java')
+    @eve = TaggableModel.create(name: 'Eve Nodd', language_list: 'ruby, c++')
+
+    @helper =
+        class Helper
+          include ActsAsTaggableOn::TagsHelper
+        end.new
   end
 
-  it "should yield the proper css classes" do
-    tags = { }
 
-    @helper.tag_cloud(TaggableModel.tag_counts_on(:languages), ["sucky", "awesome"]) do |tag, css_class|
+  it 'should yield the proper css classes' do
+    tags = {}
+
+    @helper.tag_cloud(TaggableModel.tag_counts_on(:languages), %w(sucky awesome)) do |tag, css_class|
       tags[tag.name] = css_class
     end
 
-    tags["ruby"].should == "awesome"
-    tags["java"].should == "sucky"
-    tags["c++"].should == "sucky"
-    tags["php"].should == "sucky"
+    expect(tags['ruby']).to eq('awesome')
+    expect(tags['java']).to eq('sucky')
+    expect(tags['c++']).to eq('sucky')
+    expect(tags['php']).to eq('sucky')
   end
 
-  it "should handle tags with zero counts (build for empty)" do
-    bob = ActsAsTaggableOn::Tag.create(:name => "php")
-    tom = ActsAsTaggableOn::Tag.create(:name => "java")
-    eve = ActsAsTaggableOn::Tag.create(:name => "c++")
+  it 'should handle tags with zero counts (build for empty)' do
+    ActsAsTaggableOn::Tag.create(name: 'php')
+    ActsAsTaggableOn::Tag.create(name: 'java')
+    ActsAsTaggableOn::Tag.create(name: 'c++')
 
-    tags = { }
+    tags = {}
 
-    @helper.tag_cloud(ActsAsTaggableOn::Tag.all, ["sucky", "awesome"]) do |tag, css_class|
+    @helper.tag_cloud(ActsAsTaggableOn::Tag.all, %w(sucky awesome)) do |tag, css_class|
       tags[tag.name] = css_class
     end
 
-    tags["java"].should == "sucky"
-    tags["c++"].should == "sucky"
-    tags["php"].should == "sucky"
+    expect(tags['java']).to eq('sucky')
+    expect(tags['c++']).to eq('sucky')
+    expect(tags['php']).to eq('sucky')
   end
 end

data/spec/acts_as_taggable_on/utils_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
 describe ActsAsTaggableOn::Utils do
-  describe "like_operator" do
+  describe 'like_operator' do
     before(:each) do
-      clean_database!
       TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
-      @taggable = TaggableModel.new(:name => "Bob Jones")
+      @taggable = TaggableModel.new(name: 'Bob Jones')
     end
 
-    it "should return 'ILIKE' when the adapter is PostgreSQL" do
-      TaggableModel.connection.stub(:adapter_name).and_return("PostgreSQL")
-      TaggableModel.send(:like_operator).should == "ILIKE"
+
+    it 'should return \'ILIKE\' when the adapter is PostgreSQL' do
+      allow(TaggableModel.connection).to receive(:adapter_name) { 'PostgreSQL' }
+      expect(TaggableModel.send(:like_operator)).to eq('ILIKE')
     end
 
-    it "should return 'LIKE' when the adapter is not PostgreSQL" do
-      TaggableModel.connection.stub(:adapter_name).and_return("MySQL")
-      TaggableModel.send(:like_operator).should == "LIKE"
+    it 'should return \'LIKE\' when the adapter is not PostgreSQL' do
+      allow(TaggableModel.connection).to receive(:adapter_name) { 'MySQL' }
+      expect(TaggableModel.send(:like_operator)).to eq('LIKE')
     end
   end
 end

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

@@ -0,0 +1,3 @@
+class AlteredInheritingTaggableModel < TaggableModel
+  acts_as_taggable_on :parts
+end

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

@@ -0,0 +1,3 @@
+class CachedModel < ActiveRecord::Base
+  acts_as_taggable
+end

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

@@ -0,0 +1,5 @@
+if ActsAsTaggableOn::Utils.using_postgresql?
+  class CachedModelWithArray < ActiveRecord::Base
+    acts_as_taggable
+  end
+end

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

@@ -0,0 +1,15 @@
+class Company < ActiveRecord::Base
+  acts_as_taggable_on :locations, :markets
+
+  has_many :markets, :through => :market_taggings, :source => :tag
+
+  private
+
+  def find_or_create_tags_from_list_with_context(tag_list, context)
+    if context.to_sym == :markets
+      Market.find_or_create_all_with_like_by_name(tag_list)
+    else
+      super
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+class InheritingTaggableModel < TaggableModel
+end

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

@@ -0,0 +1,2 @@
+class Market < ActsAsTaggableOn::Tag
+end

data/spec/{models.rb → internal/app/models/models.rb}

@@ -6,7 +6,8 @@ class TaggableModel < ActiveRecord::Base
   has_many :untaggable_models
 
   attr_reader :tag_list_submethod_called
-  def tag_list=v
+
+  def tag_list=(v)
     @tag_list_submethod_called = true
     super
   end
@@ -32,6 +33,25 @@ class AlteredInheritingTaggableModel < TaggableModel
   acts_as_taggable_on :parts
 end
 
+class Market < ActsAsTaggableOn::Tag
+end
+
+class Company < ActiveRecord::Base
+  acts_as_taggable_on :locations, :markets
+
+  has_many :markets, :through => :market_taggings, :source => :tag
+
+  private
+
+  def find_or_create_tags_from_list_with_context(tag_list, context)
+    if context.to_sym == :markets
+      Market.find_or_create_all_with_like_by_name(tag_list)
+    else
+      super
+    end
+  end
+end
+
 class User < ActiveRecord::Base
   acts_as_tagger
 end
@@ -44,7 +64,7 @@ class UntaggableModel < ActiveRecord::Base
 end
 
 class NonStandardIdTaggableModel < ActiveRecord::Base
-  primary_key = "an_id"
+  self.primary_key = :an_id
   acts_as_taggable
   acts_as_taggable_on :languages
   acts_as_taggable_on :skills
@@ -56,3 +76,15 @@ class OrderedTaggableModel < ActiveRecord::Base
   acts_as_ordered_taggable
   acts_as_ordered_taggable_on :colours
 end
+
+if ActsAsTaggableOn::Utils.using_postgresql?
+  class CachedModelWithArray < ActiveRecord::Base
+    acts_as_taggable
+  end
+  if ActsAsTaggableOn::Utils.postgresql_support_json?
+    class TaggableModelWithJson < ActiveRecord::Base
+      acts_as_taggable
+      acts_as_taggable_on :skills
+    end
+  end
+end