bdimcheff-is_taggable 0.1.0

data/README.rdoc

@@ -0,0 +1,62 @@
+= is_taggable
+
+At last, a short and sweet tagging implementation that you can easily modify and extend.
+
+Most of the plugins out there are on steroids or messing directly with SQL, a known gateway drug.
+
+We wanted a more sober plugin that would handle new functionality without breaking a sweat. Some plugins had minimal or no tests *gasp*. They were so messed up that operating would likely cause internal bleeding.
+
+So, we crafted the plugin we needed with the functionality we were looking for: tag kinds. It's small and healthy. So, it should be a good base to build on.
+
+== Usage
+
+After generating the migration:
+
+  $ script/generate is_taggable_migration
+  $ rake db:migrate
+
+All you need is the 'is_taggable' declaration in your models:
+
+  class User < ActiveRecord::Base
+    is_taggable :tags, :languages
+  end
+  
+In your forms, add a text fields for "tag_list" and/or "language_list" (matching the example model above):
+
+  <%= f.text_field :tag_list %>
+
+Calling is_taggable with any arguments defaults to a tag_list. Instantiating our polyglot user is easy:
+
+  User.new :tag_list => "rails, giraffesoft", :language_list => "english, french, spanish, latin, esperanto, tlhIngan Hol"
+
+A comma is the default tag separator, but this can be easily changed:
+
+  IsTaggable::TagList.delimiter = " "
+
+You can also set options on the tags.  The only option currently supported is :fixed.  If you set :fixed => true, tags will not be added to a taggable model unless you explicitly create a Tag record.  This is for tagging with fixed vocabularies.
+
+  class User < ActiveRecord::Base
+    is_taggable :tags, :fixed => true
+  end
+
+== Get it
+
+  $ sudo gem install bdimcheff-is_taggable -s http://gems.github.com
+  
+As a rails gem dependency:
+
+  config.gem 'bdimcheff-is_taggable', :lib => 'is_taggable'
+
+Or get the source from github:
+
+  $ git clone git://github.com/bdimcheff/is_taggable.git
+
+(or fork it at http://github.com/bdimcheff/is_taggable)
+
+== Credits
+
+is_taggable was created, and is maintained by Daniel Haran and James Golick.  Brandon Dimcheff added fixed tag vocabulary support.
+
+== License
+
+is_taggable is available under the MIT License

data/VERSION.yml

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

data/generators/is_taggable_migration/is_taggable_migration_generator.rb

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

data/generators/is_taggable_migration/templates/migration.rb

@@ -0,0 +1,24 @@
+class IsTaggableMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :name, :default => ''
+      t.string :kind, :default => '' 
+    end
+
+    create_table :taggings do |t|
+      t.integer :tag_id
+
+      t.string  :taggable_type, :default => ''
+      t.integer :taggable_id
+    end
+    
+    add_index :tags,     [:name, :kind]
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type]
+  end
+  
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

data/lib/is_taggable.rb

@@ -0,0 +1,103 @@
+path = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH << path unless $LOAD_PATH.include?(path)
+require 'tag'
+require 'tagging'
+
+module IsTaggable
+  class TagList < Array
+    cattr_accessor :delimiter
+    @@delimiter = ','
+    
+    def initialize(list)
+      list = list.is_a?(Array) ? list : list.split(@@delimiter).collect(&:strip).reject(&:blank?)
+      super
+    end
+    
+    def to_s
+      join(', ')
+    end
+  end
+
+  module ActiveRecordExtension
+    def is_taggable(*kinds)
+      class_inheritable_accessor :tag_kinds, :tag_options
+      default_options = { :fixed => false }
+      self.tag_options = if kinds[-1].is_a?(Hash)
+                           default_options.merge(kinds.delete_at(-1))
+                         else
+                           default_options
+                         end
+      self.tag_kinds = kinds.map(&:to_s).map(&:singularize)
+      self.tag_kinds << :tag if kinds.empty?
+
+      include IsTaggable::TaggableMethods
+    end
+  end
+
+  module TaggableMethods
+    def self.included(klass)
+      klass.class_eval do
+        include IsTaggable::TaggableMethods::InstanceMethods
+
+        has_many   :taggings, :as      => :taggable, :dependent => :destroy
+        has_many   :tags,     :through => :taggings
+        after_save :save_tags
+
+        tag_kinds.each do |k|
+          define_method("#{k}_list")  { get_tag_list(k) }
+          define_method("#{k}_list=") { |new_list| set_tag_list(k, new_list) }
+        end
+      end
+    end
+
+    module InstanceMethods
+      def set_tag_list(kind, list)
+        tag_list = TagList.new(list)
+        instance_variable_set(tag_list_name_for_kind(kind), tag_list)
+      end
+
+      def get_tag_list(kind)
+        set_tag_list(kind, tags.of_kind(kind).map(&:name)) if tag_list_instance_variable(kind).nil?
+        tag_list_instance_variable(kind)
+      end
+
+      protected
+        def tag_list_name_for_kind(kind)
+          "@#{kind}_list"
+        end
+        
+        def tag_list_instance_variable(kind)
+          instance_variable_get(tag_list_name_for_kind(kind))
+        end
+
+        def save_tags
+          tag_kinds.each do |tag_kind|
+            delete_unused_tags(tag_kind)
+            add_new_tags(tag_kind)
+            set_tag_list(tag_kind, tags.of_kind(tag_kind).map(&:name))
+          end
+
+          taggings.each(&:save)
+        end
+        
+        def delete_unused_tags(tag_kind)
+          tags.of_kind(tag_kind).each { |t| tags.delete(t) unless get_tag_list(tag_kind).include?(t.name) }
+        end
+
+        def add_new_tags(tag_kind)
+          tag_names = tags.of_kind(tag_kind).map(&:name)
+          get_tag_list(tag_kind).each do |tag_name|
+            if tag_options[:fixed]
+              tag = Tag.with_name_like_and_kind(tag_name, tag_kind) unless tag_names.include?(tag_name)
+            else
+              tag = Tag.find_or_initialize_with_name_like_and_kind(tag_name, tag_kind) unless tag_names.include?(tag_name)
+            end
+
+            tags << tag if tag
+          end
+        end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, IsTaggable::ActiveRecordExtension)

data/lib/tag.rb

@@ -0,0 +1,15 @@
+class Tag < ActiveRecord::Base
+  class << self
+    def find_or_initialize_with_name_like_and_kind(name, kind)
+      with_name_like_and_kind(name, kind).first || new(:name => name, :kind => kind)
+    end
+  end
+
+  has_many :taggings, :dependent => :destroy
+
+  validates_presence_of :name
+  validates_uniqueness_of :name, :scope => :kind
+
+  named_scope :with_name_like_and_kind, lambda { |name, kind| { :conditions => ["name like ? AND kind = ?", name, kind] } }
+  named_scope :of_kind,                 lambda { |kind| { :conditions => {:kind => kind} } }
+end

data/lib/tagging.rb

@@ -0,0 +1,4 @@
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :taggable, :polymorphic => true
+end

data/test/is_taggable_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+Expectations do
+  expect Tag do
+    Post.new.tags.build
+  end
+
+  expect Tagging do
+    Post.new.taggings.build
+  end
+  
+  expect ["is_taggable", "has 'tags' by default"] do
+    n = Comment.new :tag_list => "is_taggable, has 'tags' by default"
+    n.tag_list
+  end
+  
+  expect ["one", "two"] do
+    IsTaggable::TagList.delimiter = " "
+    n = Comment.new :tag_list => "one two"
+    IsTaggable::TagList.delimiter = "," # puts things back to avoid breaking following tests
+    n.tag_list
+  end
+
+  expect ["something cool", "something else cool"] do
+    p = Post.new :tag_list => "something cool, something else cool"
+    p.tag_list
+  end
+
+  expect ["something cool", "something new"] do
+    p = Post.new :tag_list => "something cool, something else cool"
+    p.save!
+    p.tag_list = "something cool, something new"
+    p.save!
+    p.tags.reload
+    p.instance_variable_set("@tag_list", nil)
+    p.tag_list
+  end
+
+  expect ["english", "french"] do
+    p = Post.new :language_list => "english, french"
+    p.save!
+    p.tags.reload
+    p.instance_variable_set("@language_list", nil)
+    p.language_list
+  end
+
+  expect ["english", "french"] do
+    p = Post.new :language_list => "english, french"
+    p.language_list
+  end
+
+  expect "english, french" do
+    p = Post.new :language_list => "english, french"
+    p.language_list.to_s
+  end
+  
+  # added - should clean up strings with arbitrary spaces around commas
+  expect ["spaces","should","not","matter"] do
+    p = Post.new
+    p.tag_list = "spaces,should,  not,matter"
+    p.save!
+    p.tags.reload
+    p.tag_list
+  end
+
+  expect ["blank","topics","should be ignored"] do
+    p = Post.new
+    p.tag_list = "blank, topics, should be ignored, "
+    p.save!
+    p.tags.reload
+    p.tag_list
+  end
+
+  expect 2 do
+    p = Post.new :language_list => "english, french"
+    p.save!
+    p.tags.length
+  end
+
+  expect ["foo", "bar"] do
+    Tag.create(:name => 'foo', :kind => 'category')
+    Tag.create(:name => 'bar', :kind => 'category')
+
+    p = Page.new
+    p.category_list = "foo, bar, baz"
+    p.save!
+    p.tags.reload
+    p.category_list
+  end
+end

data/test/tag_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+Expectations do
+  expect Tagging do
+    Tag.new.taggings.proxy_reflection.klass
+  end
+
+  expect Tag.new(:name => "duplicate").not.to.be.valid? do
+    Tag.create!(:name => "duplicate")
+  end
+
+  expect Tag.new(:name => "not dup").to.be.valid? do
+    Tag.create!(:name => "not dup", :kind => "something")
+  end
+
+  expect Tag.new.not.to.be.valid?
+  expect String do
+    t = Tag.new
+    t.valid?
+    t.errors[:name]
+  end
+
+  expect Tag.create!(:name => "iamawesome", :kind => "awesomestuff") do
+    Tag.find_or_initialize_with_name_like_and_kind("iaMawesome", "awesomestuff")
+  end
+
+  expect true do
+    Tag.create!(:name => "iamawesome", :kind => "stuff")
+    Tag.find_or_initialize_with_name_like_and_kind("iaMawesome", "otherstuff").new_record?
+  end
+
+  expect Tag.create!(:kind => "language", :name => "french") do
+    Tag.of_kind("language").first
+  end
+end

data/test/tagging_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+Expectations do
+  expect Tag do
+    t = Tagging.new :tag => Tag.new(:name => 'some_tag')
+    t.tag
+  end
+  
+  expect Post do
+    t = Tagging.new :taggable => Post.new
+    t.taggable
+  end
+  
+  expect 2 do
+    2.times { Post.create(:tag_list => "interesting") }
+    Tag.find_by_name("interesting").taggings.count
+  end
+  
+  expect 1 do
+    p1 = Post.create(:tag_list => "witty")
+    p2 = Post.create(:tag_list => "witty")
+    
+    p2.destroy
+    Tag.find_by_name("witty").taggings.count
+  end  
+
+  expect 2 do
+    p1 = Post.create(:tag_list => "smart, pretty")
+    p1.taggings.count
+  end
+
+  expect 1 do
+    p1 = Post.create(:tag_list => "mildly, inappropriate")
+
+    Tag.find_by_name('inappropriate').destroy
+    p1.taggings.count
+  end  
+end

data/test/test_helper.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'activerecord'
+require File.dirname(__FILE__)+'/../lib/is_taggable'
+require 'expectations'
+require 'logger'
+
+ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('sqlite3')
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :comments do |t|
+  end
+  
+  create_table :posts do |t|
+    t.string  :title, :default => ''
+  end
+
+  create_table :pages do |t|
+    t.string :title, :default => ''
+  end
+
+  create_table :tags do |t|
+    t.string :name, :default => ''
+    t.string :kind, :default => '' 
+  end
+
+  create_table :taggings do |t|
+    t.integer :tag_id
+
+    t.string  :taggable_type, :default => ''
+    t.integer :taggable_id
+  end
+end
+
+class Post < ActiveRecord::Base
+  is_taggable :tags, :languages
+end
+
+class Comment < ActiveRecord::Base
+  is_taggable
+end
+
+class Page < ActiveRecord::Base
+  is_taggable :categories, :fixed => true
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: bdimcheff-is_taggable
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Haran
+- James Golick
+- GiraffeSoft Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-16 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: chebuctonian@mgmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- generators/is_taggable_migration
+- generators/is_taggable_migration/is_taggable_migration_generator.rb
+- generators/is_taggable_migration/templates
+- generators/is_taggable_migration/templates/migration.rb
+- lib/is_taggable.rb
+- lib/tag.rb
+- lib/tagging.rb
+- test/is_taggable_test.rb
+- test/tag_test.rb
+- test/tagging_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/giraffesoft/is_taggable
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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.2.0
+signing_key: 
+specification_version: 2
+summary: tagging that doesn't want to be on steroids. it's skinny and happy to stay that way.
+test_files: []
+