make_taggable 0.6.4 → 0.7.2

data/spec/make_taggable/related_spec.rb

@@ -1,93 +0,0 @@
-require "spec_helper"
-
-describe "Acts As Taggable On" do
-  describe "Related Objects" do
-    # TODO, shared example
-    it "should find related objects based on tag names on context" do
-      taggable1 = TaggableModel.create!(name: "Taggable 1", tag_list: "one, two")
-      taggable2 = TaggableModel.create!(name: "Taggable 2", tag_list: "three, four")
-      taggable3 = TaggableModel.create!(name: "Taggable 3", tag_list: "one, four")
-
-      expect(taggable1.find_related_tags).to include(taggable3)
-      expect(taggable1.find_related_tags).to_not include(taggable2)
-    end
-
-    it "finds related tags for ordered taggable on" do
-      taggable1 = OrderedTaggableModel.create!(name: "Taggable 1", colour_list: "one, two")
-      taggable2 = OrderedTaggableModel.create!(name: "Taggable 2", colour_list: "three, four")
-      taggable3 = OrderedTaggableModel.create!(name: "Taggable 3", colour_list: "one, four")
-
-      expect(taggable1.find_related_colours).to include(taggable3)
-      expect(taggable1.find_related_colours).to_not include(taggable2)
-    end
-
-    it "should find related objects based on tag names on context - non standard id" do
-      taggable1 = NonStandardIdTaggableModel.create!(name: "Taggable 1", tag_list: "one, two")
-      taggable2 = NonStandardIdTaggableModel.create!(name: "Taggable 2", tag_list: "three, four")
-      taggable3 = NonStandardIdTaggableModel.create!(name: "Taggable 3", tag_list: "one, four")
-
-      expect(taggable1.find_related_tags).to include(taggable3)
-      expect(taggable1.find_related_tags).to_not include(taggable2)
-    end
-
-    it "should find other related objects based on tag names on context" do
-      taggable1 = TaggableModel.create!(name: "Taggable 1", tag_list: "one, two")
-      taggable2 = OtherTaggableModel.create!(name: "Taggable 2", tag_list: "three, four")
-      taggable3 = OtherTaggableModel.create!(name: "Taggable 3", tag_list: "one, four")
-
-      expect(taggable1.find_related_tags_for(OtherTaggableModel)).to include(taggable3)
-      expect(taggable1.find_related_tags_for(OtherTaggableModel)).to_not include(taggable2)
-    end
-
-    it "should find other related objects based on tags only from particular context" do
-      taggable1 = TaggableModel.create!(name: "Taggable 1", tag_list: "one, two")
-      taggable2 = TaggableModel.create!(name: "Taggable 2", tag_list: "three, four", skill_list: "one, two")
-      taggable3 = TaggableModel.create!(name: "Taggable 3", tag_list: "one, four")
-
-      expect(taggable1.find_related_tags).to include(taggable3)
-      expect(taggable1.find_related_tags).to_not include(taggable2)
-    end
-
-    shared_examples "a collection" do
-      it do
-        taggable1 = described_class.create!(name: "Taggable 1", tag_list: "one")
-        taggable2 = described_class.create!(name: "Taggable 2", tag_list: "one, two")
-
-        expect(taggable1.find_related_tags).to include(taggable2)
-        expect(taggable1.find_related_tags).to_not include(taggable1)
-      end
-    end
-
-    # it 'should not include the object itself in the list of related objects' do
-    describe TaggableModel do
-      it_behaves_like "a collection"
-    end
-
-    # it 'should not include the object itself in the list of related objects - non standard id' do
-    describe NonStandardIdTaggableModel do
-      it_behaves_like "a collection"
-    end
-
-    context "Ignored Tags" do
-      let(:taggable1) { TaggableModel.create!(name: "Taggable 1", tag_list: "one, two, four") }
-      let(:taggable2) { TaggableModel.create!(name: "Taggable 2", tag_list: "two, three") }
-      let(:taggable3) { TaggableModel.create!(name: "Taggable 3", tag_list: "one, three") }
-
-      it "should not include ignored tags in related search" do
-        expect(taggable1.find_related_tags(ignore: "two")).to_not include(taggable2)
-        expect(taggable1.find_related_tags(ignore: "two")).to include(taggable3)
-      end
-
-      it "should accept array of ignored tags" do
-        taggable4 = TaggableModel.create!(name: "Taggable 4", tag_list: "four")
-
-        expect(taggable1.find_related_tags(ignore: ["two", "four"])).to_not include(taggable2)
-        expect(taggable1.find_related_tags(ignore: ["two", "four"])).to_not include(taggable4)
-      end
-
-      it "should accept symbols as ignored tags" do
-        expect(taggable1.find_related_tags(ignore: :two)).to_not include(taggable2)
-      end
-    end
-  end
-end

data/spec/make_taggable/single_table_inheritance_spec.rb

@@ -1,220 +0,0 @@
-require "spec_helper"
-
-describe "Single Table Inheritance" do
-  let(:taggable) { TaggableModel.new(name: "taggable model") }
-
-  let(:inheriting_model) { InheritingTaggableModel.new(name: "Inheriting Taggable Model") }
-  let(:altered_inheriting) { AlteredInheritingTaggableModel.new(name: "Altered Inheriting Model") }
-
-  1.upto(4) do |n|
-    let(:"inheriting_#{n}") { InheritingTaggableModel.new(name: "Inheriting Model #{n}") }
-  end
-
-  let(:student) { Student.create! }
-
-  describe "tag contexts" do
-    it "should pass on to STI-inherited models" do
-      expect(inheriting_model).to respond_to(:tag_list, :skill_list, :language_list)
-      expect(altered_inheriting).to respond_to(:tag_list, :skill_list, :language_list)
-    end
-
-    it "should pass on to altered STI models" do
-      expect(altered_inheriting).to respond_to(:part_list)
-    end
-  end
-
-  context "matching contexts" do
-    before do
-      inheriting_1.offering_list = "one, two"
-      inheriting_1.need_list = "one, two"
-      inheriting_1.save!
-
-      inheriting_2.need_list = "one, two"
-      inheriting_2.save!
-
-      inheriting_3.offering_list = "one, two"
-      inheriting_3.save!
-
-      inheriting_4.tag_list = "one, two, three, four"
-      inheriting_4.save!
-
-      taggable.need_list = "one, two"
-      taggable.save!
-    end
-
-    it "should find objects with tags of matching contexts" do
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to include(inheriting_2)
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_3)
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_4)
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(taggable)
-
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(inheriting_2)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_3)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_4)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable)
-    end
-
-    it "should not include the object itself in the list of related objects with tags of matching contexts" do
-      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_1)
-      expect(inheriting_1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs)).to_not include(inheriting_1)
-      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_1)
-    end
-  end
-
-  context "find related tags" do
-    before do
-      inheriting_1.tag_list = "one, two"
-      inheriting_1.save
-
-      inheriting_2.tag_list = "three, four"
-      inheriting_2.save
-
-      inheriting_3.tag_list = "one, four"
-      inheriting_3.save
-
-      taggable.tag_list = "one, two, three, four"
-      taggable.save
-    end
-
-    it "should find related objects based on tag names on context" do
-      expect(inheriting_1.find_related_tags).to include(inheriting_3)
-      expect(inheriting_1.find_related_tags).to_not include(inheriting_2)
-      expect(inheriting_1.find_related_tags).to_not include(taggable)
-
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(inheriting_3)
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_2)
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(taggable)
-    end
-
-    it "should not include the object itself in the list of related objects" do
-      expect(inheriting_1.find_related_tags).to_not include(inheriting_1)
-      expect(inheriting_1.find_related_tags_for(InheritingTaggableModel)).to_not include(inheriting_1)
-      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_1)
-    end
-  end
-
-  describe "tag list" do
-    before do
-      @inherited_same = InheritingTaggableModel.new(name: "inherited same")
-      @inherited_different = AlteredInheritingTaggableModel.new(name: "inherited different")
-    end
-
-    # TODO, shared example
-    it "should be able to save tags for inherited models" do
-      inheriting_model.tag_list = "bob, kelso"
-      inheriting_model.save
-      expect(InheritingTaggableModel.tagged_with("bob").first).to eq(inheriting_model)
-    end
-
-    it "should find STI tagged models on the superclass" do
-      inheriting_model.tag_list = "bob, kelso"
-      inheriting_model.save
-      expect(TaggableModel.tagged_with("bob").first).to eq(inheriting_model)
-    end
-
-    it "should be able to add on contexts only to some subclasses" do
-      altered_inheriting.part_list = "fork, spoon"
-      altered_inheriting.save
-      expect(InheritingTaggableModel.tagged_with("fork", on: :parts)).to be_empty
-      expect(AlteredInheritingTaggableModel.tagged_with("fork", on: :parts).first).to eq(altered_inheriting)
-    end
-
-    it "should have different tag_counts_on for inherited models" do
-      inheriting_model.tag_list = "bob, kelso"
-      inheriting_model.save!
-      altered_inheriting.tag_list = "fork, spoon"
-      altered_inheriting.save!
-
-      expect(InheritingTaggableModel.tag_counts_on(:tags, order: "#{MakeTaggable.tags_table}.id").map(&:name)).to eq(%w[bob kelso])
-      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: "#{MakeTaggable.tags_table}.id").map(&:name)).to eq(%w[fork spoon])
-      expect(TaggableModel.tag_counts_on(:tags, order: "#{MakeTaggable.tags_table}.id").map(&:name)).to eq(%w[bob kelso fork spoon])
-    end
-
-    it "should have different tags_on for inherited models" do
-      inheriting_model.tag_list = "bob, kelso"
-      inheriting_model.save!
-      altered_inheriting.tag_list = "fork, spoon"
-      altered_inheriting.save!
-
-      expect(InheritingTaggableModel.tags_on(:tags, order: "#{MakeTaggable.tags_table}.id").map(&:name)).to eq(%w[bob kelso])
-      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: "#{MakeTaggable.tags_table}.id").map(&:name)).to eq(%w[fork spoon])
-      expect(TaggableModel.tags_on(:tags, order: "#{MakeTaggable.tags_table}.id").map(&:name)).to eq(%w[bob kelso fork spoon])
-    end
-
-    it "should store same tag without validation conflict" do
-      taggable.tag_list = "one"
-      taggable.save!
-
-      inheriting_model.tag_list = "one"
-      inheriting_model.save!
-
-      inheriting_model.update! name: "foo"
-    end
-
-    it "should only join with taggable table to check type for inherited models" do
-      expect(TaggableModel.tag_counts_on(:tags).to_sql).to_not match(/INNER JOIN taggable_models ON/)
-      expect(InheritingTaggableModel.tag_counts_on(:tags).to_sql).to match(/INNER JOIN taggable_models ON/)
-    end
-  end
-
-  describe "ownership" do
-    it "should have taggings" do
-      student.tag(taggable, with: "ruby,scheme", on: :tags)
-      expect(student.owned_taggings.count).to eq(2)
-    end
-
-    it "should have tags" do
-      student.tag(taggable, with: "ruby,scheme", on: :tags)
-      expect(student.owned_tags.count).to eq(2)
-    end
-
-    it "should return tags for the inheriting tagger" do
-      student.tag(taggable, with: "ruby, scheme", on: :tags)
-      expect(taggable.tags_from(student)).to eq(%w[ruby scheme])
-    end
-
-    it "returns all owner tags on the taggable" do
-      student.tag(taggable, with: "ruby, scheme", on: :tags)
-      student.tag(taggable, with: "skill_one", on: :skills)
-      student.tag(taggable, with: "english, spanish", on: :language)
-      expect(taggable.owner_tags(student).count).to eq(5)
-      expect(taggable.owner_tags(student).sort == %w[english ruby scheme skill_one spanish])
-    end
-
-    it "returns owner tags on the tagger" do
-      student.tag(taggable, with: "ruby, scheme", on: :tags)
-      expect(taggable.owner_tags_on(student, :tags).count).to eq(2)
-    end
-
-    it "returns owner tags on the taggable for an array of contexts" do
-      student.tag(taggable, with: "ruby, scheme", on: :tags)
-      student.tag(taggable, with: "skill_one, skill_two", on: :skills)
-      expect(taggable.owner_tags_on(student, [:tags, :skills]).count).to eq(4)
-      expect(taggable.owner_tags_on(student, [:tags, :skills]).sort == %w[ruby scheme skill_one skill_two])
-    end
-
-    it "should scope objects returned by tagged_with by owners" do
-      student.tag(taggable, with: "ruby, scheme", on: :tags)
-      expect(TaggableModel.tagged_with(%w[ruby scheme], owned_by: student).count).to eq(1)
-    end
-  end
-
-  describe "a subclass of Tag" do
-    let(:company) { Company.new(name: "Dewey, Cheatham & Howe") }
-    let(:user) { User.create! }
-
-    subject { Market.create! name: "finance" }
-
-    it "sets STI type through string list" do
-      company.market_list = "law, accounting"
-      company.save!
-      expect(Market.count).to eq(2)
-    end
-
-    it "does not interfere with a normal Tag context on the same model" do
-      company.location_list = "cambridge"
-      company.save!
-      expect(MakeTaggable::Tag.where(name: "cambridge")).to_not be_empty
-    end
-  end
-end

data/spec/make_taggable/tag_list_spec.rb

@@ -1,169 +0,0 @@
-require "spec_helper"
-
-describe MakeTaggable::TagList do
-  let(:tag_list) { MakeTaggable::TagList.new("awesome", "radical") }
-  let(:another_tag_list) { MakeTaggable::TagList.new("awesome", "crazy", "alien") }
-
-  it { should be_kind_of Array }
-
-  describe "#add" do
-    it "should be able to be add a new tag word" do
-      tag_list.add("cool")
-      expect(tag_list.include?("cool")).to be_truthy
-    end
-
-    it "should be able to add delimited lists of words" do
-      tag_list.add("cool, wicked", parse: true)
-      expect(tag_list).to include("cool", "wicked")
-    end
-
-    it "should be able to add delimited list of words with quoted delimiters" do
-      tag_list.add("'cool, wicked', \"really cool, really wicked\"", parse: true)
-      expect(tag_list).to include("cool, wicked", "really cool, really wicked")
-    end
-
-    it "should be able to handle other uses of quotation marks correctly" do
-      tag_list.add("john's cool car, mary's wicked toy", parse: true)
-      expect(tag_list).to include("john's cool car", "mary's wicked toy")
-    end
-
-    it "should be able to add an array of words" do
-      tag_list.add(%w[cool wicked], parse: true)
-      expect(tag_list).to include("cool", "wicked")
-    end
-
-    it "should quote escape tags with commas in them" do
-      tag_list.add("cool", "rad,bodacious")
-      expect(tag_list.to_s).to eq("awesome, radical, cool, \"rad,bodacious\"")
-    end
-  end
-
-  describe "#remove" do
-    it "should be able to remove words" do
-      tag_list.remove("awesome")
-      expect(tag_list).to_not include("awesome")
-    end
-
-    it "should be able to remove delimited lists of words" do
-      tag_list.remove("awesome, radical", parse: true)
-      expect(tag_list).to be_empty
-    end
-
-    it "should be able to remove an array of words" do
-      tag_list.remove(%w[awesome radical], parse: true)
-      expect(tag_list).to be_empty
-    end
-  end
-
-  describe "#+" do
-    it "should not have duplicate tags" do
-      new_tag_list = tag_list + another_tag_list
-      expect(tag_list).to eq(%w[awesome radical])
-      expect(another_tag_list).to eq(%w[awesome crazy alien])
-      expect(new_tag_list).to eq(%w[awesome radical crazy alien])
-    end
-
-    it "should have class : MakeTaggable::TagList" do
-      new_tag_list = tag_list + another_tag_list
-      expect(new_tag_list.class).to eq(MakeTaggable::TagList)
-    end
-  end
-
-  describe "#concat" do
-    it "should not have duplicate tags" do
-      expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
-    end
-
-    it "should have class : MakeTaggable::TagList" do
-      new_tag_list = tag_list.concat(another_tag_list)
-      expect(new_tag_list.class).to eq(MakeTaggable::TagList)
-    end
-
-    context "without duplicates" do
-      let(:arr) { ["crazy", "alien"] }
-      let(:another_tag_list) { MakeTaggable::TagList.new(*arr) }
-      it "adds other list" do
-        expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
-      end
-
-      it "adds other array" do
-        expect(tag_list.concat(arr)).to eq(%w[awesome radical crazy alien])
-      end
-    end
-  end
-
-  describe "#to_s" do
-    it "should give a delimited list of words when converted to string" do
-      expect(tag_list.to_s).to eq("awesome, radical")
-    end
-
-    it "should be able to call to_s on a frozen tag list" do
-      tag_list.freeze
-      expect(-> { tag_list.add("cool", "rad,bodacious") }).to raise_error(RuntimeError)
-      expect(-> { tag_list.to_s }).to_not raise_error
-    end
-  end
-
-  describe "cleaning" do
-    it "should parameterize if force_parameterize is set to true" do
-      MakeTaggable.force_parameterize = true
-      tag_list = MakeTaggable::TagList.new("awesome()", "radical)(cc")
-
-      expect(tag_list.to_s).to eq("awesome, radical-cc")
-      MakeTaggable.force_parameterize = false
-    end
-
-    it "should lowercase if force_lowercase is set to true" do
-      MakeTaggable.force_lowercase = true
-
-      tag_list = MakeTaggable::TagList.new("aweSomE", "RaDicaL", "Entrée")
-      expect(tag_list.to_s).to eq("awesome, radical, entrée")
-
-      MakeTaggable.force_lowercase = false
-    end
-
-    it "should ignore case when removing duplicates if strict_case_match is false" do
-      tag_list = MakeTaggable::TagList.new("Junglist", "JUNGLIST", "Junglist", "Massive", "MASSIVE", "MASSIVE")
-
-      expect(tag_list.to_s).to eq("Junglist, Massive")
-    end
-
-    it "should not ignore case when removing duplicates if strict_case_match is true" do
-      MakeTaggable.strict_case_match = true
-      tag_list = MakeTaggable::TagList.new("Junglist", "JUNGLIST", "Junglist", "Massive", "MASSIVE", "MASSIVE")
-
-      expect(tag_list.to_s).to eq("Junglist, JUNGLIST, Massive, MASSIVE")
-      MakeTaggable.strict_case_match = false
-    end
-  end
-
-  describe "custom parser" do
-    let(:parser) { double(parse: %w[cool wicked]) }
-    let(:parser_class) { stub_const("MyParser", Class) }
-
-    it "should use a the default parser if none is set as parameter" do
-      allow(MakeTaggable.default_parser).to receive(:new).and_return(parser)
-      MakeTaggable::TagList.new("cool, wicked", parse: true)
-
-      expect(parser).to have_received(:parse)
-    end
-
-    it "should use the custom parser passed as parameter" do
-      allow(parser_class).to receive(:new).and_return(parser)
-
-      MakeTaggable::TagList.new("cool, wicked", parser: parser_class)
-
-      expect(parser).to have_received(:parse)
-    end
-
-    it "should use the parser setted as attribute" do
-      allow(parser_class).to receive(:new).with("new, tag").and_return(parser)
-
-      tag_list = MakeTaggable::TagList.new("example")
-      tag_list.parser = parser_class
-      tag_list.add("new, tag", parse: true)
-
-      expect(parser).to have_received(:parse)
-    end
-  end
-end