dm-taggings 0.11.0 → 1.0.0

data/lib/dm-taggings/is/tagger.rb

@@ -39,9 +39,6 @@ module DataMapper
 
           # Add instance-methods
           include DataMapper::Is::Tagger::InstanceMethods
-
-          cattr_accessor(:taggable_object_classes)
-          self.taggable_object_classes = []
         end
 
         raise "options[:for] is missing" unless options[:for]
@@ -50,6 +47,14 @@ module DataMapper
       end
 
       module ClassMethods
+        def self.extended(base)
+          base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.taggable_object_classes
+              @@taggable_object_classes ||= []
+            end
+          RUBY
+        end
+
         # Return if a model is tagger
         #
         # @return [TrueClass]
@@ -71,10 +76,12 @@ module DataMapper
             self.taggable_object_classes << taggable_object_class
 
             has n, taggable_object_class.tagging_relationship_name,
+              :model      => taggable_object_class.tagging_class,
               :constraint => :destroy
 
             has n, taggable_object_class.taggable_relationship_name,
-              :through => taggable_object_class.tagging_relationship_name,
+              :model      => taggable_object_class.name,
+              :through    => taggable_object_class.tagging_relationship_name,
               :constraint => :destroy
           end
         end
@@ -94,7 +101,7 @@ module DataMapper
         #
         # @api public
         def tag!(taggable, options={})
-          unless self.taggable_object_classes.include?(taggable.class)
+          unless self.class.taggable_object_classes.include?(taggable.class)
             raise "Object of type #{taggable.class} isn't taggable!"
           end
 
@@ -112,4 +119,3 @@ module DataMapper
     end # Tagger
   end # Is
 end # DataMapper
-

data/lib/dm-taggings/is/tagging.rb

@@ -2,12 +2,12 @@ module Tagging
   include DataMapper::Resource
 
   property :id, Serial
-  property :tag_id, Integer, :min => 1, :required => true
+
+  belongs_to :tag
 
   is :remixable, :suffix => "tag"
 
   def tagger=(tagger)
-    send("#{DataMapper::Inflector.underscore(tagger.class.name).to_sym}=", tagger)
+    send("#{DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(tagger.class.name)).to_sym}=", tagger)
   end
 end
-

data/lib/dm-taggings/spec/taggable_shared_spec.rb

@@ -1,23 +1,21 @@
 share_examples_for 'A taggable resource' do
   def create_taggable(attrs={})
-    @taggable.create(@taggable_attributes.merge(attrs))
+    taggable.create(@taggable_attributes.merge(attrs))
   end
 
-  before :all do
-    %w[ @taggable ].each do |ivar|
-      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
-    end
-
-    @taggable_attributes ||= {}
+  def taggable
+    raise "taggable should be defined"
+  end
 
-    @foo_tag  = Tag["foo"]
-    @bar_tag  = Tag["bar"]
+  let(:foo_tag) { Tag["foo"] }
+  let(:bar_tag) { Tag["bar"] }
 
-    @tags = [@foo_tag, @bar_tag]
+  before :all do
+    @taggable_attributes ||= {}
   end
 
   describe "public class methods" do
-    subject { @taggable }
+    subject { taggable }
 
     it { should respond_to(:is_taggable) }
     it { should respond_to(:taggable?) }
@@ -27,40 +25,52 @@ share_examples_for 'A taggable resource' do
     it { should respond_to(:tagging_class) }
     it { should respond_to(:tagging_parent_name) }
     it { should respond_to(:taggable_relationship_name) }
+    it { should respond_to(:taggable_options) }
+
+    describe ".taggable_options" do
+      let(:expected_options) { { :tag_list_separator => ',' } }
+
+      it "should set the defaults" do
+        taggable.taggable_options.should == expected_options
+      end
+    end
 
     describe ".taggable?" do
       it "should return true" do
-        @taggable.taggable?.should be(true)
+        taggable.taggable?.should be(true)
       end
     end
 
     describe "relationships" do
-      subject { @taggable.relationships }
+      subject { taggable.relationships.named?(taggable.tagging_relationship_name) }
 
-      it { should have_key(@taggable.tagging_relationship_name) }
+      it { should be(true) }
 
       describe "tagging constraint" do
-        subject { @taggable.tagging_relationship.constraint }
+        subject { taggable.tagging_relationship.constraint }
         it { subject.should eql(:destroy!) }
       end
     end
 
     describe ".tagged_with" do
-      before :all do
-        @resource_one = create_taggable(:tag_list => "red, green, blue")
-        @resource_two = create_taggable(:tag_list => "orange, yellow")
+      let(:resource_one) { create_taggable(:tag_list => "red, green, blue") }
+      let(:resource_two) { create_taggable(:tag_list => "orange, yellow") }
+
+      before do
+        resource_one
+        resource_two
       end
 
+      subject { taggable.tagged_with(["red", "yellow", "purple"]) }
+
       it "should return correct resources" do
-        result = @taggable.tagged_with(["red", "yellow", "purple"])
-        result.size.should eql(2)
-        result.should include(@resource_one, @resource_two)
+        should == [ resource_one, resource_two ]
       end
     end
   end
 
   describe "public instance methods" do
-    subject { @taggable.new }
+    subject { taggable.new }
 
     it { should respond_to(:tag) }
     it { should respond_to(:tag!) }
@@ -70,189 +80,173 @@ share_examples_for 'A taggable resource' do
     it { should respond_to(:taggings) }
 
     describe ".tag" do
-      before :all do
-        @resource = create_taggable
-        @taggings = @resource.tag([@foo_tag, @bar_tag])
-      end
+      let(:resource) { create_taggable }
+      let(:tags)     { resource.tag([ foo_tag, bar_tag ]) }
 
-      it "should set new taggings" do
-        @taggings.should eql(@resource.taggings)
+      it "should set new tags" do
+        tags.should == resource.tags
       end
 
-      it "should not create new taggings" do
-        @resource.tags.should be_empty
+      it "should not save new taggings" do
+        resource.taggings.all? { |tagging| tagging.new? }.should be(true)
       end
     end
 
     describe ".tag!" do
-      before :all do
-        @resource = create_taggable
-        @taggings = @resource.tag!([@foo_tag, @bar_tag])
+      let(:resource) { create_taggable }
+      let(:new_tags) { [ foo_tag, bar_tag ] }
+      let(:tags)     { resource.tag!(new_tags) }
+
+
+      it "returns added tags" do
+        tags.should == new_tags
       end
 
-      it "should create new taggings" do
-        @resource.reload.tags.should include(@foo_tag, @bar_tag)
+      it "creates new taggings" do
+        resource.tags.should == tags
       end
     end
 
     describe ".untag" do
-      describe "all" do
-        before :all do
-          @resource = create_taggable
-          @taggings = @resource.tag!([@foo_tag, @bar_tag])
+      let(:tags)     { [ foo_tag, bar_tag ] }
+      let(:resource) { create_taggable(:tags => tags) }
 
-          @resource.untag
+      describe "all" do
+        before do
+          resource.untag
         end
 
-        it "should remove the taggings from the collection" do
-          @resource.taggings.should be_empty
+        it "removes taggings from loaded collection" do
+          resource.tags.should be_empty
         end
 
-        it "should not destroy the taggings" do
-          @resource.reload.tags.should_not be_empty
+        it "doesn't destroy the taggings" do
+          resource.reload.tags.should == tags
         end
       end
 
-      describe "specific names" do
-        before :all do
-          @resource = create_taggable
-          @taggings = @resource.tag!([@foo_tag, @bar_tag])
-
-          @resource.untag([@foo_tag])
+      describe "specific tags" do
+        before do
+          resource.untag([ foo_tag ])
         end
 
-        it "should remove the related tagging from the collection" do
-          @resource.taggings.size.should eql(1)
-        end
-
-        it "should remove the related tag" do
-          @resource.tags.should_not include(@foo_tag)
+        it "should remove the tag from loaded collection" do
+          resource.tags.should == [ bar_tag ]
         end
       end
 
       describe "when save is called" do
-        before :all do
-          @resource = create_taggable
-          @taggings = @resource.tag!([@foo_tag, @bar_tag])
-
-          @resource.untag
-        end
-
-        it "should return true" do
-          pending "Currently DataMapper doesn't support saving an empty collection" do
-            @resource.save.should be(true)
-          end
+        before do
+          resource.untag
+          resource.save
+          resource.reload
         end
 
         it "should destroy taggings" do
-          pending "Currently DataMapper doesn't support saving an empty collection" do
-            @resource.reload.taggings.should be_empty
-          end
+          resource.taggings.should be_empty
         end
 
         it "should destroy tags" do
-          pending "Currently DataMapper doesn't support saving an empty collection" do
-            @resource.reload.tags.should be_empty
-          end
+          resource.tags.should be_empty
         end
       end
     end
 
     describe ".untag!" do
+      let(:tags)     { [ foo_tag, bar_tag ] }
+      let(:resource) { create_taggable(:tags => tags) }
+
       describe "all" do
-        before :all do
-          @resource = create_taggable
-          @taggings = @resource.tag!([@foo_tag, @bar_tag])
+        before do
+          @result = resource.untag!
+          resource.reload
+        end
 
-          @resource.untag!
+        it "returns removed tags" do
+          @result == tags
         end
 
-        it "should destroy the taggings" do
-          @resource.reload.taggings.should be_empty
+        it "destroys the taggings" do
+          resource.tags.should be_empty
         end
       end
 
-      describe "specific names" do
-        before :all do
-          @resource = create_taggable
-          @taggings = @resource.tag!([@foo_tag, @bar_tag])
-
-          @resource.untag!([@foo_tag])
-          @resource.reload
+      describe "specific tags" do
+        before do
+          resource.untag!([ foo_tag ])
+          resource.reload
         end
 
-        subject { @resource.tags }
+        subject { resource.tags }
 
-        it { should_not include(@foo_tag) }
-        it { should include(@bar_tag) }
+        it { should_not include(foo_tag) }
+        it { should include(bar_tag) }
       end
     end
 
     describe ".tag_list=" do
       describe "with a list of tag names" do
         describe "with blank values" do
-          before :all do
-            @resource = create_taggable(:tag_list => "foo, , ,bar, , ")
-          end
+          let(:resource) { create_taggable(:tag_list => "foo, , ,bar, , ") }
 
           it "should add new tags and reject blank names" do
-            @resource.reload.tags.should include(Tag["foo"], Tag["bar"])
+            resource.tags.should ==  [ Tag["foo"], Tag["bar"] ]
           end
         end
 
         describe "when tags are removed and added" do
-          before :all do
-            @resource = create_taggable(:tag_list => "foo, bar")
-            @resource.update(:tag_list => "foo, bar, pub")
+          let(:resource) { create_taggable(:tag_list => "foo, bar") }
+
+          before do
+            resource.update(:tag_list => "foo, bar, pub")
           end
 
           it "should add new tags" do
-            @resource.reload.tags.should include(Tag["bar"], Tag["bar"], Tag["pub"])
+            resource.tags.should == [ Tag["foo"], Tag["bar"], Tag["pub"] ]
           end
         end
 
         describe "when tags are added" do
-          before :all do
-            @resource = create_taggable(:tag_list => "foo, bar")
-            @resource.update(:tag_list => "bar, pub")
+          let(:resource) { create_taggable(:tag_list => "foo, bar") }
+
+          before do
+            resource.update(:tag_list => "bar, pub")
           end
 
           it "should add new tags" do
-            @resource.reload.tags.should include(Tag["bar"], Tag["pub"])
+            resource.tags.should include(Tag["bar"], Tag["pub"])
           end
 
           it "should remove tags" do
-            @resource.reload.tags.should_not include(Tag["foo"])
+            resource.tags.should_not include(Tag["foo"])
           end
         end
       end
 
       describe "when no list of tag names is given" do
+        let(:resource) { create_taggable(:tag_list => "foo, bar") }
+
         before :all do
-          @resource = create_taggable(:tag_list => "foo, bar")
-          @resource.update(:tag_list => "")
+          resource.update(:tag_list => "")
         end
 
         it "should destroy taggings" do
-          @resource.reload.taggings.should be_blank
+          resource.reload.taggings.should be_blank
         end
 
         it "should remove the tags" do
-          @resource.reload.tags.should be_blank
+          resource.reload.tags.should be_blank
         end
       end
     end
 
     describe ".tag_list" do
-      before :all do
-        @tag_names = %w(red green blue)
-        @expected  = @tag_names.join(', ')
-        @resource  = create_taggable(:tag_list => @expected)
-      end
+      let(:expected_tag_names) { %w(nice cool awesome).join(',') }
+      let(:resource)           { create_taggable(:tag_list => expected_tag_names) }
 
-      it "should return the list of tag names" do
-        @resource.tag_list.should eql(@expected)
-      end
+      subject { resource.tag_list }
+
+      it { should == expected_tag_names }
     end
   end
 end

data/lib/dm-taggings/spec/tagger_shared_spec.rb

@@ -1,32 +1,33 @@
 share_examples_for 'A tagger resource' do
-  before :all do
-    %w[ @tagger @taggable ].each do |ivar|
-      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
-    end
-
-    @foo_tag  = Tag["foo"]
-    @bar_tag  = Tag["bar"]
+  def taggable
+    raise "taggable should be defined"
+  end
 
-    @tags = [@foo_tag, @bar_tag]
+  def tagger
+    raise "tagger should be defined"
   end
 
-  subject { @tagger }
+  let(:foo_tag) { Tag["foo"] }
+  let(:bar_tag) { Tag["bar"] }
+  let(:tags)    { [ foo_tag, bar_tag ] }
+
+  subject { tagger }
 
   [ :is_tagger, :tagger?, :add_taggable_object_classes, :taggable_object_classes ].each do |method|
     it { should respond_to(method) }
   end
 
   describe ".tagger?" do
-    subject { @tagger.tagger? }
+    subject { tagger.tagger? }
     it { should be(true) }
   end
 
   describe "#tag!" do
     before :all do
-      @tagger_resource   = @tagger.create
-      @taggable_resource = @taggable.create
+      @tagger_resource   = tagger.create
+      @taggable_resource = taggable.create
 
-      @tags = @tagger_resource.tag!(@taggable_resource, :with => @tags)
+      @tags = @tagger_resource.tag!(@taggable_resource, :with => tags)
     end
 
     it "should tag the taggable resource" do
@@ -34,12 +35,12 @@ share_examples_for 'A tagger resource' do
     end
 
     it "should associate tagger with taggable" do
-      @tagger_resource.reload.send(DataMapper::Inflector.underscore(@taggable.name).pluralize).should include(@taggable_resource)
+      @tagger_resource.reload.send(DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(taggable.name)))).should include(@taggable_resource)
     end
 
     it "should associate taggings with tagger" do
       @taggable_resource.taggings.each do |tagging|
-        tagging.send(DataMapper::Inflector.underscore(@tagger.name)).should eql(@tagger_resource)
+        tagging.send(DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(tagger.name))).should eql(@tagger_resource)
       end
     end
   end