sb-acts-as-taggable-on 6.5.0

data/lib/acts_as_taggable_on/taggable/tagged_with_query/query_base.rb

@@ -0,0 +1,61 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class QueryBase
+    def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
+      @taggable_model = taggable_model
+      @tag_model      = tag_model
+      @tagging_model  = tagging_model
+      @tag_list       = tag_list
+      @options        = options
+    end
+
+    private
+
+    attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
+
+    def taggable_arel_table
+      @taggable_arel_table ||= taggable_model.arel_table
+    end
+
+    def tag_arel_table
+      @tag_arel_table ||= tag_model.arel_table
+    end
+
+    def tagging_arel_table
+      @tagging_arel_table ||=tagging_model.arel_table
+    end
+
+    def tag_match_type(tag)
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches("%#{escaped_tag(tag)}%", "!")
+      else
+        matches_attribute.matches(escaped_tag(tag), "!")
+      end
+    end
+
+    def tags_match_type
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches_any(tag_list.map{|tag| "%#{escaped_tag(tag)}%"}, "!")
+      else
+        matches_attribute.matches_any(tag_list.map{|tag| "#{escaped_tag(tag)}"}, "!")
+      end
+    end
+
+    def escaped_tag(tag)
+      tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
+      ActsAsTaggableOn::Utils.escape_like(tag)
+    end
+
+    def adjust_taggings_alias(taggings_alias)
+      if taggings_alias.size > 75
+        taggings_alias = 'taggings_alias_' + Digest::SHA1.hexdigest(taggings_alias)
+      end
+      taggings_alias
+    end
+  end
+end

data/lib/acts_as_taggable_on/tagger.rb

@@ -0,0 +1,89 @@
+module ActsAsTaggableOn
+  module Tagger
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      ##
+      # Make a model a tagger. This allows an instance of a model to claim ownership
+      # of tags.
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     acts_as_tagger
+      #   end
+      def acts_as_tagger(opts={})
+        class_eval do
+          owned_taggings_scope = opts.delete(:scope)
+
+          has_many :owned_taggings, owned_taggings_scope,
+                   opts.merge(
+                     as: :tagger,
+                     class_name: '::ActsAsTaggableOn::Tagging',
+                     dependent: :destroy
+                   )
+
+          has_many :owned_tags, -> { distinct },
+                   class_name: '::ActsAsTaggableOn::Tag',
+                   source: :tag,
+                   through: :owned_taggings
+        end
+
+        include ActsAsTaggableOn::Tagger::InstanceMethods
+        extend ActsAsTaggableOn::Tagger::SingletonMethods
+      end
+
+      def tagger?
+        false
+      end
+
+      def is_tagger?
+        tagger?
+      end
+    end
+
+    module InstanceMethods
+      ##
+      # Tag a taggable model with tags that are owned by the tagger.
+      #
+      # @param taggable The object that will be tagged
+      # @param [Hash] options An hash with options. Available options are:
+      #               * <tt>:with</tt> - The tags that you want to
+      #               * <tt>:on</tt>   - The context on which you want to tag
+      #
+      # Example:
+      #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
+      def tag(taggable, opts={})
+        opts.reverse_merge!(force: true)
+        skip_save = opts.delete(:skip_save)
+        return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
+
+        fail 'You need to specify a tag context using :on' unless opts.key?(:on)
+        fail 'You need to specify some tags using :with' unless opts.key?(:with)
+        fail "No context :#{opts[:on]} defined in #{taggable.class}" unless opts[:force] || taggable.tag_types.include?(opts[:on])
+
+        taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
+        taggable.save unless skip_save
+      end
+
+      def tagger?
+        self.class.is_tagger?
+      end
+
+      def is_tagger?
+        tagger?
+      end
+    end
+
+    module SingletonMethods
+      def tagger?
+        true
+      end
+
+      def is_tagger?
+        tagger?
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tagging.rb

@@ -0,0 +1,36 @@
+module ActsAsTaggableOn
+  class Tagging < ::ActiveRecord::Base #:nodoc:
+    self.table_name = ActsAsTaggableOn.taggings_table
+
+    DEFAULT_CONTEXT = 'tags'
+    belongs_to :tag, class_name: '::ActsAsTaggableOn::Tag', counter_cache: ActsAsTaggableOn.tags_counter
+    belongs_to :taggable, polymorphic: true
+
+    belongs_to :tagger, {polymorphic: true}.tap {|o| o.merge!(optional: true) }
+
+    scope :owned_by, ->(owner) { where(tagger: owner) }
+    scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
+
+    scope :by_contexts, ->(contexts) { where(context: (contexts || DEFAULT_CONTEXT)) }
+    scope :by_context, ->(context = DEFAULT_CONTEXT) { by_contexts(context.to_s) }
+
+    validates_presence_of :context
+    validates_presence_of :tag_id
+
+    validates_uniqueness_of :tag_id, scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
+
+    after_destroy :remove_unused_tags
+
+    private
+
+    def remove_unused_tags
+      if ActsAsTaggableOn.remove_unused_tags
+        if ActsAsTaggableOn.tags_counter
+          tag.destroy if tag.reload.taggings_count.zero?
+        else
+          tag.destroy if tag.reload.taggings.count.zero?
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -0,0 +1,15 @@
+module ActsAsTaggableOn
+  module TagsHelper
+    # See the wiki for an example using tag_cloud.
+    def tag_cloud(tags, classes)
+      return [] if tags.empty?
+
+      max_count = tags.sort_by(&:taggings_count).last.taggings_count.to_f
+
+      tags.each do |tag|
+        index = ((tag.taggings_count / max_count) * (classes.size - 1))
+        yield tag, classes[index.nan? ? 0 : index.round]
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/utils.rb

@@ -0,0 +1,37 @@
+# This module is deprecated and will be removed in the incoming versions
+
+module ActsAsTaggableOn
+  module Utils
+    class << self
+      # Use ActsAsTaggableOn::Tag connection
+      def connection
+        ActsAsTaggableOn::Tag.connection
+      end
+
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
+
+      def using_mysql?
+        connection && connection.adapter_name == 'Mysql2'
+      end
+
+      def sha_prefix(string)
+        Digest::SHA1.hexdigest(string)[0..6]
+      end
+
+      def like_operator
+        using_postgresql? ? 'ILIKE' : 'LIKE'
+      end
+
+      def legacy_activerecord?
+        ActiveRecord.version <= Gem::Version.new('5.3.0')
+      end
+
+      # escape _ and % characters in strings, since these are wildcards in SQL.
+      def escape_like(str)
+        str.gsub(/[!%_]/) { |x| '!' + x }
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/version.rb

@@ -0,0 +1,3 @@
+module ActsAsTaggableOn
+  VERSION = '6.5.0'
+end

data/lib/tasks/tags_collate_utf8.rake

@@ -0,0 +1,21 @@
+# These rake tasks are to be run by MySql users only, they fix the management of
+# binary-encoded strings for tag 'names'. Issues:
+# https://github.com/mbleigh/acts-as-taggable-on/issues/623
+
+namespace :acts_as_taggable_on_engine do
+
+  namespace :tag_names do
+
+    desc "Forcing collate of tag names to utf8_bin"
+    task :collate_bin => [:environment] do |t, args|
+      ActsAsTaggableOn::Configuration.apply_binary_collation(true)
+    end
+
+    desc "Forcing collate of tag names to utf8_general_ci"
+    task :collate_ci => [:environment] do |t, args|
+      ActsAsTaggableOn::Configuration.apply_binary_collation(false)
+    end
+
+  end
+
+end

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -0,0 +1,285 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe 'Acts As Taggable On' do
+
+  it "should provide a class method 'taggable?' that is false for untaggable models" do
+    expect(UntaggableModel).to_not be_taggable
+  end
+
+  describe 'Taggable Method Generation To Preserve Order' do
+    before(:each) do
+      TaggableModel.tag_types = []
+      TaggableModel.preserve_tag_order = false
+      TaggableModel.acts_as_ordered_taggable_on(:ordered_tags)
+      @taggable = TaggableModel.new(name: 'Bob Jones')
+    end
+
+    it "should respond 'true' to preserve_tag_order?" do
+      expect(@taggable.class.preserve_tag_order?).to be_truthy
+    end
+  end
+
+  describe 'Taggable Method Generation' do
+    before(:each) do
+      TaggableModel.tag_types = []
+      TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
+      @taggable = TaggableModel.new(name: 'Bob Jones')
+    end
+
+    it "should respond 'true' to taggable?" do
+      expect(@taggable.class).to be_taggable
+    end
+
+    it 'should create a class attribute for tag types' do
+      expect(@taggable.class).to respond_to(:tag_types)
+    end
+
+    it 'should create an instance attribute for tag types' do
+      expect(@taggable).to respond_to(:tag_types)
+    end
+
+    it 'should have all tag types' do
+      expect(@taggable.tag_types).to eq([:tags, :languages, :skills, :needs, :offerings])
+    end
+
+    it 'should create a class attribute for preserve tag order' do
+      expect(@taggable.class).to respond_to(:preserve_tag_order?)
+    end
+
+    it 'should create an instance attribute for preserve tag order' do
+      expect(@taggable).to respond_to(:preserve_tag_order?)
+    end
+
+    it "should respond 'false' to preserve_tag_order?" do
+      expect(@taggable.class.preserve_tag_order?).to be_falsy
+    end
+
+    it 'should generate an association for each tag type' do
+      expect(@taggable).to respond_to(:tags, :skills, :languages)
+    end
+
+    it 'should add tagged_with and tag_counts to singleton' do
+      expect(TaggableModel).to respond_to(:tagged_with, :tag_counts)
+    end
+
+    it 'should generate a tag_list accessor/setter for each tag type' do
+      expect(@taggable).to respond_to(:tag_list, :skill_list, :language_list)
+      expect(@taggable).to respond_to(:tag_list=, :skill_list=, :language_list=)
+    end
+
+    it 'should generate a tag_list accessor, that includes owned tags, for each tag type' do
+      expect(@taggable).to respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
+    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')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2')
+      taggable3 = TaggableModel.create!(name: 'Taggable 3')
+
+      taggable1.offering_list = 'one, two'
+      taggable1.save!
+
+      taggable2.need_list = 'one, two'
+      taggable2.save!
+
+      taggable3.offering_list = 'one, two'
+      taggable3.save!
+
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to_not include(taggable3)
+    end
+
+    it 'should find other related objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = OtherTaggableModel.create!(name: 'Taggable 2')
+      taggable3 = OtherTaggableModel.create!(name: 'Taggable 3')
+
+      taggable1.offering_list = 'one, two'
+      taggable1.save
+
+      taggable2.need_list = 'one, two'
+      taggable2.save
+
+      taggable3.offering_list = 'one, two'
+      taggable3.save
+
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to_not include(taggable3)
+    end
+
+    it 'should not include the object itself in the list of related objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2')
+
+      taggable1.offering_list = 'one, two'
+      taggable1.need_list = 'one, two'
+      taggable1.save
+
+      taggable2.need_list = 'one, two'
+      taggable2.save
+
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(taggable1)
+    end
+
+    it 'should ensure joins to multiple taggings maintain their contexts when aliasing' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+
+      taggable1.offering_list = 'one'
+      taggable1.need_list = 'two'
+
+      taggable1.save
+
+      column = TaggableModel.connection.quote_column_name("context")
+      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}"
+      expect(TaggableModel.joins(:offerings, :needs).to_sql).to include "#{need_alias}.#{column}"
+    end
+
+  end
+
+  describe 'Tagging Contexts' do
+    it 'should eliminate duplicate tagging contexts ' do
+      TaggableModel.acts_as_taggable_on(:skills, :skills)
+      expect(TaggableModel.tag_types.freq[:skills]).to eq(1)
+    end
+
+    it 'should not contain embedded/nested arrays' do
+      TaggableModel.acts_as_taggable_on([:array], [:array])
+      expect(TaggableModel.tag_types.freq[[:array]]).to eq(0)
+    end
+
+    it 'should _flatten_ the content of arrays' do
+      TaggableModel.acts_as_taggable_on([:array], [:array])
+      expect(TaggableModel.tag_types.freq[:array]).to eq(1)
+    end
+
+    it 'should not raise an error when passed nil' do
+      expect(-> {
+        TaggableModel.acts_as_taggable_on
+      }).to_not raise_error
+    end
+
+    it 'should not raise an error when passed [nil]' do
+      expect(-> {
+        TaggableModel.acts_as_taggable_on([nil])
+      }).to_not raise_error
+    end
+
+    it 'should include dynamic contexts in tagging_contexts' do
+      taggable = TaggableModel.create!(name: 'Dynamic Taggable')
+      taggable.set_tag_list_on :colors, 'tag1, tag2, tag3'
+      expect(taggable.tagging_contexts).to eq(%w(tags languages skills needs offerings array colors))
+      taggable.save
+      taggable = TaggableModel.where(name: 'Dynamic Taggable').first
+      expect(taggable.tagging_contexts).to eq(%w(tags languages skills needs offerings array colors))
+    end
+  end
+
+  context 'when tagging context ends in an "s" when singular (ex. "status", "glass", etc.)' do
+    describe 'caching' do
+      before  { @taggable = OtherCachedModel.new(name: 'John Smith') }
+      subject { @taggable }
+
+      it { should respond_to(:save_cached_tag_list) }
+      its(:cached_language_list) { should be_blank }
+      its(:cached_status_list)   { should be_blank }
+      its(:cached_glass_list)    { should be_blank }
+
+      context 'language taggings cache after update' do
+        before  { @taggable.update(language_list: 'ruby, .net') }
+        subject { @taggable }
+
+        its(:language_list)        { should == ['ruby', '.net']}
+        its(:cached_language_list) { should == 'ruby, .net' }           # passes
+        its(:instance_variables)   { should     include((RUBY_VERSION < '1.9' ? '@language_list' : :@language_list)) }
+      end
+
+      context 'status taggings cache after update' do
+        before  { @taggable.update(status_list: 'happy, married') }
+        subject { @taggable }
+
+        its(:status_list)        { should     == ['happy', 'married'] }
+        its(:cached_status_list) { should     == 'happy, married'     } # fails
+        its(:cached_status_list) { should_not == ''                   } # fails, is blank
+        its(:instance_variables) { should     include((RUBY_VERSION < '1.9' ? '@status_list' : :@status_list)) }
+        its(:instance_variables) { should_not include((RUBY_VERSION < '1.9' ? '@statu_list' : :@statu_list))  } # fails, note: one "s"
+
+      end
+
+      context 'glass taggings cache after update' do
+        before do
+          @taggable.update(glass_list: 'rectangle, aviator')
+        end
+
+        subject { @taggable }
+        its(:glass_list)         { should     == ['rectangle', 'aviator'] }
+        its(:cached_glass_list)  { should     == 'rectangle, aviator'     } # fails
+        its(:cached_glass_list)  { should_not == ''                       } # fails, is blank
+        if RUBY_VERSION < '1.9'
+          its(:instance_variables) { should     include('@glass_list')      }
+          its(:instance_variables) { should_not include('@glas_list')       } # fails, note: one "s"
+        else
+          its(:instance_variables) { should     include(:@glass_list)      }
+          its(:instance_variables) { should_not include(:@glas_list)       } # fails, note: one "s"
+        end
+
+      end
+    end
+  end
+
+  describe 'taggings' do
+    before(:each) do
+      @taggable = TaggableModel.new(name: 'Art Kram')
+    end
+
+    it 'should return no taggings' do
+      expect(@taggable.taggings).to be_empty
+    end
+  end
+
+  describe '@@remove_unused_tags' do
+    before do
+      @taggable = TaggableModel.create(name: 'Bob Jones')
+      @tag = ActsAsTaggableOn::Tag.create(name: 'awesome')
+
+      @tagging = ActsAsTaggableOn::Tagging.create(taggable: @taggable, tag: @tag, context: 'tags')
+    end
+
+    context 'if set to true' do
+      before do
+        ActsAsTaggableOn.remove_unused_tags = true
+      end
+
+      it 'should remove unused tags after removing taggings' do
+        @tagging.destroy
+        expect(ActsAsTaggableOn::Tag.find_by_name('awesome')).to be_nil
+      end
+    end
+
+    context 'if set to false' do
+      before do
+        ActsAsTaggableOn.remove_unused_tags = false
+      end
+
+      it 'should not remove unused tags after removing taggings' do
+        @tagging.destroy
+        expect(ActsAsTaggableOn::Tag.find_by_name('awesome')).to eq(@tag)
+      end
+    end
+  end
+
+end