acts-as-taggable-on-padrino 0.0.1

data/lib/acts_as_taggable_on_padrino/taggable/ownership.rb

@@ -0,0 +1,104 @@
+module ActsAsTaggableOn::Taggable
+  module Ownership
+    def self.included(base)
+      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
+      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
+
+      base.class_eval do
+        after_save :save_owned_tags
+      end
+
+      base.initialize_acts_as_taggable_on_ownership
+    end
+
+    module ClassMethods
+      def acts_as_taggable_on(*args)
+        initialize_acts_as_taggable_on_ownership
+        super
+      end
+
+      def initialize_acts_as_taggable_on_ownership
+        tag_types.each do |tag_type|
+          class_eval %(
+            def #{tag_type}_from(owner)
+              owner_tag_list_on(owner, '#{tag_type}')
+            end
+          )
+        end
+      end
+    end
+
+    module InstanceMethods
+      def owner_tags_on(owner, context)
+        if owner
+          base_tags.where(:taggings => {:context => context.to_s, :tagger_id => owner.id, :tagger_type => owner.class.to_s})
+        else
+          base_tags.where(:taggings => {:context => context.to_s})
+        end
+      end
+
+      def cached_owned_tag_list_on(context)
+        variable_name = "@owned_#{context}_list"
+        cache = instance_variable_get(variable_name) || instance_variable_set(variable_name, {})
+      end
+
+      def owner_tag_list_on(owner, context)
+        add_custom_context(context)
+
+        cache = cached_owned_tag_list_on(context)
+        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
+
+        cache[owner] ||= ActsAsTaggableOn::Taggable::TagList.new(*owner_tags_on(owner, context).names)
+      end
+
+      def set_owner_tag_list_on(owner, context, new_list)
+        add_custom_context(context)
+
+        cache = cached_owned_tag_list_on(context)
+        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
+
+        cache[owner] = ActsAsTaggableOn::Taggable::TagList.from(new_list)
+      end
+
+      def reload(*args)
+        self.class.tag_types.each do |context|
+          instance_variable_set("@owned_#{context}_list", nil)
+        end
+
+        super
+      end
+
+      def save_owned_tags
+        tagging_contexts.each do |context|
+          cached_owned_tag_list_on(context).each do |owner, tag_list|
+            # Find existing tags or create non-existing tags:
+            tag_list = acts_as_taggable_on_tag_model.find_or_create_all_with_like_by_name(tag_list.uniq)
+
+            owned_tags = owner_tags_on(owner, context)
+            old_tags   = owned_tags - tag_list
+            new_tags   = tag_list   - owned_tags
+
+            # Find all taggings that belong to the taggable (self), are owned by the owner,
+            # have the correct context, and are removed from the list.
+            old_taggings = acts_as_taggable_on_tagging_model.where(
+              :taggable_id => id, :taggable_type => self.class.base_class.to_s,
+              :tagger_type => owner.class.to_s, :tagger_id => owner.id,
+              :tag_id => old_tags, :context => context)
+
+            if old_taggings.present?
+              # Destroy old taggings:
+              acts_as_taggable_on_tagging_model.destroy_all(:id => old_taggings.map {|tagging| tagging.id })
+            end
+
+            # Create new taggings:
+            new_tags.each do |tag|
+              taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
+            end
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_padrino/taggable/related.rb

@@ -0,0 +1,60 @@
+module ActsAsTaggableOn::Taggable
+  module Related
+    def self.included(base)
+      base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
+      base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
+      base.initialize_acts_as_taggable_on_related
+    end
+
+    module ClassMethods
+      def initialize_acts_as_taggable_on_related
+        tag_types.each do |tag_type|
+          class_eval %(
+            def find_related_#{tag_type}
+              related_tags_for('#{tag_type}', self.class)
+            end
+            alias_method :find_related_on_#{tag_type}, :find_related_#{tag_type}
+
+            def find_related_#{tag_type}_for(klass)
+              related_tags_for('#{tag_type}', klass)
+            end
+
+            def find_matching_contexts(search_context, result_context)
+              matching_contexts_for(search_context.to_s, result_context.to_s, self.class)
+            end
+
+            def find_matching_contexts_for(klass, search_context, result_context)
+              matching_contexts_for(search_context.to_s, result_context.to_s, klass)
+            end
+          )
+        end
+      end
+
+      def acts_as_taggable_on(*args)
+        super
+        initialize_acts_as_taggable_on_related
+      end
+    end
+
+    module InstanceMethods
+      def matching_contexts_for(search_context, result_context, klass)
+        related_tags_for(search_context, klass).where("#{acts_as_taggable_on_tagging_model.table_name}.context = ?", result_context)
+      end
+
+      def related_tags_for(context, klass)
+        tags_to_find = tags_on(context).collect { |t| t.name }
+
+        scope = klass.scoped
+        scope = scope.where("#{klass.table_name}.id != ?", id) if self.class == klass # exclude self
+        scope.select("#{klass.table_name}.*, COUNT(#{acts_as_taggable_on_tag_model.table_name}.id) AS count").
+          from("#{klass.table_name}, #{acts_as_taggable_on_tag_model.table_name}, #{acts_as_taggable_on_tagging_model.table_name}").
+          where("#{klass.table_name}.id = #{acts_as_taggable_on_tagging_model.table_name}.taggable_id").
+          where("#{acts_as_taggable_on_tagging_model.table_name}.taggable_type = ?", klass.to_s).
+          where("#{acts_as_taggable_on_tagging_model.table_name}.tag_id = #{acts_as_taggable_on_tag_model.table_name}.id").
+          where("#{acts_as_taggable_on_tag_model.table_name}.name IN (?)", tags_to_find).
+          group(grouped_column_names_for(klass)).
+          order("count DESC")
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_padrino/taggable/tag_list.rb

@@ -0,0 +1,96 @@
+module ActsAsTaggableOn::Taggable
+  class TagList < Array
+    cattr_accessor :delimiter
+    self.delimiter = ','
+
+    attr_accessor :owner
+
+    def initialize(*args)
+      add(*args)
+    end
+
+    ##
+    # Returns a new TagList using the given tag string.
+    #
+    # Example:
+    #   tag_list = TagList.from("One , Two,  Three")
+    #   tag_list # ["One", "Two", "Three"]
+    def self.from(string)
+      glue   = delimiter.ends_with?(" ") ? delimiter : "#{delimiter} "
+      string = string.join(glue) if string.respond_to?(:join)
+
+      new.tap do |tag_list|
+        string = string.to_s.dup
+
+        # Parse the quoted tags
+        string.gsub!(/(\A|#{delimiter})\s*"(.*?)"\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
+        string.gsub!(/(\A|#{delimiter})\s*'(.*?)'\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
+
+        tag_list.add(string.split(delimiter))
+      end
+    end
+
+    ##
+    # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.add("Fun", "Happy")
+    #   tag_list.add("Fun, Happy", :parse => true)
+    def add(*names)
+      extract_and_apply_options!(names)
+      concat(names)
+      clean!
+      self
+    end
+
+    ##
+    # Remove specific tags from the tag_list.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.remove("Sad", "Lonely")
+    #   tag_list.remove("Sad, Lonely", :parse => true)
+    def remove(*names)
+      extract_and_apply_options!(names)
+      delete_if { |name| names.include?(name) }
+      self
+    end
+
+    ##
+    # Transform the tag_list into a tag string suitable for edting in a form.
+    # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+    #
+    # Example:
+    #   tag_list = TagList.new("Round", "Square,Cube")
+    #   tag_list.to_s # 'Round, "Square,Cube"'
+    def to_s
+      tags = frozen? ? self.dup : self
+      tags.send(:clean!)
+
+      tags.map do |name|
+        name.include?(delimiter) ? "\"#{name}\"" : name
+      end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+    end
+
+    private
+
+    # Remove whitespace, duplicates, and blanks.
+    def clean!
+      reject! {|name| name.blank? }
+      map! {|name| name.strip }
+      uniq!
+    end
+
+    def extract_and_apply_options!(args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.assert_valid_keys :parse
+
+      if options[:parse]
+        args.map! { |a| self.class.from(a) }
+      end
+
+      args.flatten!
+    end
+  end
+end

data/lib/acts_as_taggable_on_padrino/tagger.rb

@@ -0,0 +1,65 @@
+module ActsAsTaggableOn
+  module Tagger
+    ##
+    # Make a model a tagger. This allows an instance of a model to claim ownership
+    # of tags.
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_tagger
+    #   end
+    def acts_as_tagger(opts={})
+      opts.assert_valid_keys :tagging, :tag
+      tagging_class_name = opts[:tagging] || 'Tagging'
+      tag_class_name = opts[:tag] || 'Tag'
+
+      class_eval do
+        has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
+                                             :include => :tag, :class_name => tagging_class_name)
+        has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => tag_class_name
+      end
+
+      include ActsAsTaggableOn::Tagger::InstanceMethods
+      extend ActsAsTaggableOn::Tagger::ClassMethods
+    end
+
+    def is_tagger?
+      false
+    end
+
+    module InstanceMethods
+      ##
+      # Tag a taggable model with tags that are owned by the tagger.
+      #
+      # @param taggable The object that will be tagged
+      # @param [Hash] options An hash with options. Available options are:
+      #               * <tt>:with</tt> - The tags that you want to
+      #               * <tt>:on</tt>   - The context on which you want to tag
+      #
+      # Example:
+      #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
+      def tag(taggable, opts={})
+        opts.reverse_merge!(:force => true)
+
+        return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
+
+        raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
+        raise "You need to specify some tags using :with"                  unless opts.has_key?(:with)
+        raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless (opts[:force] || taggable.tag_types.include?(opts[:on]))
+
+        taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
+        taggable.save
+      end
+
+      def is_tagger?
+        self.class.is_tagger?
+      end
+    end
+
+    module ClassMethods
+      def is_tagger?
+        true
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_padrino/tagging.rb

@@ -0,0 +1,29 @@
+module ActsAsTaggableOn
+  module Tagging
+    def acts_as_tagging(opts = {})
+      opts.assert_valid_keys :tag
+      tag_class_name = opts[:tag] || 'Tag'
+
+      class_eval do
+        attr_accessible :tag,
+                        :tag_id,
+                        :context,
+                        :taggable,
+                        :taggable_type,
+                        :taggable_id,
+                        :tagger,
+                        :tagger_type,
+                        :tagger_id
+
+        belongs_to :tag, :class_name => tag_class_name
+        belongs_to :taggable, :polymorphic => true
+        belongs_to :tagger,   :polymorphic => true
+
+        validates_presence_of :context
+        validates_presence_of :tag_id
+
+        validates_uniqueness_of :tag_id, :scope => [ :taggable_type, :taggable_id, :context, :tagger_id, :tagger_type ]
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_padrino/tags_helper.rb

@@ -0,0 +1,17 @@
+module ActsAsTaggableOn
+  module TagsHelper
+    # See the README for an example using tag_cloud.
+    def tag_cloud(tags, classes)
+      tags = tags.all if tags.respond_to?(:all)
+
+      return [] if tags.empty?
+
+      max_count = tags.sort_by {|tag| tag.count }.last.count.to_f
+
+      tags.each do |tag|
+        index = ((tag.count / max_count) * (classes.size - 1)).round
+        yield tag, classes[index]
+      end
+    end
+  end
+end

data/lib/tasks/generate_migration.rb

@@ -0,0 +1,23 @@
+namespace :taggable do
+    desc 'Creates the database migration needed for acts_as_as_taggable_on_padrino'
+    task :create_migration => :environment do
+      filename = "create_taggable_tables"
+
+      def return_last_migration_number
+        Dir[Dir.pwd + '/db/migrate/*.rb'].map { |f|
+          File.basename(f).match(/^(\d+)/)[0].to_i
+        }.max.to_i || 0
+      end
+
+      if (Dir[Dir.pwd + "/db/migrate/*_#{filename.underscore}.rb"].size > 0)
+        puts "\e[31mMigration already exists\e[0m"
+      elsif
+        migration_filename = "#{format("%03d", return_last_migration_number() +1)}_#{filename.underscore}.rb"
+        puts "Creating: \e[32m#{migration_filename}\e[0m"
+        FileUtils.cp(File.dirname(__FILE__) + "/templates/migration.rb", Dir.pwd + "/db/migrate/" + migration_filename)
+        puts "Now run: \e[32mpadrino rake ar:migrate\e[0m"
+      end
+
+
+    end
+end

data/lib/tasks/templates/migration.rb

@@ -0,0 +1,29 @@
+class CreateTaggableTables < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.column :name, :string
+    end
+
+    create_table :taggings do |t|
+      t.column :tag_id, :integer
+      t.column :taggable_id, :integer
+      t.column :tagger_id, :integer
+      t.column :tagger_type, :string
+
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.column :taggable_type, :string
+      t.column :context, :string
+
+      t.column :created_at, :datetime
+    end
+
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type, :context]
+  end
+
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

data/spec/acts_as_taggable_on_padrino/acts_as_taggable_on_spec.rb

@@ -0,0 +1,263 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Acts As Taggable On" do
+  it "should provide a class method 'taggable?' that is false for untaggable models" do
+    UntaggableModel.should_not be_taggable
+  end
+
+  describe "Taggable Method Generation" do
+    before(:each) do
+      TaggableModel.write_inheritable_attribute(:tag_types, [])
+      TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
+      @taggable = TaggableModel.new(:name => "Bob Jones")
+    end
+
+    it "should respond 'true' to taggable?" do
+      @taggable.class.should be_taggable
+    end
+
+    it "should create a class attribute for tag types" do
+      @taggable.class.should respond_to(:tag_types)
+    end
+
+    it "should create an instance attribute for tag types" do
+      @taggable.should respond_to(:tag_types)
+    end
+    
+    it "should have all tag types" do
+      @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
+    end
+
+    it "should generate an association for each tag type" do
+      @taggable.should respond_to(:tags, :skills, :languages)
+    end
+
+    it "should add tagged_with and tag_counts to singleton" do
+      TaggableModel.should respond_to(:tagged_with, :tag_counts)
+    end
+
+    it "should generate a tag_list accessor/setter for each tag type" do
+      @taggable.should respond_to(:tag_list, :skill_list, :language_list)
+      @taggable.should respond_to(:tag_list=, :skill_list=, :language_list=)
+    end
+    
+    it "should generate a tag_list accessor, that includes owned tags, for each tag type" do
+      @taggable.should respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
+    end
+  end
+
+  describe "Single Table Inheritance" do
+    before do
+      @taggable = TaggableModel.new(:name => "taggable")
+      @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
+      @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
+    end
+  
+    it "should pass on tag contexts to STI-inherited models" do
+      @inherited_same.should respond_to(:tag_list, :skill_list, :language_list)
+      @inherited_different.should respond_to(:tag_list, :skill_list, :language_list)
+    end
+  
+    it "should have tag contexts added in altered STI models" do
+      @inherited_different.should respond_to(:part_list)
+    end
+  end
+  
+  describe "Reloading" do
+    it "should save a model instantiated by Model.find" do
+      taggable = TaggableModel.create!(:name => "Taggable")
+      found_taggable = TaggableModel.find(taggable.id)
+      found_taggable.save
+    end
+  end
+
+  describe "Related Objects" do
+    it "should find related objects based on tag names on context" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+      taggable3 = TaggableModel.create!(:name => "Taggable 3")
+  
+      taggable1.tag_list = "one, two"
+      taggable1.save
+  
+      taggable2.tag_list = "three, four"
+      taggable2.save
+  
+      taggable3.tag_list = "one, four"
+      taggable3.save
+  
+      taggable1.find_related_tags.should include(taggable3)
+      taggable1.find_related_tags.should_not include(taggable2)
+    end
+  
+    it "should find other related objects based on tag names on context" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
+      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
+  
+      taggable1.tag_list = "one, two"
+      taggable1.save
+  
+      taggable2.tag_list = "three, four"
+      taggable2.save
+  
+      taggable3.tag_list = "one, four"
+      taggable3.save
+  
+      taggable1.find_related_tags_for(OtherTaggableModel).should include(taggable3)
+      taggable1.find_related_tags_for(OtherTaggableModel).should_not include(taggable2)
+    end
+  
+    it "should not include the object itself in the list of related objects" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+  
+      taggable1.tag_list = "one"
+      taggable1.save
+  
+      taggable2.tag_list = "one, two"
+      taggable2.save
+  
+      taggable1.find_related_tags.should include(taggable2)
+      taggable1.find_related_tags.should_not include(taggable1)
+    end
+  end
+
+  describe "Matching Contexts" do
+    it "should find objects with tags of matching contexts" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+      taggable3 = TaggableModel.create!(:name => "Taggable 3")
+  
+      taggable1.offering_list = "one, two"
+      taggable1.save!
+  
+      taggable2.need_list = "one, two"
+      taggable2.save!
+  
+      taggable3.offering_list = "one, two"
+      taggable3.save!
+  
+      taggable1.find_matching_contexts(:offerings, :needs).should include(taggable2)
+      taggable1.find_matching_contexts(:offerings, :needs).should_not include(taggable3)
+    end
+  
+    it "should find other related objects with tags of matching contexts" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
+      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
+  
+      taggable1.offering_list = "one, two"
+      taggable1.save
+  
+      taggable2.need_list = "one, two"
+      taggable2.save
+  
+      taggable3.offering_list = "one, two"
+      taggable3.save
+  
+      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should include(taggable2)
+      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should_not include(taggable3)
+    end
+  
+    it "should not include the object itself in the list of related objects" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+  
+      taggable1.tag_list = "one"
+      taggable1.save
+  
+      taggable2.tag_list = "one, two"
+      taggable2.save
+  
+      taggable1.find_related_tags.should include(taggable2)
+      taggable1.find_related_tags.should_not include(taggable1)
+    end
+  end
+
+  describe 'Tagging Contexts' do
+    it 'should eliminate duplicate tagging contexts ' do
+      TaggableModel.acts_as_taggable_on(:skills, :skills)
+      TaggableModel.tag_types.freq[:skills].should_not == 3
+    end
+
+    it "should not contain embedded/nested arrays" do
+      TaggableModel.acts_as_taggable_on([:array], [:array])
+      TaggableModel.tag_types.freq[[:array]].should == 0
+    end
+
+    it "should _flatten_ the content of arrays" do
+      TaggableModel.acts_as_taggable_on([:array], [:array])
+      TaggableModel.tag_types.freq[:array].should == 1
+    end
+
+    it "should not raise an error when passed nil" do
+      lambda {
+        TaggableModel.acts_as_taggable_on()
+      }.should_not raise_error
+    end
+
+    it "should not raise an error when passed [nil]" do
+      lambda {
+        TaggableModel.acts_as_taggable_on([nil])
+      }.should_not raise_error
+    end
+  end
+  
+  describe 'Caching' do
+    before(:each) do
+      @taggable = CachedModel.new(:name => "Bob Jones")  
+    end
+    
+    it "should add saving of tag lists and cached tag lists to the instance" do
+      @taggable.should respond_to(:save_cached_tag_list)
+      @taggable.should respond_to(:save_tags)
+    end  
+
+    it "should generate a cached column checker for each tag type" do
+      CachedModel.should respond_to(:caching_tag_list?)
+    end  
+    
+    it 'should not have cached tags' do
+      @taggable.cached_tag_list.should be_blank  
+    end
+    
+    it 'should cache tags' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.cached_tag_list.should == 'awesome, epic'
+    end
+    
+    it 'should keep the cache' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable = CachedModel.find(@taggable)  
+      @taggable.save!
+      @taggable.cached_tag_list.should == 'awesome, epic'   
+    end
+    
+    it 'should update the cache' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.update_attributes(:tag_list => 'awesome')
+      @taggable.cached_tag_list.should == 'awesome'      
+    end
+    
+    it 'should remove the cache' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.update_attributes(:tag_list => '')
+      @taggable.cached_tag_list.should be_blank  
+    end
+    
+    it 'should have a tag list' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.tag_list.sort.should == %w(awesome epic).sort
+    end
+    
+    it 'should keep the tag list' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.save!
+      @taggable.tag_list.sort.should == %w(awesome epic).sort
+    end
+  end
+
+end