make_taggable 0.6.3

data/spec/make_taggable/caching_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe "Acts As Taggable On" do
+  describe "Caching" do
+    before(:each) do
+      @taggable = CachedModel.new(name: "Bob Jones")
+      @another_taggable = OtherCachedModel.new(name: "John Smith")
+    end
+
+    it "should add saving of tag lists and cached tag lists to the instance" do
+      expect(@taggable).to respond_to(:save_cached_tag_list)
+      expect(@another_taggable).to respond_to(:save_cached_tag_list)
+
+      expect(@taggable).to respond_to(:save_tags)
+    end
+
+    it "should add cached tag lists to the instance if cached column is not present" do
+      expect(TaggableModel.new(name: "Art Kram")).to_not respond_to(:save_cached_tag_list)
+    end
+
+    it "should generate a cached column checker for each tag type" do
+      expect(CachedModel).to respond_to(:caching_tag_list?)
+      expect(OtherCachedModel).to respond_to(:caching_language_list?)
+    end
+
+    it "should not have cached tags" do
+      expect(@taggable.cached_tag_list).to be_blank
+      expect(@another_taggable.cached_language_list).to be_blank
+    end
+
+    it "should cache tags" do
+      @taggable.update(tag_list: "awesome, epic")
+      expect(@taggable.cached_tag_list).to eq("awesome, epic")
+
+      @another_taggable.update(language_list: "ruby, .net")
+      expect(@another_taggable.cached_language_list).to eq("ruby, .net")
+    end
+
+    it "should keep the cache" do
+      @taggable.update(tag_list: "awesome, epic")
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.save!
+      expect(@taggable.cached_tag_list).to eq("awesome, epic")
+    end
+
+    it "should update the cache" do
+      @taggable.update(tag_list: "awesome, epic")
+      @taggable.update(tag_list: "awesome")
+      expect(@taggable.cached_tag_list).to eq("awesome")
+    end
+
+    it "should remove the cache" do
+      @taggable.update(tag_list: "awesome, epic")
+      @taggable.update(tag_list: "")
+      expect(@taggable.cached_tag_list).to be_blank
+    end
+
+    it "should have a tag list" do
+      @taggable.update(tag_list: "awesome, epic")
+      @taggable = CachedModel.find(@taggable.id)
+      expect(@taggable.tag_list.sort).to eq(%w[awesome epic].sort)
+    end
+
+    it "should keep the tag list" do
+      @taggable.update(tag_list: "awesome, epic")
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.save!
+      expect(@taggable.tag_list.sort).to eq(%w[awesome epic].sort)
+    end
+
+    it "should clear the cache on reset_column_information" do
+      CachedModel.column_names
+      CachedModel.reset_column_information
+      expect(CachedModel.instance_variable_get(:@make_taggable_cache_columns)).to eql(nil)
+    end
+
+    it "should not override a user-defined columns method" do
+      expect(ColumnsOverrideModel.columns.map(&:name)).not_to include("ignored_column")
+      ColumnsOverrideModel.acts_as_taggable
+      expect(ColumnsOverrideModel.columns.map(&:name)).not_to include("ignored_column")
+    end
+  end
+
+  describe "with a custom delimiter" do
+    before(:each) do
+      @taggable = CachedModel.new(name: "Bob Jones")
+      @another_taggable = OtherCachedModel.new(name: "John Smith")
+      MakeTaggable.delimiter = ";"
+    end
+
+    after(:all) do
+      MakeTaggable.delimiter = ","
+    end
+
+    it "should cache tags with custom delimiter" do
+      @taggable.update(tag_list: "awesome; epic")
+      expect(@taggable.tag_list).to eq(["awesome", "epic"])
+      expect(@taggable.cached_tag_list).to eq("awesome; epic")
+
+      @taggable = CachedModel.find_by_name("Bob Jones")
+      expect(@taggable.tag_list).to eq(["awesome", "epic"])
+      expect(@taggable.cached_tag_list).to eq("awesome; epic")
+    end
+  end
+
+  describe "Cache methods initialization on new models" do
+    before(:all) do
+      ActiveRecord::Base.connection.execute(
+        "INSERT INTO cache_methods_injected_models (cached_tag_list) VALUES ('ciao')"
+      )
+      class CacheMethodsInjectedModel < ActiveRecord::Base
+        acts_as_taggable
+      end
+    end
+    after(:all) { Object.send(:remove_const, :CacheMethodsInjectedModel) }
+
+    it "cached_tag_list_on? get injected correctly" do
+      expect {
+        CacheMethodsInjectedModel.first.tag_list
+      }.not_to raise_error
+    end
+  end
+end

data/spec/make_taggable/default_parser_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe MakeTaggable::DefaultParser do
+  it "#parse should return empty array if empty array is passed" do
+    parser = MakeTaggable::DefaultParser.new([])
+    expect(parser.parse).to be_empty
+  end
+
+  describe "Multiple Delimiter" do
+    before do
+      @old_delimiter = MakeTaggable.delimiter
+    end
+
+    after do
+      MakeTaggable.delimiter = @old_delimiter
+    end
+
+    it "should separate tags by delimiters" do
+      MakeTaggable.delimiter = [",", " ", '\|']
+      parser = MakeTaggable::DefaultParser.new("cool, data|I have")
+      expect(parser.parse.to_s).to eq("cool, data, I, have")
+    end
+
+    it "should escape quote" do
+      MakeTaggable.delimiter = [",", " ", '\|']
+      parser = MakeTaggable::DefaultParser.new("'I have'|cool, data")
+      expect(parser.parse.to_s).to eq('"I have", cool, data')
+
+      parser = MakeTaggable::DefaultParser.new('"I, have"|cool, data')
+      expect(parser.parse.to_s).to eq('"I, have", cool, data')
+    end
+
+    it "should work for utf8 delimiter and long delimiter" do
+      MakeTaggable.delimiter = ["，", "的", "可能是"]
+      parser = MakeTaggable::DefaultParser.new("我的东西可能是不见了，还好有备份")
+      expect(parser.parse.to_s).to eq("我， 东西， 不见了， 还好有备份")
+    end
+
+    it "should work for multiple quoted tags" do
+      MakeTaggable.delimiter = [","]
+      parser = MakeTaggable::DefaultParser.new('"Ruby Monsters","eat Katzenzungen"')
+      expect(parser.parse.to_s).to eq("Ruby Monsters, eat Katzenzungen")
+    end
+  end
+end

data/spec/make_taggable/dirty_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+describe "Dirty behavior of taggable objects" do
+  context "with un-contexted tags" do
+    before(:each) do
+      @taggable = TaggableModel.create(tag_list: "awesome, epic")
+    end
+
+    context "when tag_list changed" do
+      before(:each) do
+        expect(@taggable.changes).to be_empty
+        @taggable.tag_list = "one"
+      end
+
+      it "should show changes of dirty object" do
+        expect(@taggable.changes).to eq({"tag_list" => [["awesome", "epic"], ["one"]]})
+      end
+
+      it "should show changes of freshly initialized dirty object" do
+        taggable = TaggableModel.find(@taggable.id)
+        taggable.tag_list = "one"
+        expect(taggable.changes).to eq({"tag_list" => [["awesome", "epic"], ["one"]]})
+      end
+
+      if Rails.version >= "5.1"
+        it "flags tag_list as changed" do
+          expect(@taggable.will_save_change_to_tag_list?).to be_truthy
+        end
+      end
+
+      it "preserves original value" do
+        expect(@taggable.tag_list_was).to eq(["awesome", "epic"])
+      end
+
+      it "shows what the change was" do
+        expect(@taggable.tag_list_change).to eq([["awesome", "epic"], ["one"]])
+      end
+
+      context "without order" do
+        it "should not mark attribute if order change " do
+          taggable = TaggableModel.create(name: "Dirty Harry", tag_list: %w[d c b a])
+          taggable.tag_list = %w[a b c d]
+          expect(taggable.tag_list_changed?).to be_falsey
+        end
+      end
+
+      context "with order" do
+        it "should mark attribute if order change" do
+          taggable = OrderedTaggableModel.create(name: "Clean Harry", tag_list: "d,c,b,a")
+          taggable.save
+          taggable.tag_list = %w[a b c d]
+          expect(taggable.tag_list_changed?).to be_truthy
+        end
+      end
+    end
+
+    context "when tag_list is the same" do
+      before(:each) do
+        @taggable.tag_list = "awesome, epic"
+      end
+
+      it "is not flagged as changed" do
+        expect(@taggable.tag_list_changed?).to be_falsy
+      end
+
+      it "does not show any changes to the taggable item" do
+        expect(@taggable.changes).to be_empty
+      end
+
+      context "and using a delimiter different from a ','" do
+        before do
+          @old_delimiter = MakeTaggable.delimiter
+          MakeTaggable.delimiter = ";"
+        end
+
+        after do
+          MakeTaggable.delimiter = @old_delimiter
+        end
+
+        it "does not show any changes to the taggable item when using array assignments" do
+          @taggable.tag_list = %w[awesome epic]
+          expect(@taggable.changes).to be_empty
+        end
+      end
+    end
+  end
+
+  context "with context tags" do
+    before(:each) do
+      @taggable = TaggableModel.create("language_list" => "awesome, epic")
+    end
+
+    context "when language_list changed" do
+      before(:each) do
+        expect(@taggable.changes).to be_empty
+        @taggable.language_list = "one"
+      end
+
+      it "should show changes of dirty object" do
+        expect(@taggable.changes).to eq({"language_list" => [["awesome", "epic"], ["one"]]})
+      end
+
+      it "flags language_list as changed" do
+        expect(@taggable.language_list_changed?).to be_truthy
+      end
+
+      it "preserves original value" do
+        expect(@taggable.language_list_was).to eq(["awesome", "epic"])
+      end
+
+      it "shows what the change was" do
+        expect(@taggable.language_list_change).to eq([["awesome", "epic"], ["one"]])
+      end
+    end
+
+    context "when language_list is the same" do
+      before(:each) do
+        @taggable.language_list = "awesome, epic"
+      end
+
+      it "is not flagged as changed" do
+        expect(@taggable.language_list_changed?).to be_falsy
+      end
+
+      it "does not show any changes to the taggable item" do
+        expect(@taggable.changes).to be_empty
+      end
+    end
+
+    context "when language_list changed by association" do
+      let(:tag) { MakeTaggable::Tag.new(name: "one") }
+
+      it "flags language_list as changed" do
+        expect(@taggable.changes).to be_empty
+        @taggable.languages << tag
+        expect(@taggable.language_list_changed?).to be_truthy
+      end
+    end
+  end
+end

data/spec/make_taggable/generic_parser_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe MakeTaggable::GenericParser do
+  it "#parse should return empty array if empty tag string is passed" do
+    tag_list = MakeTaggable::GenericParser.new("")
+    expect(tag_list.parse).to be_empty
+  end
+
+  it "#parse should separate tags by comma" do
+    tag_list = MakeTaggable::GenericParser.new("cool,data,,I,have")
+    expect(tag_list.parse).to eq(%w[cool data I have])
+  end
+end

data/spec/make_taggable/make_taggable_spec.rb

@@ -0,0 +1,260 @@
+require "spec_helper"
+
+describe "Acts As Taggable On" do
+  it "should provide a class method 'taggable?' that is false for untaggable models" do
+    expect(UntaggableModel).to_not be_taggable
+  end
+
+  describe "Taggable Method Generation To Preserve Order" do
+    before(:each) do
+      TaggableModel.tag_types = []
+      TaggableModel.preserve_tag_order = false
+      TaggableModel.acts_as_ordered_taggable_on(:ordered_tags)
+      @taggable = TaggableModel.new(name: "Bob Jones")
+    end
+
+    it "should respond 'true' to preserve_tag_order?" do
+      expect(@taggable.class.preserve_tag_order?).to be_truthy
+    end
+  end
+
+  describe "Taggable Method Generation" do
+    before(:each) do
+      TaggableModel.tag_types = []
+      TaggableModel.make_taggable(:tags, :languages, :skills, :needs, :offerings)
+      @taggable = TaggableModel.new(name: "Bob Jones")
+    end
+
+    it "should respond 'true' to taggable?" do
+      expect(@taggable.class).to be_taggable
+    end
+
+    it "should create a class attribute for tag types" do
+      expect(@taggable.class).to respond_to(:tag_types)
+    end
+
+    it "should create an instance attribute for tag types" do
+      expect(@taggable).to respond_to(:tag_types)
+    end
+
+    it "should have all tag types" do
+      expect(@taggable.tag_types).to eq([:tags, :languages, :skills, :needs, :offerings])
+    end
+
+    it "should create a class attribute for preserve tag order" do
+      expect(@taggable.class).to respond_to(:preserve_tag_order?)
+    end
+
+    it "should create an instance attribute for preserve tag order" do
+      expect(@taggable).to respond_to(:preserve_tag_order?)
+    end
+
+    it "should respond 'false' to preserve_tag_order?" do
+      expect(@taggable.class.preserve_tag_order?).to be_falsy
+    end
+
+    it "should generate an association for each tag type" do
+      expect(@taggable).to respond_to(:tags, :skills, :languages)
+    end
+
+    it "should add tagged_with and tag_counts to singleton" do
+      expect(TaggableModel).to respond_to(:tagged_with, :tag_counts)
+    end
+
+    it "should generate a tag_list accessor/setter for each tag type" do
+      expect(@taggable).to respond_to(:tag_list, :skill_list, :language_list)
+      expect(@taggable).to 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
+      expect(@taggable).to respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
+    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!
+
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to_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
+
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to_not include(taggable3)
+    end
+
+    it "should not include the object itself in the list of related objects with tags of matching contexts" do
+      taggable1 = TaggableModel.create!(name: "Taggable 1")
+      taggable2 = TaggableModel.create!(name: "Taggable 2")
+
+      taggable1.offering_list = "one, two"
+      taggable1.need_list = "one, two"
+      taggable1.save
+
+      taggable2.need_list = "one, two"
+      taggable2.save
+
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(taggable1)
+    end
+
+    it "should ensure joins to multiple taggings maintain their contexts when aliasing" do
+      taggable1 = TaggableModel.create!(name: "Taggable 1")
+
+      taggable1.offering_list = "one"
+      taggable1.need_list = "two"
+
+      taggable1.save
+
+      column = TaggableModel.connection.quote_column_name("context")
+      offer_alias = TaggableModel.connection.quote_table_name(MakeTaggable.taggings_table)
+      need_alias = TaggableModel.connection.quote_table_name("need_taggings_taggable_models_join")
+
+      expect(TaggableModel.joins(:offerings, :needs).to_sql).to include "#{offer_alias}.#{column}"
+      expect(TaggableModel.joins(:offerings, :needs).to_sql).to include "#{need_alias}.#{column}"
+    end
+  end
+
+  describe "Tagging Contexts" do
+    it "should eliminate duplicate tagging contexts " do
+      TaggableModel.make_taggable(:skills, :skills)
+      expect(TaggableModel.tag_types.freq[:skills]).to eq(1)
+    end
+
+    it "should not contain embedded/nested arrays" do
+      TaggableModel.make_taggable([:array], [:array])
+      expect(TaggableModel.tag_types.freq[[:array]]).to eq(0)
+    end
+
+    it "should _flatten_ the content of arrays" do
+      TaggableModel.make_taggable([:array], [:array])
+      expect(TaggableModel.tag_types.freq[:array]).to eq(1)
+    end
+
+    it "should not raise an error when passed nil" do
+      expect(-> {
+        TaggableModel.make_taggable
+      }).to_not raise_error
+    end
+
+    it "should not raise an error when passed [nil]" do
+      expect(-> {
+        TaggableModel.make_taggable([nil])
+      }).to_not raise_error
+    end
+
+    it "should include dynamic contexts in tagging_contexts" do
+      taggable = TaggableModel.create!(name: "Dynamic Taggable")
+      taggable.set_tag_list_on :colors, "tag1, tag2, tag3"
+      expect(taggable.tagging_contexts).to eq(%w[tags languages skills needs offerings array colors])
+      taggable.save
+      taggable = TaggableModel.where(name: "Dynamic Taggable").first
+      expect(taggable.tagging_contexts).to eq(%w[tags languages skills needs offerings array colors])
+    end
+  end
+
+  context 'when tagging context ends in an "s" when singular (ex. "status", "glass", etc.)' do
+    describe "caching" do
+      before { @taggable = OtherCachedModel.new(name: "John Smith") }
+      subject { @taggable }
+
+      it { should respond_to(:save_cached_tag_list) }
+
+      it { expect(@taggable.cached_language_list).to eq nil }
+      it { expect(@taggable.cached_status_list).to eq nil }
+      it { expect(@taggable.cached_glass_list).to eq nil }
+
+      context "language taggings cache after update" do
+        before { @taggable.update(language_list: "ruby, .net") }
+        subject { @taggable }
+
+        it { expect(@taggable.language_list).to eq ["ruby", ".net"] }
+        it { expect(@taggable.cached_language_list).to eq "ruby, .net" }
+      end
+
+      context "status taggings cache after update" do
+        before { @taggable.update(status_list: "happy, married") }
+        subject { @taggable }
+
+        it { expect(@taggable.status_list).to eq ["happy", "married"] }
+        it { expect(@taggable.cached_status_list).to eq "happy, married" }
+      end
+
+      context "glass taggings cache after update" do
+        before do
+          @taggable.update(glass_list: "rectangle, aviator")
+        end
+
+        subject { @taggable }
+        it { expect(@taggable.glass_list).to eq ["rectangle", "aviator"] }
+        it { expect(@taggable.cached_glass_list).to eq "rectangle, aviator" }
+      end
+    end
+  end
+
+  describe "taggings" do
+    before(:each) do
+      @taggable = TaggableModel.new(name: "Art Kram")
+    end
+
+    it "should return no taggings" do
+      expect(@taggable.taggings).to be_empty
+    end
+  end
+
+  describe "@@remove_unused_tags" do
+    before do
+      @taggable = TaggableModel.create(name: "Bob Jones")
+      @tag = MakeTaggable::Tag.create(name: "awesome")
+
+      @tagging = MakeTaggable::Tagging.create(taggable: @taggable, tag: @tag, context: "tags")
+    end
+
+    context "if set to true" do
+      before do
+        MakeTaggable.remove_unused_tags = true
+      end
+
+      it "should remove unused tags after removing taggings" do
+        @tagging.destroy
+        expect(MakeTaggable::Tag.find_by_name("awesome")).to be_nil
+      end
+    end
+
+    context "if set to false" do
+      before do
+        MakeTaggable.remove_unused_tags = false
+      end
+
+      it "should not remove unused tags after removing taggings" do
+        @tagging.destroy
+        expect(MakeTaggable::Tag.find_by_name("awesome")).to eq(@tag)
+      end
+    end
+  end
+end