acts-as-taggable-on 3.1.1 → 3.2.2

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,32 +142,35 @@ 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
 
     private
 
-    # Remove whitespace, duplicates, and blanks.
+    # Convert everything to string, remove whitespace, duplicates, and blanks.
     def clean!
       reject!(&:blank?)
+      map!(&:to_s)
       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,44 @@ 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
       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

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,5 +1,6 @@
 module ActsAsTaggableOn
   class Tagging < ::ActiveRecord::Base #:nodoc:
+    #TODO, remove from 4.0.0
     attr_accessible :tag,
                     :tag_id,
                     :context,
@@ -9,14 +10,15 @@ module ActsAsTaggableOn
                     :tagger,
                     :tagger_type,
                     :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
-    belongs_to :tag, :class_name => 'ActsAsTaggableOn::Tag' , :counter_cache => true
-    belongs_to :taggable, :polymorphic => true
-    belongs_to :tagger,   :polymorphic => true
+
+    belongs_to :tag, class_name: 'ActsAsTaggableOn::Tag' , counter_cache: true
+    belongs_to :taggable, polymorphic: true
+    belongs_to :tagger,   polymorphic: true
 
     validates_presence_of :context
     validates_presence_of :tag_id
 
-    validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
+    validates_uniqueness_of :tag_id, scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
 
     after_destroy :remove_unused_tags
 
@@ -24,10 +26,7 @@ module ActsAsTaggableOn
 
     def remove_unused_tags
       if ActsAsTaggableOn.remove_unused_tags
-        # TODO: use taggings_count in release 4.0.0
-        if tag.taggings.count.zero?
-          tag.destroy
-        end
+        tag.destroy if tag.taggings_count.zero?
       end
     end
   end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -1,6 +1,6 @@
 module ActsAsTaggableOn
   module TagsHelper
-    # See the README for an example using tag_cloud.
+    # See the wiki for an example using tag_cloud.
     def tag_cloud(tags, classes)
       return [] if tags.empty?
 

data/lib/acts_as_taggable_on/utils.rb

@@ -1,40 +1,62 @@
 module ActsAsTaggableOn
   module Utils
-
-    def connection
-      ::ActiveRecord::Base.connection
-    end
-
-    def using_postgresql?
-      connection && connection.adapter_name == 'PostgreSQL'
-    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? && ::ActiveRecord::Base.connection.collation =~ /_ci\Z/
-    end
-
-    def sha_prefix(string)
-      Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
-    end
-
-    private
-
-    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 }
+    class << 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
+        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 sha_prefix(string)
+        Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
+      end
+
+      def active_record4?
+        ::ActiveRecord::VERSION::MAJOR == 4
+      end
+
+      def active_record42?
+        active_record4? && ::ActiveRecord::VERSION::MINOR >= 2
+      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 }
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '3.1.1'
+  VERSION = '3.2.2'
 end