Namespaced everything (models and helpers included) to ActsAsTaggable…

…On to avoid conflicts with other plugins

lib/acts-as-taggable-on.rb

@@ -26,5 +26,5 @@
 end
 
 if defined?(ActionView::Base)
-  ActionView::Base.send :include, TagsHelper
+  ActionView::Base.send :include, ActsAsTaggableOn::TagsHelper
 end

lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -34,8 +34,8 @@ def acts_as_taggable_on(*tag_types)
         class_inheritable_reader(:tag_types)
 
         class_eval do
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
-          has_many :base_tags, :class_name => "Tag", :through => :taggings, :source => :tag
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
+          has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
 
           def self.taggable?
             true

lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -62,11 +62,11 @@ def all_tag_counts(options = {})
         ## Generate conditions:
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]     
 
-        start_at_conditions = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-        end_at_conditions   = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+        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(["#{Tagging.table_name}.taggable_type = ?", base_class.name])
-        taggable_conditions << sanitize_sql([" AND #{Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
+        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]
 
         conditions = [
           taggable_conditions,
@@ -77,10 +77,10 @@ def all_tag_counts(options = {})
         ].compact.reverse
 
         ## Generate joins:
-        tagging_join  = "LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"
-        tagging_join << sanitize_sql([" AND #{Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+        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]
 
-        taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
+        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      
 
         joins = [
@@ -91,7 +91,7 @@ def all_tag_counts(options = {})
 
 
         ## Generate scope:
-        scope = Tag.scoped(:select => "#{Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
+        scope = ActsAsTaggableOn::Tag.scoped(:select => "#{ActsAsTaggableOn::Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
 
         # Joins and conditions
         joins.each      { |join|      scope = scope.joins(join)      }
@@ -105,14 +105,14 @@ def all_tag_counts(options = {})
         if ActiveRecord::VERSION::MAJOR >= 3
           # 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("#{Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})")
+          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(Tag)).having(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(Tag)} HAVING COUNT(*) > 0"
+          group_by  = "#{grouped_column_names_for(ActsAsTaggableOn::Tag)} HAVING COUNT(*) > 0"
           group_by << " AND #{having}" unless having.blank?
           scope = scope.group(group_by)
         end

lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -20,9 +20,9 @@ def initialize_acts_as_taggable_on_core
           context_tags     = tags_type.to_sym
 
           class_eval do
-            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagging",
-                     :conditions => ["#{Tagging.table_name}.tagger_id IS NULL AND #{Tagging.table_name}.context = ?", tags_type]
-            has_many context_tags, :through => context_taggings, :source => :tag
+            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging",
+                     :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type]
+            has_many context_tags, :through => context_taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
           end
 
           class_eval %(
@@ -66,7 +66,7 @@ def grouped_column_names_for(object)
       #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
       #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
       def tagged_with(tags, options = {})
-        tag_list = TagList.from(tags)
+        tag_list = ActsAsTaggableOn::TagList.from(tags)
 
         return {} if tag_list.empty?
 
@@ -76,15 +76,15 @@ def tagged_with(tags, options = {})
         context = options.delete(:on)
 
         if options.delete(:exclude)
-          tags_conditions = tag_list.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
-          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND (#{tags_conditions}) WHERE #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
+          tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         elsif options.delete(:any)
-          tags_conditions = tag_list.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
-          conditions << "#{table_name}.#{primary_key} IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND (#{tags_conditions}) WHERE #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
+          tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+          conditions << "#{table_name}.#{primary_key} IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         else
-          tags = Tag.named_any(tag_list)
+          tags = ActsAsTaggableOn::Tag.named_any(tag_list)
           return scoped(:conditions => "1 = 0") unless tags.length == tag_list.length
 
           tags.each do |tag|
@@ -93,7 +93,7 @@ def tagged_with(tags, options = {})
 
             taggings_alias = "#{table_name}_taggings_#{prefix}"
 
-            tagging_join  = "JOIN #{Tagging.table_name} #{taggings_alias}" +
+            tagging_join  = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
                             " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
                             " AND #{taggings_alias}.tag_id = #{tag.id}"
@@ -106,7 +106,7 @@ def tagged_with(tags, options = {})
         taggings_alias, tags_alias = "#{table_name}_taggings_group", "#{table_name}_tags_group"
 
         if options.delete(:match_all)
-          joins << "LEFT OUTER JOIN #{Tagging.table_name} #{taggings_alias}" +
+          joins << "LEFT OUTER JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                    "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
                    " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
 
@@ -154,7 +154,7 @@ def tag_list_cache_set_on(context)
 
       def tag_list_cache_on(context)
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_get(variable_name) || instance_variable_set(variable_name, TagList.new(tags_on(context).map(&:name)))
+        instance_variable_get(variable_name) || instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
 
       def tag_list_on(context)
@@ -166,27 +166,27 @@ def all_tags_list_on(context)
         variable_name = "@all_#{context.to_s.singularize}_list"
         return instance_variable_get(variable_name) if instance_variable_get(variable_name)
 
-        instance_variable_set(variable_name, TagList.new(all_tags_on(context).map(&:name)).freeze)
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(all_tags_on(context).map(&:name)).freeze)
       end
 
       ##
       # Returns all tags of a given context
       def all_tags_on(context)
-        opts =  ["#{Tagging.table_name}.context = ?", context.to_s]
-        base_tags.where(opts).order("#{Tagging.table_name}.created_at").group("#{Tagging.table_name}.tag_id").all
+        opts =  ["#{ActsAsTaggableOn::Tagging.table_name}.context = ?", context.to_s]
+        base_tags.where(opts).order("#{ActsAsTaggableOn::Tagging.table_name}.created_at").group("#{ActsAsTaggableOn::Tagging.table_name}.tag_id").all
       end
 
       ##
       # Returns all tags that are not owned of a given context
       def tags_on(context)
-        base_tags.where(["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]).all
+        base_tags.where(["#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL", context.to_s]).all
       end
 
       def set_tag_list_on(context, new_list)
         add_custom_context(context)
 
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_set(variable_name, TagList.from(new_list))
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(new_list))
       end
 
       def tagging_contexts
@@ -209,7 +209,7 @@ def save_tags
           tag_list = tag_list_cache_on(context).uniq
 
           # Find existing tags or create non-existing tags:
-          tag_list = Tag.find_or_create_all_with_like_by_name(tag_list)
+          tag_list = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
 
           current_tags = tags_on(context)
           old_tags     = current_tags - tag_list
@@ -221,7 +221,7 @@ def save_tags
 
           if old_taggings.present?
             # Destroy old taggings:
-            Tagging.destroy_all :id => old_taggings.map(&:id)
+            ActsAsTaggableOn::Tagging.destroy_all :id => old_taggings.map(&:id)
           end
 
           # Create new taggings:

lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -30,9 +30,9 @@ def #{tag_type}_from(owner)
 
     module InstanceMethods
       def owner_tags_on(owner, context)
-        base_tags.where([%(#{Tagging.table_name}.context = ? AND
-                           #{Tagging.table_name}.tagger_id = ? AND
-                           #{Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.to_s]).all
+        base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND
+                           #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = ? AND
+                           #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.to_s]).all
       end
 
       def cached_owned_tag_list_on(context)
@@ -46,7 +46,7 @@ def owner_tag_list_on(owner, context)
         cache = cached_owned_tag_list_on(context)
         cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
 
-        cache[owner] ||= TagList.new(*owner_tags_on(owner, context).map(&:name))
+        cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
       end
 
       def set_owner_tag_list_on(owner, context, new_list)
@@ -55,7 +55,7 @@ def set_owner_tag_list_on(owner, context, new_list)
         cache = cached_owned_tag_list_on(context)
         cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
 
-        cache[owner] = TagList.from(new_list)
+        cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
       end
 
       def reload(*args)
@@ -70,21 +70,21 @@ def save_owned_tags
         tagging_contexts.each do |context|
           cached_owned_tag_list_on(context).each do |owner, tag_list|
             # Find existing tags or create non-existing tags:
-            tag_list = Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
+            tag_list = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
 
             owned_tags = owner_tags_on(owner, context)              
             old_tags   = owned_tags - tag_list
             new_tags   = tag_list   - owned_tags
 
             # Find all taggings that belong to the taggable (self), are owned by the owner, 
             # have the correct context, and are removed from the list.
-            old_taggings = Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
-                                         :tagger_type => owner.class.to_s, :tagger_id => owner.id,
-                                         :tag_id => old_tags, :context => context).all
+            old_taggings = ActsAsTaggableOn::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
+                                                           :tagger_type => owner.class.to_s, :tagger_id => owner.id,
+                                                           :tag_id => old_tags, :context => context).all
 
             if old_taggings.present?
               # Destroy old taggings:
-              Tagging.destroy_all(:id => old_taggings.map(&:id))
+              ActsAsTaggableOn::Tagging.destroy_all(:id => old_taggings.map(&:id))
             end
 
             # Create new taggings:

lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -42,9 +42,9 @@ def matching_contexts_for(search_context, result_context, klass, options = {})
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
-                       :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?) AND #{Tagging.table_name}.context = ?", tags_to_find, result_context],
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.id) AS count",
+                       :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
+                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context],
                        :group      => grouped_column_names_for(klass),
                        :order      => "count DESC" }.update(options))
       end
@@ -54,9 +54,9 @@ def related_tags_for(context, klass, options = {})
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
-                       :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?)", tags_to_find],
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.id) AS count",
+                       :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
+                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find],
                        :group      => grouped_column_names_for(klass),
                        :order      => "count DESC" }.update(options))
       end

lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -16,8 +16,8 @@ module ClassMethods
       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
+                                               :include => :tag, :class_name => "ActsAsTaggableOn::Tagging")
+          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => "ActsAsTaggableOn::Tag"
         end
 
         include ActsAsTaggableOn::Tagger::InstanceMethods