acts_as_organizable 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in acts_as_organizable.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/acts_as_organizable.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "acts_as_organizable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "acts_as_organizable"
+  s.version     = ActsAsOrganizable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mike Hansen"]
+  s.email       = ["mhansen@pathlightmedia.com"]
+  s.summary     = %q{Simpler tagging.}
+
+  s.rubyforge_project = "acts_as_organizable"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/init.rb

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

data/lib/acts_as_organizable.rb

@@ -0,0 +1,133 @@
+# To find a person's available tags for the object we go through owned_tags, which pulls uniq items from join table
+
+require "acts_as_organizable/version"
+path = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH << path unless $LOAD_PATH.include?(path)
+require 'acts_as_organizable/tag'
+require 'acts_as_organizable/tagging'
+require 'acts_as_organizable/core_ext/string'
+
+module ActsAsOrganizable
+  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 acts_as_organizable(*kinds)
+      # Example: acts_as_organizable :tags, :languages
+      class_inheritable_accessor :tag_kinds
+      self.tag_kinds = kinds.map(&:to_s).map(&:singularize)
+      self.tag_kinds << :tag if kinds.empty?
+
+      include ActsAsOrganizable::TaggableMethods
+    end
+    
+    def acts_as_tagger(opts={})
+      class_eval do
+        has_many :owned_tags, :through => :owned_taggings, :source => :tag, :class_name => "Tag", :uniq => true
+        has_many :owned_taggings, opts.merge(:as => :owner, :dependent => :destroy, :include => :tag, :class_name => "Tagging")
+      end
+    end
+  end
+
+  module TaggableMethods
+    def self.included(klass)
+      klass.class_eval do
+        include ActsAsOrganizable::TaggableMethods::InstanceMethods
+
+        has_many :taggings, :as => :taggable, :dependent => :destroy
+        has_many :tags, :through => :taggings
+        before_save :cache_tags
+
+        tag_kinds.each do |k|
+          # Example: language gets passed in and becomes language_list
+          define_method("#{k}_list") { get_tag_list(k) }
+          # this is expexting language_list = "spanish, italian" 
+          define_method("#{k}_list=") { |new_list| set_tag_list(k, new_list.clean_up_tags) }
+        end
+      end
+    end
+
+    module InstanceMethods
+      def set_tag_list(kind, list)
+        tag_list = TagList.new(list) # ["spanish", "italian"]
+        # @language_list = ["spanish", "italian"]
+        instance_variable_set(tag_list_name_for_kind(kind), tag_list)
+      end
+
+      def get_tag_list(kind)
+        # set instance variable unless it exists
+        set_tag_list(kind, tags.of_kind(kind).map(&:name)) if tag_list_instance_variable(kind).nil?
+        tag_list_instance_variable(kind)
+      end
+      
+      def save_with_tags(tag_owner = nil)
+        self.save # save the parent object first
+        tag_kinds.each do |tag_kind|
+          delete_unused_tags(tag_kind)
+          create_taggings(tag_kind, tag_owner)
+        end
+      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 delete_unused_tags(tag_kind)
+          # if the new list does not have the previous tag, kill the old tag associated to the object
+          tags.of_kind(tag_kind).each { |t| tags.delete(t) unless get_tag_list(tag_kind).include?(t.name) }
+        end
+        
+        def create_taggings(tag_kind, tag_owner)
+          # get tags passed in, such as ["russian", "english"] from @language_list
+          previous_tags = tags.of_kind(tag_kind).map(&:name)
+          get_tag_list(tag_kind).each do |tag_name|
+            tag = Tag.find_or_create_with_name_like_and_kind(tag_name, tag_kind) unless previous_tags.include?(tag_name)
+            if tag_owner
+              # save taggings to tag_owner passed in explicitly
+              # NOTE: this includes visitors - they must be passed in explicitly 
+              taggings.create!(:tag_id => tag.id, :owner => tag_owner)
+            # look for user or owner of object to attach to tagging
+            elsif user = (self.respond_to?(:owner) && self.try(:owner)) || (self.respond_to?(:user) && self.try(:user))
+              taggings.create!(:tag_id => tag.id, :owner => user)
+            else
+              raise "No user asociated to tagging. Please specify one."
+            end
+          end
+        end
+        
+        def cache_tags
+          tag_kinds.each do |tag_kind|
+            t = tag_kind.to_s
+            if self.class.column_names.include?("cached_#{t}_list")
+              list = get_tag_list(tag_kind).join(", ")
+              self["cached_#{t}_list"] = list
+            else
+              logger.info("
+                ************************************************************************************************
+                You should consider adding cached_#{t}_list to your #{t} for performance benefits!
+                ************************************************************************************************
+                ")
+            end
+          end
+        end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, ActsAsOrganizable::ActiveRecordExtension)

data/lib/acts_as_organizable/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def clean_up_tags
+    gsub(/,/, '').gsub(' ', ', ')
+  end
+end

data/lib/acts_as_organizable/tag.rb

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

data/lib/acts_as_organizable/tagging.rb

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

data/lib/acts_as_organizable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsOrganizable
+  VERSION = "0.0.1"
+end

data/lib/generators/acts_as_organizable/categorizable_migration_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators'
+
+class ActsAsOrganizable::CategorizableMigrationGenerator < Rails::Generators::Base
+  def self.source_root
+    # source root must return path to where templates are stored
+     @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+  
+  
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_migration_file
+    template 'categorizable_migration.rb', "db/migrate/#{Time.now.utc.strftime("%Y%m%d%H%M%S")}_create_categorizables.rb"
+  end
+  
+end

data/lib/generators/acts_as_organizable/taggable_migration_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators'
+
+class ActsAsOrganizable::TaggableMigrationGenerator < Rails::Generators::Base
+  def self.source_root
+    # source root must return path to where templates are stored
+     @source_root ||= File.join(File.dirname(__FILE__), '../templates')
+  end
+  
+  
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_migration_file
+    template 'create_taggables.rb', "db/migrate/#{Time.now.utc.strftime("%Y%m%d%H%M%S")}_create_taggables.rb"
+  end
+  
+end

data/lib/generators/templates/create_taggables.rb

@@ -0,0 +1,26 @@
+class CreateTaggables < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :name
+      t.string :kind
+      t.timestamps
+    end
+
+    create_table :taggings do |t|
+      t.integer :tag_id
+      t.references :taggable, :polymorphic => true
+      t.references :owner, :polymorphic => true
+      t.timestamps
+    end
+    
+    add_index :tags, [:name, :kind]
+    add_index :taggings, [:tag_id]  
+    add_index :taggings, [:taggable_id, :taggable_type]
+    add_index :taggings, [:owner_id, :owner_type]
+  end
+  
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_organizable
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mike Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-28 00:00:00 Z
+dependencies: []
+
+description: 
+email: 
+- mhansen@pathlightmedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- acts_as_organizable.gemspec
+- init.rb
+- lib/acts_as_organizable.rb
+- lib/acts_as_organizable/core_ext/string.rb
+- lib/acts_as_organizable/tag.rb
+- lib/acts_as_organizable/tagging.rb
+- lib/acts_as_organizable/version.rb
+- lib/generators/acts_as_organizable/categorizable_migration_generator.rb
+- lib/generators/acts_as_organizable/taggable_migration_generator.rb
+- lib/generators/templates/create_taggables.rb
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: acts_as_organizable
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Simpler tagging.
+test_files: []
+