taglish 0.1.0

data/spec/schema.rb

@@ -0,0 +1,72 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table "taggings", :force => true do |t|
+    t.integer  "tag_id",        :limit => 11
+    t.integer  "taggable_id",   :limit => 11
+    t.string   "taggable_type"
+    t.string   "context"
+    t.datetime "created_at"
+    t.integer  "tagger_id",     :limit => 11
+    t.integer  "score"
+    t.string   "tagger_type"
+  end
+
+  add_index "taggings", ["tag_id"], :name => "index_taggings_on_tag_id"
+  add_index "taggings", ["taggable_id", "taggable_type", "context"], :name => "index_taggings_on_taggable_id_and_taggable_type_and_context"
+
+  create_table "tags", :force => true do |t|
+    t.string "name"
+  end
+  
+  create_table :taggable_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+  
+  create_table :non_standard_id_taggable_models, :primary_key => "an_id", :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+  
+  create_table :untaggable_models, :force => true do |t|
+    t.column :taggable_model_id, :integer
+    t.column :name, :string
+  end
+  
+  create_table :cached_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+    t.column :cached_tag_list, :string
+  end
+  
+  create_table :other_cached_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+    t.column :cached_language_list, :string    
+    t.column :cached_status_list, :string
+    t.column :cached_glass_list, :string
+  end
+  
+  create_table :taggable_users, :force => true do |t|
+    t.column :name, :string
+  end
+  
+  create_table :other_taggable_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+  
+  create_table :ordered_taggable_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+
+  create_table :mixed_taggable_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+
+  create_table :scored_taggable_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,82 @@
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+require 'logger'
+
+begin
+  require "rubygems"
+  require "bundler"
+
+  if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.5")
+    raise RuntimeError, "Your bundler version is too old." +
+     "Run `gem install bundler` to upgrade."
+  end
+
+  # Set up load paths for all bundled gems
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run \`bundle install\`?"
+end
+
+Bundler.require
+require File.expand_path('../../lib/taglish', __FILE__)
+
+unless [].respond_to?(:freq)
+  class Array
+    def freq
+      k=Hash.new(0)
+      each {|e| k[e]+=1}
+      k
+    end
+  end
+end
+
+# set adapter to use, default is sqlite3
+# to use an alternative adapter run => rake spec DB='postgresql'
+db_name = ENV['DB'] || 'sqlite3'
+database_yml = File.expand_path('../database.yml', __FILE__)
+
+if File.exists?(database_yml)
+  active_record_configuration = YAML.load_file(database_yml)
+  
+  ActiveRecord::Base.configurations = active_record_configuration
+  config = ActiveRecord::Base.configurations[db_name]
+  
+  begin
+    ActiveRecord::Base.establish_connection(db_name)
+    ActiveRecord::Base.connection
+  rescue
+    case db_name
+    when /mysql/      
+      ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+      ActiveRecord::Base.connection.create_database(config['database'],  {:charset => 'utf8', :collation => 'utf8_unicode_ci'})
+    when 'postgresql'
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+      ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
+    end
+    
+    ActiveRecord::Base.establish_connection(config)
+  end
+    
+  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+  ActiveRecord::Base.default_timezone = :utc
+  
+  ActiveRecord::Base.silence do
+    ActiveRecord::Migration.verbose = false
+    
+    load(File.dirname(__FILE__) + '/schema.rb')
+    load(File.dirname(__FILE__) + '/models.rb')
+  end  
+  
+else
+  raise "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+end
+
+def clean_database!
+  models = [Taglish::Tag, Taglish::Tagging, TaggableModel, OtherTaggableModel, InheritingTaggableModel,
+            AlteredInheritingTaggableModel, TaggableUser, UntaggableModel, OrderedTaggableModel, MixedTaggableModel, ScoredTaggableModel]
+  models.each do |model|
+    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+  end
+end
+
+clean_database!

data/spec/taglish/taggable_spec.rb

@@ -0,0 +1,695 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+=begin
+describe "Taggable To Preserve Order" do
+  before(:each) do
+    clean_database!
+    @taggable = OrderedTaggableModel.new(:name => "Bob Jones")
+  end
+  
+  it "should have tag types" do
+    [:tags, :colours].each do |type|
+      OrderedTaggableModel.tag_types.should include type
+    end
+
+    @taggable.tag_types.should == OrderedTaggableModel.tag_types
+  end
+  
+  it "should have tag associations" do
+    [:tags, :colours].each do |type|
+      @taggable.respond_to?(type).should be_true
+      @taggable.respond_to?("#{type.to_s.singularize}_tags").should be_true
+    end
+  end
+  
+  it "should have tag associations ordered by id" do
+    [:tags, :colours].each do |type|
+      OrderedTaggableModel.reflect_on_association(type).options[:order].should include('id')
+      OrderedTaggableModel.reflect_on_association("#{type.to_s.singularize}_taggings".to_sym).options[:order].should include('id')
+    end
+  end
+  
+  it "should have tag methods" do
+    [:tags, :colours].each do |type|
+      @taggable.respond_to?("#{type.to_s.singularize}_list").should be_true
+      @taggable.respond_to?("#{type.to_s.singularize}_list=").should be_true
+      @taggable.respond_to?("all_#{type.to_s}_list").should be_true
+    end
+  end
+
+  it "should return tag list in the order the tags were created" do
+    # create
+    @taggable.tag_list = "rails, ruby, css"
+    @taggable.instance_variable_get("@tag_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+    
+    lambda {
+      @taggable.save
+    }.should change(ActsAsTaggableOn::Tag, :count).by(3)
+    
+    @taggable.reload
+    @taggable.tag_list.should == %w(rails ruby css)
+    
+    # update
+    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.save
+        
+    @taggable.reload
+    @taggable.tag_list.should == %w(pow ruby rails)
+    
+    # update with no change
+    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.save
+        
+    @taggable.reload
+    @taggable.tag_list.should == %w(pow ruby rails)
+    
+    # update to clear tags
+    @taggable.tag_list = ""
+    @taggable.save
+        
+    @taggable.reload
+    @taggable.tag_list.should == []
+  end
+  
+  it "should return tag objects in the order the tags were created" do
+    # create
+    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.instance_variable_get("@tag_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+    
+    lambda {
+      @taggable.save
+    }.should change(ActsAsTaggableOn::Tag, :count).by(3)
+    
+    @taggable.reload
+    @taggable.tags.map{|t| t.name}.should == %w(pow ruby rails)
+    
+    # update
+    @taggable.tag_list = "rails, ruby, css, pow"
+    @taggable.save
+    
+    @taggable.reload
+    @taggable.tags.map{|t| t.name}.should == %w(rails ruby css pow)
+  end
+  
+  it "should return tag objects in tagging id order" do
+    # create
+    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.save
+    
+    @taggable.reload
+    ids = @taggable.tags.map{|t| t.taggings.first.id}
+    ids.should == ids.sort
+    
+    # update
+    @taggable.tag_list = "rails, ruby, css, pow"
+    @taggable.save
+    
+    @taggable.reload
+    ids = @taggable.tags.map{|t| t.taggings.first.id}
+    ids.should == ids.sort
+  end
+end
+=end
+
+describe "Taggable" do
+  before(:each) do
+    clean_database!
+    @taggable = TaggableModel.new(:name => "Bob Jones")
+    @taggables = [@taggable, TaggableModel.new(:name => "John Doe")]
+  end
+
+  it "should have tag types" do
+    [:tags, :languages, :skills, :needs, :offerings].each do |type|
+      TaggableModel.tag_types.should include type
+    end
+
+    @taggable.class.should be_taggable
+    @taggable.should be_taggable
+    @taggable.tag_types.should == TaggableModel.tag_types
+  end
+
+  it "should have tag associations" do
+    [:tags, :languages, :skills, :needs, :offerings].each do |type|
+      @taggable.respond_to?(type).should be_true
+      @taggable.respond_to?("#{type.to_s.singularize}_tags").should be_true
+    end
+  end
+  
+  it "should have tag methods" do
+    [:tags, :languages, :skills, :needs, :offerings].each do |type|
+      @taggable.respond_to?("#{type.to_s.singularize}_list").should be_true
+      @taggable.respond_to?("#{type.to_s.singularize}_list=").should be_true
+      # @taggable.respond_to?("all_#{type.to_s}_list").should be_true
+    end
+  end
+
+  it "should return [] right after create" do
+    blank_taggable = TaggableModel.new(:name => "Bob Jones")
+    blank_taggable.tag_list.should == []
+  end
+
+  it "should save taggings" do
+    @taggable.skill_list = "ruby, rails, css"
+
+    @taggable.instance_variable_get("@skills_list").instance_of?(Taglish::TagList).should be_true
+    lambda {
+      @taggable.save
+    }.should change(Taglish::Tagging, :count).by(3)
+
+    @taggable.reload
+    @taggable.skill_list.sort.should == %w(ruby rails css).sort
+  end
+
+  it "should be able to create tags" do
+    @taggable.skill_list = "ruby, rails, css"
+
+    lambda {
+      @taggable.save
+    }.should change(Taglish::Tag, :count).by(3)
+  end
+
+  context "with scored tag types" do
+    before do
+      @taggable = ScoredTaggableModel.new(:name => "Bob Jones")
+    end
+
+    it "should save taggings" do
+      @taggable.question_count_list = "ruby:9, sql:5"
+
+      @taggable.instance_variable_get("@question_counts_list").instance_of?(Taglish::TagList).should be_true
+      lambda {
+        @taggable.save
+      }.should change(Taglish::Tagging, :count).by(2)
+
+      @taggable.reload
+      @taggable.question_count_list.sort.should == %w(ruby:9 sql:5).sort
+      @taggable.question_counts.map{|tg| tg.name}.sort.should == %w(ruby sql)
+      @taggable.question_counts.map{|tg| tg.score}.sort.should == [5, 9]
+    end
+
+    it "should remove old tags" do
+      @taggable.question_count_list = "ruby:9, sql:5, js:4"
+      @taggable.save!
+      @taggable.reload
+
+      # Change the score of one, remove one, add one, leave one unchanged:
+      @taggable.question_count_list = "ruby:12, sql:5, chef:2"
+      @taggable.instance_variable_get("@question_counts_list").instance_of?(Taglish::TagList).should be_true
+      lambda {
+        @taggable.save
+      }.should change(Taglish::Tagging, :count).by(0)
+      @taggable.reload
+      @taggable.question_count_list.sort.should == %w(ruby:12 sql:5 chef:2).sort
+      @taggable.question_counts.map{|tg| tg.name}.sort.should == %w(chef ruby sql)
+      @taggable.question_counts.map{|tg| tg.score}.sort.should == [2, 5, 12]
+    end
+
+    it "should save tags with zero and negative scores" do
+      @taggable.question_count_list = "ruby:0, sql:-5"
+
+      @taggable.instance_variable_get("@question_counts_list").instance_of?(Taglish::TagList).should be_true
+      lambda {
+        @taggable.save
+      }.should change(Taglish::Tagging, :count).by(2)
+
+      @taggable.reload
+      @taggable.question_count_list.sort.should == %w(ruby:0 sql:-5).sort
+      @taggable.question_counts.map{|tg| tg.name}.sort.should == %w(ruby sql)
+      @taggable.question_counts.map{|tg| tg.score}.sort.should == [-5, 0]
+    end
+  end
+
+  context "with mixed tag types" do
+    before do
+      @taggable = MixedTaggableModel.new(:name => "Bob Jones")
+    end
+
+    it "should remember which tag types are ordered" do
+      @taggable.tags_have_score?(:skills).should be_false
+      @taggable.tags_have_score?(:colors).should be_false
+      @taggable.tags_have_score?(:question_counts).should be_true
+      @taggable.tags_have_score?(:needs).should be_false
+      @taggable.tags_have_score?(:offerings).should be_false
+    end
+
+    it "should remember which tag types are scored" do
+      @taggable.tags_have_order?(:skills).should be_false
+      @taggable.tags_have_order?(:colors).should be_true
+      @taggable.tags_have_order?(:question_counts).should be_false
+      @taggable.tags_have_order?(:needs).should be_false
+      @taggable.tags_have_order?(:offerings).should be_false
+    end
+  end
+
+=begin
+  it "should have tag_counts_on" do
+    TaggableModel.tag_counts_on(:tags).all.should be_empty
+
+    @taggable.tag_list = ["awesome", "epic"]
+    @taggable.save
+
+    TaggableModel.tag_counts_on(:tags).length.should == 2
+    @taggable.tag_counts_on(:tags).length.should == 2
+  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
+
+  it "should differentiate between contexts" do
+    @taggable.skill_list = "ruby, rails, css"
+    @taggable.tag_list = "ruby, bob, charlie"
+    @taggable.save
+    @taggable.reload
+    @taggable.skill_list.should include("ruby")
+    @taggable.skill_list.should_not include("bob")
+  end
+
+  it "should be able to remove tags through list alone" do
+    @taggable.skill_list = "ruby, rails, css"
+    @taggable.save
+    @taggable.reload
+    @taggable.should have(3).skills
+    @taggable.skill_list = "ruby, rails"
+    @taggable.save
+    @taggable.reload
+    @taggable.should have(2).skills
+  end
+
+  it "should be able to select taggables by subset of tags using ActiveRelation methods" do
+    @taggables[0].tag_list = "bob"
+    @taggables[1].tag_list = "charlie"
+    @taggables[0].skill_list = "ruby"
+    @taggables[1].skill_list = "css"
+    @taggables.each{|taggable| taggable.save}
+
+    @found_taggables_by_tag = TaggableModel.joins(:tags).where(:tags => {:name => ["bob"]})
+    @found_taggables_by_skill = TaggableModel.joins(:skills).where(:tags => {:name => ["ruby"]})
+
+    @found_taggables_by_tag.should include @taggables[0]
+    @found_taggables_by_tag.should_not include @taggables[1]
+    @found_taggables_by_skill.should include @taggables[0]
+    @found_taggables_by_skill.should_not include @taggables[1]
+  end
+
+  it "should be able to find by tag" do
+    @taggable.skill_list = "ruby, rails, css"
+    @taggable.save
+
+    TaggableModel.tagged_with("ruby").first.should == @taggable
+  end
+
+  it "should be able to find by tag with context" do
+    @taggable.skill_list = "ruby, rails, css"
+    @taggable.tag_list = "bob, charlie"
+    @taggable.save
+
+    TaggableModel.tagged_with("ruby").first.should == @taggable
+    TaggableModel.tagged_with("ruby, css").first.should == @taggable
+    TaggableModel.tagged_with("bob", :on => :skills).first.should_not == @taggable
+    TaggableModel.tagged_with("bob", :on => :tags).first.should == @taggable
+  end
+
+  it "should not care about case" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "Ruby")
+
+    ActsAsTaggableOn::Tag.find(:all).size.should == 1
+    TaggableModel.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
+  end
+
+  it "should be able to get tag counts on model as a whole" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+    TaggableModel.tag_counts.all.should_not be_empty
+    TaggableModel.skill_counts.all.should_not be_empty
+  end
+
+  it "should be able to get all tag counts on model as whole" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+
+    TaggableModel.all_tag_counts.all.should_not be_empty
+    TaggableModel.all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
+  end
+
+  it "should be able to use named scopes to chain tag finds by any tags by context" do
+    bob   = TaggableModel.create(:name => "Bob",   :need_list => "rails", :offering_list => "c++")
+    frank = TaggableModel.create(:name => "Frank", :need_list => "css",   :offering_list => "css")
+    steve = TaggableModel.create(:name => 'Steve', :need_list => "c++",   :offering_list => "java")
+
+    # Let's only find those who need rails or css and are offering c++ or java
+    TaggableModel.tagged_with(['rails, css'], :on => :needs, :any => true).tagged_with(['c++', 'java'], :on => :offerings, :any => true).to_a.should == [bob]
+  end
+
+  it "should not return read-only records" do
+    TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    TaggableModel.tagged_with("ruby").first.should_not be_readonly
+  end
+
+  it "should be able to get scoped tag counts" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+
+    TaggableModel.tagged_with("ruby").tag_counts(:order => 'tags.id').first.count.should == 2   # ruby
+    TaggableModel.tagged_with("ruby").skill_counts.first.count.should == 1 # ruby
+  end
+
+  it "should be able to get all scoped tag counts" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+
+    TaggableModel.tagged_with("ruby").all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
+  end
+
+  it 'should only return tag counts for the available scope' do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby, java")
+
+    TaggableModel.tagged_with('rails').all_tag_counts.should have(3).items
+    TaggableModel.tagged_with('rails').all_tag_counts.any? { |tag| tag.name == 'java' }.should be_false
+
+    # Test specific join syntaxes:
+    frank.untaggable_models.create!
+    TaggableModel.tagged_with('rails').scoped(:joins => :untaggable_models).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').scoped(:joins => { :untaggable_models => :taggable_model }).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').scoped(:joins => [:untaggable_models]).all_tag_counts.should have(2).items
+  end
+
+  it "should be able to set a custom tag context list" do
+    bob = TaggableModel.create(:name => "Bob")
+    bob.set_tag_list_on(:rotors, "spinning, jumping")
+    bob.tag_list_on(:rotors).should == ["spinning","jumping"]
+    bob.save
+    bob.reload
+    bob.tags_on(:rotors).should_not be_empty
+  end
+
+  it "should be able to find tagged" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+
+    TaggableModel.tagged_with("ruby", :order => 'taggable_models.name').to_a.should == [bob, frank, steve]
+    TaggableModel.tagged_with("ruby, rails", :order => 'taggable_models.name').to_a.should == [bob, frank]
+    TaggableModel.tagged_with(["ruby", "rails"], :order => 'taggable_models.name').to_a.should == [bob, frank]
+  end
+
+  it "should be able to find tagged with quotation marks" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive, 'I love the ,comma,'")
+    TaggableModel.tagged_with("'I love the ,comma,'").should include(bob)
+  end
+
+  it "should be able to find tagged with invalid tags" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive")
+    TaggableModel.tagged_with("sad, happier").should_not include(bob)
+  end
+
+  it "should be able to find tagged with any tag" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+
+    TaggableModel.tagged_with(["ruby", "java"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank, steve]
+    TaggableModel.tagged_with(["c++", "fitter"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, steve]
+    TaggableModel.tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank]
+  end
+
+  context "wild: true" do
+    it "should use params as wildcards" do
+      bob = TaggableModel.create(:name => "Bob", :tag_list => "bob, tricia")
+      frank = TaggableModel.create(:name => "Frank", :tag_list => "bobby, jim")
+      steve = TaggableModel.create(:name => "Steve", :tag_list => "john, patricia")
+      jim = TaggableModel.create(:name => "Jim", :tag_list => "jim, steve")
+
+
+      TaggableModel.tagged_with(["bob", "tricia"], :wild => true, :any => true).to_a.sort_by{|o| o.id}.should == [bob, frank, steve]
+      TaggableModel.tagged_with(["bob", "tricia"], :wild => true, :exclude => true).to_a.should == [jim]
+    end
+  end
+
+  it "should be able to find tagged on a custom tag context" do
+    bob = TaggableModel.create(:name => "Bob")
+    bob.set_tag_list_on(:rotors, "spinning, jumping")
+    bob.tag_list_on(:rotors).should == ["spinning","jumping"]
+    bob.save
+
+    TaggableModel.tagged_with("spinning", :on => :rotors).to_a.should == [bob]
+  end
+
+  it "should be able to use named scopes to chain tag finds" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
+    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').to_a.should == [bob, frank]
+    TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').to_a.should == [bob, steve]
+    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).to_a.should == [bob]
+    TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).to_a.should == [bob]
+  end
+
+  it "should be able to find tagged with only the matching tags" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "lazy, happier")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "fitter, happier, inefficient")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => "fitter, happier")
+
+    TaggableModel.tagged_with("fitter, happier", :match_all => true).to_a.should == [steve]
+  end
+
+  it "should be able to find tagged with some excluded tags" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "happier, lazy")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "happier")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => "happier")
+
+    TaggableModel.tagged_with("lazy", :exclude => true).to_a.should == [frank, steve]
+  end
+
+  it "should return an empty scope for empty tags" do
+    TaggableModel.tagged_with('').should == []
+    TaggableModel.tagged_with(' ').should == []
+    TaggableModel.tagged_with(nil).should == []
+    TaggableModel.tagged_with([]).should == []
+  end
+
+  it "should not create duplicate taggings" do
+    bob = TaggableModel.create(:name => "Bob")
+    lambda {
+      bob.tag_list << "happier"
+      bob.tag_list << "happier"
+      bob.save
+    }.should change(ActsAsTaggableOn::Tagging, :count).by(1)
+  end
+
+  describe "Associations" do
+    before(:each) do
+      @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+    end
+
+    it "should not remove tags when creating associated objects" do
+      @taggable.untaggable_models.create!
+      @taggable.reload
+      @taggable.tag_list.should have(2).items
+    end
+  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(ActsAsTaggableOn::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"
+    end
+
+    it "should return all column names joined for NonStandardIdTaggableModel GROUP clause" do
+      @taggable.grouped_column_names_for(TaggableModel).should == "taggable_models.#{TaggableModel.primary_key}, taggable_models.name, taggable_models.type"
+    end
+  end
+
+  describe "Single Table Inheritance" do
+    before do
+      @taggable = TaggableModel.new(:name => "taggable")
+      @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, :order => 'tags.id').map(&:name).should == %w(bob kelso)
+      AlteredInheritingTaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(fork spoon)
+      TaggableModel.tag_counts_on(:tags, :order => 'tags.id').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
+
+  describe "NonStandardIdTaggable" do
+    before(:each) do
+      clean_database!
+      @taggable = NonStandardIdTaggableModel.new(:name => "Bob Jones")
+      @taggables = [@taggable, NonStandardIdTaggableModel.new(:name => "John Doe")]
+    end
+
+    it "should have tag types" do
+      [:tags, :languages, :skills, :needs, :offerings].each do |type|
+        NonStandardIdTaggableModel.tag_types.should include type
+      end
+
+      @taggable.tag_types.should == NonStandardIdTaggableModel.tag_types
+    end
+
+    it "should have tag_counts_on" do
+      NonStandardIdTaggableModel.tag_counts_on(:tags).all.should be_empty
+
+      @taggable.tag_list = ["awesome", "epic"]
+      @taggable.save
+
+      NonStandardIdTaggableModel.tag_counts_on(:tags).length.should == 2
+      @taggable.tag_counts_on(:tags).length.should == 2
+    end
+
+    it "should be able to create tags" do
+      @taggable.skill_list = "ruby, rails, css"
+      @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+
+      lambda {
+        @taggable.save
+      }.should change(ActsAsTaggableOn::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
+      @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
+  end
+
+  describe "Dirty Objects" do
+    before(:each) do
+      @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+    end
+
+    it 'should show changes of dirty object' do
+      @taggable.changes.should == {}
+      @taggable.tag_list = 'one'
+      @taggable.changes.should == {"tag_list"=>["awesome, epic", ["one"]]}
+
+      @taggable.tag_list_changed?.should be_true
+      @taggable.tag_list_was.should == "awesome, epic"
+      @taggable.tag_list_change.should == ["awesome, epic", ["one"]]
+    end
+
+    it 'should show no changes if the same tag_list' do
+      @taggable.tag_list = "awesome, epic"
+      @taggable.tag_list_changed?.should be_false
+      @taggable.changes.should == {}
+    end
+  end
+
+  describe "Scored taggings" do
+    before(:each) do
+      @taggable = ScoredTaggableModel.create
+    end
+
+    it "should have tag types" do
+      [:question_counts].each do |type|
+        ScoredTaggableModel.tag_types.should include type
+      end
+
+      @taggable.tag_types.should == ScoredTaggableModel.tag_types
+    end
+
+    it "should have tag_counts_on" do
+      ScoredTaggableModel.tag_counts_on(:question_counts).all.should be_empty
+
+      @taggable.question_count_list = ["ruby:5", "sql:4"]
+      @taggable.save
+
+      ScoredTaggableModel.tag_counts_on(:question_counts).length.should == 2
+      @taggable.tag_counts_on(:question_counts).length.should == 2
+    end
+
+    it "should be able to create tags" do
+      @taggable.question_count_list = 'ruby:5, sql:4'
+      @taggable.instance_variable_get("@question_count_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+
+      lambda {
+        @taggable.save
+      }.should change(ActsAsTaggableOn::Tag, :count).by(2)
+
+      @taggable.reload
+      @taggable.question_count_list.sort.should == %w(ruby:5 sql:4).sort
+    end
+
+    it "should be able to create tags through the tag list directly" do
+      @taggable.tag_list_on(:question_counts).add("ruby:9")
+      @taggable.tag_list_cache_on(:question_counts).should_not be_empty
+      @taggable.tag_list_on(:question_counts).should == ["ruby:9"]
+
+      @taggable.save
+      @taggable.save_tags
+
+      @taggable.reload
+      @taggable.tag_list_on(:question_counts).should == ["ruby:9"]
+    end
+
+  end
+=end
+
+end
+
+