acts-as-taggable-on 2.0.0.pre3 → 2.0.0.pre4

data/VERSION

@@ -1 +1 @@
-2.0.0.pre3
+2.0.0.pre4

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -31,11 +31,11 @@ module ActsAsTaggableOn
         end
       end
       
-      include Core
-      include Aggregate
-      include Cache
-      include Ownership
-      include Related
+      include ActsAsTaggableOn::Taggable::Core
+      include ActsAsTaggableOn::Taggable::Aggregate
+      include ActsAsTaggableOn::Taggable::Cache
+      include ActsAsTaggableOn::Taggable::Ownership
+      include ActsAsTaggableOn::Taggable::Related
     end
   end
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/aggregate.rb

@@ -1,8 +1,10 @@
 module ActsAsTaggableOn::Taggable
   module Aggregate
     def self.included(base)
-      include InstanceMethods
-      base.extend ClassMethods
+      unless base.ancestors.include?(ActsAsTaggableOn::Taggable::Aggregate::InstanceMethods)
+        base.send :include, ActsAsTaggableOn::Taggable::Aggregate::InstanceMethods
+        base.extend ActsAsTaggableOn::Taggable::Aggregate::ClassMethods
+      end
       
       base.tag_types.map(&:to_s).each do |tag_type|
         base.class_eval %(

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -3,6 +3,9 @@ module ActsAsTaggableOn::Taggable
     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        
@@ -15,9 +18,6 @@ module ActsAsTaggableOn::Taggable
           end        
         )
       end
-      
-      base.extend ClassMethods
-      include InstanceMethods
     end
     
     module ClassMethods

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -1,6 +1,9 @@
 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
 
@@ -39,9 +42,6 @@ module ActsAsTaggableOn::Taggable
           end
         )
       end
-      
-      base.extend ClassMethods
-      include InstanceMethods
     end
     
     module ClassMethods
@@ -142,6 +142,7 @@ module ActsAsTaggableOn::Taggable
       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
 
@@ -149,7 +150,7 @@ module ActsAsTaggableOn::Taggable
       # 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")
+        base_tags.where(opts).order("#{Tagging.table_name}.created_at").group("#{Tagging.table_name}.tag_id").all
       end
 
       ##
@@ -169,6 +170,15 @@ module ActsAsTaggableOn::Taggable
         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|
@@ -184,13 +194,13 @@ module ActsAsTaggableOn::Taggable
             # Find taggings to remove:
             old_taggings = Tagging.where(:taggable_id => self.id, :taggable_type => self.class.base_class.to_s,
                                          :tagger_type => nil, :tagger_id => nil,
-                                         :context => context, :tag_id => old_tags)
+                                         :context => context.to_s, :tag_id => old_tags)
 
             Tagging.destroy_all :id => old_taggings.map(&:id)
 
             # Create new taggings:
             new_tags.each do |tag|
-              Tagging.create!(:tag_id => tag.id, :context => context, :taggable => self)
+              Tagging.create!(:tag_id => tag.id, :context => context.to_s, :taggable => self)
             end
           end
         end

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -1,8 +1,12 @@
 module ActsAsTaggableOn::Taggable
   module Ownership
     def self.included(base)
-      include InstanceMethods
-      base.extend ClassMethods
+      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
+      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
+     
+      base.class_eval do
+        after_save :save_owned_tags    
+      end     
       
       base.tag_types.map(&:to_s).each do |tag_type|
         base.class_eval %(
@@ -17,34 +21,50 @@ module ActsAsTaggableOn::Taggable
     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 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])
-      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_tags
+      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
@@ -56,17 +76,17 @@ module ActsAsTaggableOn::Taggable
                                            :tagger_type => owner.class.to_s, :tagger_id => owner.id,
                                            :tag_id => old_tags, :context => context)
             
-              # Destroy old taggings:
-              Tagging.destroy_all(:id => old_taggings.map(&:id))
+              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, :tagger => owner, :taggable => self)
+                Tagging.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
               end
             end
           end
-        
-          super
         end
       end
     end

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -1,8 +1,10 @@
 module ActsAsTaggableOn::Taggable
   module Related
     def self.included(base)
-      include InstanceMethods
-      base.extend ClassMethods
+      unless base.ancestors.include?(ActsAsTaggableOn::Taggable::Related::InstanceMethods)
+        base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
+        base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
+      end
       
       base.tag_types.map(&:to_s).each do |tag_type|
         base.class_eval %(

data/lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -20,9 +20,6 @@ module ActsAsTaggableOn
     end
 
     module InstanceMethods
-      def self.included(base)
-      end
-
       def tag(taggable, opts={})
         opts.reverse_merge!(:force => true)
 

data/rails/init.rb

@@ -0,0 +1 @@
+require 'acts-as-taggable-on'

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -64,8 +64,9 @@ describe "acts_as_tagger" do
       
       it "should not add owned tags to the common list" do
         @taggable.tag_list = 'ruby, python'
-        @tagger.tag(@taggable, :with => 'java, lisp', :on => :foo)
-        @tagger.tag(@taggable, :with => '', :on => :foo)
+        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
+        @taggable.tag_list.should == %w(ruby python)
+        @tagger.tag(@taggable, :with => '', :on => :tags)
         @taggable.tag_list.should == %w(ruby python)
       end
       

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -3,8 +3,8 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe "Tagger" do
   before(:each) do
     clean_database!
-    @user = TaggableUser.new
-    @taggable = TaggableModel.new(:name => "Bob Jones")
+    @user = TaggableUser.create
+    @taggable = TaggableModel.create(:name => "Bob Jones")
   end
 
   it "should have taggings" do
@@ -17,13 +17,15 @@ describe "Tagger" do
     @user.owned_tags.size == 2
   end
   
-  it "should not overlap or lose tags from different users" do
+  it "should not overlap tags from different taggers" do
     @user2 = TaggableUser.new
     lambda{
       @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
       @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
     }.should change(Tagging, :count).by(6)
 
+    [@user, @user2, @taggable].each(&:reload)
+
     @user.owned_tags.map(&:name).sort.should == %w(ruby scheme).sort
     @user2.owned_tags.map(&:name).sort.should == %w(java python lisp ruby).sort
     
@@ -31,23 +33,40 @@ describe "Tagger" do
     @taggable.tags_from(@user2).sort.should == %w(java lisp python ruby).sort
     
     @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
-    @taggable.all_tags_on(:tags).size.should == 6
+    @taggable.all_tags_on(:tags).size.should == 5
   end
+  
+  it "should not lose tags from different taggers" do
+    @user2 = TaggableUser.create
+    @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
+    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)  
+    
+    lambda {
+      @user2.tag(@taggable, :with => 'java, python, lisp', :on => :tags)
+    }.should change(Tagging, :count).by(-1)
 
-  it "should not lose tags" do
-    @taggable.update_attributes(:tag_list => 'ruby')
-    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
+    [@user, @user2, @taggable].each(&:reload)
     
-    [@taggable, @user].each(&:reload)
-    @taggable.tag_list.should == %w(ruby)
-    @taggable.all_tags_list.sort.should == %w(ruby scheme).sort
+    @taggable.tags_from(@user).sort.should == %w(ruby scheme).sort
+    @taggable.tags_from(@user2).sort.should == %w(java python lisp).sort
     
+    @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
+    @taggable.all_tags_on(:tags).length.should == 5
+  end
+
+  it "should not lose tags" do
+    @user2 = TaggableUser.create
+    
+    @user.tag(@taggable, :with => 'awesome', :on => :tags)
+    @user2.tag(@taggable, :with => 'awesome, epic', :on => :tags)
+
     lambda {
-      @taggable.update_attributes(:tag_list => "")
+      @user2.tag(@taggable, :with => 'epic', :on => :tags)
     }.should change(Tagging, :count).by(-1)
-    
-    @taggable.tag_list.should == []
-    @taggable.all_tags_list.sort.should == %w(ruby scheme).sort
+
+    @taggable.reload  
+    @taggable.all_tags_list.should include('awesome')
+    @taggable.all_tags_list.should include('epic')
   end
 
   it "is tagger" do

data/spec/schema.rb

@@ -31,4 +31,8 @@ ActiveRecord::Schema.define :version => 0 do
     t.column :type, :string
     #t.column :cached_tag_list, :string
   end
+  
+  create_table :untaggable_models, :force => true do |t|
+    t.column :name, :string
+  end
 end

data/spec/spec_helper.rb

@@ -37,10 +37,11 @@ ActiveRecord::Base.silence do
 end
 
 def clean_database!
-  $debug = false
   models = [Tag, Tagging, TaggableModel, OtherTaggableModel, InheritingTaggableModel,
-            AlteredInheritingTaggableModel, TaggableUser]
+            AlteredInheritingTaggableModel, TaggableUser, UntaggableModel]
   models.each do |model|
     model.destroy_all
   end
 end
+
+clean_database!

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version 
-  prerelease: true
-  segments: 
-  - 2
-  - 0
-  - 0
-  - pre3
-  version: 2.0.0.pre3
+  version: 2.0.0.pre4
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -52,6 +46,7 @@ files:
 - lib/acts_as_taggable_on/tags_helper.rb
 - lib/generators/acts_as_taggable_on/migration/migration_generator.rb
 - lib/generators/acts_as_taggable_on/migration/templates/active_record/migration.rb
+- rails/init.rb
 - spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb
 - spec/acts_as_taggable_on/acts_as_tagger_spec.rb
 - spec/acts_as_taggable_on/tag_list_spec.rb
@@ -77,22 +72,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 3
-      - 1
       version: 1.3.1
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: ActsAsTaggableOn is a tagging plugin for Rails that provides multiple tagging contexts on a single model.