is_taggable_rails3 0.3.0

data/README.rdoc

@@ -0,0 +1,56 @@
+= 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 = " "
+
+== Get it
+
+  $ sudo gem install is_taggable
+  
+As a rails gem dependency:
+
+  config.gem 'is_taggable'
+
+Or get the source from github:
+
+  $ git clone git://github.com/giraffesoft/is_taggable.git
+
+(or fork it at http://github.com/giraffesoft/is_taggable)
+
+== Credits
+
+is_taggable was created, and is maintained by Daniel Haran and James Golick.
+
+== 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,92 @@
+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(@@delimiter)
+    end
+  end
+
+  module ActiveRecordExtension
+    def is_taggable(*kinds)
+      if respond_to?(:class_attribute)
+        class_attribute :tag_kinds
+      else
+        class_inheritable_accessor :tag_kinds
+      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)
+          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| 
+            tags << Tag.find_or_initialize_with_name_like_and_kind(tag_name, tag_kind) unless tag_names.include?(tag_name)
+          end
+        end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, IsTaggable::ActiveRecordExtension)

data/lib/tag.rb

@@ -0,0 +1,24 @@
+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
+
+  if Tag.respond_to? :scope
+    scope :with_name_like_and_kind, lambda {|name, kind|
+      where(:name => name.to_s.downcase, :kind => kind.to_s.singularize)
+    }
+    scope :of_kind, lambda {|kind| where(:kind => kind.to_s.singularize) }
+  else
+    named_scope :with_name_like_and_kind, lambda {|name, kind|
+      { :conditions => {:name => name.to_s.downcase, :kind => kind.to_s.singularize} }
+    }
+    named_scope :of_kind, lambda {|kind| { :conditions => {:kind => kind} } }
+  end
+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,83 @@
+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 1 do
+    Tag.with_name_like_and_kind('english', :languages).count
+  end
+end

data/test/tag_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+Expectations do
+  expect Tagging do
+    t = Tag.new
+    if t.respond_to?(:association)
+      t.association(:taggings).reflection.klass
+    else
+      t.taggings.proxy_reflection.klass
+    end
+  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?
+    m = t.errors[:name]
+    m.is_a?(Array) ? m.first : m
+  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,41 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'active_record'
+require '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 :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

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: is_taggable_rails3
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Daniel Haran
+- James Golick
+- GiraffeSoft Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-10 00:00:00 Z
+dependencies: []
+
+description: ""
+email: chebuctonian@mgmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- generators/is_taggable_migration/is_taggable_migration_generator.rb
+- 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
+homepage: http://github.com/sbeam/is_taggable_rails3
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+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: []
+