acts-as-taggable-on 2.0.0.rc1 → 2.0.0.rc2

data/README.rdoc

@@ -52,7 +52,7 @@ To use it, add it to your Gemfile:
 1. rails generate acts_as_taggable_on:migration
 2. rake db:migrate
 
-=== Testing
+= Testing
 
 Acts As Taggable On uses RSpec for its test coverage. Inside the plugin
 directory, you can run the specs for RoR 3.0.0 with:
@@ -68,7 +68,7 @@ If you already have RSpec on your application, the specs will run while using:
 rake spec:plugins
 
 
-== Usage
+= Usage
 
     class User < ActiveRecord::Base
       acts_as_taggable_on :tags, :skills, :interests
@@ -87,7 +87,7 @@ rake spec:plugins
     User.skill_counts # => [<Tag name="joking" count=2>,<Tag name="clowning" count=1>...]
     @frankie.skill_counts
 
-=== Finding Tagged Objects
+== Finding Tagged Objects
 
 Acts As Taggable On utilizes named_scopes to create an association for tags.
 This way you can mix and match to filter down your results, and it also improves
@@ -107,7 +107,7 @@ compatibility with the will_paginate gem:
     # Find a user with any of the tags:
     User.tagged_with(["awesome", "cool"], :any => true)
 
-=== Relationships
+== Relationships
 
 You can find objects of the same type based on similar tags on certain contexts.
 Also, objects will be returned in descending order based on the total number of 
@@ -126,7 +126,7 @@ matched tags.
     @bobby.find_related_skills # => [<User name="Tom">] 
     @frankie.find_related_skills # => [<User name="Tom">] 
 
-=== Dynamic Tag Contexts
+== Dynamic Tag Contexts
 
 In addition to the generated tag contexts in the definition, it is also possible
 to allow for dynamic tag contexts (this could be user generated tag contexts!)
@@ -139,7 +139,7 @@ to allow for dynamic tag contexts (this could be user generated tag contexts!)
     @user.tag_counts_on(:customs)
     User.find_tagged_with("same", :on => :customs) # => [@user]
 
-=== Tag Ownership
+== Tag Ownership
 
 Tags can have owners:
 
@@ -156,7 +156,7 @@ Tags can have owners:
     @some_user.owned_tags
     @some_photo.locations_from(@some_user)
     
-=== Tag cloud calculations
+== Tag cloud calculations
 
 To construct tag clouds, the frequency of each tag needs to be calculated.
 Because we specified +acts_as_taggable_on+ on the <tt>User</tt> class, we can
@@ -196,7 +196,7 @@ CSS:
   .css3 { font-size: 1.4em; }
   .css4 { font-size: 1.6em; }
 
-== Contributors
+= Contributors
 
 * TomEric (i76) - Maintainer
 * Michael Bleigh - Original Author

data/VERSION

@@ -1 +1 @@
-2.0.0.rc1
+2.0.0.rc2

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -35,12 +35,7 @@ module ActsAsTaggableOn::Taggable
       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
-      
+    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?")
@@ -50,6 +45,8 @@ module ActsAsTaggableOn::Taggable
             end
           end
         end
+        
+        true
       end
     end
   end

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -14,27 +14,28 @@ module ActsAsTaggableOn::Taggable
     
     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
+        tag_types.map(&:to_s).each do |tags_type|
+          tag_type         = tags_type.to_s.singularize
+          context_taggings = "#{tag_type}_taggings".to_sym
+          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 = ?', tag_type]
+                     :conditions => ['#{Tagging.table_name}.tagger_id IS NULL AND #{Tagging.table_name}.context = ?', tags_type]
             has_many context_tags, :through => context_taggings, :source => :tag
           end
 
           class_eval %(
-            def #{tag_type.singularize}_list
-              tag_list_on('#{tag_type}')
+            def #{tag_type}_list
+              tag_list_on('#{tags_type}')
             end
 
-            def #{tag_type.singularize}_list=(new_tags)
-              set_tag_list_on('#{tag_type}', new_tags)
+            def #{tag_type}_list=(new_tags)
+              set_tag_list_on('#{tags_type}', new_tags)
             end
 
-            def all_#{tag_type}_list
-              all_tags_list_on('#{tag_type}')
+            def all_#{tags_type}_list
+              all_tags_list_on('#{tags_type}')
             end
           )
         end        
@@ -129,6 +130,11 @@ module ActsAsTaggableOn::Taggable
         self["cached_#{context.to_s.singularize}_list"]
       end
 
+      def tag_list_cache_set_on(context)
+        variable_name = "@#{context.to_s.singularize}_list"
+        !instance_variable_get(variable_name).nil?
+      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)))
@@ -156,18 +162,12 @@ module ActsAsTaggableOn::Taggable
       ##
       # 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
+        base_tags.where(["#{Tagging.table_name}.context = ? AND #{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))
       end
@@ -186,30 +186,30 @@ module ActsAsTaggableOn::Taggable
       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
+        tagging_contexts.each do |context|
+          next unless tag_list_cache_set_on(context)
 
-            # Create new taggings:
-            new_tags.each do |tag|
-              taggings.create!(:tag_id => tag.id, :context => context.to_s, :taggable => self)
-            end
+          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|
+            taggings.create!(:tag_id => tag.id, :context => context.to_s, :taggable => self)
           end
         end
 

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -67,34 +67,34 @@ module ActsAsTaggableOn::Taggable
       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
+        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)            
 
-              # Create new taggings:
-              new_tags.each do |tag|
-                taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
-              end
+            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|
+              taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
             end
           end
         end
+        
+        true
       end
     end
   end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -31,6 +31,9 @@ describe "Taggable" do
     lambda {
       @taggable.save
     }.should change(Tag, :count).by(3)
+    
+    @taggable.reload
+    @taggable.skill_list.sort.should == %w(ruby rails css).sort
   end
 
   it "should be able to create tags through the tag list directly" do

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 2
   - 0
   - 0
-  - rc1
-  version: 2.0.0.rc1
+  - rc2
+  version: 2.0.0.rc2
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-25 00:00:00 +01:00
+date: 2010-03-28 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -41,7 +41,6 @@ files:
 - lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/core.rb
-- lib/acts_as_taggable_on/acts_as_taggable_on/dirty.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/related.rb
 - lib/acts_as_taggable_on/acts_as_tagger.rb

data/lib/acts_as_taggable_on/acts_as_taggable_on/dirty.rb

@@ -1,30 +0,0 @@
-# WIP: dirty attributes support for tags
-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