sb-acts-as-taggable-on 6.5.0

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -0,0 +1,153 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe 'Tagger' do
+  before(:each) do
+    @user = User.create
+    @taggable = TaggableModel.create(name: 'Bob Jones')
+  end
+
+
+
+  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 '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 = 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)
+
+    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 = 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)
+
+    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 = User.create
+
+    @user.tag(@taggable, with: 'awesome', on: :tags)
+    @user2.tag(@taggable, with: 'awesome, epic', on: :tags)
+
+    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(tag_list: 'ruby')
+    @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
+
+    [@taggable, @user].each(&:reload)
+    expect(@taggable.tag_list).to eq(%w(ruby))
+    expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)
+
+    expect(-> {
+      @taggable.update(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 'should change tags order in ordered taggable' do
+    @ordered_taggable = OrderedTaggableModel.create name: 'hey!'
+
+    @user.tag @ordered_taggable, with: 'tag, tag1', on: :tags
+    expect(@ordered_taggable.reload.tags_from(@user)).to eq(['tag', 'tag1'])
+
+    @user.tag @ordered_taggable, with: 'tag2, tag1', on: :tags
+    expect(@ordered_taggable.reload.tags_from(@user)).to eq(['tag2', 'tag1'])
+
+    @user.tag @ordered_taggable, with: 'tag1, tag2', on: :tags
+    expect(@ordered_taggable.reload.tags_from(@user)).to eq(['tag1', 'tag2'])
+  end
+
+end

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -0,0 +1,117 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::Tagging do
+  before(:each) do
+    @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'
+
+    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')
+
+    expect(-> {
+      2.times { ActsAsTaggableOn::Tagging.create(taggable: @taggable, tag: @tag, context: 'tags') }
+    }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+  end
+
+  it 'should not delete tags of other records' do
+    6.times { TaggableModel.create(name: 'Bob Jones', tag_list: 'very, serious, bug') }
+    expect(ActsAsTaggableOn::Tag.count).to eq(3)
+    taggable = TaggableModel.first
+    taggable.tag_list = 'bug'
+    taggable.save
+
+    expect(taggable.tag_list).to eq(['bug'])
+
+    another_taggable = TaggableModel.where('id != ?', taggable.id).sample
+    expect(another_taggable.tag_list.sort).to eq(%w(very serious bug).sort)
+  end
+
+  it 'should destroy unused tags after tagging destroyed' do
+    previous_setting = ActsAsTaggableOn.remove_unused_tags
+    ActsAsTaggableOn.remove_unused_tags = true
+    ActsAsTaggableOn::Tag.destroy_all
+    @taggable = TaggableModel.create(name: 'Bob Jones')
+    @taggable.update_attribute :tag_list, 'aaa,bbb,ccc'
+    @taggable.update_attribute :tag_list, ''
+    expect(ActsAsTaggableOn::Tag.count).to eql(0)
+    ActsAsTaggableOn.remove_unused_tags = previous_setting
+  end
+
+  describe 'context scopes' do
+    before do
+      @tagging_2 = ActsAsTaggableOn::Tagging.new
+      @tagging_3 = ActsAsTaggableOn::Tagging.new
+
+      @tagger = User.new
+      @tagger_2 = User.new
+
+      @tagging.taggable = TaggableModel.create(name: "Black holes")
+      @tagging.tag = ActsAsTaggableOn::Tag.create(name: "Physics")
+      @tagging.tagger = @tagger
+      @tagging.context = 'Science'
+      @tagging.save
+
+      @tagging_2.taggable = TaggableModel.create(name: "Satellites")
+      @tagging_2.tag = ActsAsTaggableOn::Tag.create(name: "Technology")
+      @tagging_2.tagger = @tagger_2
+      @tagging_2.context = 'Science'
+      @tagging_2.save
+
+      @tagging_3.taggable = TaggableModel.create(name: "Satellites")
+      @tagging_3.tag = ActsAsTaggableOn::Tag.create(name: "Engineering")
+      @tagging_3.tagger = @tagger_2
+      @tagging_3.context = 'Astronomy'
+      @tagging_3.save
+
+    end
+
+    describe '.owned_by' do
+      it "should belong to a specific user" do
+        expect(ActsAsTaggableOn::Tagging.owned_by(@tagger).first).to eq(@tagging)
+      end
+    end
+
+    describe '.by_context' do
+      it "should be found by context" do
+        expect(ActsAsTaggableOn::Tagging.by_context('Science').length).to eq(2);
+      end
+    end
+
+    describe '.by_contexts' do
+      it "should find taggings by contexts" do
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).first).to eq(@tagging);
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).second).to eq(@tagging_2);
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).third).to eq(@tagging_3);
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).length).to eq(3);
+      end
+    end
+
+    describe '.not_owned' do
+      before do
+        @tagging_4 = ActsAsTaggableOn::Tagging.new
+        @tagging_4.taggable = TaggableModel.create(name: "Gravity")
+        @tagging_4.tag = ActsAsTaggableOn::Tag.create(name: "Space")
+        @tagging_4.context = "Science"
+        @tagging_4.save
+      end
+
+      it "should found the taggings that do not have owner" do
+        expect(ActsAsTaggableOn::Tagging.all.length).to eq(4)
+        expect(ActsAsTaggableOn::Tagging.not_owned.length).to eq(1)
+        expect(ActsAsTaggableOn::Tagging.not_owned.first).to eq(@tagging_4)
+      end
+    end
+  end
+end

data/spec/acts_as_taggable_on/tags_helper_spec.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::TagsHelper do
+  before(:each) do
+    @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 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
+
+    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

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+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
+
+  describe '#sha_prefix' do
+    it 'should return a consistent prefix for a given word' do
+      expect(ActsAsTaggableOn::Utils.sha_prefix('kittens')).to eq(ActsAsTaggableOn::Utils.sha_prefix('kittens'))
+      expect(ActsAsTaggableOn::Utils.sha_prefix('puppies')).not_to eq(ActsAsTaggableOn::Utils.sha_prefix('kittens'))
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require_relative 'taggable_model'
+
+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,11 @@
+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

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

@@ -0,0 +1,5 @@
+class ColumnsOverrideModel < ActiveRecord::Base
+  def self.columns
+    super.reject { |c| c.name == 'ignored_column' }
+  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,4 @@
+require_relative 'taggable_model'
+
+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/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,4 @@
+require_relative 'user'
+
+class Student < User
+end

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

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