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

data/lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -1,60 +1,50 @@
-module ActiveRecord
-  module Acts
-    module Tagger
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-
-        def acts_as_tagger(opts={})
-          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 ActiveRecord::Acts::Tagger::InstanceMethods
-          extend ActiveRecord::Acts::Tagger::SingletonMethods
-        end
+module ActsAsTaggableOn
+  module Tagger
+    def self.included(base)
+      base.extend ClassMethods
+    end
 
-        def is_tagger?
-          false
-        end
+    module ClassMethods
+      def acts_as_tagger(opts={})
+        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 ActsAsTaggableOn::Tagger::InstanceMethods
+        extend ActsAsTaggableOn::Tagger::SingletonMethods
       end
 
-      module InstanceMethods
-
-        def self.included(base)
-        end
-
-        def tag(taggable, opts={})
-          opts.reverse_merge!(:force => true)
+      def is_tagger?
+        false
+      end
+    end
 
-          return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
+    module InstanceMethods
+      def self.included(base)
+      end
 
-          raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
-          raise "You need to specify some tags using :with"                  unless opts.has_key?(:with)
-          raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless (opts[:force] || taggable.tag_types.include?(opts[:on]))
+      def tag(taggable, opts={})
+        opts.reverse_merge!(:force => true)
 
-          taggable.set_tag_list_on(opts[:on].to_s, opts[:with], self)
-          taggable.save
-        end
+        return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
 
-        def is_tagger?
-          self.class.is_tagger?
-        end
+        raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
+        raise "You need to specify some tags using :with"                  unless opts.has_key?(:with)
+        raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless (opts[:force] || taggable.tag_types.include?(opts[:on]))
 
+        taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
+        taggable.save
       end
 
-      module SingletonMethods
-
-        def is_tagger?
-          true
-        end
-
+      def is_tagger?
+        self.class.is_tagger?
       end
+    end
 
+    module SingletonMethods
+      def is_tagger?
+        true
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/compatibility/Gemfile

@@ -0,0 +1,6 @@
+source :gemcutter
+
+# Rails 2.3
+gem 'rails',        '2.3.5'
+gem 'rspec',        '1.3.0', :require => 'spec'
+gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'

data/lib/acts_as_taggable_on/compatibility/active_record_backports.rb

@@ -0,0 +1,17 @@
+module ActsAsTaggableOn
+  module ActiveRecord
+    module Backports
+      def self.included(base)
+        base.class_eval do
+          named_scope :where,    lambda { |conditions| { :conditions => conditions } }  
+          named_scope :joins,    lambda { |joins|      { :joins => joins } }
+          named_scope :group,    lambda { |group|      { :group => group } }
+          named_scope :readonly, lambda { |readonly|   { :readonly => readonly } }
+          named_scope :order,    lambda { |order|      { :order => order } }
+          named_scope :select,   lambda { |select|     { :select => select } }
+          named_scope :limit,    lambda { |limit|      { :limit => limit } }      
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/compatibility/tag.rb

@@ -0,0 +1,3 @@
+class Tag < ActiveRecord::Base
+  include ActsAsTaggableOn::ActiveRecord::Backports
+end

data/lib/acts_as_taggable_on/compatibility/tagging.rb

@@ -0,0 +1,3 @@
+class Tagging < ActiveRecord::Base
+  include ActsAsTaggableOn::ActiveRecord::Backports
+end

data/lib/acts_as_taggable_on/tag.rb

@@ -11,12 +11,23 @@ class Tag < ActiveRecord::Base
   validates_presence_of :name
   validates_uniqueness_of :name
 
-  ### NAMED SCOPES:
+  ### SCOPES:
 
-  scope :named,          lambda { |name| { :conditions => ["name LIKE ?", name] } }
-  scope :named_any,      lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR ") } }
-  scope :named_like,     lambda { |name| { :conditions => ["name LIKE ?", "%#{name}%"] } }
-  scope :named_like_any, lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", "%#{tag.to_s}%"]) }.join(" OR ") } }
+  def self.named(name)
+    where(["name LIKE ?", name])
+  end
+  
+  def self.named_any(list)
+    where(list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR "))
+  end
+  
+  def self.named_like(name)
+    where(["name LIKE ?", "%#{name}%"])
+  end
+
+  def self.named_like_any(list)
+    where(list.map { |tag| sanitize_sql(["name LIKE ?", "%#{tag.to_s}%"]) }.join(" OR "))
+  end
 
   ### CLASS METHODS:
 

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -2,7 +2,7 @@ module TagsHelper
 
   # See the README for an example using tag_cloud.
   def tag_cloud(tags, classes)
-    tags = tags.all if tags.is_a? ActiveRecord::Relation
+    tags = tags.all if tags.respond_to?(:all)
 
     return [] if tags.empty?
 

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -26,6 +26,10 @@ describe "Acts As Taggable On" do
     it "should create an instance attribute for tag types" do
       @taggable.should respond_to(:tag_types)
     end
+    
+    it "should have all tag types" do
+      @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
+    end
 
     it "should generate an association for each tag type" do
       @taggable.should respond_to(:tags, :skills, :languages)
@@ -48,6 +52,10 @@ describe "Acts As Taggable On" do
       @taggable.should respond_to(:tag_list, :skill_list, :language_list)
       @taggable.should respond_to(:tag_list=, :skill_list=, :language_list=)
     end
+    
+    it "should generate a tag_list accessor, that includes owned tags, for each tag type" do
+      @taggable.should respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
+    end
   end
 
   describe "Single Table Inheritance" do
@@ -56,17 +64,17 @@ describe "Acts As Taggable On" do
       @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
       @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
     end
-
+  
     it "should pass on tag contexts to STI-inherited models" do
       @inherited_same.should respond_to(:tag_list, :skill_list, :language_list)
       @inherited_different.should respond_to(:tag_list, :skill_list, :language_list)
     end
-
+  
     it "should have tag contexts added in altered STI models" do
       @inherited_different.should respond_to(:part_list)
     end
   end
-
+  
   describe "Reloading" do
     it "should save a model instantiated by Model.find" do
       taggable = TaggableModel.create!(:name => "Taggable")
@@ -80,48 +88,48 @@ describe "Acts As Taggable On" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
       taggable2 = TaggableModel.create!(:name => "Taggable 2")
       taggable3 = TaggableModel.create!(:name => "Taggable 3")
-
+  
       taggable1.tag_list = "one, two"
       taggable1.save
-
+  
       taggable2.tag_list = "three, four"
       taggable2.save
-
+  
       taggable3.tag_list = "one, four"
       taggable3.save
-
+  
       taggable1.find_related_tags.should include(taggable3)
       taggable1.find_related_tags.should_not include(taggable2)
     end
-
+  
     it "should find other related objects based on tag names on context" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
       taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
       taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
-
+  
       taggable1.tag_list = "one, two"
       taggable1.save
-
+  
       taggable2.tag_list = "three, four"
       taggable2.save
-
+  
       taggable3.tag_list = "one, four"
       taggable3.save
-
+  
       taggable1.find_related_tags_for(OtherTaggableModel).should include(taggable3)
       taggable1.find_related_tags_for(OtherTaggableModel).should_not include(taggable2)
     end
-
+  
     it "should not include the object itself in the list of related objects" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
       taggable2 = TaggableModel.create!(:name => "Taggable 2")
-
+  
       taggable1.tag_list = "one"
       taggable1.save
-
+  
       taggable2.tag_list = "one, two"
       taggable2.save
-
+  
       taggable1.find_related_tags.should include(taggable2)
       taggable1.find_related_tags.should_not include(taggable1)
     end
@@ -132,48 +140,48 @@ describe "Acts As Taggable On" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
       taggable2 = TaggableModel.create!(:name => "Taggable 2")
       taggable3 = TaggableModel.create!(:name => "Taggable 3")
-
+  
       taggable1.offering_list = "one, two"
       taggable1.save!
-
+  
       taggable2.need_list = "one, two"
       taggable2.save!
-
+  
       taggable3.offering_list = "one, two"
       taggable3.save!
-
+  
       taggable1.find_matching_contexts(:offerings, :needs).should include(taggable2)
       taggable1.find_matching_contexts(:offerings, :needs).should_not include(taggable3)
     end
-
+  
     it "should find other related objects with tags of matching contexts" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
       taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
       taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
-
+  
       taggable1.offering_list = "one, two"
       taggable1.save
-
+  
       taggable2.need_list = "one, two"
       taggable2.save
-
+  
       taggable3.offering_list = "one, two"
       taggable3.save
-
+  
       taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should include(taggable2)
       taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should_not include(taggable3)
     end
-
+  
     it "should not include the object itself in the list of related objects" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
       taggable2 = TaggableModel.create!(:name => "Taggable 2")
-
+  
       taggable1.tag_list = "one"
       taggable1.save
-
+  
       taggable2.tag_list = "one, two"
       taggable2.save
-
+  
       taggable1.find_related_tags.should include(taggable2)
       taggable1.find_related_tags.should_not include(taggable1)
     end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -72,10 +72,21 @@ describe Tag do
 
   it "should require a name" do
     @tag.valid?
-    @tag.errors[:name].should == ["can't be blank"]
+    
+    if ActiveRecord::VERSION::MAJOR >= 3
+      @tag.errors[:name].should == ["can't be blank"]
+    else
+      @tag.errors[:name].should == "can't be blank"
+    end
+
     @tag.name = "something"
     @tag.valid?
-    @tag.errors[:name].should == []
+    
+    if ActiveRecord::VERSION::MAJOR >= 3      
+      @tag.errors[:name].should == []
+    else
+      @tag.errors[:name].should be_nil
+    end
   end
 
   it "should equal a tag with the same name" do

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -7,10 +7,11 @@ describe "Taggable" do
   end
 
   it "should have tag types" do
-      for type in [:tags, :languages, :skills, :needs, :offerings]
-        TaggableModel.tag_types.should include type
-      end
-      @taggable.tag_types.should == TaggableModel.tag_types
+    [:tags, :languages, :skills, :needs, :offerings].each do |type|
+      TaggableModel.tag_types.should include type
+    end
+
+    @taggable.tag_types.should == TaggableModel.tag_types
   end
 
   it "should have tag_counts_on" do
@@ -25,18 +26,21 @@ describe "Taggable" do
 
   it "should be able to create tags" do
     @taggable.skill_list = "ruby, rails, css"
-    @taggable.instance_variable_get("@skill_list").instance_of?(Hash).should be_true
-    @taggable.instance_variable_get("@skill_list")[nil].instance_of?(TagList).should be_true
-    @taggable.save
-
-    Tag.find(:all).size.should == 3
+    @taggable.instance_variable_get("@skill_list").instance_of?(TagList).should be_true
+    
+    lambda {
+      @taggable.save
+    }.should change(Tag, :count).by(3)
   end
 
   it "should be able to create tags through the tag list directly" do
     @taggable.tag_list_on(:test).add("hello")
     @taggable.tag_list_cache_on(:test).should_not be_empty
+    @taggable.tag_list_on(:test).should == ["hello"]
+    
     @taggable.save
     @taggable.save_tags
+    
     @taggable.reload
     @taggable.tag_list_on(:test).should == ["hello"]
   end
@@ -171,10 +175,10 @@ describe "Taggable" do
     steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, python')
 
     # Let's only find those productive Rails developers
-    TaggableModel.tagged_with('rails', :on => :skills, :order => 'taggable_models.name').should == [bob, frank]
-    TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').should == [bob, steve]
-    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).should == [bob]
-    TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).should == [bob]
+    TaggableModel.tagged_with('rails', :on => :skills, :order => 'taggable_models.name').all.should == [bob, frank]
+    TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').all.should == [bob, steve]
+    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).all.should == [bob]
+    TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).all.should == [bob]
   end
 
   it "should be able to find tagged with only the matching tags" do
@@ -202,6 +206,16 @@ describe "Taggable" do
     }.should change(Tagging, :count).by(1)
   end
 
+  describe "grouped_column_names_for method" do
+    it "should return all column names joined for Tag GROUP clause" do
+      @taggable.grouped_column_names_for(Tag).should == "tags.id, tags.name"
+    end
+
+    it "should return all column names joined for TaggableModel GROUP clause" do
+      @taggable.grouped_column_names_for(TaggableModel).should == "taggable_models.id, taggable_models.name, taggable_models.type, taggable_models.cached_tag_list"
+    end
+  end
+
   describe "Single Table Inheritance" do
     before do
       [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
@@ -209,44 +223,44 @@ describe "Taggable" do
       @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
       @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
     end
-
+  
     it "should be able to save tags for inherited models" do
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save
       InheritingTaggableModel.tagged_with("bob").first.should == @inherited_same
     end
-
+  
     it "should find STI tagged models on the superclass" do
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save
       TaggableModel.tagged_with("bob").first.should == @inherited_same
     end
-
+  
     it "should be able to add on contexts only to some subclasses" do
       @inherited_different.part_list = "fork, spoon"
       @inherited_different.save
       InheritingTaggableModel.tagged_with("fork", :on => :parts).should be_empty
       AlteredInheritingTaggableModel.tagged_with("fork", :on => :parts).first.should == @inherited_different
     end
-
+  
     it "should have different tag_counts_on for inherited models" do
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save!
       @inherited_different.tag_list = "fork, spoon"
       @inherited_different.save!
-
+  
       InheritingTaggableModel.tag_counts_on(:tags).map(&:name).should == %w(bob kelso)
       AlteredInheritingTaggableModel.tag_counts_on(:tags).map(&:name).should == %w(fork spoon)
       TaggableModel.tag_counts_on(:tags).map(&:name).should == %w(bob kelso fork spoon)
     end
-
+  
     it 'should store same tag without validation conflict' do
       @taggable.tag_list = 'one'
       @taggable.save!
-
+  
       @inherited_same.tag_list = 'one'
       @inherited_same.save!
-
+  
       @inherited_same.update_attributes! :name => 'foo'
     end
   end