tagtical 1.0.6

data/spec/bm.rb

@@ -0,0 +1,53 @@
+require 'active_record'
+require 'action_view'
+require File.expand_path('../../lib/tagtical', __FILE__)
+
+if defined?(ActiveRecord::Acts::TaggableOn)
+  ActiveRecord::Base.send :include, ActiveRecord::Acts::TaggableOn
+  ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
+  ActionView::Base.send :include, TagsHelper if defined?(ActionView::Base)
+end
+
+TEST_DATABASE_FILE = File.join(File.dirname(__FILE__), '..', 'test.sqlite3')
+File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => TEST_DATABASE_FILE
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Schema.define :version => 0 do
+    create_table "taggings", :force => true do |t|
+      t.float    "relevance"
+      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.string   "tagger_type" if Tagtical.config.polymorphic_tagger?
+    end
+
+    add_index "taggings", ["tag_id"], :name => "index_taggings_on_tag_id"
+    add_index "taggings", ["taggable_id", "taggable_type"], :name => "index_taggings_on_taggable_id_and_taggable_type"
+
+    create_table :tags, :force => true do |t|
+      t.string :value
+      t.string :type
+    end
+    add_index :tags, [:type, :value], :unique => true
+    add_index :tags, :value
+
+    create_table :taggable_models, :force => true do |t|
+      t.column :name, :string
+      t.column :type, :string
+      t.column :cached_tag_list, :string
+    end
+  end
+
+  class TaggableModel < ActiveRecord::Base
+    acts_as_taggable(:languages, :skills, :needs, :offerings)
+  end
+end
+
+puts Benchmark.measure {
+  1000.times { TaggableModel.create :tag_list => "awesome, epic, neat" }
+}

data/spec/database.yml

@@ -0,0 +1,17 @@
+sqlite3:
+  adapter: sqlite3
+  database: tagtical.sqlite3
+
+mysql:
+  adapter: mysql
+  hostname: localhost
+  username: root
+  password:
+  database: tagtical
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: tagtical

data/spec/database.yml.sample

@@ -0,0 +1,17 @@
+sqlite3:
+  adapter: sqlite3
+  database: tagtical.sqlite3
+
+mysql:
+  adapter: mysql
+  hostname: localhost
+  username: root
+  password:
+  database: tagtical
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: tagtical

data/spec/models.rb

@@ -0,0 +1,60 @@
+### START Tag Subclasses ###
+
+module Tagtical
+  class Tag
+    class Language < Tagtical::Tag
+    end
+    class PartTag < Tagtical::Tag
+      
+      def dump_value(value)
+        value && value.downcase
+      end
+
+    end
+  end
+end
+module Tag
+  class Skill < Tagtical::Tag
+
+    def load_value(value)
+      value.gsub("ball", "baller") if value
+    end
+    
+  end
+  class Craft < Skill # Multiple levels of inheritance
+  end
+end
+class NeedTag < Tagtical::Tag # Tag subclass ending in "Tag"
+end
+class Offering < Tagtical::Tag # Top level
+end
+
+### END Tag Subclasses ###
+
+class TaggableModel < ActiveRecord::Base
+  acts_as_taggable(:languages, :skills, :crafts, :needs, :offerings)
+  has_many :untaggable_models
+end
+
+class CachedModel < ActiveRecord::Base
+  acts_as_taggable
+end
+
+class OtherTaggableModel < ActiveRecord::Base
+  acts_as_taggable(:languages, :needs, :offerings)
+end
+
+class InheritingTaggableModel < TaggableModel
+end
+
+class AlteredInheritingTaggableModel < TaggableModel
+  acts_as_taggable(:parts)
+end
+
+class TaggableUser < ActiveRecord::Base
+  acts_as_tagger
+end
+
+class UntaggableModel < ActiveRecord::Base
+  belongs_to :taggable_model
+end

data/spec/schema.rb

@@ -0,0 +1,46 @@
+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.datetime "created_at"
+    t.column :tagger_id, :integer
+    t.column :tagger_type, :string
+    t.column :relevance, :float
+  end
+
+  add_index :taggings, :tag_id
+  add_index :taggings, [:taggable_id, :taggable_type]
+
+  create_table :tags, :force => true do |t|
+    t.column :value, :string
+    t.column :type, :string
+  end
+  add_index :tags, [:type, :value], :unique => true
+  add_index :tags, :value
+
+  create_table :taggable_models, :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 :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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,159 @@
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+
+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 \`bundler install\`?"
+end
+
+Bundler.require(:test, :default)
+require File.expand_path('../../lib/tagtical', __FILE__)
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+
+RSpec::Matchers.define :have_tag_values do |expected|
+  match do |actual|
+    actual.map(&:value).sort == expected.sort
+  end
+end
+
+unless [].respond_to?(:freq)
+  class Array
+    def freq
+      k=Hash.new(0)
+      each {|e| k[e]+=1}
+      k
+    end
+  end
+end
+
+ENV['DB'] ||= 'sqlite3'
+
+database_yml = File.expand_path('../database.yml', __FILE__)
+if File.exists?(database_yml)
+  active_record_configuration = YAML.load_file(database_yml)[ENV['DB']]
+  
+  ActiveRecord::Base.establish_connection(active_record_configuration)
+  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+  
+  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 = [Tagtical::Tag, Tagtical::Tagging, TaggableModel, OtherTaggableModel, InheritingTaggableModel,
+            AlteredInheritingTaggableModel, TaggableUser, UntaggableModel]
+  models.each do |model|
+    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+  end
+end
+
+clean_database!
+
+module QueryAnalyzer
+  extend self
+  attr_accessor :enabled, :options
+  self.enabled = false
+  self.options = {}
+
+  IGNORE_SQL_REGEXP = /^explain/i # ignore SQL explain
+
+  def start(options=nil)
+    options = {:match => options} if options.is_a?(Regexp)
+    if block_given?
+      begin
+        (old_options, @options = @options, options) if options
+        old_enabled, @enabled = @enabled, true
+        yield
+      ensure
+        @enabled = old_enabled
+        @options = old_options if options
+      end
+    else
+      @options = options if options
+      @enabled = true
+    end
+  end
+
+  # Always disable it in production environment
+  def enabled?(sql=nil)
+    !Rails.env.production? && (@enabled && (!sql || match_sql?(sql)))
+  end
+
+  def match_sql?(sql)
+    sql !~ IGNORE_SQL_REGEXP && (!options[:match] || options[:match]===sql)
+  end
+
+  def stop
+    options.clear
+    @enabled = false
+  end
+
+  #  class Results < Array
+  #
+  #    def qa_columnized
+  #      sized = {}
+  #      self.each do |row|
+  #        row.values.each_with_index do |value, i|
+  #          sized[i] = [sized[i].to_i, row.keys[i].length, value.to_s.length].max
+  #        end
+  #      end
+  #
+  #      table = []
+  #      table << qa_columnized_row(self.first.keys, sized)
+  #      table << '-' * table.first.length
+  #      self.each { |row| table << qa_columnized_row(row.values, sized) }
+  #      table.join("\n   ") # Spaces added to work with format_log_entry
+  #    end
+  #
+  #    private
+  #
+  #    def qa_columnized_row(fields, sized)
+  #      row = []
+  #      fields.each_with_index do |f, i|
+  #        row << sprintf("%0-#{sized[i]}s", f.to_s)
+  #      end
+  #      row.join(' | ')
+  #    end
+  #
+  #  end # Results
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLiteAdapter < AbstractAdapter
+      private
+
+      def execute_with_analyzer(sql, name = nil)
+        if QueryAnalyzer.enabled?(sql)
+          display = "\nQUERY ANALYZER: \n#{sql}"
+          puts [display, nil, caller.map { |str| str.insert(0, "   -> ")}]
+          @logger.debug(display) if @logger && @logger.debug?
+        end
+        execute_without_analyzer(sql, name)
+      end
+      # Always disable this in production
+      alias_method_chain :execute, :analyzer unless Rails.env.production?
+
+    end
+  end
+end

data/spec/tagtical/acts_as_tagger_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "acts_as_tagger" do
+  before(:each) do
+    clean_database!
+  end
+  
+  describe "Tagger Method Generation" do
+    before(:each) do
+      @tagger = TaggableUser.new()
+    end
+
+    it "should add #is_tagger? query method to the class-side" do
+      TaggableUser.should respond_to(:is_tagger?)
+    end
+    
+    it "should return true from the class-side #is_tagger?" do
+      TaggableUser.is_tagger?.should be_true
+    end
+    
+    it "should return false from the base #is_tagger?" do
+      ActiveRecord::Base.is_tagger?.should be_false
+    end
+    
+    it "should add #is_tagger? query method to the singleton" do
+      @tagger.should respond_to(:is_tagger?)
+    end
+    
+    it "should add #tag method on the instance-side" do
+      @tagger.should respond_to(:tag)
+    end
+    
+    it "should generate an association for #owned_taggings and #owned_tags" do
+      @tagger.should respond_to(:owned_taggings, :owned_tags)
+    end
+  end
+  
+  describe "#tag" do
+    context 'when called with a non-existent tag context' do
+      before(:each) do
+        @tagger = TaggableUser.new()
+        @taggable = TaggableModel.new(:name=>"Richard Prior")
+      end
+
+      it "should by default not throw an exception " do
+        @taggable.tag_list_on(:foo).should be_empty
+        lambda {
+          @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo)
+        }.should_not raise_error
+      end
+
+      it "should show all the tag list when both public and owned tags exist" do
+        @taggable.tag_list = 'ruby, python'
+        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
+        @taggable.all_tags_on(:tags).map(&:value).sort.should == %w(ruby python java lisp).sort
+      end
+      
+      it "should not add owned tags to the common list" do
+        @taggable.tag_list = 'ruby, python'
+        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
+        @taggable.tag_list.should == %w(ruby python)
+        @tagger.tag(@taggable, :with => '', :on => :tags)
+        @taggable.tag_list.should == %w(ruby python)
+      end
+      
+    end
+
+    describe "when called by multiple tagger's" do
+      before(:each) do
+        @user_x = TaggableUser.create(:name => "User X")
+        @user_y = TaggableUser.create(:name => "User Y")
+        @taggable = TaggableModel.create(:name => 'tagtical', :tag_list => 'plugin')
+
+        @user_x.tag(@taggable, :with => 'ruby, rails',  :on => :tags)
+        @user_y.tag(@taggable, :with => 'ruby, plugin', :on => :tags)
+
+        @user_y.tag(@taggable, :with => '', :on => :tags)
+        @user_y.tag(@taggable, :with => '', :on => :tags)
+      end
+
+      it "should delete owned tags" do
+        @user_y.owned_tags.should == []
+      end
+
+      it "should not delete other taggers tags" do
+        @user_x.owned_tags.should have(2).items
+      end
+
+      it "should not delete original tags" do
+        @taggable.all_tags_list_on(:tags).should include('plugin')
+      end
+    end
+  end
+end

data/spec/tagtical/tag_list_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Tagtical::TagList do
+  before { @tag_list = Tagtical::TagList.new("awesome", "radical") }
+  subject { @tag_list }
+
+  it { should be_an Array }
+
+  specify do
+    @tag_list.each do |value|
+      value.should be_an_instance_of Tagtical::TagList::TagValue
+      value.relevance.should be_nil
+    end
+  end
+
+  describe ".from" do
+
+    it "should accept a hash with relevance values" do
+      @tag_list = Tagtical::TagList.from("tag 1" => 4.5, "tag 2" => 4.454)
+      @tag_list.map(&:relevance).should == [4.5, 4.454]
+    end
+    
+  end
+
+  it "should convert all values to Tagtical::TagList::TagValue" do
+    @tag_list << "foo"
+    @tag_list.concat(["bar"])
+    @tag_list.each do |value|
+      value.should be_an_instance_of Tagtical::TagList::TagValue
+    end
+  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.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 be able to add a hash" do
+    @tag_list.add("crazy" => 0.45, "narly" => 5.4)
+    @tag_list.should include("crazy", "narly")
+    @tag_list.detect { |t| t=="crazy" }.relevance.should == 0.45
+  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
+  end
+
+  its(:to_s) { should == "awesome, radical" }
+
+  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
+
+  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
+
+  describe "TagValue" do
+    before do
+      @tag_value = Tagtical::TagList::TagValue.new("sweetness", @relevance = 3.2)
+    end
+    subject { @tag_value }
+
+    its(:relevance) { should == @relevance }
+
+  end
+  
+end