acts-as-taggable-on 2.0.0 → 3.2.2

data/lib/acts_as_taggable_on/tag_list.rb

@@ -1,95 +1,176 @@
-class TagList < Array
+require 'active_support/core_ext/module/delegation'
 
-  cattr_accessor :delimiter
-  self.delimiter = ','
+module ActsAsTaggableOn
+  class TagList < Array
+    attr_accessor :owner
 
-  attr_accessor :owner
+    def initialize(*args)
+      add(*args)
+    end
+
+    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
+        # Separate multiple delimiters by bitwise operator
+        d = d.join('|') if d.kind_of?(Array)
+
+        d
+      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
 
-  def initialize(*args)
-    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(", ") if string.respond_to?(:join)
-
-    new.tap do |tag_list|
-      string = string.to_s.dup
-
-      # Parse the quoted tags
-      string.gsub!(/(\A|#{delimiter})\s*"(.*?)"\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
-      string.gsub!(/(\A|#{delimiter})\s*'(.*?)'\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
-
-      tag_list.add(string.split(delimiter))
     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.
+    #
+    # Example:
+    #   tag_list.add("Fun", "Happy")
+    #   tag_list.add("Fun, Happy", :parse => true)
+    def add(*names)
+      extract_and_apply_options!(names)
+      concat(names)
+      clean!
+      self
+    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.
-  #
-  # Example:
-  #   tag_list.add("Fun", "Happy")
-  #   tag_list.add("Fun, Happy", :parse => true)
-  def add(*names)
-    extract_and_apply_options!(names)
-    concat(names)
-    clean!
-    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
 
-  ##
-  # Remove specific tags from the tag_list.
-  # Use the <tt>:parse</tt> option to add an unparsed tag string.
-  #
-  # Example:
-  #   tag_list.remove("Sad", "Lonely")
-  #   tag_list.remove("Sad, Lonely", :parse => true)
-  def remove(*names)
-    extract_and_apply_options!(names)
-    delete_if { |name| names.include?(name) }
-    self
-  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
 
-  ##
-  # Transform the tag_list into a tag string suitable for edting in a form.
-  # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
-  #
-  # Example:
-  #   tag_list = TagList.new("Round", "Square,Cube")
-  #   tag_list.to_s # 'Round, "Square,Cube"'
-  def to_s
-    tags = frozen? ? self.dup : self
-    tags.send(:clean!)
-
-    tags.map do |name|
-      name.include?(delimiter) ? "\"#{name}\"" : name
-    end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
-  end
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      super(other_tag_list).send(:clean!)
+    end
 
-  private
-  
-  # Remove whitespace, duplicates, and blanks.
-  def clean!
-    reject!(&:blank?)
-    map!(&:strip)
-    uniq!
-  end
+    ##
+    # Remove specific tags from the tag_list.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.remove("Sad", "Lonely")
+    #   tag_list.remove("Sad, Lonely", :parse => true)
+    def remove(*names)
+      extract_and_apply_options!(names)
+      delete_if { |name| names.include?(name) }
+      self
+    end
 
-  def extract_and_apply_options!(args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    options.assert_valid_keys :parse
+    ##
+    # Transform the tag_list into a tag string suitable for editing in a form.
+    # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+    #
+    # Example:
+    #   tag_list = TagList.new("Round", "Square,Cube")
+    #   tag_list.to_s # 'Round, "Square,Cube"'
+    def to_s
+      tags = frozen? ? self.dup : self
+      tags.send(:clean!)
 
-    if options[:parse]
-      args.map! { |a| self.class.from(a) }
+      tags.map do |name|
+        d = ActsAsTaggableOn.delimiter
+        d = Regexp.new d.join('|') if d.kind_of? Array
+        name.index(d) ? "\"#{name}\"" : name
+      end.join(ActsAsTaggableOn.glue)
     end
 
-    args.flatten!
-  end
+    private
+
+    # 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!(&: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
+
+      args.map! { |a| self.class.from(a) } if options[:parse]
+
+      args.flatten!
+    end
+
+
+  end
 end
+

data/lib/acts_as_taggable_on/taggable.rb

@@ -0,0 +1,101 @@
+module ActsAsTaggableOn
+  module Taggable
+    def taggable?
+      false
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_taggable
+    #   end
+    def acts_as_taggable
+      acts_as_taggable_on :tags
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_ordered_taggable
+    #   end
+    def acts_as_ordered_taggable
+      acts_as_ordered_taggable_on :tags
+    end
+
+    ##
+    # Make a model taggable on specified contexts.
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_taggable_on :languages, :skills
+    #   end
+    def acts_as_taggable_on(*tag_types)
+      taggable_on(false, tag_types)
+    end
+
+    ##
+    # Make a model taggable on specified contexts
+    # and preserves the order in which tags are created
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_ordered_taggable_on :languages, :skills
+    #   end
+    def acts_as_ordered_taggable_on(*tag_types)
+      taggable_on(true, tag_types)
+    end
+
+    private
+
+      # Make a model taggable on specified contexts
+      # and optionally preserves the order in which tags are created
+      #
+      # 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 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
+
+        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'
+
+          def self.taggable?
+            true
+          end
+        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/{acts_as_tagger.rb → tagger.rb}

@@ -15,23 +15,36 @@ module ActsAsTaggableOn
       #   end
       def acts_as_tagger(opts={})
         class_eval do
-          has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
-                                               :include => :tag, :class_name => "Tagging")
-          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true
+          has_many_with_taggable_compatibility :owned_taggings,
+                                               opts.merge(
+                                                   as: :tagger,
+                                                   dependent: :destroy,
+                                                   class_name: 'ActsAsTaggableOn::Tagging'
+                                               )
+
+          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
       ##
-      # Tag a taggable model with tags that are owned by the tagger. 
+      # Tag a taggable model with tags that are owned by the tagger.
       #
       # @param taggable The object that will be tagged
       # @param [Hash] options An hash with options. Available options are:
@@ -41,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
+        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,23 +1,33 @@
-class Tagging < ActiveRecord::Base #:nodoc:
-  include ActsAsTaggableOn::ActiveRecord::Backports if ActiveRecord::VERSION::MAJOR < 3
+module ActsAsTaggableOn
+  class Tagging < ::ActiveRecord::Base #:nodoc:
+    #TODO, remove from 4.0.0
+    attr_accessible :tag,
+                    :tag_id,
+                    :context,
+                    :taggable,
+                    :taggable_type,
+                    :taggable_id,
+                    :tagger,
+                    :tagger_type,
+                    :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
 
-  attr_accessible :tag,
-                  :tag_id,
-                  :context,
-                  :taggable,
-                  :taggable_type,
-                  :taggable_id,
-                  :tagger,
-                  :tagger_type,
-                  :tagger_id
+    belongs_to :tag, class_name: 'ActsAsTaggableOn::Tag' , counter_cache: true
+    belongs_to :taggable, polymorphic: true
+    belongs_to :tagger,   polymorphic: true
 
-  belongs_to :tag
-  belongs_to :taggable, :polymorphic => true
-  belongs_to :tagger,   :polymorphic => true
+    validates_presence_of :context
+    validates_presence_of :tag_id
 
-  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
 
-end
+    private
+
+    def remove_unused_tags
+      if ActsAsTaggableOn.remove_unused_tags
+        tag.destroy if tag.taggings_count.zero?
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tags_helper.rb

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

data/lib/acts_as_taggable_on/utils.rb

@@ -0,0 +1,62 @@
+module ActsAsTaggableOn
+  module Utils
+    class << self
+      # Use ActsAsTaggableOn::Tag connection
+      def connection
+        ActsAsTaggableOn::Tag.connection
+      end
+
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
+
+      def 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

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

data/lib/acts_as_taggable_on.rb

@@ -0,0 +1,6 @@
+$stderr.puts <<EOF
+You are requiring 'acts_as_taggable_on' in the 'acts-as-taggable-on' gem.
+
+Please change your require to 'acts-as-taggable-on'.
+EOF
+require_relative 'acts-as-taggable-on'