acts-as-taggable-on 3.3.0 → 3.4.4

data/lib/acts_as_taggable_on/tag_list_parser.rb

@@ -7,72 +7,15 @@ module ActsAsTaggableOn
   #   tag_list # ["One", "Two", "Three"]
   module TagListParser
     class << self
+      ## DEPRECATED
       def parse(string)
-        string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
-        TagList.new.tap do |tag_list|
-          string = string.to_s.dup
-
-
-          string.gsub!(double_quote_pattern) {
-            # Append the matched tag to the tag list
-            tag_list << Regexp.last_match[2]
-            # Return the matched delimiter ($3) to replace the matched items
-            ''
-          }
-
-          string.gsub!(single_quote_pattern) {
-            # Append the matched tag ($2) to the tag list
-            tag_list << Regexp.last_match[2]
-            # Return an empty string to replace the matched items
-            ''
-          }
-
-          # split the string by the delimiter
-          # and add to the tag_list
-          tag_list.add(string.split(Regexp.new delimiter))
-        end
+        ActiveRecord::Base.logger.warn <<WARNING
+ActsAsTaggableOn::TagListParser.parse is deprecated \
+and will be removed from v4.0+, use  \
+ActsAsTaggableOn::TagListParser.new instead
+WARNING
+        DefaultParser.new(string).parse
       end
-
-
-      # private
-      def delimiter
-        # Parse the quoted tags
-        d = ActsAsTaggableOn.delimiter
-        # Separate multiple delimiters by bitwise operator
-        d = d.join('|') if d.kind_of?(Array)
-        d
-      end
-
-      # (             # Tag start delimiter ($1)
-      # \A       |  # Either string start or
-      # #{delimiter}        # a delimiter
-      # )
-      # \s*"          # quote (") optionally preceded by whitespace
-      # (.*?)         # Tag ($2)
-      # "\s*          # quote (") optionally followed by whitespace
-      # (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
-      # #{delimiter}\s*  |  # Either a delimiter optionally followed by whitespace or
-      # \z          # string end
-      # )
-      def double_quote_pattern
-        /(\A|#{delimiter})\s*"(.*?)"\s*(?=#{delimiter}\s*|\z)/
-      end
-
-      # (             # Tag start delimiter ($1)
-      # \A       |  # Either string start or
-      # #{delimiter}        # a delimiter
-      # )
-      # \s*'          # quote (') optionally preceded by whitespace
-      # (.*?)         # Tag ($2)
-      # '\s*          # quote (') optionally followed by whitespace
-      # (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
-      # #{delimiter}\s*  | d # Either a delimiter optionally followed by whitespace or
-      # \z          # string end
-      # )
-      def single_quote_pattern
-        /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
-      end
-
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/cache.rb

@@ -40,6 +40,10 @@ module ActsAsTaggableOn::Taggable
           end
         end
 
+        def reset_column_information
+          super
+          @acts_as_taggable_on_cache_columns = nil
+        end
       end
     end
 

data/lib/acts_as_taggable_on/taggable/collection.rb

@@ -135,7 +135,7 @@ module ActsAsTaggableOn::Taggable
         table_name_pkey = "#{table_name}.#{primary_key}"
         if ActsAsTaggableOn::Utils.using_mysql?
           # See https://github.com/mbleigh/acts-as-taggable-on/pull/457 for details
-          scoped_ids = select(table_name_pkey).map(&:id)
+          scoped_ids = pluck(table_name_pkey)
           tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN (?)", scoped_ids)
         else
           tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(table_name_pkey))})")
@@ -169,7 +169,7 @@ module ActsAsTaggableOn::Taggable
     end
 
     module CalculationMethods
-      def count(column_name=:all)
+      def count(column_name=:all, options = {})
         # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
         super
       end

data/lib/acts_as_taggable_on/taggable/core.rb

@@ -27,7 +27,7 @@ module ActsAsTaggableOn::Taggable
                                                  dependent: :destroy,
                                                  class_name: 'ActsAsTaggableOn::Tagging',
                                                  order: taggings_order,
-                                                 conditions: ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
+                                                 conditions: {context: tags_type},
                                                  include: :tag
 
             has_many_with_taggable_compatibility context_tags, through: context_taggings,
@@ -77,15 +77,15 @@ module ActsAsTaggableOn::Taggable
       #                       * <tt>:end_at</tt> - Restrict the tags to those created before a certain time
       #
       # Example:
-      #   User.tagged_with("awesome", "cool")                     # Users that are tagged with awesome and cool
-      #   User.tagged_with("awesome", "cool", :exclude => true)   # Users that are not tagged with awesome or cool
-      #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
-      #   User.tagged_with("awesome", "cool", :any => true, :order_by_matching_tag_count => true)  # Sort by users who match the most tags, descending
-      #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
-      #   User.tagged_with("awesome", "cool", :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
-      #   User.tagged_with("awesome", "cool", :owned_by => foo, :start_at => Date.today ) # Users that are tagged with just awesome, cool by 'foo' and starting today
+      #   User.tagged_with(["awesome", "cool"])                     # Users that are tagged with awesome and cool
+      #   User.tagged_with(["awesome", "cool"], :exclude => true)   # Users that are not tagged with awesome or cool
+      #   User.tagged_with(["awesome", "cool"], :any => true)       # Users that are tagged with awesome or cool
+      #   User.tagged_with(["awesome", "cool"], :any => true, :order_by_matching_tag_count => true)  # Sort by users who match the most tags, descending
+      #   User.tagged_with(["awesome", "cool"], :match_all => true) # Users that are tagged with just awesome and cool
+      #   User.tagged_with(["awesome", "cool"], :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
+      #   User.tagged_with(["awesome", "cool"], :owned_by => foo, :start_at => Date.today ) # Users that are tagged with just awesome, cool by 'foo' and starting today
       def tagged_with(tags, options = {})
-        tag_list = ActsAsTaggableOn::TagListParser.parse(tags)
+        tag_list = ActsAsTaggableOn.default_parser.new(tags).parse
         options = options.dup
         empty_result = where('1 = 0')
 
@@ -100,6 +100,7 @@ module ActsAsTaggableOn::Taggable
         context = options.delete(:on)
         owned_by = options.delete(:owned_by)
         alias_base_name = undecorated_table_name.gsub('.', '_')
+        # FIXME use ActiveRecord's connection quote_column_name
         quote = ActsAsTaggableOn::Utils.using_postgresql? ? '"' : ''
 
         if options.delete(:exclude)
@@ -117,7 +118,7 @@ module ActsAsTaggableOn::Taggable
                       " AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)}" +
                       " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = #{quote_value(owned_by.id, nil)}" +
                       " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = #{quote_value(owned_by.class.base_class.to_s, nil)}"
-            
+
             joins << " AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
             joins << " AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
           end
@@ -130,7 +131,7 @@ module ActsAsTaggableOn::Taggable
                    ActsAsTaggableOn::Tag.named_any(tag_list)
                  end
 
-          return empty_result unless tags.length > 0
+          return empty_result if tags.length == 0
 
           # setup taggings alias so we can chain, ex: items_locations_taggings_awesome_cool_123
           # avoid ambiguous column name
@@ -140,21 +141,22 @@ module ActsAsTaggableOn::Taggable
               "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tags.map(&:name).join('_'))}"
           )
 
-          tagging_join = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
-                          "  ON #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
+          tagging_cond = "#{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
+                          " WHERE #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
                           " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}"
 
-          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+          tagging_cond << " AND " + sanitize_sql(["#{taggings_alias}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+          tagging_cond << " AND " + sanitize_sql(["#{taggings_alias}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
 
-          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          tagging_cond << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
           # don't need to sanitize sql, map all ids and join with OR logic
-          conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{quote_value(t.id, nil)}" }.join(' OR ')
+          tag_ids = tags.map { |t| quote_value(t.id, nil) }.join(', ')
+          tagging_cond << " AND #{taggings_alias}.tag_id in (#{tag_ids})"
           select_clause << " #{table_name}.*" unless context and tag_types.one?
 
           if owned_by
-            tagging_join << ' AND ' +
+            tagging_cond << ' AND ' +
                 sanitize_sql([
                                  "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
                                  owned_by.id,
@@ -162,10 +164,9 @@ module ActsAsTaggableOn::Taggable
                              ])
           end
 
-          joins << tagging_join
-          unless any == 'distinct' # Fix issue #544
-            group = "#{table_name}.#{primary_key}"
-            select_clause << group
+          conditions << "EXISTS (SELECT 1 FROM #{tagging_cond})"
+          if options.delete(:order_by_matching_tag_count)
+            order_by << "(SELECT count(*) FROM #{tagging_cond}) desc"
           end
         else
           tags = ActsAsTaggableOn::Tag.named_any(tag_list)
@@ -224,11 +225,11 @@ module ActsAsTaggableOn::Taggable
         query = self
         query = self.select(select_clause.join(',')) unless select_clause.empty?
         query.joins(joins.join(' '))
-        .where(conditions.join(' AND '))
-        .group(group)
-        .having(having)
-        .order(order_by.join(', '))
-        .readonly(false)
+          .where(conditions.join(' AND '))
+          .group(group)
+          .having(having)
+          .order(order_by.join(', '))
+          .readonly(false)
       end
 
       def is_taggable?
@@ -278,7 +279,7 @@ module ActsAsTaggableOn::Taggable
       if instance_variable_get(variable_name)
         instance_variable_get(variable_name)
       elsif cached_tag_list_on(context) && self.class.caching_tag_list_on?(context)
-        instance_variable_set(variable_name, ActsAsTaggableOn::TagListParser.parse(cached_tag_list_on(context)))
+        instance_variable_set(variable_name, ActsAsTaggableOn.default_parser.new(cached_tag_list_on(context)).parse)
       else
         instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
@@ -328,7 +329,7 @@ module ActsAsTaggableOn::Taggable
       variable_name = "@#{context.to_s.singularize}_list"
       process_dirty_object(context, new_list) unless custom_contexts.include?(context.to_s)
 
-      instance_variable_set(variable_name, ActsAsTaggableOn::TagListParser.parse(new_list))
+      instance_variable_set(variable_name, ActsAsTaggableOn.default_parser.new(new_list).parse)
     end
 
     def tagging_contexts
@@ -342,13 +343,13 @@ module ActsAsTaggableOn::Taggable
       if changed_attributes.include?(attrib)
         # The attribute already has an unsaved change.
         old = changed_attributes[attrib]
-        changed_attributes.delete(attrib) if old.to_s == value.to_s
+        @changed_attributes.delete(attrib) if old.to_s == value.to_s
       else
         old = tag_list_on(context)
         if self.class.preserve_tag_order
-          changed_attributes[attrib] = old if old.to_s != value.to_s
+          @changed_attributes[attrib] = old if old.to_s != value.to_s
         else
-          changed_attributes[attrib] = old.to_s if old.sort != ActsAsTaggableOn::TagListParser.parse(value).sort
+          @changed_attributes[attrib] = old.to_s if old.sort != ActsAsTaggableOn.default_parser.new(value).parse.sort
         end
       end
     end
@@ -420,6 +421,18 @@ module ActsAsTaggableOn::Taggable
 
     private
 
+    # Filters the tag lists from the attribute names.
+    def attributes_for_update(attribute_names)
+      tag_lists = tag_types.map {|tags_type| "#{tags_type.to_s.singularize}_list"}
+      super.delete_if {|attr| tag_lists.include? attr }
+    end
+
+    # Filters the tag lists from the attribute names.
+    def attributes_for_create(attribute_names)
+      tag_lists = tag_types.map {|tags_type| "#{tags_type.to_s.singularize}_list"}
+      super.delete_if {|attr| tag_lists.include? attr }
+    end
+    
     ##
     # Override this hook if you wish to subclass {ActsAsTaggableOn::Tag} --
     # context is provided so that you may conditionally use a Tag subclass

data/lib/acts_as_taggable_on/taggable/ownership.rb

@@ -63,7 +63,7 @@ module ActsAsTaggableOn::Taggable
 
       cache = cached_owned_tag_list_on(context)
 
-      cache[owner] = ActsAsTaggableOn::TagListParser.parse(new_list)
+      cache[owner] = ActsAsTaggableOn.default_parser.new(new_list).parse
     end
 
     def reload(*args)
@@ -82,7 +82,7 @@ module ActsAsTaggableOn::Taggable
           tags = find_or_create_tags_from_list_with_context(tag_list.uniq, context)
 
           # Tag objects for owned tags
-          owned_tags = owner_tags_on(owner, context)
+          owned_tags = owner_tags_on(owner, context).to_a
 
           # Tag maintenance based on whether preserving the created order of tags
           if self.class.preserve_tag_order?

data/lib/acts_as_taggable_on/taggable/related.rb

@@ -43,7 +43,7 @@ module ActsAsTaggableOn::Taggable
     def related_tags_for(context, klass, options = {})
       tags_to_ignore = Array.wrap(options[:ignore]).map(&:to_s) || []
       tags_to_find = tags_on(context).map { |t| t.name }.reject { |t| tags_to_ignore.include? t }
-      related_where(klass, ["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find])
+      related_where(klass, ["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, context])
     end
 
     private

data/lib/acts_as_taggable_on/tagging.rb

@@ -11,7 +11,7 @@ module ActsAsTaggableOn
                     :tagger_type,
                     :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
 
-    belongs_to :tag, class_name: 'ActsAsTaggableOn::Tag' , counter_cache: true
+    belongs_to :tag, class_name: 'ActsAsTaggableOn::Tag', counter_cache: ActsAsTaggableOn.tags_counter
     belongs_to :taggable, polymorphic: true
     belongs_to :tagger,   polymorphic: true
 
@@ -32,7 +32,11 @@ module ActsAsTaggableOn
 
     def remove_unused_tags
       if ActsAsTaggableOn.remove_unused_tags
-        tag.destroy if tag.reload.taggings_count.zero?
+        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

data/lib/acts_as_taggable_on/utils.rb

@@ -18,7 +18,7 @@ module ActsAsTaggableOn
       end
 
       def sha_prefix(string)
-        Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
+        Digest::SHA1.hexdigest(string)[0..6]
       end
 
       def active_record4?

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '3.3.0'
+  VERSION = '3.4.4'
 end
 

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -133,6 +133,22 @@ describe 'Acts As Taggable On' do
       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("taggings")
+      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

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -69,6 +69,12 @@ describe 'Acts As Taggable On' do
       @taggable.save!
       expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
     end
+
+    it 'should clear the cache on reset_column_information' do
+      CachedModel.column_names
+      CachedModel.reset_column_information
+      expect(CachedModel.instance_variable_get(:@acts_as_taggable_on_cache_columns)).to eql(nil)
+    end
   end
 
   describe 'CachingWithArray' do

data/spec/acts_as_taggable_on/default_parser_spec.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::DefaultParser do
+  it '#parse should return empty array if empty array is passed' do
+    parser = ActsAsTaggableOn::DefaultParser.new([])
+    expect(parser.parse).to be_empty
+  end
+
+  describe 'Multiple Delimiter' do
+    before do
+      @old_delimiter = ActsAsTaggableOn.delimiter
+    end
+
+    after do
+      ActsAsTaggableOn.delimiter = @old_delimiter
+    end
+
+    it 'should separate tags by delimiters' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      parser = ActsAsTaggableOn::DefaultParser.new('cool, data|I have')
+      expect(parser.parse.to_s).to eq('cool, data, I, have')
+    end
+
+    it 'should escape quote' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      parser = ActsAsTaggableOn::DefaultParser.new("'I have'|cool, data")
+      expect(parser.parse.to_s).to eq('"I have", cool, data')
+
+      parser = ActsAsTaggableOn::DefaultParser.new('"I, have"|cool, data')
+      expect(parser.parse.to_s).to eq('"I, have", cool, data')
+    end
+
+    it 'should work for utf8 delimiter and long delimiter' do
+      ActsAsTaggableOn.delimiter = ['，', '的', '可能是']
+      parser = ActsAsTaggableOn::DefaultParser.new('我的东西可能是不见了，还好有备份')
+      expect(parser.parse.to_s).to eq('我， 东西， 不见了， 还好有备份')
+    end
+
+    it 'should work for multiple quoted tags' do
+      ActsAsTaggableOn.delimiter = [',']
+      parser = ActsAsTaggableOn::DefaultParser.new('"Ruby Monsters","eat Katzenzungen"')
+      expect(parser.parse.to_s).to eq('Ruby Monsters, eat Katzenzungen')
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/generic_parser_spec.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::GenericParser do
+  it '#parse should return empty array if empty tag string is passed' do
+    tag_list = ActsAsTaggableOn::GenericParser.new('')
+    expect(tag_list.parse).to be_empty
+  end
+
+  it '#parse should separate tags by comma' do
+    tag_list = ActsAsTaggableOn::GenericParser.new('cool,data,,I,have')
+    expect(tag_list.parse).to eq(%w(cool data I have))
+  end
+end

data/spec/acts_as_taggable_on/related_spec.rb

@@ -42,6 +42,15 @@ describe 'Acts As Taggable On' do
       expect(taggable1.find_related_tags_for(OtherTaggableModel)).to_not include(taggable2)
     end
 
+    it 'should find other related objects based on tags only from particular context' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four', skill_list: 'one, two')
+      taggable3 = TaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
+
+      expect(taggable1.find_related_tags).to include(taggable3)
+      expect(taggable1.find_related_tags).to_not include(taggable2)
+    end
+
 
     shared_examples "a collection" do
       it do

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -114,7 +114,36 @@ describe ActsAsTaggableOn::TagList do
 
       ActsAsTaggableOn.force_lowercase = false
     end
+  end
+
+  describe 'custom parser' do
+    let(:parser)       { double(parse: %w(cool wicked)) }
+    let(:parser_class) { stub_const('MyParser', Class) }
+
+    it 'should use a the default parser if none is set as parameter' do
+      allow(ActsAsTaggableOn.default_parser).to receive(:new).and_return(parser)
+      ActsAsTaggableOn::TagList.new('cool, wicked', parse: true)
+
+      expect(parser).to have_received(:parse)
+    end
+
+    it 'should use the custom parser passed as parameter' do
+      allow(parser_class).to receive(:new).and_return(parser)
 
+      ActsAsTaggableOn::TagList.new('cool, wicked', parser: parser_class)
+
+      expect(parser).to have_received(:parse)
+    end
+
+    it 'should use the parser setted as attribute' do
+      allow(parser_class).to receive(:new).with('new, tag').and_return(parser)
+
+      tag_list = ActsAsTaggableOn::TagList.new('example')
+      tag_list.parser = parser_class
+      tag_list.add('new, tag', parse: true)
+
+      expect(parser).to have_received(:parse)
+    end
   end
 
 

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -46,6 +46,14 @@ describe ActsAsTaggableOn::Tag do
     end
   end
 
+  describe 'named any' do
+    context 'with some special characters combinations', if: using_mysql? do
+      it 'should not raise an invalid encoding exception' do
+        expect{ActsAsTaggableOn::Tag.named_any(["holä", "hol'ä"])}.not_to raise_error
+      end
+    end
+  end
+
   describe 'find or create by name' do
     before(:each) do
       @tag.name = 'awesome'
@@ -250,13 +258,19 @@ describe ActsAsTaggableOn::Tag do
       end
     end
 
-    it 'should not change enconding' do
+    it 'should not change encoding' do
       name = "\u3042"
       original_encoding = name.encoding
       record = ActsAsTaggableOn::Tag.find_or_create_with_like_by_name(name)
       record.reload
       expect(record.name.encoding).to eq(original_encoding)
     end
+
+    context 'named any with some special characters combinations', if: using_mysql? do
+      it 'should not raise an invalid encoding exception' do
+        expect{ActsAsTaggableOn::Tag.named_any(["holä", "hol'ä"])}.not_to raise_error
+      end
+    end
   end
 
   describe 'name uniqeness validation' do
@@ -286,4 +300,24 @@ describe ActsAsTaggableOn::Tag do
       end
     end
   end
+
+  describe 'popular tags' do
+    before do
+      %w(sports rails linux tennis golden_syrup).each_with_index do |t, i|
+        tag = ActsAsTaggableOn::Tag.new(name: t)
+        tag.taggings_count = i
+        tag.save!
+      end
+    end
+    
+    it 'should find the most popular tags' do
+      expect(ActsAsTaggableOn::Tag.most_used(3).first.name).to eq("golden_syrup")
+      expect(ActsAsTaggableOn::Tag.most_used(3).length).to eq(3)
+    end
+
+    it 'should find the least popular tags' do
+      expect(ActsAsTaggableOn::Tag.least_used(3).first.name).to eq("sports")
+      expect(ActsAsTaggableOn::Tag.least_used(3).length).to eq(3)
+    end
+  end
 end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -261,7 +261,7 @@ describe 'Taggable' do
     @taggable.tag_list = 'bob, charlie'
     @taggable.save
 
-    expect(TaggableModel.group(:created_at).tagged_with(['bob', 'css'], :any => true).first).to eq(@taggable)
+    expect(TaggableModel.tagged_with(['bob', 'css'], :any => true).to_a).to eq([@taggable])
 
     bob = TaggableModel.create(:name => 'Bob', :tag_list => 'ruby, rails, css')
     frank = TaggableModel.create(:name => 'Frank', :tag_list => 'ruby, rails')
@@ -459,6 +459,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).to eq([frank, jim])
     end
   end
 

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -137,4 +137,17 @@ describe 'Tagger' do
     }).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/utils_spec.rb

@@ -13,4 +13,11 @@ describe ActsAsTaggableOn::Utils do
       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/spec_helper.rb

@@ -1,3 +1,7 @@
+begin
+  require 'byebug'
+rescue LoadError
+end
 $LOAD_PATH << '.' unless $LOAD_PATH.include?('.')
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 require 'logger'