gnugeek-is_taggable 0.0.1

data/CHANGELOG

@@ -0,0 +1,6 @@
+[master]
+
+*
+
+[0.0.1]
+* (05 Feb 2009) Gemified

data/README.rdoc

@@ -0,0 +1,85 @@
+= Is Taggable
+
+Rails plugin for working easily with tagging stuff in your application.
+
+Stores _tags_ in separate table and implements a polymorphic interface _taggable_ for attaching tags to ActiveRecord objects.
+
+Comes with a generator for database migrations and autocompleting tags in forms (with the <tt>--with-autocompleter</tt> option)
+
+See examples below.
+
+
+== Usage
+
+Install the plugin by cloning the repository and running
+
+    script/generate is_taggable .
+    
+To generate migration tables. The dot _is_ necessary.
+
+
+== Example
+
+In your _Article_ model:
+
+    class Article < ActiveRecord::Base
+      is_taggable :tags
+    end
+
+Then:
+
+    >> Tag.all
+      Tag Load (0.3ms)   SELECT * FROM `tags` 
+    => [#<Tag id: 1, name: "one", kind: "tag", ...>, #<Tag id: 2, name: "two", kind: "tag", ...>]
+
+    >> a = Article.first
+      Article Load (0.4ms)   SELECT * FROM `articles` LIMIT 1
+    => #<Article id: 1, title: ....>
+
+    >> a.tag_list
+      Article Load (0.4ms)   SELECT * FROM `articles` LIMIT 1
+      Tag Load (0.5ms)   SELECT `tags`.* FROM `tags` INNER JOIN taggings ON tags.id = taggings.tag_id WHERE ((`taggings`.taggable_type = 'Article') AND (`taggings`.taggable_id = 1)) AND (`tags`.`kind` = 'tag') 
+    => ["one"]
+
+    >> a.tag_list = ['one', 'two']
+    => ["one", "two"]
+
+    >> a.save
+      ...
+      Tagging Create (0.3ms)   INSERT INTO `taggings` (`updated_at`, `tag_id`, `taggable_type`, `taggable_id`, `created_at`) VALUES('2008-12-18 16:51:50', 2, 'Article', 1, '2008-12-18 16:51:50')
+      ...
+    => true
+    
+    >> Article.find_all_tagged_with 'one'
+      Article Load (1.9ms)   SELECT * FROM `articles` 
+      Tagging Load (66.6ms)   SELECT `taggings`.* FROM `taggings` WHERE (`taggings`.`taggable_id` IN (1,2,3) and `taggings`.`taggable_type` = 'Article') 
+      Tag Load (0.4ms)   SELECT * FROM `tags` WHERE (`tags`.`id` IN (1,2)) 
+    => [#<Article id: 1, title: "Lorem...", ...>]
+
+    >> Article.find_all_tagged_with ['one', 'two']
+      Article Load (2.1ms)   SELECT * FROM `articles` 
+      Tagging Load (2.9ms)   SELECT `taggings`.* FROM `taggings` WHERE (`taggings`.`taggable_id` IN (1,2,3) and `taggings`.`taggable_type` = 'Article') 
+      Tag Load (0.3ms)   SELECT * FROM `tags` WHERE (`tags`.`id` IN (1,2)) 
+    => [#<Article id: 1, title: "Lorem...", ...>]
+
+    >> Article.first.find_tagged_alike
+      SQL (0.5ms)   SELECT count(*) AS count_all FROM `tags` INNER JOIN taggings ON tags.id = taggings.tag_id WHERE ((`taggings`.taggable_type = 'Article') AND (`taggings`.taggable_id = 1)) 
+      Article Load (1.5ms)   SELECT * FROM `articles` WHERE (id != '1') 
+      Tagging Load (2.9ms)   SELECT `taggings`.* FROM `taggings` WHERE (`taggings`.`taggable_id` IN (1,2,3) and `taggings`.`taggable_type` = 'Article') 
+      Tag Load (0.3ms)   SELECT * FROM `tags` WHERE (`tags`.`id` IN (1,2,3)) 
+      Tag Load (0.4ms)   SELECT `tags`.* FROM `tags` INNER JOIN taggings ON tags.id = taggings.tag_id WHERE ((`taggings`.taggable_type = 'Article') AND (`taggings`.taggable_id = 1)) AND (`tags`.`kind` = 'tag') 
+    => [#<Article id: 201, title: "Another...", ...>]
+    
+
+When you run generator with the <tt>--with-autocompleter</tt> option, also a controller and view are generated. 
+You can use it like this then:
+
+    <% form_for(@my_object) do |f| %>
+      <%= f.text_area :tag_list %>
+      <%= taggable_autocompleter_for('my_object_tag_list') %>
+    <% end %>
+
+Tags matching input will be then added to your input/textarea. Assumes you separate tags with commas (,).
+
+
+Copyright (c) 2008 James Golick & Karel Minarik, released under the MIT license

data/generators/is_taggable/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Generate migrations for +is_taggable+ plugin
+
+Example:
+    ./script/generate is_taggable .
+
+    This will create:
+        db/migrate/XXXXXXXXXX_create_taggables.rb
+
+		If the --with-autocomplete options is passed, it will generate this as well:
+				create  app/controllers/taggable_controller.rb
+				create  app/views/taggable
+				create  app/views/taggable/autocomplete.js.erb
+				create  app/helpers/taggable_helper.rb

data/generators/is_taggable/is_taggable_generator.rb

@@ -0,0 +1,35 @@
+class IsTaggableGenerator < Rails::Generator::NamedBase
+
+  def manifest
+    record do |m|
+
+      # * Generate migration
+      m.migration_template 'migration.rb', "db/migrate", {
+        :assigns => { :migration_name => 'CreateTaggables' },
+        :migration_file_name => 'create_taggables'
+      }
+
+      # * Generate controller and view for Scriptaculous autocompleter
+      if options[:with_autocompleter]
+        m.file 'taggable_controller.rb', 'app/controllers/taggable_controller.rb', :collision => :skip
+        m.directory 'app/views/taggable'
+        m.file 'autocomplete.js.erb', 'app/views/taggable/autocomplete.js.erb', :collision => :skip
+      end
+
+    end
+  end
+
+  private
+
+  def banner
+    "\nUsage: script/generate is_taggable . [options]\n\n"
+  end
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--with-autocompleter",
+      "Generate controller and view for autocompleting tags") { |v| options[:with_autocompleter] = v }
+  end
+
+end

data/generators/is_taggable/templates/autocomplete.js.erb

@@ -0,0 +1,5 @@
+<ul>
+  <%- @autocomplete_tags.each do |tag| -%>
+  <li id="<%= tag.id %>"><%= tag.name %></li>
+  <%- end -%>
+</ul>

data/generators/is_taggable/templates/migration.rb

@@ -0,0 +1,31 @@
+# = Migration for the is_taggable plugin
+# 
+class CreateTaggables < ActiveRecord::Migration
+  def self.up
+
+    create_table :tags do |t|
+      t.string :name, :default => ''
+      t.string :kind, :default => ''
+      t.timestamps
+    end
+
+    create_table :taggings do |t|
+      t.integer :tag_id
+      # Interface +taggable+
+      t.string  :taggable_type
+      t.integer :taggable_id
+      t.timestamps
+    end
+
+    # Add indices
+    add_index :tags, :name
+    add_index :tags, [:name, :kind], :name => "name_and_kind"
+    add_index :taggings, [:taggable_type, :taggable_id], :name => "taggable_interface_index"
+
+  end
+
+  def self.down
+    drop_table :tags
+    drop_table :taggings
+  end
+end

data/generators/is_taggable/templates/taggable_controller.rb

@@ -0,0 +1,15 @@
+# = Return autocomplete results for the Tag class from is_taggable plugin
+# Add before_filters, copy it somewhere else, etc, as you like.
+# Just don't forget the <tt>app/views/taggable/autocomplete.js.erb</tt> file as well
+# 
+class TaggableController < ApplicationController
+
+  # Return autocomplete results
+  def autocomplete
+    @autocomplete_tags = Tag.all( :conditions => ['name LIKE ?', "#{params[:autocomplete_tags]}%"], :order => 'name', :limit => 50)
+    respond_to do |format|
+      format.js { render :template => "autocomplete", :layout => false }
+    end
+  end
+
+end

data/generators/is_taggable/templates/taggable_helper.rb

@@ -0,0 +1,32 @@
+# = Encapsulating Script.aculo.us <tt>Ajax.Autocompleter</tt> method
+# Over-ride the CSS in your stylesheets with a more specific selector, like <tt>.my-page div.autocomplete { color: red }</tt>
+
+module TaggableHelper
+
+  # Returns <tt><div></tt>, CSS and JavaScript code needed for autocompleting tags
+  # See http://github.com/madrobby/scriptaculous/wikis/ajax-autocompleter
+  def taggable_autocompleter_for(field_name, options={})
+    authenticity_token_param = protect_against_forgery? ? "authenticity_token=#{form_authenticity_token}" : '' # Beware of tests :)
+    autocompleter=<<HTML
+    <style type="text/css" media="screen">
+      div.autocomplete {
+        position:absolute; width:250px;
+        background-color: white;
+        border:1px solid #888; margin:0; padding:0; }
+      div.autocomplete ul { list-style-type:none; margin:0; padding:0; }
+      div.autocomplete ul li.selected { background-color: #ecf4fe;}
+      div.autocomplete ul li { display: block; margin: 0; padding: 0.2em; height: 1em; cursor: pointer; }
+    </style>
+     <div id="#{field_name}_autocomplete_choices" class="autocomplete"></div>
+     <script type="text/javascript">
+       new Ajax.Autocompleter("#{field_name}",
+                              "#{field_name}_autocomplete_choices",
+                              "/taggable/autocomplete?#{authenticity_token_param}",
+                              { paramName: 'autocomplete_tag', tokens: ',' }
+                             );
+     </script>
+HTML
+    return autocompleter
+  end
+
+end

data/init.rb

@@ -0,0 +1 @@
+require 'is_taggable'

data/lib/is_taggable.rb

@@ -0,0 +1,112 @@
+path = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH << path unless $LOAD_PATH.include?(path)
+require 'tag'
+require 'tagging'
+
+module IsTaggable
+  class TagList < Array
+    def to_s
+      join(', ')
+    end
+  end
+
+  module ActiveRecordExtension
+    def is_taggable(*kinds)
+      class_inheritable_accessor :tag_kinds
+      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
+        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
+        
+        # Find all records tagged with a +'tag'+ or ['tag one', 'tag two']
+        # Pass either String for single tag or Array for multiple tags
+        # TODO : Add option all x any
+        def self.find_all_tagged_with(tag_or_tags, conditions=[])
+          return [] if tag_or_tags.nil? || tag_or_tags.empty?
+          case tag_or_tags
+          when Array, IsTaggable::TagList
+            all(:include => ['tags', 'taggings'], :conditions => conditions ).select { |record| tag_or_tags.all? { |tag| record.tags.map(&:name).include?(tag) } } || []
+          else
+            all(:include => ['tags', 'taggings'], :conditions => conditions).select { |record| record.tags.map(&:name).include?(tag_or_tags)  } || []
+          end
+        end
+        
+        def self.find_all_ids_tagged_with(tag_or_tags, conditions=[])
+          find_all_tagged_with(tag_or_tags, conditions).map(&:id)
+        end
+        
+        # Find all records tagged with the same tags as current object,
+        # *excluding* the current object (for things like "Related articles")
+        # TODO : Add option all x any
+        # TODO : Remove hardcoded +tag_list+ kind of tags, could be any kind
+        def find_tagged_alike
+          return [] if self.tags.empty?
+          self.class.all(:include => ['tags', 'taggings'],
+                         :conditions => ["id != '?'", self.id]).
+                         select { |record| self.tag_list.all? { |tag| record.tags.map(&:name).include?(tag) } } || []
+        end
+
+      end
+    end
+
+    module InstanceMethods
+      def set_tag_list(kind, list)
+        list.gsub!(/ *, */,',') unless list.is_a?(Array)
+        tag_list = TagList.new(list.is_a?(Array) ? list : list.split(','))
+        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,20 @@
+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
+
+  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} } }
+  named_scope :unique_by_name_for_kind,  lambda { |kind| { :conditions => {:kind => kind}, :group => 'id,name,kind,created_at,updated_at' } }
+  
+  def self.unique_tag_list_by_kind(kind)
+    unique_by_name_for_kind('available_service').map(&:name)
+  end
+end

data/lib/tagging.rb

@@ -0,0 +1,3 @@
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+end

data/test/is_taggable_test.rb

@@ -0,0 +1,59 @@
+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 ["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 2 do
+    p = Post.new :language_list => "english, french"
+    p.save!
+    p.tags.length
+  end
+end

data/test/tag_test.rb

@@ -0,0 +1,36 @@
+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,8 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+Expectations do
+  expect Tag do
+    t = Tagging.new :tag => Tag.new(:name => 'some_tag')
+    t.tag
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+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 :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, :unique
+end
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: gnugeek-is_taggable
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- giraffesoft,Karmi,Brian Knox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-04 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Extends activerecord to make models taggable
+email: gnutse@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG
+files: 
+- init.rb
+- README.rdoc
+- CHANGELOG
+- lib/is_taggable.rb
+- lib/tagging.rb
+- lib/tag.rb
+- generators/is_taggable/is_taggable_generator.rb
+- generators/is_taggable/USAGE
+- generators/is_taggable/templates/autocomplete.js.erb
+- generators/is_taggable/templates/migration.rb
+- generators/is_taggable/templates/taggable_controller.rb
+- generators/is_taggable/templates/taggable_helper.rb
+has_rdoc: true
+homepage: http://github.com/gnugeek/is_taggable/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+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 isn't ugly
+test_files: 
+- test/is_taggable_test.rb
+- test/tagging_test.rb
+- test/tag_test.rb
+- test/test_helper.rb