acts-as-taggable-on 0.0.0 → 1.0.6

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -1,56 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Cache
-    def self.included(base)
-      # Skip adding caching capabilities if no cache columns exist
-      return unless 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        
-      end
-      
-      base.intialize_acts_as_taggable_on_cache
-    end
-    
-    module ClassMethods
-      def intialize_acts_as_taggable_on_cache      
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
-            def self.caching_#{tag_type.singularize}_list?
-              caching_tag_list_on?("#{tag_type}")
-            end        
-          )
-        end        
-      end
-      
-      def acts_as_taggable_on(*args)
-        super(*args)
-        intialize_acts_as_taggable_on_cache
-      end
-      
-      def caching_tag_list_on?(context)
-        column_names.include?("cached_#{context.to_s.singularize}_list")
-      end
-    end
-    
-    module InstanceMethods
-      def tag_list_cache_set_on(context)
-        variable_name = "@#{context.to_s.singularize}_list"
-        !instance_variable_get(variable_name).nil?
-      end
-      
-      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(', ')
-              self["cached_#{tag_type.singularize}_list"] = list
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -1,97 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Collection
-    def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Collection::InstanceMethods
-      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 %(
-            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        
-          )
-        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
-      
-      # Calculate the tag counts for all tags.
-      #
-      # 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.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
-
-        start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-        end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
-
-        taggable_type = sanitize_sql(["#{Tagging.table_name}.taggable_type = ?", base_class.name])
-        taggable_id = sanitize_sql(["#{Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
-        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
-
-        conditions = [
-          taggable_type,
-          taggable_id,
-          options[:conditions],
-          start_at,
-          end_at
-        ]
-
-        conditions = conditions.compact.join(' AND ')
-
-        joins = ["LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
-        joins << sanitize_sql(["AND #{Tagging.table_name}.context = ?",options.delete(:on).to_s]) unless options[:on].nil?
-        joins << " INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
-
-        unless descends_from_active_record?
-          # Current model is STI descendant, so add type checking to the join condition
-          joins << " AND #{table_name}.#{inheritance_column} = '#{name}'"
-        end
-
-        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 ')
-        group_by  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
-        group_by << " AND #{having}" unless having.blank?
-
-        Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(joins.join(" ")).where(conditions).group(group_by).limit(options[:limit]).order(options[:order])
-      end
-    end
-    
-    module InstanceMethods
-      def tag_counts_on(context, options={})
-        self.class.tag_counts_on(context, options.merge(:id => id))
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -1,220 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Core
-    def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Core::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Core::ClassMethods
-
-      base.class_eval do
-        attr_writer :custom_contexts
-        after_save :save_tags
-      end
-      
-      base.initialize_acts_as_taggable_on_core
-    end
-    
-    module ClassMethods
-      def initialize_acts_as_taggable_on_core
-        tag_types.map(&:to_s).each do |tag_type|
-          context_taggings = "#{tag_type.singularize}_taggings".to_sym
-          context_tags     = tag_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 = ?', tag_type]
-            has_many context_tags, :through => context_taggings, :source => :tag
-          end
-
-          class_eval %(
-            def #{tag_type.singularize}_list
-              tag_list_on('#{tag_type}')
-            end
-
-            def #{tag_type.singularize}_list=(new_tags)
-              set_tag_list_on('#{tag_type}', new_tags)
-            end
-
-            def all_#{tag_type}_list
-              all_tags_list_on('#{tag_type}')
-            end
-          )
-        end        
-      end
-      
-      def acts_as_taggable_on(*args)
-        super(*args)
-        initialize_acts_as_taggable_on_core
-      end
-      
-      # all column names are necessary for PostgreSQL group clause
-      def grouped_column_names_for(object)
-        object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
-      end
-
-      def tagged_with(tags, options = {})
-        tag_list = TagList.from(tags)
-
-        return {} if tag_list.empty?
-
-        joins = []
-        conditions = []
-
-        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)})"
-
-        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)})"
-
-        else
-          tags = Tag.named_any(tag_list)
-          return where("1 = 0") unless tags.length == tag_list.length
-
-          tags.each do |tag|
-            safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
-            prefix   = "#{safe_tag}_#{rand(1024)}"
-
-            taggings_alias = "#{table_name}_taggings_#{prefix}"
-
-            tagging_join  = "JOIN #{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}"
-            tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
-
-            joins << tagging_join
-          end
-        end
-
-        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}" +
-                   "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
-                   " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
-
-          group = "#{grouped_column_names_for(self)} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
-        end
-
-
-        joins(joins.join(" ")).group(group).where(conditions.join(" AND ")).readonly(false)
-      end
-
-      def is_taggable?
-        true
-      end
-    end    
-    
-    module InstanceMethods
-      # all column names are necessary for PostgreSQL group clause
-      def grouped_column_names_for(object)
-        self.class.grouped_column_names_for(object)
-      end
-
-      def custom_contexts
-        @custom_contexts ||= []
-      end
-
-      def is_taggable?
-        self.class.is_taggable?
-      end
-
-      def add_custom_context(value)
-        custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) or self.class.tag_types.map(&:to_s).include?(value.to_s)
-      end
-
-      def cached_tag_list_on(context)
-        self["cached_#{context.to_s.singularize}_list"]
-      end
-
-      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)))
-      end
-
-      def tag_list_on(context)
-        add_custom_context(context)
-        tag_list_cache_on(context)
-      end
-
-      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)
-      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
-      end
-
-      ##
-      # Returns all tags that are not owned of a given context
-      def tags_on(context)
-        if respond_to?(context)
-          # If the association is available, use it:
-          send(context).all
-        else
-          # If the association is not available, query it the old fashioned way
-          base_tags.where(["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]).all
-        end
-      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))
-      end
-
-      def tagging_contexts
-        custom_contexts + self.class.tag_types.map(&:to_s)
-      end
-
-      def reload
-        self.class.tag_types.each do |context|
-          instance_variable_set("@#{context.to_s.singularize}_list", nil)
-          instance_variable_set("@all_#{context.to_s.singularize}_list", nil)
-        end
-      
-        super
-      end
-
-      def save_tags
-        transaction do          
-          tagging_contexts.each do |context|
-            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)
-
-            current_tags = tags_on(context)
-            old_tags     = current_tags - tag_list
-            new_tags     = tag_list     - current_tags
-            
-            # Find taggings to remove:
-            old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil,
-                                          :context => context.to_s, :tag_id => old_tags).all
-
-            if old_taggings.present?
-              # Destroy old taggings:
-              Tagging.destroy_all :id => old_taggings.map(&:id)
-            end
-
-            # Create new taggings:
-            new_tags.each do |tag|
-              Tagging.create!(:tag_id => tag.id, :context => context.to_s, :taggable => self)
-            end
-          end
-        end
-
-        true
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on/dirty.rb

@@ -1,29 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Dirty
-    def self.included(base)
-      include ActsAsTaggableOn::Taggable::Dirty::InstanceMethods
-
-      base.tag_types.map(&:to_s).each do |tag_type|
-        base.class_eval %(
-          def #{tag_type.singularize}_list_changed?
-            tag_list_changed_on?('#{tag_type}')
-            tag_list_on('#{tag_type}')
-          end
-
-          def #{tag_type.singularize}_list=(new_tags)
-            change_tag_list_on('#{tag_type}', new_tags)
-            super(new_tags)
-          end
-        )
-      end      
-    end
-    
-    module InstanceMethods
-      def tag_list_changed_on?(context)
-      end
-      
-      def change_tag_list_on(context, new_tags)        
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -1,101 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Ownership
-    def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
-     
-      base.class_eval do
-        after_save :save_owned_tags    
-      end
-      
-      base.initialize_acts_as_taggable_on_ownership
-    end
-    
-    module ClassMethods
-      def acts_as_taggable_on(*args)
-        initialize_acts_as_taggable_on_ownership
-        super(*args)
-      end
-      
-      def initialize_acts_as_taggable_on_ownership      
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
-            def #{tag_type}_from(owner)
-              owner_tag_list_on(owner, '#{tag_type}')
-            end      
-          )
-        end        
-      end
-    end
-    
-    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
-      end
-
-      def cached_owned_tag_list_on(context)
-        variable_name = "@owned_#{context}_list"
-        cache = instance_variable_get(variable_name) || instance_variable_set(variable_name, {})
-      end
-      
-      def owner_tag_list_on(owner, context)
-        add_custom_context(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))
-      end
-      
-      def set_owner_tag_list_on(owner, context, new_list)
-        add_custom_context(context)
-        
-        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)
-      end
-      
-      def reload
-        self.class.tag_types.each do |context|
-          instance_variable_set("@owned_#{context}_list", nil)
-        end
-      
-        super
-      end
-    
-      def save_owned_tags
-        transaction do
-          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)            
- 
-              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
-            
-              if old_taggings.present?
-                # Destroy old taggings:
-                Tagging.destroy_all(:id => old_taggings.map(&:id))
-              end
-
-              # Create new taggings:
-              new_tags.each do |tag|
-                Tagging.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end