mongoid-slug 4.0.0

data/spec/models/integer_id.rb

@@ -0,0 +1,9 @@
+class IntegerId
+  include Mongoid::Document
+  include Mongoid::Slug
+
+  field :_id, type: Integer
+  field :name, type: String
+
+  slug :name, history: true
+end

data/spec/models/magazine.rb

@@ -0,0 +1,7 @@
+class Magazine
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title
+  field :publisher_id
+  slug  :title, :scope => :publisher_id
+end

data/spec/models/page.rb

@@ -0,0 +1,9 @@
+class Page
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title
+  field :content
+  field :order, :type => Integer
+  slug  :title
+  default_scope ->{ asc(:order) }
+end

data/spec/models/page_localize.rb

@@ -0,0 +1,9 @@
+class PageLocalize
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title, localize: true
+  field :content
+  field :order, :type => Integer
+  slug  :title
+  default_scope ->{ asc(:order) }
+end

data/spec/models/page_slug_localized.rb

@@ -0,0 +1,9 @@
+class PageSlugLocalized
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title, localize: true
+  field :content
+  field :order, :type => Integer
+  slug  :title, localize: true
+  default_scope ->{ asc(:order) }
+end

data/spec/models/page_slug_localized_custom.rb

@@ -0,0 +1,11 @@
+class PageSlugLocalizedCustom
+  include Mongoid::Document
+  include Mongoid::Slug
+
+  attr_accessor :title
+
+  slug :title, localize: true do |obj|
+    obj.title.to_url
+  end
+
+end

data/spec/models/page_slug_localized_history.rb

@@ -0,0 +1,9 @@
+class PageSlugLocalizedHistory
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title, localize: true
+  field :content
+  field :order, :type => Integer
+  slug  :title, localize: true, history: true
+  default_scope ->{ asc(:order) }
+end

data/spec/models/paranoid_document.rb

@@ -0,0 +1,8 @@
+class ParanoidDocument
+  include Mongoid::Document
+  include Mongoid::Paranoia
+  include Mongoid::Slug
+
+  field :title
+  slug  :title
+end

data/spec/models/paranoid_permanent.rb

@@ -0,0 +1,8 @@
+class ParanoidPermanent
+  include Mongoid::Document
+  include Mongoid::Paranoia
+  include Mongoid::Slug
+
+  field :title
+  slug  :title, permanent: true
+end

data/spec/models/partner.rb

@@ -0,0 +1,7 @@
+class Partner
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :name
+  slug  :name
+  embedded_in :relationship
+end

data/spec/models/person.rb

@@ -0,0 +1,8 @@
+class Person
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :name
+  slug  :name, :permanent => true, :scope => :author
+  embeds_many :relationships
+  belongs_to :author, :inverse_of => :characters
+end

data/spec/models/relationship.rb

@@ -0,0 +1,8 @@
+class Relationship
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :name
+  slug  :name
+  embeds_many :partners
+  embedded_in :person
+end

data/spec/models/string_id.rb

@@ -0,0 +1,9 @@
+class StringId
+  include Mongoid::Document
+  include Mongoid::Slug
+
+  field :_id, type: String
+  field :name, type: String
+
+  slug :name, history: true
+end

data/spec/models/subject.rb

@@ -0,0 +1,7 @@
+class Subject
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :name
+  slug  :name, :scope => :book, :history => true
+  embedded_in :book
+end

data/spec/models/without_slug.rb

@@ -0,0 +1,5 @@
+class WithoutSlug
+  include Mongoid::Document
+
+  field :_id, type: Integer
+end

data/spec/mongoid/criteria_spec.rb

@@ -0,0 +1,190 @@
+#encoding: utf-8
+require "spec_helper"
+
+describe Mongoid::Slug::Criteria do
+  describe ".find" do
+    let!(:book) { Book.create(:title => "A Working Title").tap { |d| d.update_attribute(:title, "A Thousand Plateaus") } }
+    let!(:book2) { Book.create(:title => "Difference and Repetition") }
+    let!(:friend) { Friend.create(:name => "Jim Bob") }
+    let!(:friend2) { Friend.create(:name => friend.id.to_s) }
+    let!(:integer_id) { IntegerId.new(:name => "I have integer ids").tap { |d| d.id = 123; d.save } }
+    let!(:integer_id2) { IntegerId.new(:name => integer_id.id.to_s).tap { |d| d.id = 456; d.save } }
+    let!(:string_id) { StringId.new(:name => "I have string ids").tap { |d| d.id = 'abc'; d.save } }
+    let!(:string_id2) { StringId.new(:name => string_id.id.to_s).tap { |d| d.id = 'def'; d.save } }
+    let!(:subject) { Subject.create(:name  => "A Subject", :book => book) }
+    let!(:subject2) { Subject.create(:name  => "A Subject", :book => book2) }
+    let!(:without_slug) { WithoutSlug.new().tap { |d| d.id = 456; d.save } }
+
+    context "when the model does not use mongoid slugs" do
+      it "should not use mongoid slug's custom find methods" do
+        Mongoid::Slug::Criteria.any_instance.should_not_receive(:find)
+        WithoutSlug.find(without_slug.id.to_s).should == without_slug
+      end
+    end
+
+    context "using slugs" do
+      context "(single)" do
+        context "and a document is found" do
+          it "returns the document as an object" do
+            Book.find(book.slugs.first).should == book
+          end
+        end
+
+        context "but no document is found" do
+          it "raises a Mongoid::Errors::DocumentNotFound error" do
+            lambda {
+              Book.find("Anti Oedipus")
+            }.should raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+      end
+
+      context "(multiple)" do
+        context "and all documents are found" do
+          it "returns the documents as an array without duplication" do
+            Book.find(book.slugs + book2.slugs).should =~ [book, book2]
+          end
+        end
+
+        context "but not all documents are found" do
+          it "raises a Mongoid::Errors::DocumentNotFound error" do
+            lambda {
+              Book.find(book.slugs + ['something-nonexistent'])
+            }.should raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+      end
+
+      context "when no documents match" do
+        it "raises a Mongoid::Errors::DocumentNotFound error" do
+          lambda {
+            Book.find("Anti Oedipus")
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+
+      context "when ids are BSON::ObjectIds and the supplied argument looks like a BSON::ObjectId" do
+        it "it should find based on ids not slugs" do # i.e. it should type cast the argument
+          Friend.find(friend.id.to_s).should == friend
+        end
+      end
+
+      context "when ids are Strings" do
+        it "it should find based on ids not slugs" do # i.e. string ids should take precedence over string slugs
+          StringId.find(string_id.id.to_s).should == string_id
+        end
+      end
+
+      context "when ids are Integers and the supplied arguments looks like an Integer" do
+        it "it should find based on slugs not ids" do # i.e. it should not type cast the argument
+          IntegerId.find(integer_id.id.to_s).should == integer_id2
+        end
+      end
+
+      context "models that does not use slugs, should find using the original find" do
+        it "it should find based on ids" do # i.e. it should not type cast the argument
+          WithoutSlug.find(without_slug.id.to_s).should == without_slug
+        end
+      end
+
+      context "when scoped" do
+        context "and a document is found" do
+          it "returns the document as an object" do
+            book.subjects.find(subject.slugs.first).should == subject
+            book2.subjects.find(subject.slugs.first).should == subject2
+          end
+        end
+
+        context "but no document is found" do
+          it "raises a Mongoid::Errors::DocumentNotFound error" do
+            lambda {
+              book.subjects.find('Another Subject')
+            }.should raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+      end
+    end
+
+    context "using ids" do
+      it "raises a Mongoid::Errors::DocumentNotFound error if no document is found" do
+        lambda {
+          Book.find(friend.id)
+        }.should raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      context "given a single document" do
+        it "returns the document" do
+          Friend.find(friend.id).should == friend
+        end
+      end
+
+      context "given multiple documents" do
+        it "returns the documents" do
+          Book.find([book.id, book2.id]).should =~ [book, book2]
+        end
+      end
+    end
+  end
+
+  describe ".find_by_slug!" do
+    let!(:book) { Book.create(:title => "A Working Title").tap { |d| d.update_attribute(:title, "A Thousand Plateaus") } }
+    let!(:book2) { Book.create(:title => "Difference and Repetition") }
+    let!(:friend) { Friend.create(:name => "Jim Bob") }
+    let!(:friend2) { Friend.create(:name => friend.id.to_s) }
+    let!(:integer_id) { IntegerId.new(:name => "I have integer ids").tap { |d| d.id = 123; d.save } }
+    let!(:integer_id2) { IntegerId.new(:name => integer_id.id.to_s).tap { |d| d.id = 456; d.save } }
+    let!(:string_id) { StringId.new(:name => "I have string ids").tap { |d| d.id = 'abc'; d.save } }
+    let!(:string_id2) { StringId.new(:name => string_id.id.to_s).tap { |d| d.id = 'def'; d.save } }
+    let!(:subject) { Subject.create(:name  => "A Subject", :book => book) }
+    let!(:subject2) { Subject.create(:name  => "A Subject", :book => book2) }
+
+    context "(single)" do
+      context "and a document is found" do
+        it "returns the document as an object" do
+          Book.find_by_slug!(book.slugs.first).should == book
+        end
+      end
+
+      context "but no document is found" do
+        it "raises a Mongoid::Errors::DocumentNotFound error" do
+          lambda {
+            Book.find_by_slug!("Anti Oedipus")
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+    end
+
+    context "(multiple)" do
+      context "and all documents are found" do
+        it "returns the documents as an array without duplication" do
+          Book.find_by_slug!(book.slugs + book2.slugs).should =~ [book, book2]
+        end
+      end
+
+      context "but not all documents are found" do
+        it "raises a Mongoid::Errors::DocumentNotFound error" do
+          lambda {
+            Book.find_by_slug!(book.slugs + ['something-nonexistent'])
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+    end
+
+    context "when scoped" do
+      context "and a document is found" do
+        it "returns the document as an object" do
+          book.subjects.find_by_slug!(subject.slugs.first).should == subject
+          book2.subjects.find_by_slug!(subject.slugs.first).should == subject2
+        end
+      end
+
+      context "but no document is found" do
+        it "raises a Mongoid::Errors::DocumentNotFound error" do
+          lambda {
+            book.subjects.find_by_slug!('Another Subject')
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/index_spec.rb

@@ -0,0 +1,34 @@
+#encoding: utf-8
+require "spec_helper"
+
+describe Mongoid::Slug::Index do
+
+  let(:scope_key)     { nil }
+  let(:by_model_type) { false }
+  subject { Mongoid::Slug::Index.build_index(scope_key, by_model_type) }
+
+  context "when scope_key is set" do
+    let(:scope_key) { :foo }
+
+    context "when by_model_type is true" do
+      let(:by_model_type) { true }
+      it { should eq [{:_slugs=>1, :foo=>1, :_type=>1}, {}] }
+    end
+
+    context "when by_model_type is false" do
+      it { should eq [{:_slugs=>1, :foo=>1}, {:unique=>true, :sparse=>true}] }
+    end
+  end
+
+  context "when scope_key is not set" do
+
+    context "when by_model_type is true" do
+      let(:by_model_type) { true }
+      it { should eq [{:_slugs=>1, :_type=>1}, {}] }
+    end
+
+    context "when by_model_type is false" do
+      it { should eq [{:_slugs=>1}, {:unique=>true, :sparse=>true}] }
+    end
+  end
+end

data/spec/mongoid/paranoia_spec.rb

@@ -0,0 +1,169 @@
+#encoding: utf-8
+require "spec_helper"
+
+describe "Mongoid::Paranoia with Mongoid::Slug" do
+
+  let(:paranoid_doc)    { ParanoidDocument.create!(:title => "slug") }
+  let(:paranoid_doc_2)  { ParanoidDocument.create!(:title => "slug") }
+  let(:paranoid_perm)   { ParanoidPermanent.create!(:title => "slug") }
+  let(:paranoid_perm_2) { ParanoidPermanent.create!(:title => "slug") }
+  let(:non_paranoid_doc){ Article.create!(:title => "slug") }
+  subject{ paranoid_doc }
+
+  describe ".paranoid?" do
+
+    context "when Mongoid::Paranoia is included" do
+      subject { paranoid_doc.class }
+      its(:is_paranoid_doc?){ should be_truthy }
+    end
+
+    context "when Mongoid::Paranoia not included" do
+      subject { non_paranoid_doc.class }
+      its(:is_paranoid_doc?){ should be_falsey }
+    end
+  end
+
+  describe "#paranoid_deleted?" do
+
+    context "when Mongoid::Paranoia is included" do
+
+      context "when not destroyed" do
+        its(:paranoid_deleted?){ should be_falsey }
+      end
+
+      context "when destroyed" do
+        before { subject.destroy }
+        its(:paranoid_deleted?){ should be_truthy }
+      end
+    end
+
+    context "when Mongoid::Paranoia not included" do
+      subject { non_paranoid_doc }
+      its(:paranoid_deleted?){ should be_falsey }
+    end
+  end
+
+  describe "restore callbacks" do
+
+    context "when Mongoid::Paranoia is included" do
+      subject { paranoid_doc.class }
+      it { should respond_to(:before_restore) }
+      it { should respond_to(:after_restore) }
+    end
+
+    context "when Mongoid::Paranoia not included" do
+      it { should_not respond_to(:before_restore) }
+      it { should_not respond_to(:after_restore) }
+    end
+  end
+
+  describe "index" do
+    before  { ParanoidDocument.create_indexes }
+    after   { ParanoidDocument.remove_indexes }
+    subject { ParanoidDocument }
+
+    it_should_behave_like "has an index", { _slugs: 1 }, { unique: true, sparse: true }
+  end
+
+  shared_examples_for "paranoid slugs" do
+
+    context "querying" do
+
+      it "returns paranoid_doc for correct slug" do
+        subject.class.find(subject.slug).should eq(subject)
+      end
+    end
+
+    context "delete (callbacks not fired)" do
+
+      before { subject.delete }
+
+      it "retains slug value" do
+        subject.slug.should eq "slug"
+        subject.class.unscoped.find("slug").should eq subject
+      end
+    end
+
+    context "destroy" do
+
+      before { subject.destroy }
+
+      it "unsets slug value when destroyed" do
+        subject._slugs.should eq []
+        subject.slug.should be_nil
+      end
+
+      it "persists the removed slug" do
+        subject.reload._slugs.should eq []
+        subject.reload.slug.should be_nil
+      end
+
+      it "persists the removed slug in the database" do
+        subject.class.unscoped.exists(_slugs: false).first.should eq subject
+        expect{subject.class.unscoped.find("slug")}.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      context "when saving the doc again" do
+
+        before { subject.save }
+
+        it "should have the default slug value" do
+          subject._slugs.should eq []
+          subject.slug.should be_nil
+        end
+
+        it "the slug remains unset in the database" do
+          subject.class.unscoped.exists(_slugs: false).first.should eq subject
+          expect{subject.class.unscoped.find("slug")}.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+    end
+
+    context "restore" do
+
+      before do
+        subject.destroy
+        subject.restore
+      end
+
+      it "resets slug value when restored" do
+        subject.slug.should eq "slug"
+        subject.reload.slug.should eq "slug"
+      end
+    end
+
+    context "multiple documents" do
+
+      it "new documents should be able to use the slug of destroyed documents" do
+        subject.slug.should eq "slug"
+        subject.destroy
+        subject.reload.slug.should be_nil
+        other_doc.slug.should eq "slug"
+        subject.restore
+        subject.slug.should eq "slug-1"
+        subject.reload.slug.should eq "slug-1"
+      end
+
+      it "should allow multiple documents to be destroyed without index conflict" do
+        subject.slug.should eq "slug"
+        subject.destroy
+        subject.reload.slug.should be_nil
+        other_doc.slug.should eq "slug"
+        other_doc.destroy
+        other_doc.reload.slug.should be_nil
+      end
+    end
+  end
+
+  context "non-permanent slug" do
+    subject { paranoid_doc }
+    let(:other_doc) { paranoid_doc_2 }
+    it_behaves_like "paranoid slugs"
+  end
+
+  context "permanent slug" do
+    subject { paranoid_perm }
+    let(:other_doc) { paranoid_perm_2 }
+    it_behaves_like "paranoid slugs"
+  end
+end