scoped-tags 0.3.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Josh Kalderimis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 3

data/generators/scoped_tags_migration/scoped_tags_generator.rb

@@ -0,0 +1,7 @@
+class ScopedTagsGenerator < Rails::Generator::Base 
+  def manifest 
+    record do |m| 
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "scoped_tags_migration"
+    end
+  end
+end

data/generators/scoped_tags_migration/templates/migration.rb

@@ -0,0 +1,21 @@
+class ScopedTagsMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :name
+      t.string :context
+    end
+
+    create_table :taggings do |t|
+      t.references :tag
+      t.references :taggable, :polymorphic => true
+    end
+
+    add_index "tags", ['context', 'name']
+    add_index "taggings", ['taggable_id', 'taggable_type']
+  end
+  
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/scoped_tags.rb

@@ -0,0 +1,13 @@
+require 'scoped_tags/active_record_additions'
+require 'scoped_tags/tag'
+require 'scoped_tags/tagging'
+require 'scoped_tags/tag_list_proxy'
+require 'scoped_tags/tag_list_collection'
+
+module ActiveRecord
+  Base.class_eval do
+    include ScopedTags::ActiveRecordAdditions
+  end
+end
+
+TagListCollection.delimiter = ','

data/lib/scoped_tags/active_record_additions.rb

@@ -0,0 +1,64 @@
+module ScopedTags
+  
+  module ActiveRecordAdditions
+    
+    def self.included(base)
+      base.class_eval do
+        def self.scoped_tags(contexts, options = nil)
+          self.class.instance_eval{ attr_accessor :tag_contexts }
+          
+          raise ScopedTagsError, 'context is required for scoped-tags setup' if contexts.blank?
+          
+          self.tag_contexts = [contexts].flatten
+          
+          has_many :taggings, :as => :taggable,       :class_name => 'Tagging', :dependent => :delete_all
+          has_many :tags,     :through => :taggings,  :class_name => 'Tag',     :readonly => true
+            
+          self.tag_contexts.each do |context|
+            has_many context, :through => :taggings, :class_name => 'Tag',
+                              :source  => :tag,
+                              :conditions => ['context = ?', context.to_s.downcase]
+            
+            c = context.to_s.singularize
+            define_method("#{c}_list")   { get_tag_list(context) }
+            define_method("#{c}_list=")  { |new_list| set_tag_list(context, new_list) }
+            self.class.instance_eval do
+              define_method("tagged_with_#{context}") { |*args| find_tagged_with(args.first, context.to_s, args.extract_options!) }
+            end
+          end          
+          
+          self.send :extend,  ClassMethods
+          self.send :include, InstanceMethods
+        end
+      end
+    end
+    
+    
+    module ClassMethods
+      def find_tagged_with(tag_names, context, options = {})
+        tag_names = tag_names.is_a?(Array) ? tag_names : tag_names.split(TagListCollection.delimiter)
+        tag_names = tag_names.collect(&:strip).reject(&:blank?)
+        
+        required_options = { :include => [:taggings, :tags], 
+                             :conditions => ['tags.name IN (?) AND tags.context = ?', tag_names, context] }
+                             
+        self.all(options.merge(required_options))
+      end
+    end
+
+    
+    module InstanceMethods
+      protected
+        def get_tag_list(context)
+          @tag_list_collections = { } if not @tag_list_collections
+          @tag_list_collections[context] ||= TagListCollection.new(self, context.to_s.downcase)
+        end
+    
+        def set_tag_list(context, new_tags)
+          get_tag_list(context).replace(new_tags)
+        end  
+    end
+    
+  end
+  
+end

data/lib/scoped_tags/tag.rb

@@ -0,0 +1,32 @@
+class Tag < ActiveRecord::Base
+  has_many :taggings, :dependent => :delete_all
+   
+  validates_presence_of :context
+  validates_uniqueness_of :name, :case_sensitive => false, :scope => :context
+  
+  attr_accessible :name, :context
+  
+  before_validation :trim_spaces, :lowercase_name
+  
+  
+  def self.find_or_new_by_name_and_context(name, context)
+    tag = self.find(:first, :conditions => ["name = ? and context = ?", name, context])
+    tag || Tag.new(:name => name, :context => context)
+  end
+  
+  def ==(object)
+    super || (object.is_a?(Tag) && self.name == object.name && self.context == object.context)
+  end
+  
+  
+  private
+    def trim_spaces
+      self.name.try(:strip!).try(:squeeze!, ' ')
+      self.context.try(:strip!).try(:squeeze!, ' ')
+    end
+    
+    def lowercase_name
+      self.name.try(:downcase!)
+      self.context.try(:downcase!)
+    end
+end

data/lib/scoped_tags/tag_list_collection.rb

@@ -0,0 +1,76 @@
+class TagListCollection < TagListProxy
+  
+  self.class.instance_eval do
+    attr_accessor :delimiter
+  end
+  
+  
+  def <<(tag_names)
+    tag_names = clean_tag_list(tag_names)
+    current_list = self.to_a
+    context_tags = self.proxy_owner.send(self.proxy_context)
+    tag_names.each do |new_tag|
+      unless current_list.include?(new_tag)
+        context_tags << Tag.find_or_new_by_name_and_context(new_tag, self.proxy_context.to_s) 
+      end
+    end
+    self
+  end
+  
+  alias_method :push, :<<
+  alias_method :concat, :<<
+  
+  
+  def delete(tag_names)
+    context_tags = self.proxy_owner.send(self.proxy_context)
+    to_delete = []
+    tag_names = clean_tag_list(tag_names)
+    context_tags.each do |tag|
+      to_delete << tag if tag_names.include?(tag.name)
+    end
+    context_tags.delete(to_delete)
+    to_delete.collect(&:name)
+  end
+  
+  def delete_at(index)
+    context_tags = self.proxy_owner.send(self.proxy_context)
+    return nil if 0 > index or index > context_tags.size
+    tag_at_index = context_tags[index]
+    context_tags.delete(tag_at_index)
+    tag_at_index
+  end
+  
+  def pop
+    self.delete_at(self.size - 1)
+  end
+  
+  def replace(tag_names)
+    new_uniq_list = clean_tag_list(tag_names).uniq
+    new_tag_list = new_uniq_list.inject([]) do |list, tag_name|
+      list << Tag.find_or_new_by_name_and_context(tag_name, self.proxy_context)
+      list
+    end
+    context_tags = self.proxy_owner.send(self.proxy_context)
+    context_tags.replace(new_tag_list)
+    self
+  end
+  
+    
+  def to_s
+    self.join("#{TagListCollection.delimiter} ")
+  end
+  
+  
+  private
+  
+    def find_target
+      association = self.proxy_owner.send proxy_context
+      association.collect(&:name)
+    end
+    
+    def clean_tag_list(tags)
+      tags = tags.is_a?(Array) ? tags : tags.split(TagListCollection.delimiter)
+      tags.collect(&:strip).reject(&:blank?)
+    end
+  
+end

data/lib/scoped_tags/tag_list_proxy.rb

@@ -0,0 +1,98 @@
+class TagListProxy
+
+  alias_method :proxy_respond_to?, :respond_to?
+  alias_method :proxy_extend, :extend
+  delegate :to_param, :to => :proxy_target
+  instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+  def initialize(owner, context)
+    @owner, @context = owner, context
+    @target = nil
+  end
+
+  # Returns the owner of the proxy.
+  def proxy_owner
+    @owner
+  end
+
+  # Returns the \context of the proxy, same as +context+.
+  def proxy_context
+    @context
+  end
+  
+  # Returns the \target of the proxy, same as +target+.
+  def proxy_target
+    @target
+  end
+  
+  # Does the proxy or its \target respond to +symbol+?
+  def respond_to?(*args)
+    proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
+  end
+
+  # Forwards <tt>===</tt> explicitly to the \target because the instance method
+  # removal above doesn't catch it. Loads the \target if needed.
+  def ===(other)
+    reload
+    other === @target
+  end
+
+  # Reloads the \target and returns +self+ on success.
+  def reload
+    @target = nil
+    load_target
+    self unless @target.nil?
+  end
+
+  # Returns the target of this proxy, same as +proxy_target+.
+  def target
+    @target
+  end
+
+  # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
+  def target=(target)
+    @target = target
+  end
+
+  # Forwards the call to the target. Loads the \target if needed.
+  def inspect
+    reload
+    @target.inspect
+  end
+
+  def send(method, *args)
+    if proxy_respond_to?(method)
+      super
+    else
+      reload
+      @target.send(method, *args)
+    end
+  end
+
+
+  private
+    # Forwards any missing method call to the \target.
+    def method_missing(method, *args)
+      if reload
+        unless @target.respond_to?(method)
+          message = "undefined method `#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
+          raise NoMethodError, message
+        end
+
+        if block_given?
+          @target.send(method, *args)  { |*block_args| yield(*block_args) }
+        else
+          @target.send(method, *args)
+        end
+      end
+    end
+
+    def load_target
+      @target = find_target
+      @target
+    rescue ActiveRecord::RecordNotFound
+      reset
+    end
+
+
+end

data/lib/scoped_tags/tagging.rb

@@ -0,0 +1,8 @@
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :taggable, :polymorphic => true
+  
+  validates_uniqueness_of :taggable_id, :scope => :tag_id
+  
+  attr_accessible :taggable_type, :taggable_id, :tag_id
+end

data/readme.md

@@ -0,0 +1,93 @@
+Scoped-Tags
+===========
+
+When it comes to tagging dsls there are three main players, acts-as-taggable-on, acts-as-taggable-on-steriods and is-taggable.
+Each seem to have one thing is common and thats using an after save callback to sync the tags list (usually an array) with
+the tags association. 
+
+The key difference between scoped-tags and the other players on the field is that scoped-tags syncs 
+the array version with the association version upon each request. 
+
+The initial array tag list implementation was half Array half beast. The current version has been updated to use a proxy
+based implementation for the array list, similar to the ActiveRecord ProxyAssociation which is used for the different
+relationship associations. This is the heart of the code which syncs the array style listing with the association listing.
+
+Scoped-tags will, in its next release, allow for tags to be strictly or silently scoped, with the default allowing
+tag creation if the tag does not exist.
+
+
+Key Features
+------------
+
+- multiple tag contexts per model
+- works with sphinx and thinking-sphinx
+- add and remove tags using array like features
+- association and array list stay in sync
+- tags are available for use in the validations as they are always kept in sync
+
+
+
+How can I use it?
+-----------------
+
+    class Person
+      scoped_tags :genres
+    end
+
+    me = Person.new(:name => 'Josh')
+
+    me.interests << Tag.new(:name => 'scuba', :context => 'interests') 
+    # it would be nice to leave the context out, but sadly not just yet
+    # and me.interests.build(:name => 'scuba') does not work at the moment either 
+    # (has_many through issue)
+
+    me.interest_list => ['scuba']
+
+    me.interest_list << 'cycling'
+    # comma seperated strings are excepted, as well as arrays of strings
+
+    me.interests => [#<Tag id: nil, name: "scuba", context: 'interests'>,#<Tag id: nil, name: "cycling", context: 'interests'>]
+    
+
+
+Things to watch out for
+-----------------------
+
+### _updating a scoped tagged model via a controller update_
+
+be aware that if no tags are selected then the browser
+does not pass through a blank array. This means if the model previously had tags saved to it and you remove the tags, the browser
+will not pass though the changes because the select box is empty meaning the tags will not be removed. 
+
+An example of
+this is the  FCBKcomplete javascript plugin, it uses a select box behind the scenes to store the tags and pass
+them through to the controller, but if none are selected then the browser passes nothing to the controller, 
+not even a blank array. To fix this, add the following method to the controller and add it as a before\_filter to the update
+action.  
+
+Add to the controller:
+    
+    before_filter :check_blank_tag_ids, :only => :update
+    
+    def check_blank_tag_ids
+        params[:person][:interest_ids] = [] if params[:person] && params[:person][:interest_ids].blank?
+    end
+
+
+### _use a transaction when updating the scoped model_
+
+otherwise the tags will save even if the model validations fail.
+This is due to the standard behavior of has\_many :through relationships.
+    
+Example
+
+    Person.transaction { @person.update_attributes!(params[:person]) }
+
+
+
+
+Future enhancements
+-------------------
+
+- add strict and silent scoping on setup (scoped_tags :interests, :strict => true), thus any tag added which is not already in the tags table for that context will be rejected
+- get the instance.context.build method to work correctly

data/spec/debug.log

@@ -0,0 +1 @@
+# Logfile created on Sat Oct 17 19:04:03 +0200 2009 by logger.rb/22285

data/spec/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define :version => 0 do
+  
+  create_table "scoped_tagged_models", :force => true do |t|
+    t.string :name
+  end
+  
+  create_table "tags", :force => true do |t|
+    t.string :name
+    t.string :context
+  end
+  
+  create_table "taggings", :force => true do |t|
+    t.references :tag
+    t.references :taggable, :polymorphic => true
+  end
+  
+  add_index "tags", ['context', 'name']
+  add_index "taggings", ['taggable_id', 'taggable_type']
+  
+end

data/spec/scoped_tags/scoped_tags_spec.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe "ScopedTaggedModel" do   
+  context "attaching scoped-tags to a model" do
+    before(:each) do
+      @scoped_model = ScopedTaggedModel.new 
+    end
+    
+    it "should include the taggings method" do 
+      @scoped_model.should respond_to(:taggings)
+    end
+
+    it "should include a tags method" do 
+      @scoped_model.should respond_to(:tags)
+    end
+
+    it "should include the genres method" do 
+      @scoped_model.should respond_to(:genres)
+    end
+    
+    it "should at tag_contexts to the class" do
+      ScopedTaggedModel.should respond_to(:tag_contexts)
+    end
+    
+    it "should create a getter and setter context tag list" do
+      @scoped_model.should respond_to(:genre_list, :genre_list=)
+    end
+  end
+  
+  context "using scoped-tags in an every day situation" do
+    before(:each) do
+      @scoped_model = ScopedTaggedModel.new 
+      @scoped_model.genres << Tag.new(:name => 'rock', :context => 'genres')
+    end
+    
+    it "should return the genres association name list when genre_list is called" do
+      @scoped_model.genre_list.should include('rock')
+    end
+    
+    it "should add a tag to the association when genre_list << is used" do
+      @scoped_model.genre_list << 'pop'
+      @scoped_model.genres.size.should == 2 
+      @scoped_model.genre_list.should include('pop')
+    end
+    
+    it "should change the entire list when using genre_list =" do
+      @scoped_model.genre_list = 'blues'
+      @scoped_model.genres.size.should == 1 
+      @scoped_model.genre_list.should include('blues')
+    end
+    
+    it "should change the entire list when using genre_list= with a comma seperated list of tags" do
+      @scoped_model.genre_list = 'blues, rock, country'
+      @scoped_model.genres.size.should == 3
+      @scoped_model.genre_list.should == ["rock", "blues", "country"]
+    end
+    
+    it "should only add uniq tags to the association" do
+      @scoped_model.genre_list << 'blues'
+      @scoped_model.genres.size.should == 2 
+      @scoped_model.genre_list.should include('blues', 'rock')
+      @scoped_model.genre_list << 'blues'
+      @scoped_model.genre_list << 'blues'
+      @scoped_model.genre_list << 'rock'
+      @scoped_model.genres.size.should == 2
+      @scoped_model.genre_list.should include('blues', 'rock')
+    end
+    
+    it "should allow tags to be removed from the association and have the tag list act consistently" do
+      @scoped_model.genre_list << 'blues'
+      @scoped_model.genres.size.should == 2 
+      @scoped_model.genres.delete(@scoped_model.genres.last)
+      @scoped_model.genres.size.should == 1
+      @scoped_model.genre_list.should include('rock')
+    end
+    
+    it "#tagged_with_genres" do
+      tag = 'pop'
+      
+      @scoped_model.genre_list << tag
+      @scoped_model.save!
+      
+      ar_check = ScopedTaggedModel.all(:conditions => ['tags.name IN (?) AND tags.context = ?', tag, 'genres'], :include => [:taggings, :tags])
+      ar_check.size.should == 1
+      
+      ScopedTaggedModel.methods.should include('tagged_with_genres')
+      
+      st_check = ScopedTaggedModel.tagged_with_genres(tag)
+      st_check.size.should == 1
+      st_check.first.id.should == @scoped_model.id
+    end
+    
+    it "#tagged_with_genres with options" do
+      tag = 'pop'
+      
+      ScopedTaggedModel.delete_all
+      options_check1 = ScopedTaggedModel.new
+      options_check1.genre_list << tag
+      options_check1.save!
+      
+      options_check2 = ScopedTaggedModel.new
+      options_check2.genre_list << tag
+      options_check2.save!
+      
+      st_check = ScopedTaggedModel.tagged_with_genres(tag, :limit => 1)
+      st_check.size.should == 1
+      st_check.first.id.should == options_check1.id
+    end
+    
+    it "#tagged_with_genres with options and multiple tags in an array" do
+      tag = ['pop', 'techno', 'dance']
+      
+      ScopedTaggedModel.delete_all
+      options_check1 = ScopedTaggedModel.new
+      options_check1.genre_list << tag
+      options_check1.save!
+      
+      options_check2 = ScopedTaggedModel.new
+      options_check2.genre_list << tag
+      options_check2.save!
+      
+      st_check = ScopedTaggedModel.tagged_with_genres(tag, :limit => 1)
+      st_check.size.should == 1
+      st_check.first.id.should == options_check1.id
+    end
+    
+    it "#tagged_with_genres with options and multiple tags in a string" do
+      tag = 'pop, techno, dance'
+      
+      ScopedTaggedModel.delete_all
+      options_check1 = ScopedTaggedModel.new
+      options_check1.genre_list << tag
+      options_check1.save!
+      
+      options_check2 = ScopedTaggedModel.new
+      options_check2.genre_list << tag
+      options_check2.save!
+      
+      st_check = ScopedTaggedModel.tagged_with_genres(tag, :limit => 1)
+      st_check.size.should == 1
+      st_check.first.id.should == options_check1.id
+    end
+  end
+end 

data/spec/scoped_tags/tag_and_tagging_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Tagging do
+  before(:all) { Tagging.create!(:tag_id => 1, :taggable_id => 1) }
+  
+  it { should belong_to(:tag) }
+  it { should belong_to(:taggable) }
+  it { should validate_uniqueness_of(:taggable_id).scoped_to(:tag_id) }
+  
+  it { should allow_mass_assignment_of(:taggable_id)
+       should allow_mass_assignment_of(:taggable_type)
+       should allow_mass_assignment_of(:tag_id) }
+  
+  it { should_not allow_mass_assignment_of(:created_at)
+       should_not allow_mass_assignment_of(:updated_at) }
+       
+  it { should have_db_index([:taggable_id, :taggable_type]) }
+end
+
+
+describe Tag do
+  before(:all) { Tag.create!(:name => 'rock', :context => 'genres') }
+  
+  it { should have_many(:taggings).dependent(:delete_all) }
+    
+  it { should validate_uniqueness_of(:name).scoped_to(:context).case_insensitive }
+  it { should validate_presence_of(:context) }
+  
+  it { should allow_mass_assignment_of(:name)
+       should allow_mass_assignment_of(:context) }
+  
+  it { should_not allow_mass_assignment_of(:created_at)
+       should_not allow_mass_assignment_of(:updated_at) }
+  
+  it { should have_db_index([:context, :name]) }
+  
+  it "should trim and squeeze spaces from name and context before validation" do
+    t = Tag.new(:name => ' rock   and      roll', :context => '   genres   ')
+    t.valid?
+    t.name.should == 'rock and roll'
+    t.context.should == 'genres' 
+  end
+  
+  it "should lowercase the name and context before validation" do
+    t = Tag.new(:name => 'POP', :context => 'GENRES')
+    t.valid?
+    t.name.should == 'pop'
+    t.context.should == 'genres'
+  end
+  
+  it "should recognize that it is equal to another tag with the same name and context" do
+    t = Tag.new(:name => 'pop', :context => 'genres')
+    s = Tag.new(:name => 'pop', :context => 'genres')
+    t.should == s
+  end
+  
+  it "#find_or_new_by_name_ane_context" do
+    Tag.create!(:name => 'pop', :context => 'genres')
+    s = Tag.find_or_new_by_name_and_context('pop', 'genres')
+    s.new_record?.should be_false
+  end
+end

data/spec/scoped_tags/tag_list_spec.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe TagListCollection do
+  
+  before(:each) do
+    @sm = ScopedTaggedModel.new
+    @tlc = TagListCollection.new(@sm, :genres)
+  end
+  
+  it "#delimiter" do
+    TagListCollection.delimiter.should == ','
+    TagListCollection.delimiter = '-'
+    TagListCollection.delimiter.should == '-'
+    TagListCollection.delimiter = ','
+    TagListCollection.delimiter.should == ','
+  end
+  
+  it ".proxy_owner" do
+    @sm.genre_list.proxy_owner.should == @sm
+  end
+  
+  it ".===" do
+    @sm.genre_list << "disco"
+    @sm.genre_list.should === ['disco']
+  end
+  
+  it "should return an array with the class method is called (think its an array)" do
+    @tlc.class.should == Array
+  end
+  
+  it "should return the tag names in the genre list" do
+    @sm.genres << Tag.new(:name => 'pop', :context => 'genres')
+    @sm.genres << Tag.new(:name => 'rock', :context => 'genres')
+    @sm.genre_list.should == ['pop', 'rock']
+  end
+  
+  it "should add a tag to the tag list when the association << method is used" do
+    @sm.genre_list.should == []
+    @sm.genres << Tag.new(:name => 'rock', :context => 'genres')
+    @sm.genre_list.should == ['rock']
+  end
+  
+  it "should be able to be add a new tag word using <<" do
+    @sm.genre_list << "disco"
+    @sm.genre_list.should include('disco')
+  end
+  
+  it "should be able to be add a new tag word using push" do
+    @tlc.push('techno')
+    @tlc.should include('techno')
+  end
+  
+  it "should be able to be add a new tag word using concat" do
+    @tlc.concat('dance')
+    @tlc.should include('dance')
+  end
+  
+  it "should be able to add delimited lists of tags" do
+    @tlc << "techno, house"
+    @tlc.should include('techno')
+    @tlc.should include('house')
+    @tlc.size.should == 2
+  end
+  
+  it "should be able to delete tags using delete" do
+    @tlc << 'rock'
+    @sm.genres.size.should == 1
+    @tlc.delete('rock')
+    @tlc.should_not include('rock')
+    @sm.genres.size.should == 0
+  end
+  
+  it "should be able to delete tags using delete_at" do
+    @tlc << 'rock' << 'pop' << 'disco'
+    @sm.genres.size.should == 3
+    @sm.save!
+    @tlc.delete_at(0)
+    @tlc.should_not include('rock')
+    @sm.genres.size.should == 2
+    @sm.save!
+    @sm.reload
+    @sm.genres.size.should == 2
+  end
+  
+  it "should be able to delete tags using pop" do
+    @tlc << 'rock' << 'pop' << 'disco'
+    @sm.genres.size.should == 3
+    @sm.genre_list.last.should == 'disco'
+    @tlc.pop
+    @tlc.should_not include('disco')
+    @sm.save!
+    @sm.reload
+    @sm.genres.size.should == 2
+  end
+  
+  it "should give a delimited list of words when converted to string" do
+    @tlc << 'rock' << 'pop'
+    @tlc.to_s.should == "rock, pop"
+  end
+  
+  it "should not add duplicate tags" do
+    @tlc << 'rock' << 'pop' << 'disco'
+    @sm.genres.size.should == 3
+    @tlc.should == ['rock', 'pop', 'disco']
+    @tlc << "rock"
+    @tlc.should == ['rock', 'pop', 'disco']
+    @sm.genres.size.should == 3
+  end
+  
+  it ".replace" do
+    @tlc << 'rock' << 'pop' << 'disco'
+    @sm.genre_list.should == ['rock', 'pop', 'disco']
+    @sm.genre_list = ['funk', 'house']
+    @sm.genre_list.should == ['funk', 'house']
+  end
+  
+  it ".to_param" do
+    @sm.genre_list = ['funk', 'house']
+    @sm.genre_list.to_param.should == 'funk/house'
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'spec'
+require 'shoulda'
+
+require 'active_support'
+require 'active_record'
+
+require 'scoped_tags'
+
+Spec::Runner.configure do |config|
+  config.include(Shoulda::ActiveRecord::Matchers, :type => :model)
+end
+
+TEST_DATABASE_FILE = 'spec/test.sqlite3'
+
+File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
+ActiveRecord::Base.establish_connection(
+  "adapter" => "sqlite3", "database" => TEST_DATABASE_FILE
+)
+ 
+load('schema.rb')
+
+RAILS_DEFAULT_LOGGER = Logger.new("spec/debug.log")
+
+class ScopedTaggedModel < ActiveRecord::Base
+  scoped_tags :genres
+end
+
+class UnScopedTaggedModel < ActiveRecord::Base
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: scoped-tags
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Josh Kalderimis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-18 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: 
+email: josh.kalderimis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- VERSION.yml
+- generators/scoped_tags_migration/scoped_tags_generator.rb
+- generators/scoped_tags_migration/templates/migration.rb
+- install.rb
+- lib/scoped_tags.rb
+- lib/scoped_tags/active_record_additions.rb
+- lib/scoped_tags/tag.rb
+- lib/scoped_tags/tag_list_collection.rb
+- lib/scoped_tags/tag_list_proxy.rb
+- lib/scoped_tags/tagging.rb
+- readme.md
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/joshk/scoped-tags
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Scoped tagging plugin for your rails models which keeps your associations in sync with your tag arrays
+test_files: 
+- spec/debug.log
+- spec/schema.rb
+- spec/scoped_tags/scoped_tags_spec.rb
+- spec/scoped_tags/tag_and_tagging_spec.rb
+- spec/scoped_tags/tag_list_spec.rb
+- spec/spec_helper.rb
+- spec/test.sqlite3