acts-as-taggable-on 2.0.0 → 3.2.2

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -1,91 +1,140 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
-describe "Tagger" do
+describe 'Tagger' do
   before(:each) do
-    clean_database!
-    @user = TaggableUser.create
-    @taggable = TaggableModel.create(:name => "Bob Jones")
+    @user = User.create
+    @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)
+    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')
+
+    @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)
+
+    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 "should have tags" do
-    @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
-    @user.owned_tags.size == 2
+  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')
+
+    @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)
+
+  end
+
+  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')
+
+    @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)
+    expect(tags).to eq([@taggable2])
   end
-  
-  it "should not overlap tags from different taggers" do
-    @user2 = TaggableUser.new
-    lambda{
-      @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
-      @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
-    }.should change(Tagging, :count).by(6)
+
+  it 'should not overlap tags from different taggers' do
+    @user2 = User.new
+    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
-    
-    @taggable.tags_from(@user).sort.should == %w(ruby scheme).sort
-    @taggable.tags_from(@user2).sort.should == %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(@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)
+
+    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)
+
+    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
-    @user2 = TaggableUser.create
-    @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(Tagging, :count).by(-1)
+
+  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)
+
+    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
-    
-    @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
-    @taggable.all_tags_on(:tags).length.should == 5
+
+    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)
+
+    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
-    @user2 = TaggableUser.create
-    
-    @user.tag(@taggable, :with => 'awesome', :on => :tags)
-    @user2.tag(@taggable, :with => 'awesome, epic', :on => :tags)
+  it 'should not lose tags' do
+    @user2 = User.create
 
-    lambda {
-      @user2.tag(@taggable, :with => 'epic', :on => :tags)
-    }.should change(Tagging, :count).by(-1)
+    @user.tag(@taggable, with: 'awesome', on: :tags)
+    @user2.tag(@taggable, with: 'awesome, epic', on: :tags)
 
-    @taggable.reload  
-    @taggable.all_tags_list.should include('awesome')
-    @taggable.all_tags_list.should include('epic')
+    expect(-> {
+      @user2.tag(@taggable, with: 'epic', on: :tags)
+    }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
+
+    @taggable.reload
+    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
-    
-    lambda {
-      @taggable.update_attributes(:tag_list => "")
-    }.should change(Tagging, :count).by(-1)
-    
-    @taggable.tag_list.should == []
-    @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)
+
+    expect(-> {
+      @taggable.update_attributes(tag_list: '')
+    }).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)
+  end
+
+  it 'is tagger' do
+    expect(@user.is_tagger?).to be_truthy
+  end
+
+  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
 
-  it "is tagger" do
-    @user.is_tagger?.should(be_true)
-  end  
-end
+end

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -1,31 +1,27 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
-describe Tagging do
+describe ActsAsTaggableOn::Tagging do
   before(:each) do
-    clean_database!
-    @tagging = Tagging.new
+    @tagging = ActsAsTaggableOn::Tagging.new
   end
 
-  it "should not be valid with a invalid tag" do
-    @tagging.taggable = TaggableModel.create(:name => "Bob Jones")
-    @tagging.tag = 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
-    
-    if ActiveRecord::VERSION::MAJOR >= 3
-      @tagging.errors[:tag_id].should == ["can't be blank"]
-    else
-      @tagging.errors[:tag_id].should == "can't be blank"
-    end
+    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 = 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 { Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
-    }.should change(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

@@ -1,28 +1,44 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
-describe TagsHelper do
+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 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), %w(sucky awesome)) do |tag, css_class|
+      tags[tag.name] = css_class
+    end
+
+    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 yield the proper css classes" do 
-    tags = { }
-    
-    @helper.tag_cloud(TaggableModel.tag_counts_on(:languages), ["sucky", "awesome"]) do |tag, css_class|
+
+  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 = {}
+
+    @helper.tag_cloud(ActsAsTaggableOn::Tag.all, %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['java']).to eq('sucky')
+    expect(tags['c++']).to eq('sucky')
+    expect(tags['php']).to eq('sucky')
   end
-end
+end

data/spec/acts_as_taggable_on/utils_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ActsAsTaggableOn::Utils do
+  describe '#like_operator' do
+    it 'should return \'ILIKE\' when the adapter is PostgreSQL' do
+      allow(ActsAsTaggableOn::Utils.connection).to receive(:adapter_name) { 'PostgreSQL' }
+      expect(ActsAsTaggableOn::Utils.like_operator).to eq('ILIKE')
+    end
+
+    it 'should return \'LIKE\' when the adapter is not PostgreSQL' do
+      allow(ActsAsTaggableOn::Utils.connection).to receive(:adapter_name) { 'MySQL' }
+      expect(ActsAsTaggableOn::Utils.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/internal/app/models/models.rb

@@ -0,0 +1,90 @@
+class TaggableModel < ActiveRecord::Base
+  acts_as_taggable
+  acts_as_taggable_on :languages
+  acts_as_taggable_on :skills
+  acts_as_taggable_on :needs, :offerings
+  has_many :untaggable_models
+
+  attr_reader :tag_list_submethod_called
+
+  def tag_list=(v)
+    @tag_list_submethod_called = true
+    super
+  end
+end
+
+class CachedModel < ActiveRecord::Base
+  acts_as_taggable
+end
+
+class OtherCachedModel < ActiveRecord::Base
+  acts_as_taggable_on :languages, :statuses, :glasses
+end
+
+class OtherTaggableModel < ActiveRecord::Base
+  acts_as_taggable_on :tags, :languages
+  acts_as_taggable_on :needs, :offerings
+end
+
+class InheritingTaggableModel < TaggableModel
+end
+
+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
+
+class Student < User
+end
+
+class UntaggableModel < ActiveRecord::Base
+  belongs_to :taggable_model
+end
+
+class NonStandardIdTaggableModel < ActiveRecord::Base
+  self.primary_key = :an_id
+  acts_as_taggable
+  acts_as_taggable_on :languages
+  acts_as_taggable_on :skills
+  acts_as_taggable_on :needs, :offerings
+  has_many :untaggable_models
+end
+
+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

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

@@ -0,0 +1,8 @@
+class NonStandardIdTaggableModel < ActiveRecord::Base
+  self.primary_key = 'an_id'
+  acts_as_taggable
+  acts_as_taggable_on :languages
+  acts_as_taggable_on :skills
+  acts_as_taggable_on :needs, :offerings
+  has_many :untaggable_models
+end

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

@@ -0,0 +1,4 @@
+class OrderedTaggableModel < ActiveRecord::Base
+  acts_as_ordered_taggable
+  acts_as_ordered_taggable_on :colours
+end

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

@@ -0,0 +1,3 @@
+class OtherCachedModel < ActiveRecord::Base
+  acts_as_taggable_on :languages, :statuses, :glasses
+end

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

@@ -0,0 +1,4 @@
+class OtherTaggableModel < ActiveRecord::Base
+  acts_as_taggable_on :tags, :languages
+  acts_as_taggable_on :needs, :offerings
+end

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

@@ -0,0 +1,2 @@
+class Student < User
+end

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

@@ -0,0 +1,13 @@
+class TaggableModel < ActiveRecord::Base
+  acts_as_taggable
+  acts_as_taggable_on :languages
+  acts_as_taggable_on :skills
+  acts_as_taggable_on :needs, :offerings
+  has_many :untaggable_models
+
+  attr_reader :tag_list_submethod_called
+  def tag_list=(v)
+    @tag_list_submethod_called = true
+    super
+  end
+end

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

@@ -0,0 +1,3 @@
+class UntaggableModel < ActiveRecord::Base
+  belongs_to :taggable_model
+end

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

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  acts_as_tagger
+end

data/spec/internal/config/database.yml.sample

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: ':memory:'
+
+mysql:
+  adapter: mysql2
+  host: localhost
+  username: root
+  password:
+  database: acts_as_taggable_on
+  charset: utf8
+  
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: acts_as_taggable_on
+  encoding: utf8

data/spec/internal/db/schema.rb

@@ -0,0 +1,97 @@
+ActiveRecord::Schema.define version: 0 do
+  create_table :tags, force: true do |t|
+    t.string :name
+    t.integer :taggings_count, default: 0
+    t.string :type
+  end
+  add_index 'tags', ['name'], name: 'index_tags_on_name', unique: true
+
+  create_table :taggings, force: true do |t|
+    t.references :tag
+
+    # You should make sure that the column created is
+    # long enough to store the required class names.
+    t.references :taggable, polymorphic: true
+    t.references :tagger, polymorphic: true
+
+    # Limit is created to prevent MySQL error on index
+    # length for MyISAM table type: http://bit.ly/vgW2Ql
+    t.string :context, limit: 128
+
+    t.datetime :created_at
+  end
+  add_index 'taggings',
+            ['tag_id', 'taggable_id', 'taggable_type', 'context', 'tagger_id', 'tagger_type'],
+            unique: true, name: 'taggings_idx'
+
+  # above copied from
+  # generators/acts_as_taggable_on/migration/migration_generator
+
+  create_table :taggable_models, force: true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+
+  create_table :non_standard_id_taggable_models, primary_key: 'an_id', force: true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+
+  create_table :untaggable_models, force: true do |t|
+    t.column :taggable_model_id, :integer
+    t.column :name, :string
+  end
+
+  create_table :cached_models, force: true do |t|
+    t.column :name, :string
+    t.column :type, :string
+    t.column :cached_tag_list, :string
+  end
+
+  create_table :other_cached_models, force: true do |t|
+    t.column :name, :string
+    t.column :type, :string
+    t.column :cached_language_list, :string
+    t.column :cached_status_list, :string
+    t.column :cached_glass_list, :string
+  end
+
+  create_table :companies, force: true do |t|
+    t.column :name, :string
+  end
+
+  create_table :users, force: true do |t|
+    t.column :name, :string
+  end
+
+  create_table :other_taggable_models, force: true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+
+  create_table :ordered_taggable_models, force: true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+
+
+  # Special cases for postgresql
+  if ActsAsTaggableOn::Utils.using_postgresql?
+
+    create_table :other_cached_with_array_models, force: true do |t|
+      t.column :name, :string
+      t.column :type, :string
+      t.column :cached_language_list, :string, array: true
+      t.column :cached_status_list, :string, array: true
+      t.column :cached_glass_list, :string, array: true
+    end
+
+    if ActsAsTaggableOn::Utils.postgresql_support_json?
+      create_table :taggable_model_with_jsons, :force => true do |t|
+        t.column :name, :string
+        t.column :type, :string
+        t.column :opts, :json
+      end
+    end
+  end
+end