acts-as-taggable-on 2.0.6 → 3.0.0

data/lib/acts-as-taggable-on.rb

@@ -1,30 +1,61 @@
 require "active_record"
+require "active_record/version"
+require "active_support/core_ext/module"
 require "action_view"
+require 'active_support/all'
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require "digest/sha1"
 
-require "acts_as_taggable_on/compatibility/active_record_backports" if ActiveRecord::VERSION::MAJOR < 3
+module ActsAsTaggableOn
+  mattr_accessor :delimiter
+  @@delimiter = ','
 
-require "acts_as_taggable_on/acts_as_taggable_on"
+  mattr_accessor :force_lowercase
+  @@force_lowercase = false
+
+  mattr_accessor :force_parameterize
+  @@force_parameterize = false
+
+  mattr_accessor :strict_case_match
+  @@strict_case_match = false
+
+  mattr_accessor :remove_unused_tags
+  self.remove_unused_tags = false
+
+  def self.glue
+    delimiter = @@delimiter.kind_of?(Array) ? @@delimiter[0] : @@delimiter
+    delimiter.ends_with?(" ") ? delimiter : "#{delimiter} "
+  end
+
+  def self.setup
+    yield self
+  end
+end
+
+
+require "acts_as_taggable_on/utils"
+
+require "acts_as_taggable_on/taggable"
+require "acts_as_taggable_on/acts_as_taggable_on/compatibility"
 require "acts_as_taggable_on/acts_as_taggable_on/core"
 require "acts_as_taggable_on/acts_as_taggable_on/collection"
 require "acts_as_taggable_on/acts_as_taggable_on/cache"
 require "acts_as_taggable_on/acts_as_taggable_on/ownership"
 require "acts_as_taggable_on/acts_as_taggable_on/related"
+require "acts_as_taggable_on/acts_as_taggable_on/dirty"
 
-require "acts_as_taggable_on/acts_as_tagger"
+require "acts_as_taggable_on/tagger"
 require "acts_as_taggable_on/tag"
 require "acts_as_taggable_on/tag_list"
 require "acts_as_taggable_on/tags_helper"
 require "acts_as_taggable_on/tagging"
+require 'acts_as_taggable_on/engine'
 
-$LOAD_PATH.shift
-
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
-  ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
+ActiveSupport.on_load(:active_record) do
+  extend ActsAsTaggableOn::Compatibility
+  extend ActsAsTaggableOn::Taggable
+  include ActsAsTaggableOn::Tagger
+end
+ActiveSupport.on_load(:action_view) do
+  include ActsAsTaggableOn::TagsHelper
 end
-
-if defined?(ActionView::Base)
-  ActionView::Base.send :include, ActsAsTaggableOn::TagsHelper
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -1,53 +1,82 @@
 module ActsAsTaggableOn::Taggable
   module Cache
     def self.included(base)
-      # Skip adding caching capabilities if table not exists or no cache columns exist
-      return unless base.table_exists? && base.tag_types.any? { |context| base.column_names.include?("cached_#{context.to_s.singularize}_list") }
-
-      base.send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
-      
-      base.class_eval do
-        before_save :save_cached_tag_list        
+      # 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? {|context|
+            db_column_names.include?("cached_#{context.to_s.singularize}_list")
+          }
+        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_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
+        def columns
+          @acts_as_taggable_on_columns ||= begin
+            db_columns = super
+            if _has_tags_cache_columns?(db_columns)
+              _add_tags_caching_methods
+            end
+            db_columns
+          end
+        end
+
       end
-      
-      base.intialize_acts_as_taggable_on_cache
     end
-    
+
     module ClassMethods
-      def intialize_acts_as_taggable_on_cache      
+      def initialize_tags_cache
         tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.caching_#{tag_type.singularize}_list?
               caching_tag_list_on?("#{tag_type}")
-            end        
-          )
-        end        
+            end
+          RUBY
+        end
       end
-      
+
       def acts_as_taggable_on(*args)
         super(*args)
-        intialize_acts_as_taggable_on_cache
+        initialize_tags_cache
       end
-      
+
       def caching_tag_list_on?(context)
         column_names.include?("cached_#{context.to_s.singularize}_list")
       end
     end
-    
-    module InstanceMethods      
+
+    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.singularize).to_a.flatten.compact.join(', ')
+              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/acts_as_taggable_on/collection.rb

@@ -5,11 +5,11 @@ module ActsAsTaggableOn::Taggable
       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 %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.#{tag_type.singularize}_counts(options={})
               tag_counts_on('#{tag_type}', options)
             end
@@ -24,20 +24,75 @@ module ActsAsTaggableOn::Taggable
 
             def self.top_#{tag_type}(limit = 10)
               tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
-            end        
-          )
-        end        
+            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.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
+
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+        start_at_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+        end_at_conditions   = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_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]
+
+        tagging_conditions = [
+          taggable_conditions,
+          start_at_conditions,
+          end_at_conditions
+        ].compact.reverse
+
+        tag_conditions = [
+          options[:conditions]
+        ].compact.reverse
+
+        ## 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.each { |condition| tagging_scope = tagging_scope.where(condition) }
+        tag_conditions.each     { |condition| tag_scope     = tag_scope.where(condition)     }
+
+        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:
+        scoped_select = "#{table_name}.#{primary_key}"
+        tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(scoped_select))})").group(group_columns)
+
+        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
+
       ##
       # Calculate the tag counts for all tags.
       #
@@ -53,80 +108,87 @@ module ActsAsTaggableOn::Taggable
       def all_tag_counts(options = {})
         options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
 
-        scope = if ActiveRecord::VERSION::MAJOR >= 3
-                  {}
-                else
-                  scope(:find) || {}           
-                end
+        scope = {}
 
         ## Generate conditions:
-        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]     
-          
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
         start_at_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
         end_at_conditions   = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
 
         taggable_conditions  = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?", base_class.name])
-        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options[:id]])  if options[:id]
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
 
-        conditions = [
+        tagging_conditions = [
           taggable_conditions,
-          options[:conditions],
           scope[:conditions],
           start_at_conditions,
           end_at_conditions
         ].compact.reverse
-        
-        ## Generate joins:
-        tagging_join  = "LEFT OUTER JOIN #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tag.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.tag_id"
-        tagging_join << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
 
+        tag_conditions = [
+          options[:conditions]
+        ].compact.reverse
+
+        ## 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      
+        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
 
-        joins = [
-          tagging_join,
+        tagging_joins = [
           taggable_join,
           scope[:joins]
         ].compact
 
-        joins = joins.reverse if ActiveRecord::VERSION::MAJOR < 3
-
+        tag_joins = [
+        ].compact
 
         ## Generate scope:
-        scope = ActsAsTaggableOn::Tag.scoped(:select => "#{ActsAsTaggableOn::Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
-        
+        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
-        joins.each      { |join|      scope = scope.joins(join)      }
-        conditions.each { |condition| scope = scope.where(condition) }
-        
+        tagging_joins.each      { |join|      tagging_scope = tagging_scope.joins(join)      }
+        tagging_conditions.each { |condition| tagging_scope = tagging_scope.where(condition) }
+
+        tag_joins.each          { |join|      tag_scope     = tag_scope.joins(join)          }
+        tag_conditions.each     { |condition| tag_scope     = tag_scope.where(condition)     }
+
         # GROUP BY and HAVING clauses:
-        at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
-        at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
-        having    = [at_least, at_most].compact.join(' AND ')        
+        at_least  = sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) >= ?", options.delete(:at_least)]) if options[:at_least]
+        at_most   = sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) <= ?", options.delete(:at_most)]) if options[:at_most]
+        having    = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0", at_least, at_most].compact.join(' AND ')
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
 
-        if ActiveRecord::VERSION::MAJOR >= 3
+        unless options[:id]
           # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
           scoped_select = "#{table_name}.#{primary_key}"
-          scope = scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})")
-          
-          # We have having() in RoR 3.0 so use it:
-          having = having.blank? ? "COUNT(*) > 0" : "COUNT(*) > 0 AND #{having}"
-          scope = scope.group(grouped_column_names_for(ActsAsTaggableOn::Tag)).having(having)
-        else
-          # Having is not available in 2.3.x:
-          group_by  = "#{grouped_column_names_for(ActsAsTaggableOn::Tag)} HAVING COUNT(*) > 0"
-          group_by << " AND #{having}" unless having.blank?
-          scope = scope.group(group_by)
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(scoped_select))})")
         end
 
-        scope
+        tagging_scope = tagging_scope.group(group_columns).having(having)
+
+        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
+
+      def safe_to_sql(relation)
+        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement{relation.to_sql} : relation.to_sql
       end
     end
-    
+
     module InstanceMethods
       def tag_counts_on(context, options={})
         self.class.tag_counts_on(context, options.merge(:id => id))
       end
     end
+
+    module CalculationMethods
+      def count
+        # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
+        super(:all)
+      end
+    end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/compatibility.rb

@@ -0,0 +1,34 @@
+module ActsAsTaggableOn::Compatibility
+  def has_many_with_compatibility(name, options = {}, &extention)
+    if ActiveRecord::VERSION::MAJOR >= 4
+      scope, opts = build_scope_and_options(options)
+      has_many(name, scope, opts, &extention)
+    else
+      has_many(name, options, &extention)
+    end
+  end
+
+  def build_scope_and_options(opts)
+    scope_opts, opts = parse_options(opts)
+
+    unless scope_opts.empty?
+      scope = lambda do 
+        scope_opts.inject(self) { |result, hash| result.send *hash }
+      end
+    end
+
+    [defined?(scope) ? scope : nil, opts]
+  end
+
+  def parse_options(opts)
+    scope_opts = {}
+    [:order, :having, :select, :group, :limit, :offset, :readonly].each do |o|
+      scope_opts[o] = opts.delete o if opts[o]
+    end
+    scope_opts[:where] = opts.delete :conditions if opts[:conditions]
+    scope_opts[:joins] = opts.delete :include if opts [:include]
+    scope_opts[:distinct] = opts.delete :uniq if opts[:uniq]
+
+    [scope_opts, opts]
+  end
+end