acts-as-taggable-on 3.2.1 → 3.3.0

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/core.rb

@@ -24,16 +24,16 @@ module ActsAsTaggableOn::Taggable
             # when preserving tag order, include order option so that for a 'tags' context
             # the associations tag_taggings & tags are always returned in created order
             has_many_with_taggable_compatibility context_taggings, as: :taggable,
-                                                                   dependent: :destroy,
-                                                                   class_name: 'ActsAsTaggableOn::Tagging',
-                                                                   order: taggings_order,
-                                                                   conditions: ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
-                                                                   include: :tag
+                                                 dependent: :destroy,
+                                                 class_name: 'ActsAsTaggableOn::Tagging',
+                                                 order: taggings_order,
+                                                 conditions: ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
+                                                 include: :tag
 
             has_many_with_taggable_compatibility context_tags, through: context_taggings,
-                                                               source: :tag,
-                                                               class_name: 'ActsAsTaggableOn::Tag',
-                                                               order: taggings_order
+                                                 source: :tag,
+                                                 class_name: 'ActsAsTaggableOn::Tag',
+                                                 order: taggings_order
 
           end
 
@@ -73,6 +73,8 @@ module ActsAsTaggableOn::Taggable
       #                       * <tt>:order_by_matching_tag_count</tt> - if set to true and used with :any, sort by objects matching the most tags, descending
       #                       * <tt>:match_all</tt> - if set to true, return objects that are *ONLY* tagged with the specified tags
       #                       * <tt>:owned_by</tt> - return objects that are *ONLY* owned by the owner
+      #                       * <tt>:start_at</tt> - Restrict the tags to those created after a certain time
+      #                       * <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
@@ -81,8 +83,10 @@ module ActsAsTaggableOn::Taggable
       #   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::TagList.from(tags)
+        tag_list = ActsAsTaggableOn::TagListParser.parse(tags)
+        options = options.dup
         empty_result = where('1 = 0')
 
         return empty_result if tag_list.empty?
@@ -108,14 +112,17 @@ module ActsAsTaggableOn::Taggable
           conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)})"
 
           if owned_by
-            joins << "JOIN #{ActsAsTaggableOn::Tagging.table_name}" \
-                "  ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" \
-                " 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 <<  "JOIN #{ActsAsTaggableOn::Tagging.table_name}" +
+                      "  ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
+                      " 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
 
-        elsif options.delete(:any)
+        elsif any = options.delete(:any)
           # get tags, drop out if nothing returned (we need at least one)
           tags = if options.delete(:wild)
                    ActsAsTaggableOn::Tag.named_like_any(tag_list)
@@ -130,49 +137,59 @@ module ActsAsTaggableOn::Taggable
           taggings_context = context ? "_#{context}" : ''
 
           taggings_alias = adjust_taggings_alias(
-              "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{sha_prefix(tags.map(&:name).join('_'))}"
+              "#{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}" \
-              " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}"
-          tagging_join << ' AND ' + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          tagging_join = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
+                          "  ON #{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_join << " 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 ')
-          select_clause = " #{table_name}.*" unless context and tag_types.one?
+          select_clause << " #{table_name}.*" unless context and tag_types.one?
 
           if owned_by
             tagging_join << ' AND ' +
                 sanitize_sql([
-                  "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                  owned_by.id,
-                  owned_by.class.base_class.to_s
+                                 "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                                 owned_by.id,
+                                 owned_by.class.base_class.to_s
                              ])
           end
 
           joins << tagging_join
-          group = "#{table_name}.#{primary_key}"
+          unless any == 'distinct' # Fix issue #544
+            group = "#{table_name}.#{primary_key}"
+            select_clause << group
+          end
         else
           tags = ActsAsTaggableOn::Tag.named_any(tag_list)
 
           return empty_result unless tags.length == tag_list.length
 
           tags.each do |tag|
-            taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{sha_prefix(tag.name)}")
+            taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag.name)}")
             tagging_join = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" \
                 "  ON #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
                 " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}" +
                 " AND #{taggings_alias}.tag_id = #{quote_value(tag.id, nil)}"
 
-            tagging_join << ' AND ' + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+            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_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
             if owned_by
               tagging_join << ' AND ' +
                   sanitize_sql([
-                    "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                    owned_by.id,
-                    owned_by.class.base_class.to_s
+                                   "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                                   owned_by.id,
+                                   owned_by.class.base_class.to_s
                                ])
             end
 
@@ -182,7 +199,7 @@ module ActsAsTaggableOn::Taggable
 
         group ||= [] # Rails interprets this as a no-op in the group() call below
         if options.delete(:order_by_matching_tag_count)
-          select_clause = "#{table_name}.*, COUNT(#{taggings_alias}.tag_id) AS #{taggings_alias}_count"
+          select_clause << "#{table_name}.*, COUNT(#{taggings_alias}.tag_id) AS #{taggings_alias}_count"
           group_columns = ActsAsTaggableOn::Utils.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
           group = group_columns
           order_by << "#{taggings_alias}_count DESC"
@@ -193,7 +210,9 @@ module ActsAsTaggableOn::Taggable
               "  ON #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" \
               " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}"
 
-          joins << ' AND ' + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          joins << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          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]
 
           group_columns = ActsAsTaggableOn::Utils.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
           group = group_columns
@@ -202,13 +221,14 @@ module ActsAsTaggableOn::Taggable
 
         order_by << options[:order] if options[:order].present?
 
-        request = select(select_clause).
-            joins(joins.join(' ')).
-            where(conditions.join(' AND ')).
-            group(group).
-            having(having).
-            order(order_by.join(', ')).
-            readonly(false)
+        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)
       end
 
       def is_taggable?
@@ -258,7 +278,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::TagList.from(cached_tag_list_on(context)))
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagListParser.parse(cached_tag_list_on(context)))
       else
         instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
@@ -308,7 +328,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::TagList.from(new_list))
+      instance_variable_set(variable_name, ActsAsTaggableOn::TagListParser.parse(new_list))
     end
 
     def tagging_contexts
@@ -324,8 +344,12 @@ module ActsAsTaggableOn::Taggable
         old = changed_attributes[attrib]
         changed_attributes.delete(attrib) if old.to_s == value.to_s
       else
-        old = tag_list_on(context).to_s
-        changed_attributes[attrib] = old if old.to_s != value.to_s
+        old = tag_list_on(context)
+        if self.class.preserve_tag_order
+          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
+        end
       end
     end
 
@@ -382,7 +406,7 @@ module ActsAsTaggableOn::Taggable
 
         # Destroy old taggings:
         if old_tags.present?
-          ActsAsTaggableOn::Tagging.destroy_all(tagger_type: nil, tagger_id: nil, context: context.to_s, tag_id: old_tags)
+          taggings.not_owned.by_context(context).destroy_all(tag_id: old_tags)
         end
 
         # Create new taggings:

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/ownership.rb

@@ -63,7 +63,7 @@ module ActsAsTaggableOn::Taggable
 
       cache = cached_owned_tag_list_on(context)
 
-      cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
+      cache[owner] = ActsAsTaggableOn::TagListParser.parse(new_list)
     end
 
     def reload(*args)

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/related.rb

@@ -41,7 +41,7 @@ module ActsAsTaggableOn::Taggable
     end
 
     def related_tags_for(context, klass, options = {})
-      tags_to_ignore = Array.wrap(options.delete(:ignore)).map(&:to_s) || []
+      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])
     end
@@ -61,11 +61,11 @@ module ActsAsTaggableOn::Taggable
     end
 
     def related_where(klass, conditions)
-      klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count").
-          from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}").
-          group(group_columns(klass)).
-          order('count DESC').
-          where(conditions)
+      klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count")
+      .from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}")
+      .group(group_columns(klass))
+      .order('count DESC')
+      .where(conditions)
     end
   end
 end

data/lib/acts_as_taggable_on/taggable.rb

@@ -1,5 +1,6 @@
 module ActsAsTaggableOn
   module Taggable
+
     def taggable?
       false
     end
@@ -85,19 +86,17 @@ module ActsAsTaggableOn
           def self.taggable?
             true
           end
-
-          extend ActsAsTaggableOn::Utils
         end
       end
 
       # each of these add context-specific methods and must be
       # called on each call of taggable_on
-      include ActsAsTaggableOn::Taggable::Core
-      include ActsAsTaggableOn::Taggable::Collection
-      include ActsAsTaggableOn::Taggable::Cache
-      include ActsAsTaggableOn::Taggable::Ownership
-      include ActsAsTaggableOn::Taggable::Related
-      include ActsAsTaggableOn::Taggable::Dirty
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+      include Dirty
     end
   end
 end

data/lib/acts_as_taggable_on/tagging.rb

@@ -15,6 +15,12 @@ module ActsAsTaggableOn
     belongs_to :taggable, polymorphic: true
     belongs_to :tagger,   polymorphic: true
 
+    scope :owned_by, ->(owner) { where(tagger: owner) }
+    scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
+
+    scope :by_contexts, ->(contexts = ['tags']) { where(context: contexts) }
+    scope :by_context, ->(context= 'tags') { by_contexts(context.to_s) }
+
     validates_presence_of :context
     validates_presence_of :tag_id
 
@@ -26,7 +32,7 @@ module ActsAsTaggableOn
 
     def remove_unused_tags
       if ActsAsTaggableOn.remove_unused_tags
-        tag.destroy if tag.taggings_count.zero?
+        tag.destroy if tag.reload.taggings_count.zero?
       end
     end
   end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -4,10 +4,10 @@ module ActsAsTaggableOn
     def tag_cloud(tags, classes)
       return [] if tags.empty?
 
-      max_count = tags.sort_by(&:count).last.count.to_f
+      max_count = tags.sort_by(&:taggings_count).last.taggings_count.to_f
 
       tags.each do |tag|
-        index = ((tag.count / max_count) * (classes.size - 1))
+        index = ((tag.taggings_count / max_count) * (classes.size - 1))
         yield tag, classes[index.nan? ? 0 : index.round]
       end
     end

data/lib/acts_as_taggable_on/utils.rb

@@ -1,62 +1,38 @@
+# This module is deprecated and will be removed in the incoming versions
+
 module ActsAsTaggableOn
   module Utils
-    extend self
-
-    # Use ActsAsTaggableOn::Tag connection
-    def connection
-      ActsAsTaggableOn::Tag.connection
-    end
-
-    def using_postgresql?
-      connection && connection.adapter_name == 'PostgreSQL'
-    end
-
-    def postgresql_version
-      if using_postgresql?
-        connection.execute("SHOW SERVER_VERSION").first["server_version"].to_f
+    class << self
+      # Use ActsAsTaggableOn::Tag connection
+      def connection
+        ActsAsTaggableOn::Tag.connection
       end
-    end
-
-    def postgresql_support_json?
-      postgresql_version >= 9.2
-    end
-
-    def using_sqlite?
-      connection && connection.adapter_name == 'SQLite'
-    end
-
-    def using_mysql?
-      #We should probably use regex for mysql to support prehistoric adapters
-      connection && connection.adapter_name == 'Mysql2'
-    end
 
-    def using_case_insensitive_collation?
-      using_mysql? && connection.collation =~ /_ci\Z/
-    end
-
-    def supports_concurrency?
-      !using_sqlite?
-    end
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
 
-    def sha_prefix(string)
-      Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
-    end
+      def using_mysql?
+        #We should probably use regex for mysql to support prehistoric adapters
+        connection && connection.adapter_name == 'Mysql2'
+      end
 
-    def active_record4?
-      ::ActiveRecord::VERSION::MAJOR == 4
-    end
+      def sha_prefix(string)
+        Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
+      end
 
-    def active_record42?
-      active_record4? && ::ActiveRecord::VERSION::MINOR >= 2
-    end
+      def active_record4?
+        ::ActiveRecord::VERSION::MAJOR == 4
+      end
 
-    def like_operator
-      using_postgresql? ? 'ILIKE' : 'LIKE'
-    end
+      def like_operator
+        using_postgresql? ? 'ILIKE' : 'LIKE'
+      end
 
-    # escape _ and % characters in strings, since these are wildcards in SQL.
-    def escape_like(str)
-      str.gsub(/[!%_]/) { |x| '!' + x }
+      # 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

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

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -1,4 +1,4 @@
-# coding: utf-8
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe 'Acts As Taggable On' do

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe 'acts_as_tagger' do

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe 'Acts As Taggable On' do

data/spec/acts_as_taggable_on/related_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe 'Acts As Taggable On' do

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe 'Single Table Inheritance' do

data/spec/acts_as_taggable_on/tag_list_parser_spec.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::TagListParser do
+  it '#parse should return empty array if empty array is passed' do
+    expect(ActsAsTaggableOn::TagListParser.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 = [',', ' ', '\|']
+      tag_list = ActsAsTaggableOn::TagListParser.parse('cool, data|I have')
+      expect(tag_list.to_s).to eq('cool, data, I, have')
+    end
+
+    it 'should escape quote' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      tag_list = ActsAsTaggableOn::TagListParser.parse "'I have'|cool, data"
+      expect(tag_list.to_s).to eq('"I have", cool, data')
+
+      tag_list = ActsAsTaggableOn::TagListParser.parse '"I, have"|cool, data'
+      expect(tag_list.to_s).to eq('"I, have", cool, data')
+    end
+
+    it 'should work for utf8 delimiter and long delimiter' do
+      ActsAsTaggableOn.delimiter = ['，', '的', '可能是']
+      tag_list = ActsAsTaggableOn::TagListParser.parse('我的东西可能是不见了，还好有备份')
+      expect(tag_list.to_s).to eq('我， 东西， 不见了， 还好有备份')
+    end
+
+    it 'should work for multiple quoted tags' do
+      ActsAsTaggableOn.delimiter = [',']
+      tag_list = ActsAsTaggableOn::TagListParser.parse('"Ruby Monsters","eat Katzenzungen"')
+      expect(tag_list.to_s).to eq('Ruby Monsters, eat Katzenzungen')
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# -*- encoding : utf-8 -*-
+
 require 'spec_helper'
 
 describe ActsAsTaggableOn::TagList do
@@ -7,9 +8,7 @@ describe ActsAsTaggableOn::TagList do
 
   it { should be_kind_of Array }
 
-  it '#from should return empty array if empty array is passed' do
-    expect(ActsAsTaggableOn::TagList.from([])).to be_empty
-  end
+
 
   describe '#add' do
     it 'should be able to be add a new tag word' do
@@ -118,41 +117,5 @@ describe ActsAsTaggableOn::TagList do
 
   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 = [',', ' ', '\|']
-      tag_list = ActsAsTaggableOn::TagList.from 'cool, data|I have'
-      expect(tag_list.to_s).to eq('cool, data, I, have')
-    end
-
-    it 'should escape quote' do
-      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
-      tag_list = ActsAsTaggableOn::TagList.from "'I have'|cool, data"
-      expect(tag_list.to_s).to eq('"I have", cool, data')
-
-      tag_list = ActsAsTaggableOn::TagList.from '"I, have"|cool, data'
-      expect(tag_list.to_s).to eq('"I, have", cool, data')
-    end
-
-    it 'should work for utf8 delimiter and long delimiter' do
-      ActsAsTaggableOn.delimiter = ['，', '的', '可能是']
-      tag_list = ActsAsTaggableOn::TagList.from '我的东西可能是不见了，还好有备份'
-      expect(tag_list.to_s).to eq('我， 东西， 不见了， 还好有备份')
-    end
-
-    it 'should work for multiple quoted tags' do
-      ActsAsTaggableOn.delimiter = [',']
-      tag_list = ActsAsTaggableOn::TagList.from '"Ruby Monsters","eat Katzenzungen"'
-      expect(tag_list.to_s).to eq('Ruby Monsters, eat Katzenzungen')
-    end
-  end
 
 end