acts_as_taggable_simple 0.0.4 → 0.1.0

data/.gitignore

@@ -8,3 +8,5 @@ doc/**/*
 rdoc/**/*
 Gemfile.lock
 Manifest
+.idea/
+spec/*.log

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@acts_as_taggable_simple --create

data/README.rdoc

@@ -9,11 +9,6 @@ the following methods to a taggable model:
 * tag_list - returns an Array of tag String objects
 * tag_list= - takes either a String of tags or an array of tag String objects and sets the tags for the object
 
-acts_as_taggable provides two new attributes for a model:
-
-* tags - the ActsAsTaggable::Tag objects associated with the taggable item
-* taggings - the ActsAsTaggable::Tagging join objects associated with the taggable item
-
 
 === Installation
 
@@ -79,17 +74,6 @@ Note that our note will not be tagged until we save it.
 Now when we retrieve our note from active record,
 it will retain the tags we have given it.
 
-If necessary we can directly manipulate a note's tag objects.
-This should not be necessary though, and for normal use we can
-do all of our tag editing through tag_list.
-
-    note.tags << ActsAsTaggableSimple::Tag.new :name => 'why_did_we_do_this?'
-
-We can also manipulate the join objects by accessing taggings on a note.
-Again, there is usually never a need to do this.
-
-    note.taggings  # returns all of the ActsAsTaggableSimple::Tagging objects for our note
-
 This is all we can do with this gem. Things like searching are left to
 the user or solutions like:
 http://github.com/ernie/meta_search
@@ -97,6 +81,22 @@ http://github.com/ernie/meta_search
 If you want to do cloud calculations on tags, this task is left to you.
 
 
+=== Contexts
+
+    class Note < ActiveRecord::Base
+        attr_accessible :content
+        acts_as_taggable :tag, :color
+    end
+
+    note = Note.new
+    note.tag_list = "new important"
+    note.color_list = "red blue purple"
+    note.save
+
+    note.tag_list    # returns ["new", "important"]
+    note.color_list  # returns ["red", "blue", "purple"]
+
+
 === Example
 
 app/models/taggable_model.rb

data/Rakefile

@@ -1,23 +1,10 @@
 require 'bundler'
 require 'rspec/core/rake_task'
 
-require 'rake'
-
 Bundler::GemHelper.install_tasks
 
 RSpec::Core::RakeTask.new do |t|
   pattern = "spec/**/*_spec.rb"
 end
 
-task :default => :spec
-
-require 'rake/rdoctask'
-require 'acts_as_taggable_simple/version'
-Rake::RDocTask.new do |rdoc|
-  version = ActsAsTaggableSimple::VERSION
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "acts_as_taggable_simple #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+task :default => :spec

data/acts_as_taggable_simple.gemspec

@@ -17,6 +17,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'activerecord'
   s.add_development_dependency 'activesupport'
   s.add_development_dependency 'sqlite3-ruby'
+  s.add_development_dependency 'mongoid'
+  s.add_development_dependency 'bson_ext'
+  s.add_development_dependency 'factory_girl'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/active_model/acts/taggable.rb

@@ -0,0 +1,100 @@
+module ActiveModel #:nodoc:
+  module Acts #:nodoc:
+
+    # This +acts_as+ extension provides capabilities for adding and removing tags to ActiveRecord objects.
+    #
+    # Basic note example:
+    #
+    #   class Note < ActiveRecord::Base
+    #     acts_as_taggable
+    #   end
+    #
+    #   note.tag_list = "rails css javascript"
+    #   note.tag_list  # returns ["rails", "css", "javascript"]
+    #
+    module Taggable
+      extend ActiveSupport::Concern
+
+        # Provides one method: ActiveRecord::Base#acts_as_taggable.
+      module ClassMethods
+
+        # Call this method to make one of your models taggable.
+        #
+        # Future support for a :delimeter option for specifying the tag delimeter
+        def acts_as_taggable(*args)
+          has_many :taggings, as: :taggable, class_name: "ActsAsTaggableSimple::Tagging"
+          after_save :save_tags
+
+          args << "tag" if args.empty?
+          contexts = args.map(&:to_s).map(&:singularize)
+          self.class_variable_set(:@@tagging_contexts, contexts)
+
+          contexts.each do |context|
+            class_eval <<-EOV
+              def #{context}_list
+                self.instance_variable_get('@#{context}_list') || self.instance_variable_set('@#{context}_list', TagList.new(tags_on("#{context}").map(&:name)))
+              end
+
+              def #{context}_list=(list)
+                self.instance_variable_set('@#{context}_list', list.is_a?(String) ? TagList.new(list.split(" ")) : list)
+              end
+            EOV
+          end
+        end
+      end
+
+        # Provides methods to manage tags for a taggable model:
+        # * tag_list - returns an Array of tag String's
+        # * tag_list= - takes and Array of tag Strings or a String of tags separated by spaces
+        # * save_tags - updates the ActsAsTaggableSimple::Tag objects after saving a taggable model
+      module InstanceMethods
+        def tagging_contexts
+          self.class.class_variable_get(:@@tagging_contexts)
+        end
+
+        def tag_list_on(context)
+          try("#{context}_list")
+        end
+
+        def tags_on(context)
+          taggings.where(context: context).map(&:tag)
+        end
+
+        def taggings_on(context)
+          taggings.where(context: context)
+        end
+
+          # Called right before saving the model to update the associated ActsAsTaggableSimple::Tag objects
+          # Once saved this also necessarily updates the ActsAsTaggableSimple::Tagging objects for this record
+        def save_tags
+          tagging_contexts.each do |context|
+            tag_list = tag_list_on(context)
+
+            ActsAsTaggableSimple::Tag.find_or_create_all_tags(tag_list)
+
+            existing_tags = taggings_on(context).collect do |tagging|
+              tagging.tag.name
+            end
+            new_tags = tag_list - existing_tags
+            old_tags = existing_tags - tag_list
+
+            destroyed_taggings = []
+            taggings_on(context).each do |tagging|
+              if old_tags.include? tagging.tag.name
+                tagging.destroy
+                destroyed_taggings << tagging
+              end
+            end
+
+            self.taggings -= destroyed_taggings
+
+            new_tags = ActsAsTaggableSimple::Tag.find_by_names(new_tags)
+            new_tags.each do |tag|
+              taggings.create! tag: tag, context: context
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/active_record.rb

@@ -0,0 +1,4 @@
+require 'active_record/tag'
+require 'active_record/tagging'
+
+ActiveRecord::Base.send :include, ActiveModel::Acts::Taggable

data/lib/{tag.rb → active_record/tag.rb}

@@ -34,5 +34,9 @@ module ActsAsTaggableSimple #:nodoc:
 
       create_tags + existing_tags.all
     end
+
+    def self.find_by_names(names)
+      where(name: names)
+    end
   end
 end

data/lib/acts_as_taggable_simple.rb

@@ -1,6 +1,7 @@
 # ActsAsTaggableSimple
 
 require 'tag_list'
-require 'tag'
-require 'tagging'
-require 'active_record/acts/taggable'
+require 'active_model/acts/taggable'
+
+require 'active_record/active_record' if defined? ::ActiveRecord
+require 'mongoid/mongoid' if defined? ::Mongoid

data/lib/acts_as_taggable_simple/version.rb

@@ -1,3 +1,3 @@
 module ActsAsTaggableSimple
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/lib/generators/acts_as_taggable_simple/migration/templates/active_record/migration.rb

@@ -20,6 +20,8 @@ class ActsAsTaggableSimpleMigration < ActiveRecord::Migration
     create_table :taggings do |t|
       t.references :taggable, :polymorphic => true
       t.references :tag
+
+      t.string :context
     end
   end
 

data/lib/mongoid/mongoid.rb

@@ -0,0 +1,4 @@
+require 'mongoid/tag'
+require 'mongoid/tagging'
+
+Mongoid::Document.send :include, ActiveModel::Acts::Taggable

data/lib/mongoid/tag.rb

@@ -0,0 +1,44 @@
+module ActsAsTaggableSimple #:nodoc:
+
+  # ActiveRecord model for storing a tag in the database.
+  #
+  # Tags have only one attribute: +name+, which is just the text representation of the tag.
+  # +name+ must be unique for each instance.
+  class Tag
+    include Mongoid::Document
+
+    attr_accessible :name
+
+    validates_uniqueness_of :name
+
+    # Finds or creates all of the tags contained in +list+ and returns them.
+    #
+    # +list+ is an Array of String's containing the +name+'s of the desired tags.
+    # If an ActsAsTaggableSimple::Tag does not yet exist for a tag, then it is created, otherwise the already existing tag is used.
+    #
+    # Empty database example:
+    # 
+    #   tags = ActsAsTaggableSimple::Tag.find_or_create_all_tags(%w{rails css html})
+    #
+    # Will create 3 new ActsAsTaggableSimple::Tag objects and save them to the database.
+    #
+    # If +rails+, +css+, and +html+ tags already exist in the database, then the following example will only create 1 new tag.
+    # 
+    #   tags = ActsAsTaggableSimple::Tag.find_or_create_all_tags(%w{rails css html javascript})
+    #
+    def self.find_or_create_all_tags(list)
+      existing_tags = Tag.where(:name.in => list)
+      create_tags_list = list - existing_tags.map(&:name)
+
+      create_tags = create_tags_list.collect do |tag|
+        Tag.create!(:name => tag)
+      end
+
+      create_tags + existing_tags.all
+    end
+
+    def self.find_by_names(names)
+      where(:name.in => names)
+    end
+  end
+end

data/lib/mongoid/tagging.rb

@@ -0,0 +1,11 @@
+module ActsAsTaggableSimple #:nodoc:
+
+  # Model for storing a join between a taggable object and an ActsAsTaggableSimple::Tag object.
+  class Tagging
+    include Mongoid::Document
+
+    belongs_to :taggable, :polymorphic => true
+    belongs_to :tag, :class_name => "ActsAsTaggableSimple::Tag"
+    has_one :name, :through => :tag
+  end
+end

data/spec/active_record/models.rb

@@ -0,0 +1,18 @@
+class Todo < ActiveRecord::Base
+  acts_as_taggable
+end
+
+class Other < ActiveRecord::Base
+  acts_as_taggable
+end
+
+class Note < ActiveRecord::Base
+  acts_as_taggable :country
+end
+
+class Multi <  ActiveRecord::Base
+  acts_as_taggable :country, :city
+end
+
+class Untaggable <  ActiveRecord::Base
+end

data/spec/database.yml

@@ -1,3 +1,3 @@
 sqlite3:
   adapter: sqlite3
-  database: ":memory:"
+  database: ""

data/spec/factories.rb

@@ -0,0 +1,11 @@
+Factory.define :note do |f|
+end
+
+Factory.define :todo do |f|
+end
+
+Factory.define :other do |f|
+end
+
+Factory.define :multi do |f|
+end

data/spec/lib/acts_as_taggable_simple/acts_as_taggable_simple_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "Acts As Taggable Simple" do
+  describe "Taggable Method Generation" do
+    describe "with a context tagging" do
+      before do
+        @taggable = Factory.build :note
+      end
+
+      it "should generate a country_list method" do
+        @taggable.should respond_to(:country_list)
+      end
+
+      it "should generate a country_list= method" do
+        @taggable.should respond_to(:country_list=)
+      end
+    end
+
+    describe "without a context tagging" do
+      before do
+        @taggable = Factory.build :todo
+      end
+
+      it "should generate a tag_list method" do
+        @taggable.should respond_to(:tag_list)
+      end
+
+      it "should generate a tag_list= method" do
+        @taggable.should respond_to(:tag_list=)
+      end
+    end
+  end
+end

data/spec/lib/acts_as_taggable_simple/taggable_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe "Taggable" do
+  describe "with multiple context taggings" do
+    before do
+      @taggable = Factory.create :multi
+    end
+
+    it "creates tags" do
+      @taggable.country_list = "mexico usa canada"
+      @taggable.city_list = "tijuana ithaca montreal"
+
+      lambda {
+        @taggable.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(6)
+    end
+
+    it "doesn't create tags that already exist" do
+      @taggable.country_list = "tag2 tag3 tag1"
+      @taggable.city_list = "tijuana ithaca montreal"
+      @taggable.save
+
+      taggable1 = Factory.build(:note, :country_list => "tag2 tag1 rails css tijuana")
+
+      lambda {
+        taggable1.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(2)
+    end
+  end
+
+  describe "with a context tagging" do
+    before do
+      @taggable = Factory.create :note
+    end
+
+    it "create tags" do
+      @taggable.country_list = "mexico usa canada"
+
+      lambda {
+        @taggable.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(3)
+    end
+
+    it "doesn't create tags that already exist" do
+      @taggable.country_list = "tag2 tag3 tag1"
+      @taggable.save
+
+      taggable1 = Factory.build(:note, :country_list => "tag2 tag1 rails css")
+
+      lambda {
+        taggable1.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(2)
+    end
+
+    it "deletes old taggings" do
+      @taggable.country_list = "ruby rails css"
+      @taggable.save
+
+      @taggable.country_list = "ruby rails"
+
+      lambda {
+        @taggable.save
+      }.should change(@taggable.taggings, :count).by(-1)
+    end
+  end
+
+  describe "without a context tagging" do
+    before do
+      @taggable = Factory.create :todo
+      @other = Factory.create :other
+    end
+
+    it "creates tags" do
+      @taggable.tag_list = "tag2 tag3 tag1"
+      @taggable.tag_list.should be_kind_of(Array)
+
+      lambda {
+        @taggable.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(3)
+
+      @taggable.tag_list.sort.should == %w(tag2 tag3 tag1).sort
+    end
+
+    it "does not create tags that already exist and create tags that do not yet exist when saving" do
+      @taggable.tag_list = "tag2 tag3 tag1"
+      @taggable.save
+
+      taggable1 = Factory.build(:todo, :tag_list => "tag2 tag1 rails css")
+      taggable2 = Factory.build(:todo, :tag_list => "tag2 tag1 rails css")
+
+      lambda {
+        taggable1.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(2)
+
+      lambda {
+        taggable2.save
+      }.should change(ActsAsTaggableSimple::Tag, :count).by(0)
+    end
+
+    it "deletes old taggings when saving" do
+      @taggable.tag_list = "ruby rails css"
+      @taggable.save
+
+      @taggable.tag_list = "ruby rails"
+
+      lambda {
+        @taggable.save
+      }.should change(@taggable.taggings, :count).by(-1)
+    end
+
+    it "retains unchanged taggings when saving" do
+      @taggable.tag_list = "ruby rails css"
+      @taggable.save
+      old_taggings = @taggable.taggings
+
+      @taggable.tag_list = "ruby rails"
+      @taggable.save
+
+      @taggable.taggings.should == old_taggings[0..1]
+    end
+
+    it "tags multiple models simultaneously" do
+      @taggable.tag_list = "ruby rails css"
+      @taggable.save
+
+      @other.tag_list = "ruby rails css"
+      @other.save
+
+      taggable1 = Factory.build(:todo, :tag_list => "ruby tag1 tag2")
+      other1 = Factory.build(:other, :tag_list => "rails tag1 tag3 tag4")
+
+      taggable1.save
+      other1.save
+
+      @taggable = Todo.find @taggable.id
+      @other = Other.find @other.id
+      taggable1 = Todo.find taggable1.id
+      other1 = Other.find other1.id
+
+      @taggable.tag_list.sort.should == %w{ruby rails css}.sort
+      @other.tag_list.sort.should == %w{ruby rails css}.sort
+      taggable1.tag_list.sort.should == %w{ruby tag1 tag2}.sort
+      other1.tag_list.sort.should == %w{rails tag1 tag3 tag4}.sort
+    end
+  end
+end