acts-as-taggable-on 2.0.0.pre5 → 3.5.0

data/lib/acts_as_taggable_on/tag_list.rb

@@ -1,95 +1,116 @@
-class TagList < Array
 
-  cattr_accessor :delimiter
+require 'active_support/core_ext/module/delegation'
 
-  self.delimiter = ','
+module ActsAsTaggableOn
+  class TagList < Array
+    attr_accessor :owner
+    attr_accessor :parser
 
-  def initialize(*args)
-    add(*args)
-  end
+    def initialize(*args)
+      @parser = ActsAsTaggableOn.default_parser
+      add(*args)
+    end
 
-  attr_accessor :owner
-
-  # Add tags to the tag_list. Duplicate or blank tags will be ignored.
-  #
-  #   tag_list.add("Fun", "Happy")
-  #
-  # Use the <tt>:parse</tt> option to add an unparsed tag string.
-  #
-  #   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
 
-  # Remove specific tags from the tag_list.
-  #
-  #   tag_list.remove("Sad", "Lonely")
-  #
-  # Like #add, the <tt>:parse</tt> option can be used to remove multiple tags in a string.
-  #
-  #   tag_list.remove("Sad, Lonely", :parse => true)
-  def remove(*names)
-    extract_and_apply_options!(names)
-    delete_if { |name| names.include?(name) }
-    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
 
-  # 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.
-  #
-  #   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
+    # 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
 
- private
-  # Remove whitespace, duplicates, and blanks.
-  def clean!
-    reject!(&:blank?)
-    map!(&:strip)
-    uniq!
-  end
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      super(other_tag_list).send(:clean!)
+    end
 
-  def extract_and_apply_options!(args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    options.assert_valid_keys :parse
+    ##
+    # 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
 
-    if options[:parse]
-      args.map! { |a| self.class.from(a) }
+    ##
+    # 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!)
+
+      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
 
-  class << self
+    # 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
 
-    # Returns a new TagList using the given tag string.
-    #
-    #   tag_list = TagList.from("One , Two,  Three")
-    #   tag_list # ["One", "Two", "Three"]
-    def from(string)
-      string = string.join(", ") if string.respond_to?(:join)
+      uniq!
+    end
+
+
+    def extract_and_apply_options!(args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.assert_valid_keys :parse, :parser
 
-      new.tap do |tag_list|
-        string = string.to_s.dup
+      parser = options[:parser] ? options[:parser] : @parser
 
-        # 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 }
+      args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
 
-        tag_list.add(string.split(delimiter))
-      end
+      args.flatten!
     end
 
-  end
 
+    ## DEPRECATED
+    def self.from(string)
+      ActiveRecord::Base.logger.warn <<WARNING
+ActsAsTaggableOn::TagList.from is deprecated \
+and will be removed from v4.0+, use  \
+ActsAsTaggableOn::DefaultParser.new instead
+WARNING
+      @parser.new(string).parse
+    end
+
+
+  end
 end
+

data/lib/acts_as_taggable_on/tag_list_parser.rb

@@ -0,0 +1,21 @@
+module ActsAsTaggableOn
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  #   tag_list = ActsAsTaggableOn::TagListParser.parse("One , Two,  Three")
+  #   tag_list # ["One", "Two", "Three"]
+  module TagListParser
+    class << self
+      ## DEPRECATED
+      def parse(string)
+        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
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/cache.rb

@@ -0,0 +1,86 @@
+module ActsAsTaggableOn::Taggable
+  module Cache
+    def self.included(base)
+      # When included, conditionally adds tag caching methods when the model
+      #   has any "cached_#{tag_type}_list" column
+      base.instance_eval do
+        # @private
+        def _has_tags_cache_columns?(db_columns)
+          db_column_names = db_columns.map(&:name)
+          tag_types.any? do |context|
+            db_column_names.include?("cached_#{context.to_s.singularize}_list")
+          end
+        end
+
+        # @private
+        def _add_tags_caching_methods
+          send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
+          extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
+
+          before_save :save_cached_tag_list
+
+          initialize_tags_cache
+        end
+
+        # ActiveRecord::Base.columns makes a database connection and caches the
+        #   calculated columns hash for the record as @columns.  Since we don't
+        #   want to add caching methods until we confirm the presence of a
+        #   caching column, and we don't want to force opening a database
+        #   connection when the class is loaded, here we intercept and cache
+        #   the call to :columns as @acts_as_taggable_on_cache_columns
+        #   to mimic the underlying behavior.  While processing this first
+        #   call to columns, we do the caching column check and dynamically add
+        #   the class and instance methods
+        #   FIXME: this method cannot compile in rubinius
+        def columns
+          @acts_as_taggable_on_cache_columns ||= begin
+            db_columns = super
+            _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
+            db_columns
+          end
+        end
+
+        def reset_column_information
+          super
+          @acts_as_taggable_on_cache_columns = nil
+        end
+      end
+    end
+
+    module ClassMethods
+      def initialize_tags_cache
+        tag_types.map(&:to_s).each do |tag_type|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.caching_#{tag_type.singularize}_list?
+              caching_tag_list_on?("#{tag_type}")
+            end
+          RUBY
+        end
+      end
+
+      def acts_as_taggable_on(*args)
+        super(*args)
+        initialize_tags_cache
+      end
+
+      def caching_tag_list_on?(context)
+        column_names.include?("cached_#{context.to_s.singularize}_list")
+      end
+    end
+
+    module InstanceMethods
+      def save_cached_tag_list
+        tag_types.map(&:to_s).each do |tag_type|
+          if self.class.send("caching_#{tag_type.singularize}_list?")
+            if tag_list_cache_set_on(tag_type)
+              list = tag_list_cache_on(tag_type).to_a.flatten.compact.join(', ')
+              self["cached_#{tag_type.singularize}_list"] = list
+            end
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/collection.rb

@@ -0,0 +1,178 @@
+module ActsAsTaggableOn::Taggable
+  module Collection
+    def self.included(base)
+      base.extend ActsAsTaggableOn::Taggable::Collection::ClassMethods
+      base.initialize_acts_as_taggable_on_collection
+    end
+
+    module ClassMethods
+      def initialize_acts_as_taggable_on_collection
+        tag_types.map(&:to_s).each do |tag_type|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{tag_type.singularize}_counts(options={})
+              tag_counts_on('#{tag_type}', options)
+            end
+
+            def #{tag_type.singularize}_counts(options = {})
+              tag_counts_on('#{tag_type}', options)
+            end
+
+            def top_#{tag_type}(limit = 10)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
+            end
+
+            def self.top_#{tag_type}(limit = 10)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
+            end
+          RUBY
+        end
+      end
+
+      def acts_as_taggable_on(*args)
+        super(*args)
+        initialize_acts_as_taggable_on_collection
+      end
+
+      def tag_counts_on(context, options = {})
+        all_tag_counts(options.merge({on: context.to_s}))
+      end
+
+      def tags_on(context, options = {})
+        all_tags(options.merge({on: context.to_s}))
+      end
+
+      ##
+      # Calculate the tag names.
+      # To be used when you don't need tag counts and want to avoid the taggable joins.
+      #
+      # @param [Hash] options Options:
+      #                       * :start_at   - Restrict the tags to those created after a certain time
+      #                       * :end_at     - Restrict the tags to those created before a certain time
+      #                       * :conditions - A piece of SQL conditions to add to the query. Note we don't join the taggable objects for performance reasons.
+      #                       * :limit      - The maximum number of tags to return
+      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
+      #                       * :on         - Scope the find to only include a certain context
+      def all_tags(options = {})
+        options = options.dup
+        options.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
+
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+        ## Generate scope:
+        tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id")
+        tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*").order(options[:order]).limit(options[:limit])
+
+        # Joins and conditions
+        tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
+        tag_scope = tag_scope.where(options[:conditions])
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+        # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+        tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key).group(group_columns)
+
+        tag_scope_joins(tag_scope, tagging_scope)
+      end
+
+      ##
+      # Calculate the tag counts for all tags.
+      #
+      # @param [Hash] options Options:
+      #                       * :start_at   - Restrict the tags to those created after a certain time
+      #                       * :end_at     - Restrict the tags to those created before a certain time
+      #                       * :conditions - A piece of SQL conditions to add to the query
+      #                       * :limit      - The maximum number of tags to return
+      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
+      #                       * :at_least   - Exclude tags with a frequency less than the given value
+      #                       * :at_most    - Exclude tags with a frequency greater than the given value
+      #                       * :on         - Scope the find to only include a certain context
+      def all_tag_counts(options = {})
+        options = options.dup
+        options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
+
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+        ## Generate joins:
+        taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id"
+        taggable_join << " AND #{table_name}.#{inheritance_column} = '#{name}'" unless descends_from_active_record? # Current model is STI descendant, so add type checking to the join condition
+
+        ## Generate scope:
+        tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id, COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) AS tags_count")
+        tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*, #{ActsAsTaggableOn::Tagging.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
+
+        # Joins and conditions
+        tagging_scope = tagging_scope.joins(taggable_join)
+        tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
+        tag_scope = tag_scope.where(options[:conditions])
+
+        # GROUP BY and HAVING clauses:
+        having = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0"]
+        having.push sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) >= ?", options.delete(:at_least)]) if options[:at_least]
+        having.push sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) <= ?", options.delete(:at_most)]) if options[:at_most]
+        having = having.compact.join(' AND ')
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+        unless options[:id]
+          # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+          tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+        end
+
+        tagging_scope = tagging_scope.group(group_columns).having(having)
+
+        tag_scope_joins(tag_scope, tagging_scope)
+      end
+
+      def safe_to_sql(relation)
+        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement { relation.to_sql } : relation.to_sql
+      end
+
+      private
+
+      def generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+        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 = 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))})")
+        end
+
+        tagging_scope
+      end
+
+      def tagging_conditions(options)
+        tagging_conditions = []
+        tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+        tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+
+        taggable_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?", base_class.name])
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options[:id]]) if options[:id]
+
+        tagging_conditions.push taggable_conditions
+
+        tagging_conditions
+      end
+
+      def tag_scope_joins(tag_scope, tagging_scope)
+        tag_scope = tag_scope.joins("JOIN (#{safe_to_sql(tagging_scope)}) AS #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id")
+        tag_scope.extending(CalculationMethods)
+      end
+    end
+
+    def tag_counts_on(context, options={})
+      self.class.tag_counts_on(context, options.merge(id: id))
+    end
+
+    module CalculationMethods
+      def count(column_name=:all, options = {})
+        # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
+        super
+      end
+    end
+  end
+end