acts-as-taggable-on 3.1.1 → 3.2.1

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -79,7 +79,7 @@ module ActsAsTaggableOn::Taggable
         cached_owned_tag_list_on(context).each do |owner, tag_list|
 
           # Find existing tags or create non-existing tags:
-          tags = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list.uniq)
+          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)
@@ -108,20 +108,13 @@ module ActsAsTaggableOn::Taggable
 
           # Find all taggings that belong to the taggable (self), are owned by the owner,
           # have the correct context, and are removed from the list.
-          if old_tags.present?
-            old_taggings = ActsAsTaggableOn::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
-                                                            :tagger_type => owner.class.base_class.to_s, :tagger_id => owner.id,
-                                                            :tag_id => old_tags, :context => context)
-          end
-
-          # Destroy old taggings:
-          if old_taggings.present?
-            ActsAsTaggableOn::Tagging.destroy_all(:id => old_taggings.map(&:id))
-          end
+          ActsAsTaggableOn::Tagging.destroy_all(taggable_id: id, taggable_type: self.class.base_class.to_s,
+                                                            tagger_type: owner.class.base_class.to_s, tagger_id: owner.id,
+                                                            tag_id: old_tags, context: context) if old_tags.present?
 
           # Create new taggings:
           new_tags.each do |tag|
-            taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
+            taggings.create!(tag_id: tag.id, context: context.to_s, tagger: owner, taggable: self)
           end
         end
       end

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -36,24 +36,24 @@ module ActsAsTaggableOn::Taggable
     end
 
     def matching_contexts_for(search_context, result_context, klass, options = {})
-      tags_to_find = tags_on(search_context).collect { |t| t.name }
-      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.to_s}' 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, result_context])
+      tags_to_find = tags_on(search_context).map { |t| t.name }
+      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, result_context])
     end
 
     def related_tags_for(context, klass, options = {})
       tags_to_ignore = Array.wrap(options.delete(:ignore)).map(&:to_s) || []
-      tags_to_find = tags_on(context).collect { |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.to_s}' 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])
+      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
 
     private
 
     def exclude_self(klass, id)
-        "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
+      "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
     end
 
     def group_columns(klass)
-      if ActsAsTaggableOn::Tag.using_postgresql?
+      if ActsAsTaggableOn::Utils.using_postgresql?
         grouped_column_names_for(klass)
       else
         "#{klass.table_name}.#{klass.primary_key}"
@@ -64,7 +64,7 @@ module ActsAsTaggableOn::Taggable
       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").
+          order('count DESC').
           where(conditions)
     end
   end

data/lib/acts_as_taggable_on/engine.rb

@@ -1,6 +1,5 @@
 require 'rails/engine'
 module ActsAsTaggableOn
   class Engine < Rails::Engine
-
   end
 end

data/lib/acts_as_taggable_on/tag.rb

@@ -1,19 +1,18 @@
 # coding: utf-8
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
-    extend ActsAsTaggableOn::Utils
 
     attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
 
     ### ASSOCIATIONS:
 
-    has_many :taggings, :dependent => :destroy, :class_name => 'ActsAsTaggableOn::Tagging'
+    has_many :taggings, dependent: :destroy, class_name: 'ActsAsTaggableOn::Tagging'
 
     ### VALIDATIONS:
 
     validates_presence_of :name
-    validates_uniqueness_of :name, :if => :validates_name_uniqueness?
-    validates_length_of :name, :maximum => 255
+    validates_uniqueness_of :name, if: :validates_name_uniqueness?
+    validates_length_of :name, maximum: 255
 
     # monkey patch this method if don't need name uniqueness validation
     def validates_name_uniqueness?
@@ -26,7 +25,7 @@ module ActsAsTaggableOn
       if ActsAsTaggableOn.strict_case_match
         where(["name = #{binary}?", as_8bit_ascii(name)])
       else
-        where(["LOWER(name) = LOWER(?)", as_8bit_ascii(unicode_downcase(name))])
+        where(['LOWER(name) = LOWER(?)', as_8bit_ascii(unicode_downcase(name))])
       end
     end
 
@@ -34,35 +33,35 @@ module ActsAsTaggableOn
       if ActsAsTaggableOn.strict_case_match
         clause = list.map { |tag|
           sanitize_sql(["name = #{binary}?", as_8bit_ascii(tag)])
-        }.join(" OR ")
+        }.join(' OR ')
         where(clause)
       else
         clause = list.map { |tag|
-          sanitize_sql(["LOWER(name) = LOWER(?)", as_8bit_ascii(unicode_downcase(tag))])
-        }.join(" OR ")
+          sanitize_sql(['LOWER(name) = LOWER(?)', as_8bit_ascii(unicode_downcase(tag))])
+        }.join(' OR ')
         where(clause)
       end
     end
 
     def self.named_like(name)
-      clause = ["name #{like_operator} ? ESCAPE '!'", "%#{escape_like(name)}%"]
+      clause = ["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(name)}%"]
       where(clause)
     end
 
     def self.named_like_any(list)
       clause = list.map { |tag|
-        sanitize_sql(["name #{like_operator} ? ESCAPE '!'", "%#{escape_like(tag.to_s)}%"])
-      }.join(" OR ")
+        sanitize_sql(["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(tag.to_s)}%"])
+      }.join(' OR ')
       where(clause)
     end
 
     ### CLASS METHODS:
 
     def self.find_or_create_with_like_by_name(name)
-      if (ActsAsTaggableOn.strict_case_match)
+      if ActsAsTaggableOn.strict_case_match
         self.find_or_create_all_with_like_by_name([name]).first
       else
-        named_like(name).first || create(:name => name)
+        named_like(name).first || create(name: name)
       end
     end
 
@@ -71,13 +70,19 @@ module ActsAsTaggableOn
 
       return [] if list.empty?
 
-      existing_tags = Tag.named_any(list)
+      existing_tags = named_any(list)
 
       list.map do |tag_name|
         comparable_tag_name = comparable_name(tag_name)
-        existing_tag = existing_tags.detect { |tag| comparable_name(tag.name) == comparable_tag_name }
-
-        existing_tag || Tag.create(:name => tag_name)
+        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
+        begin
+          existing_tag || create(name: tag_name)
+        rescue ActiveRecord::RecordNotUnique
+          # Postgres aborts the current transaction with
+          # PG::InFailedSqlTransaction: ERROR:  current transaction is aborted, commands ignored until end of transaction block
+          # so we have to rollback this transaction
+          raise DuplicateTagError.new("'#{tag_name}' has already been taken")
+        end
       end
     end
 
@@ -107,14 +112,14 @@ module ActsAsTaggableOn
       end
 
       def binary
-        using_mysql? ? "BINARY " : nil
+        ActsAsTaggableOn::Utils.using_mysql? ? 'BINARY ' : nil
       end
 
       def unicode_downcase(string)
         if ActiveSupport::Multibyte::Unicode.respond_to?(:downcase)
           ActiveSupport::Multibyte::Unicode.downcase(string)
         else
-          ActiveSupport::Multibyte::Chars.new(string).downcase.to_s  
+          ActiveSupport::Multibyte::Chars.new(string).downcase.to_s
         end
       end
 

data/lib/acts_as_taggable_on/tag_list.rb

@@ -8,28 +8,82 @@ module ActsAsTaggableOn
       add(*args)
     end
 
-    ##
-    # Returns a new TagList using the given tag string.
-    #
-    # Example:
-    #   tag_list = TagList.from("One , Two,  Three")
-    #   tag_list # ["One", "Two", "Three"]
-    def self.from(string)
-      string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
-
-      new.tap do |tag_list|
-        string = string.to_s.dup
+    class << self
+      ##
+      # Returns a new TagList using the given tag string.
+      #
+      # Example:
+      #   tag_list = ActsAsTaggableOn::TagList.from("One , Two,  Three")
+      #   tag_list # ["One", "Two", "Three"]
+      def from(string)
+        string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
+
+        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
+      end
 
+      def delimiter
         # Parse the quoted tags
         d = ActsAsTaggableOn.delimiter
-        d = d.join("|") if d.kind_of?(Array) 
-        string.gsub!(/(\A|#{d})\s*"(.*?)"\s*(#{d}\s*|\z)/) { tag_list << $2; $3 }
-        string.gsub!(/(\A|#{d})\s*'(.*?)'\s*(#{d}\s*|\z)/) { tag_list << $2; $3 }
+        # Separate multiple delimiters by bitwise operator
+        d = d.join('|') if d.kind_of?(Array)
 
-        tag_list.add(string.split(Regexp.new d))
+        d
       end
-    end
 
+      def single_quote_pattern
+        %r{
+          (             # 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
+          )
+      }x
+      end
+
+      def double_quote_pattern
+        %r{
+          (             # 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
+          )
+      }x
+      end
+
+    end
     ##
     # Add tags to the tag_list. Duplicate or blank tags will be ignored.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -44,6 +98,24 @@ module ActsAsTaggableOn
       self
     end
 
+    # Append---Add the tag to the tag_list. This
+    # expression returns the tag_list itself, so several appends
+    # may be chained together.
+    def <<(obj)
+      add(obj)
+    end
+
+    # Concatenation --- Returns a new tag list built by concatenating the
+    # two tag lists together to produce a third tag list.
+    def +(other_tag_list)
+      TagList.new.add(self).add(other_tag_list)
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      super(other_tag_list).send(:clean!)
+    end
+
     ##
     # Remove specific tags from the tag_list.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -70,7 +142,7 @@ module ActsAsTaggableOn
 
       tags.map do |name|
         d = ActsAsTaggableOn.delimiter
-        d = Regexp.new d.join("|") if d.kind_of? Array
+        d = Regexp.new d.join('|') if d.kind_of? Array
         name.index(d) ? "\"#{name}\"" : name
       end.join(ActsAsTaggableOn.glue)
     end
@@ -81,21 +153,23 @@ module ActsAsTaggableOn
     def clean!
       reject!(&:blank?)
       map!(&:strip)
-      map!{ |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
+      map! { |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
       map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
 
       uniq!
     end
 
+
     def extract_and_apply_options!(args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       options.assert_valid_keys :parse
 
-      if options[:parse]
-        args.map! { |a| self.class.from(a) }
-      end
+      args.map! { |a| self.class.from(a) } if options[:parse]
 
       args.flatten!
     end
+
+
   end
 end
+

data/lib/acts_as_taggable_on/taggable.rb

@@ -39,7 +39,6 @@ module ActsAsTaggableOn
       taggable_on(false, tag_types)
     end
 
-
     ##
     # Make a model taggable on specified contexts
     # and preserves the order in which tags are created
@@ -59,47 +58,46 @@ module ActsAsTaggableOn
       # Make a model taggable on specified contexts
       # and optionally preserves the order in which tags are created
       #
-      # Seperate methods used above for backwards compatibility
+      # Separate methods used above for backwards compatibility
       # so that the original acts_as_taggable_on method is unaffected
-      # as it's not possible to add another arguement to the method
+      # as it's not possible to add another argument to the method
       # without the tag_types being enclosed in square brackets
       #
       # NB: method overridden in core module in order to create tag type
       #     associations and methods after this logic has executed
       #
-      def taggable_on(preserve_tag_order, *tag_types)
-        tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
-
-        if taggable?
-          self.tag_types = (self.tag_types + tag_types).uniq
-          self.preserve_tag_order = preserve_tag_order
-        else
-          class_attribute :tag_types
-          self.tag_types = tag_types
-          class_attribute :preserve_tag_order
-          self.preserve_tag_order = preserve_tag_order
+    def taggable_on(preserve_tag_order, *tag_types)
+      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
 
-          class_eval do
-            has_many :taggings, :as => :taggable, :dependent => :destroy, :class_name => "ActsAsTaggableOn::Tagging"
-            has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
+      if taggable?
+        self.tag_types = (self.tag_types + tag_types).uniq
+        self.preserve_tag_order = preserve_tag_order
+      else
+        class_attribute :tag_types
+        self.tag_types = tag_types
+        class_attribute :preserve_tag_order
+        self.preserve_tag_order = preserve_tag_order
 
-            def self.taggable?
-              true
-            end
+        class_eval do
+          has_many :taggings, as: :taggable, dependent: :destroy, class_name: 'ActsAsTaggableOn::Tagging'
+          has_many :base_tags, through: :taggings, source: :tag, class_name: 'ActsAsTaggableOn::Tag'
 
-            extend ActsAsTaggableOn::Utils
+          def self.taggable?
+            true
           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
+          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
+    end
   end
 end

data/lib/acts_as_taggable_on/tagger.rb

@@ -15,27 +15,31 @@ module ActsAsTaggableOn
       #   end
       def acts_as_tagger(opts={})
         class_eval do
-          has_many_with_compatibility :owned_taggings,
-            opts.merge(
-              :as => :tagger,
-              :dependent => :destroy,
-              :class_name => "ActsAsTaggableOn::Tagging"
-            )
+          has_many_with_taggable_compatibility :owned_taggings,
+                                               opts.merge(
+                                                   as: :tagger,
+                                                   dependent: :destroy,
+                                                   class_name: 'ActsAsTaggableOn::Tagging'
+                                               )
 
-          has_many_with_compatibility :owned_tags,
-                                      :through => :owned_taggings,
-                                      :source => :tag,
-                                      :class_name => "ActsAsTaggableOn::Tag",
-                                      :uniq => true
+          has_many_with_taggable_compatibility :owned_tags,
+                                               through: :owned_taggings,
+                                               source: :tag,
+                                               class_name: 'ActsAsTaggableOn::Tag',
+                                               uniq: true
         end
 
         include ActsAsTaggableOn::Tagger::InstanceMethods
         extend ActsAsTaggableOn::Tagger::SingletonMethods
       end
 
-      def is_tagger?
+      def tagger?
         false
       end
+
+      def is_tagger?
+        tagger?
+      end
     end
 
     module InstanceMethods
@@ -50,27 +54,35 @@ module ActsAsTaggableOn
       # Example:
       #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
       def tag(taggable, opts={})
-        opts.reverse_merge!(:force => true)
+        opts.reverse_merge!(force: true)
         skip_save = opts.delete(:skip_save)
         return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
 
-        raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
-        raise "You need to specify some tags using :with"                  unless opts.has_key?(:with)
-        raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless (opts[:force] || taggable.tag_types.include?(opts[:on]))
+        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 is_tagger?
+      def tagger?
         self.class.is_tagger?
       end
+
+      def is_tagger?
+        tagger?
+      end
     end
 
     module SingletonMethods
-      def is_tagger?
+      def tagger?
         true
       end
+
+      def is_tagger?
+        tagger?
+      end
     end
   end
 end