acts-as-taggable-on 2.2.2 → 2.3.0

data/lib/acts_as_taggable_on/tag.rb

@@ -2,9 +2,6 @@ module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
     include ActsAsTaggableOn::Utils
 
-    cattr_accessor :remove_unused
-    self.remove_unused = false
-     
     attr_accessible :name
 
     ### ASSOCIATIONS:
@@ -15,15 +12,16 @@ module ActsAsTaggableOn
 
     validates_presence_of :name
     validates_uniqueness_of :name
+    validates_length_of :name, :maximum => 255
 
     ### SCOPES:
 
     def self.named(name)
-      where(["name #{like_operator} ? ESCAPE '!'", escape_like(name)])
+      where(["lower(name) = ?", name.downcase])
     end
 
     def self.named_any(list)
-      where(list.map { |tag| sanitize_sql(["name #{like_operator} ? ESCAPE '!'", escape_like(tag.to_s)]) }.join(" OR "))
+      where(list.map { |tag| sanitize_sql(["lower(name) = ?", tag.to_s.downcase]) }.join(" OR "))
     end
 
     def self.named_like(name)
@@ -69,15 +67,11 @@ module ActsAsTaggableOn
       read_attribute(:count).to_i
     end
 
-    def safe_name
-      name.gsub(/[^a-zA-Z0-9]/, '')
-    end
-
     class << self
       private
         def comparable_name(str)
-          RUBY_VERSION >= "1.9" ? str.downcase : str.mb_chars.downcase
+          str.mb_chars.downcase.to_s
         end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/tag_list.rb

@@ -1,14 +1,13 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActsAsTaggableOn
   class TagList < Array
-    cattr_accessor :delimiter
-    self.delimiter = ','
-
     attr_accessor :owner
 
     def initialize(*args)
       add(*args)
     end
-  
+
     ##
     # Returns a new TagList using the given tag string.
     #
@@ -16,17 +15,16 @@ module ActsAsTaggableOn
     #   tag_list = TagList.from("One , Two,  Three")
     #   tag_list # ["One", "Two", "Three"]
     def self.from(string)
-      glue   = delimiter.ends_with?(" ") ? delimiter : "#{delimiter} "
-      string = string.join(glue) if string.respond_to?(:join)
+      string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
 
       new.tap do |tag_list|
         string = string.to_s.dup
 
         # Parse the quoted tags
-        string.gsub!(/(\A|#{delimiter})\s*"(.*?)"\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
-        string.gsub!(/(\A|#{delimiter})\s*'(.*?)'\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
+        string.gsub!(/(\A|#{ActsAsTaggableOn.delimiter})\s*"(.*?)"\s*(#{ActsAsTaggableOn.delimiter}\s*|\z)/) { tag_list << $2; $3 }
+        string.gsub!(/(\A|#{ActsAsTaggableOn.delimiter})\s*'(.*?)'\s*(#{ActsAsTaggableOn.delimiter}\s*|\z)/) { tag_list << $2; $3 }
 
-        tag_list.add(string.split(delimiter))
+        tag_list.add(string.split(ActsAsTaggableOn.delimiter))
       end
     end
 
@@ -69,16 +67,19 @@ module ActsAsTaggableOn
       tags.send(:clean!)
 
       tags.map do |name|
-        name.include?(delimiter) ? "\"#{name}\"" : name
-      end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+        name.include?(ActsAsTaggableOn.delimiter) ? "\"#{name}\"" : name
+      end.join(ActsAsTaggableOn.glue)
     end
 
     private
-  
+
     # Remove whitespace, duplicates, and blanks.
     def clean!
       reject!(&:blank?)
       map!(&:strip)
+      map!(&:downcase) if ActsAsTaggableOn.force_lowercase
+      map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
+
       uniq!
     end
 

data/lib/acts_as_taggable_on/taggable.rb

@@ -15,6 +15,17 @@ module ActsAsTaggableOn
       acts_as_taggable_on :tags
     end
 
+    ##
+    # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_ordered_taggable
+    #   end
+    def acts_as_ordered_taggable
+      acts_as_ordered_taggable_on :tags
+    end
+    
     ##
     # Make a model taggable on specified contexts.
     #
@@ -25,30 +36,67 @@ module ActsAsTaggableOn
     #     acts_as_taggable_on :languages, :skills
     #   end
     def acts_as_taggable_on(*tag_types)
-      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
+      taggable_on(false, tag_types)
+    end
+    
+    
+    ##
+    # Make a model taggable on specified contexts
+    # and preserves the order in which tags are created
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_ordered_taggable_on :languages, :skills
+    #   end
+    def acts_as_ordered_taggable_on(*tag_types)
+      taggable_on(true, tag_types)
+    end
+    
+    private
+    
+      # Make a model taggable on specified contexts
+      # and optionally preserves the order in which tags are created
+      #
+      # Seperate methods used above for backwards compatibility
+      # so that the original acts_as_taggable_on method is unaffected
+      # as it's not possible to add another arguement to the method
+      # without the tag_types being enclosed in square brackets
+      #
+      # NB: method overridden in core module in order to create tag type
+      #     associations and methods after this logic has executed
+      #
+      def taggable_on(preserve_tag_order, *tag_types)
+        tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
 
-      if taggable?
+        if taggable?
           self.tag_types = (self.tag_types + tag_types).uniq
-      else
+          self.preserve_tag_order = preserve_tag_order
+        else
           class_attribute :tag_types
           self.tag_types = tag_types
+          class_attribute :preserve_tag_order
+          self.preserve_tag_order = preserve_tag_order
+        
+          class_eval do
+            has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
+            has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
 
-        class_eval do
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
-          has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
+            def self.taggable?
+              true
+            end
 
-          def self.taggable?
-            true
+            include ActsAsTaggableOn::Utils
+            include ActsAsTaggableOn::Taggable::Core
+            include ActsAsTaggableOn::Taggable::Collection
+            include ActsAsTaggableOn::Taggable::Cache
+            include ActsAsTaggableOn::Taggable::Ownership
+            include ActsAsTaggableOn::Taggable::Related
+            include ActsAsTaggableOn::Taggable::Dirty
           end
-
-          include ActsAsTaggableOn::Utils
-          include ActsAsTaggableOn::Taggable::Core
-          include ActsAsTaggableOn::Taggable::Collection
-          include ActsAsTaggableOn::Taggable::Cache
-          include ActsAsTaggableOn::Taggable::Ownership
-          include ActsAsTaggableOn::Taggable::Related
         end
       end
-    end
+
   end
 end

data/lib/acts_as_taggable_on/tagger.rb

@@ -31,7 +31,7 @@ module ActsAsTaggableOn
 
     module InstanceMethods
       ##
-      # Tag a taggable model with tags that are owned by the tagger. 
+      # Tag a taggable model with tags that are owned by the tagger.
       #
       # @param taggable The object that will be tagged
       # @param [Hash] options An hash with options. Available options are:
@@ -42,7 +42,7 @@ module ActsAsTaggableOn
       #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
       def tag(taggable, opts={})
         opts.reverse_merge!(:force => true)
-
+        skip_save = opts.delete(:skip_save)
         return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
 
         raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
@@ -50,7 +50,7 @@ module ActsAsTaggableOn
         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
+        taggable.save unless skip_save
       end
 
       def is_tagger?

data/lib/acts_as_taggable_on/tagging.rb

@@ -24,7 +24,7 @@ module ActsAsTaggableOn
     private
 
     def remove_unused_tags
-      if Tag.remove_unused
+      if ActsAsTaggableOn.remove_unused_tags
         if tag.taggings.count.zero?
           tag.destroy
         end

data/lib/acts_as_taggable_on/utils.rb

@@ -16,7 +16,7 @@ module ActsAsTaggableOn
       end
 
       def sha_prefix(string)
-        Digest::SHA1.hexdigest(string + Time.now.to_s)[0..6]
+        Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
       end
       
       private

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -8,6 +8,20 @@ describe "Acts As Taggable On" do
   it "should provide a class method 'taggable?' that is false for untaggable models" do
     UntaggableModel.should_not be_taggable
   end
+  
+  describe "Taggable Method Generation To Preserve Order" do
+    before(:each) do
+      clean_database!
+      TaggableModel.tag_types = []
+      TaggableModel.preserve_tag_order = false
+      TaggableModel.acts_as_ordered_taggable_on(:ordered_tags)
+      @taggable = TaggableModel.new(:name => "Bob Jones")
+    end
+
+    it "should respond 'true' to preserve_tag_order?" do
+      @taggable.class.preserve_tag_order?.should be_true
+    end
+  end
 
   describe "Taggable Method Generation" do
     before(:each) do
@@ -32,6 +46,18 @@ describe "Acts As Taggable On" do
     it "should have all tag types" do
       @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
     end
+    
+    it "should create a class attribute for preserve tag order" do
+      @taggable.class.should respond_to(:preserve_tag_order?)
+    end
+
+    it "should create an instance attribute for preserve tag order" do
+      @taggable.should respond_to(:preserve_tag_order?)
+    end
+    
+    it "should respond 'false' to preserve_tag_order?" do
+      @taggable.class.preserve_tag_order?.should be_false
+    end
 
     it "should generate an association for each tag type" do
       @taggable.should respond_to(:tags, :skills, :languages)
@@ -453,4 +479,36 @@ describe "Acts As Taggable On" do
       @taggable.taggings.should == []
     end
   end
+
+  describe "@@remove_unused_tags" do
+    before do
+      @taggable = TaggableModel.create(:name => "Bob Jones")
+      @tag = ActsAsTaggableOn::Tag.create(:name => "awesome")
+
+      @tagging = ActsAsTaggableOn::Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags')
+    end
+
+    context "if set to true" do
+      before do
+        ActsAsTaggableOn.remove_unused_tags = true
+      end
+
+      it "should remove unused tags after removing taggings" do
+        @tagging.destroy
+        ActsAsTaggableOn::Tag.find_by_name("awesome").should be_nil
+      end
+    end
+
+    context "if set to false" do
+      before do
+        ActsAsTaggableOn.remove_unused_tags = false
+      end
+
+      it "should not remove unused tags after removing taggings" do
+        @tagging.destroy
+        ActsAsTaggableOn::Tag.find_by_name("awesome").should == @tag
+      end
+    end
+  end
+
 end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -1,74 +1,93 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
 describe ActsAsTaggableOn::TagList do
-  before(:each) do
-    @tag_list = ActsAsTaggableOn::TagList.new("awesome","radical")
-  end
-  
-  it "should be an array" do
-    @tag_list.is_a?(Array).should be_true
-  end
-  
-  it "should be able to be add a new tag word" do
-    @tag_list.add("cool")
-    @tag_list.include?("cool").should be_true
-  end
-  
-  it "should be able to add delimited lists of words" do
-    @tag_list.add("cool, wicked", :parse => true)
-    @tag_list.include?("cool").should be_true
-    @tag_list.include?("wicked").should be_true
-  end
-  
-  it "should be able to add delimited list of words with quoted delimiters" do
-    @tag_list.add("'cool, wicked', \"really cool, really wicked\"", :parse => true)
-    @tag_list.include?("cool, wicked").should be_true
-    @tag_list.include?("really cool, really wicked").should be_true
-  end
-  
-  it "should be able to handle other uses of quotation marks correctly" do
-    @tag_list.add("john's cool car, mary's wicked toy", :parse => true)
-    @tag_list.include?("john's cool car").should be_true
-    @tag_list.include?("mary's wicked toy").should be_true
-  end
-  
-  it "should be able to add an array of words" do
-    @tag_list.add(["cool", "wicked"], :parse => true)
-    @tag_list.include?("cool").should be_true
-    @tag_list.include?("wicked").should be_true
-  end
-  
-  it "should be able to remove words" do
-    @tag_list.remove("awesome")
-    @tag_list.include?("awesome").should be_false
-  end
-  
-  it "should be able to remove delimited lists of words" do
-    @tag_list.remove("awesome, radical", :parse => true)
-    @tag_list.should be_empty
-  end
-  
-  it "should be able to remove an array of words" do
-    @tag_list.remove(["awesome", "radical"], :parse => true)
-    @tag_list.should be_empty
+  let(:tag_list) { ActsAsTaggableOn::TagList.new("awesome","radical") }
+
+  it { should be_kind_of Array }
+
+  it "#from should return empty array if empty array is passed" do
+    ActsAsTaggableOn::TagList.from([]).should be_empty
   end
-  
-  it "should give a delimited list of words when converted to string" do
-    @tag_list.to_s.should == "awesome, radical"
+
+  describe "#add" do
+    it "should be able to be add a new tag word" do
+      tag_list.add("cool")
+      tag_list.include?("cool").should be_true
+    end
+
+    it "should be able to add delimited lists of words" do
+      tag_list.add("cool, wicked", :parse => true)
+      tag_list.should include("cool", "wicked")
+    end
+
+    it "should be able to add delimited list of words with quoted delimiters" do
+      tag_list.add("'cool, wicked', \"really cool, really wicked\"", :parse => true)
+      tag_list.should include("cool, wicked", "really cool, really wicked")
+    end
+
+    it "should be able to handle other uses of quotation marks correctly" do
+      tag_list.add("john's cool car, mary's wicked toy", :parse => true)
+      tag_list.should include("john's cool car", "mary's wicked toy")
+    end
+
+    it "should be able to add an array of words" do
+      tag_list.add(["cool", "wicked"], :parse => true)
+      tag_list.should include("cool", "wicked")
+    end
+
+    it "should quote escape tags with commas in them" do
+      tag_list.add("cool","rad,bodacious")
+      tag_list.to_s.should == "awesome, radical, cool, \"rad,bodacious\""
+    end
+
   end
-  
-  it "should quote escape tags with commas in them" do
-    @tag_list.add("cool","rad,bodacious")
-    @tag_list.to_s.should == "awesome, radical, cool, \"rad,bodacious\""
+
+  describe "#remove" do
+    it "should be able to remove words" do
+      tag_list.remove("awesome")
+      tag_list.should_not include("awesome")
+    end
+
+    it "should be able to remove delimited lists of words" do
+      tag_list.remove("awesome, radical", :parse => true)
+      tag_list.should be_empty
+    end
+
+    it "should be able to remove an array of words" do
+      tag_list.remove(["awesome", "radical"], :parse => true)
+      tag_list.should be_empty
+    end
   end
-  
-  it "#from should return empty array if empty array is passed" do
-    ActsAsTaggableOn::TagList.from([]).should == []
+
+  describe "#to_s" do
+    it "should give a delimited list of words when converted to string" do
+      tag_list.to_s.should == "awesome, radical"
+    end
+
+    it "should be able to call to_s on a frozen tag list" do
+      tag_list.freeze
+      lambda { tag_list.add("cool","rad,bodacious") }.should raise_error
+      lambda { tag_list.to_s }.should_not raise_error
+    end
   end
-  
-  it "should be able to call to_s on a frozen tag list" do
-    @tag_list.freeze
-    lambda { @tag_list.add("cool","rad,bodacious") }.should raise_error
-    lambda { @tag_list.to_s }.should_not raise_error
+
+  describe "cleaning" do
+    it "should parameterize if force_parameterize is set to true" do
+      ActsAsTaggableOn.force_parameterize = true
+      tag_list = ActsAsTaggableOn::TagList.new("awesome()","radical)(cc")
+
+      tag_list.to_s.should == "awesome, radical-cc"
+      ActsAsTaggableOn.force_parameterize = false
+    end
+
+    it "should lowercase if force_lowercase is set to true" do
+      ActsAsTaggableOn.force_lowercase = true
+
+      tag_list = ActsAsTaggableOn::TagList.new("aweSomE","RaDicaL")
+      tag_list.to_s.should == "awesome, radical"
+
+      ActsAsTaggableOn.force_lowercase = false
+    end
+
   end
 end