yetanothernguyen-acts-as-taggable-on 0.0.4 → 0.0.5

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -11,11 +11,11 @@ module ActsAsTaggableOn::Taggable
         before_save :save_cached_tag_list        
       end
       
-      base.initialize_acts_as_taggable_on_cache
+      base.intialize_acts_as_taggable_on_cache
     end
     
     module ClassMethods
-      def initialize_acts_as_taggable_on_cache      
+      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?
@@ -27,7 +27,7 @@ module ActsAsTaggableOn::Taggable
       
       def acts_as_taggable_on(*args)
         super(*args)
-        initialize_acts_as_taggable_on_cache
+        intialize_acts_as_taggable_on_cache
       end
       
       def caching_tag_list_on?(context)

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -61,72 +61,65 @@ module ActsAsTaggableOn::Taggable
 
         ## 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}.taggable_id = ?", options.delete(:id)])  if options[:id]
-        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
-        
-        tagging_conditions = [
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
+
+        conditions = [
           taggable_conditions,
+          options[:conditions],
           scope[:conditions],
           start_at_conditions,
           end_at_conditions
         ].compact.reverse
         
-        tag_conditions = [
-          options[: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]
+
         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      
 
-        tagging_joins = [
+        joins = [
+          tagging_join,
           taggable_join,
           scope[:joins]
         ].compact
 
-        tag_joins = [
-        ].compact
+        joins = joins.reverse if ActiveRecord::VERSION::MAJOR < 3
 
-        [tagging_joins, tag_joins].each(&:reverse!) if ActiveRecord::VERSION::MAJOR < 3
 
         ## 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])   
-
+        scope = ActsAsTaggableOn::Tag.scoped(:select => "#{ActsAsTaggableOn::Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
+        
         # Joins and conditions
-        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)     }
-
+        joins.each      { |join|      scope = scope.joins(join)      }
+        conditions.each { |condition| scope = scope.where(condition) }
+        
         # GROUP BY and HAVING clauses:
-        at_least  = sanitize_sql(['tags_count >= ?', options.delete(:at_least)]) if options[:at_least]
-        at_most   = sanitize_sql(['tags_count <= ?', 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"
+        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 ')        
 
         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}"
-          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})").
-                                        group(group_columns).
-                                        having(having)
+          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  = "#{group_columns} HAVING COUNT(*) > 0"
+          group_by  = "#{grouped_column_names_for(ActsAsTaggableOn::Tag)} HAVING COUNT(*) > 0"
           group_by << " AND #{having}" unless having.blank?
-          tagging_scope = tagging_scope.group(group_by)
+          scope = scope.group(group_by)
         end
 
-        tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS taggings ON taggings.tag_id = tags.id")
-        tag_scope
+        scope
       end
     end
     

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -21,7 +21,7 @@ module ActsAsTaggableOn::Taggable
 
           class_eval do
             has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging",
-            :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type]
+                     :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
 
@@ -80,18 +80,8 @@ module ActsAsTaggableOn::Taggable
           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)
-          conditions << tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
-
-          tagging_join  = " JOIN #{ActsAsTaggableOn::Tagging.table_name}" +
-                          "   ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{table_name}.#{primary_key}" +
-                          "  AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)}" +
-                          " JOIN #{ActsAsTaggableOn::Tag.table_name}" +
-                          "   ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id"
-
-          tagging_join << "  AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.context = ?", context.to_s]) if context
-          select_clause = "DISTINCT #{table_name}.*" unless context and tag_types.one?
-
-          joins << tagging_join
+          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 = ActsAsTaggableOn::Tag.named_any(tag_list)
@@ -101,7 +91,7 @@ module ActsAsTaggableOn::Taggable
             safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
             prefix   = "#{safe_tag}_#{rand(1024)}"
 
-            taggings_alias = "#{undecorated_table_name}_taggings_#{prefix}"
+            taggings_alias = "#{table_name}_taggings_#{prefix}"
 
             tagging_join  = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
@@ -113,20 +103,18 @@ module ActsAsTaggableOn::Taggable
           end
         end
 
-        taggings_alias, tags_alias = "#{undecorated_table_name}_taggings_group", "#{undecorated_table_name}_tags_group"
+        taggings_alias, tags_alias = "#{table_name}_taggings_group", "#{table_name}_tags_group"
 
         if options.delete(:match_all)
           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)}"
 
-
-          group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
-          group = "#{group_columns} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
+          group = "#{grouped_column_names_for(self)} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
         end
 
-        scoped(:select     => select_clause,
-               :joins      => joins.join(" "),
+
+        scoped(:joins      => joins.join(" "),
                :group      => group,
                :conditions => conditions.join(" AND "),
                :order      => options[:order],
@@ -188,17 +176,8 @@ module ActsAsTaggableOn::Taggable
         tag_table_name = ActsAsTaggableOn::Tag.table_name
         tagging_table_name = ActsAsTaggableOn::Tagging.table_name
 
-        opts  =  ["#{tagging_table_name}.context = ?", context.to_s]
-        scope = base_tags.where(opts)
-        
-        if ActsAsTaggableOn::Tag.using_postgresql?
-          group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
-          scope = scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
-        else
-          scope = scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
-        end
-
-        scope.all
+        opts =  ["#{tagging_table_name}.context = ?", context.to_s]
+        base_tags.where(opts).order("max(#{tagging_table_name}.created_at)").group("#{tag_table_name}.id, #{tag_table_name}.name").all
       end
 
       ##

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -30,13 +30,9 @@ module ActsAsTaggableOn::Taggable
     
     module InstanceMethods
       def owner_tags_on(owner, context)
-        if owner.nil?
-          base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s]).all                    
-        else
-          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
+        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)

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -42,12 +42,10 @@ module ActsAsTaggableOn::Taggable
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
         
-        group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
-        
         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      => group_columns,
+                       :group      => grouped_column_names_for(klass),
                        :order      => "count DESC" }.update(options))
       end
       
@@ -56,12 +54,10 @@ module ActsAsTaggableOn::Taggable
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
-group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
-
         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      => group_columns,
+                       :group      => grouped_column_names_for(klass),
                        :order      => "count DESC" }.update(options))
       end
     end

data/lib/acts_as_taggable_on/compatibility/active_record_backports.rb

@@ -9,11 +9,7 @@ module ActsAsTaggableOn
           named_scope :order,    lambda { |order|      { :order => order } }
           named_scope :select,   lambda { |select|     { :select => select } }
           named_scope :limit,    lambda { |limit|      { :limit => limit } }
-          named_scope :readonly, lambda { |readonly|   { :readonly => readonly } }
-          
-          def self.to_sql
-            construct_finder_sql({})
-          end
+          named_scope :readonly, lambda { |readonly|   { :readonly => readonly } }   
         end
       end
     end

data/lib/acts_as_taggable_on/tag.rb

@@ -14,10 +14,6 @@ module ActsAsTaggableOn
     validates_uniqueness_of :name
 
     ### SCOPES:
-    
-    def self.using_postgresql?
-      connection.adapter_name == 'PostgreSQL'
-    end
 
     def self.named(name)
       where(["name #{like_operator} ?", name])
@@ -47,10 +43,7 @@ module ActsAsTaggableOn
       return [] if list.empty?
 
       existing_tags = Tag.named_any(list).all
-      new_tag_names = list.reject do |name| 
-                        name = comparable_name(name)
-                        existing_tags.any? { |tag| comparable_name(tag.name) == name }
-                      end
+      new_tag_names = list.reject { |name| existing_tags.any? { |tag| tag.name.mb_chars.downcase == name.mb_chars.downcase } }
       created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
 
       existing_tags + created_tags
@@ -73,12 +66,9 @@ module ActsAsTaggableOn
     class << self
       private
         def like_operator
-          using_postgresql? ? 'ILIKE' : 'LIKE'
-        end
-        
-        def comparable_name(str)
-          RUBY_VERSION >= "1.9" ? str.downcase : str.mb_chars.downcase
+          connection.adapter_name == 'PostgreSQL' ? 'ILIKE' : 'LIKE'
         end
     end
+
   end
 end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -4,7 +4,6 @@ describe "Taggable" do
   before(:each) do
     clean_database!
     @taggable = TaggableModel.new(:name => "Bob Jones")
-    @taggables = [@taggable, TaggableModel.new(:name => "John Doe")]
   end
 
   it "should have tag types" do
@@ -69,22 +68,6 @@ describe "Taggable" do
     @taggable.should have(2).skills
   end
 
-  it "should be able to select taggables by subset of tags using ActiveRelation methods" do
-    @taggables[0].tag_list = "bob"
-    @taggables[1].tag_list = "charlie"
-    @taggables[0].skill_list = "ruby"
-    @taggables[1].skill_list = "css"
-    @taggables.each{|taggable| taggable.save}
-    
-    @found_taggables_by_tag = TaggableModel.joins(:tags).where(:tags => {:name => ["bob"]})
-    @found_taggables_by_skill = TaggableModel.joins(:skills).where(:tags => {:name => ["ruby"]})
-
-    @found_taggables_by_tag.should include @taggables[0]
-    @found_taggables_by_tag.should_not include @taggables[1]
-    @found_taggables_by_skill.should include @taggables[0]
-    @found_taggables_by_skill.should_not include @taggables[1]
-  end
-  
   it "should be able to find by tag" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save

data/spec/spec_helper.rb

@@ -13,7 +13,7 @@ begin
   Bundler.setup
 rescue Bundler::GemNotFound
   raise RuntimeError, "Bundler couldn't find some gems." +
-    "Did you run \`bundlee install\`?"
+    "Did you run `bundle install`?"
 end
 
 Bundler.require
@@ -57,4 +57,4 @@ def clean_database!
   end
 end
 
-clean_database!
+clean_database!

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: yetanothernguyen-acts-as-taggable-on
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Michael Bleigh