mongoid_slug 0.10.0 → 1.0.0.rc1

data/lib/mongoid/slug/criteria.rb

@@ -0,0 +1,90 @@
+# require 'moped/bson/object_id'
+
+module Mongoid
+  module Slug
+    class Criteria < Mongoid::Criteria
+      # Find the matchind document(s) in the criteria for the provided ids or slugs.
+      #
+      # If the document _ids are of the type Moped::BSON::ObjectId, and all the supplied parameters are
+      # convertible to Moped::BSON::ObjectId (via Moped::BSON::ObjectId#from_string), finding will be
+      # performed via _ids.
+      #
+      # If the document has any other type of _id field, and all the supplied parameters are of the same
+      # type, finding will be performed via _ids.
+      #
+      # Otherwise finding will be performed via slugs.
+      #
+      # @example Find by an id.
+      #   criteria.find(Moped::BSON::ObjectId.new)
+      #
+      # @example Find by multiple ids.
+      #   criteria.find([ Moped::BSON::ObjectId.new, Moped::BSON::ObjectId.new ])
+      #
+      # @example Find by a slug.
+      #   criteria.find('some-slug')
+      #
+      # @example Find by multiple slugs.
+      #   criteria.find([ 'some-slug', 'some-other-slug' ])
+      #
+      # @param [ Array<Object> ] args The ids or slugs to search for.
+      #
+      # @return [ Array<Document>, Document ] The matching document(s).
+      def find(*args)
+        look_like_slugs?(args.__find_args__) ? find_by_slug!(*args) : super
+      end
+
+      # Find the matchind document(s) in the criteria for the provided slugs.
+      #
+      # @example Find by a slug.
+      #   criteria.find('some-slug')
+      #
+      # @example Find by multiple slugs.
+      #   criteria.find([ 'some-slug', 'some-other-slug' ])
+      #
+      # @param [ Array<Object> ] args The slugs to search for.
+      #
+      # @return [ Array<Document>, Document ] The matching document(s).
+      def find_by_slug!(*args)
+        slugs = args.__find_args__
+        raise_invalid if slugs.any?(&:nil?)
+        for_slugs(slugs).execute_or_raise_for_slugs(slugs, args.multi_arged?)
+      end
+
+
+      # True if all supplied args look like slugs. Will only attempt to type cast for Moped::BSON::ObjectId.
+      # Thus '123' will be interpreted as a slug even if the _id is an Integer field, etc.
+      def look_like_slugs?(args)
+        if args.all? { |id| id.is_a?(String) }
+          id_type = @klass.fields['_id'].type
+          case
+            when id_type == Moped::BSON::ObjectId
+              args.any? { |id| !Moped::BSON::ObjectId.legal?(id) }
+            else args.any? { |id| id.class != id_type }
+          end
+        else
+          false
+        end
+      end
+      
+      protected
+
+      def for_slugs(slugs)
+        where({ _slugs: { '$in' => slugs } }).limit(slugs.length)
+      end
+
+      def execute_or_raise_for_slugs(slugs, multi)
+        result = uniq
+        check_for_missing_documents_for_slugs!(result, slugs)
+        multi ? result : result.first
+      end
+
+      def check_for_missing_documents_for_slugs!(result, slugs)
+        missing_slugs = slugs - result.map(&:slugs).flatten
+
+        if !missing_slugs.blank? && Mongoid.raise_not_found_error
+          raise Errors::DocumentNotFound.new(klass, slugs, missing_slugs)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/slug/version.rb

@@ -1,5 +1,5 @@
 module Mongoid #:nodoc:
   module Slug
-    VERSION = '0.10.0'
+    VERSION = '1.0.0.rc1'
   end
 end

data/lib/mongoid_slug.rb

@@ -1 +1,4 @@
+require 'mongoid'
+require 'stringex'
 require 'mongoid/slug'
+require 'mongoid/slug/criteria'

data/spec/models/author.rb

@@ -3,9 +3,9 @@ class Author
   include Mongoid::Slug
   field :first_name
   field :last_name
-  slug  :first_name, :last_name, :scope => :book, :index => true
-  referenced_in :book
-  references_many :characters,
-                  :class_name => 'Person',
-                  :foreign_key => :author_id
+  slug  :first_name, :last_name, :scope => :book
+  belongs_to :book
+  has_many :characters,
+           :class_name => 'Person',
+           :foreign_key => :author_id
 end

data/spec/models/book.rb

@@ -2,9 +2,10 @@ class Book
   include Mongoid::Document
   include Mongoid::Slug
   field :title
-  slug  :title, :index => true, :history => true
+
+  slug  :title, :history => true
   embeds_many :subjects
-  references_many :authors
+  has_many :authors
 end
 
 class ComicBook < Book

data/spec/models/caption.rb

@@ -1,17 +1,17 @@
 class Caption
   include Mongoid::Document
   include Mongoid::Slug
-  field :identity
+  field :my_identity, :type => String
   field :title
   field :medium
 
   # A fairly complex scenario, where we want to create a slug out of an
-  # identity field, which comprises name of artist and some more bibliographic
+  # my_identity field, which comprises name of artist and some more bibliographic
   # info in parantheses, and the title of the work.
   #
   # We are only interested in the name of the artist so we remove the
   # paranthesized details.
-  slug :identity, :title do |doc|
-    [doc.identity.gsub(/\s*\([^)]+\)/, ''), doc.title].join(' ')
+  slug :my_identity, :title do |cur_object|
+    cur_object.slug_builder.gsub(/\s*\([^)]+\)/, '').to_url
   end
 end

data/spec/models/friend.rb

@@ -2,5 +2,6 @@ class Friend
   include Mongoid::Document
   include Mongoid::Slug
   field :name
-  slug  :name, :reserve => ['foo', 'bar', /^[a-z]{2}$/i]
+  field :slug_history, :type => Array
+  slug  :name, :reserve => ['foo', 'bar', /^[a-z]{2}$/i], :history => true
 end

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/person.rb

@@ -2,7 +2,7 @@ class Person
   include Mongoid::Document
   include Mongoid::Slug
   field :name
-  slug  :name, :as => :permalink, :permanent => true, :scope => :author
+  slug  :name, :permanent => true, :scope => :author
   embeds_many :relationships
-  referenced_in :author, :inverse_of => :characters
+  belongs_to :author, :inverse_of => :characters
 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/without_slug.rb

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

data/spec/mongoid/slug_spec.rb

@@ -25,6 +25,11 @@ module Mongoid
         }
       end
 
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = Book.create(:title => "4ea0389f0364313d79104fb3")
+        bad.slugs.should_not include("4ea0389f0364313d79104fb3")
+      end
+
       it "does not update slug if slugged fields have not changed" do
         book.save
         book.to_param.should eql "a-thousand-plateaus"
@@ -36,8 +41,26 @@ module Mongoid
         book.to_param.should eql "a-thousand-plateaus"
       end
 
-      it "finds by slug" do
-        Book.find_by_slug(book.to_param).should eql book
+      context "using find" do
+        it "finds by id as string" do
+          Book.find(book.id.to_s).should eql book
+        end
+
+        it "finds by id as array of strings" do
+          Book.find([book.id.to_s]).should eql [book]
+        end
+
+        it "finds by id as Moped::BSON::ObjectId" do
+          Book.find(book.id).should eql book
+        end
+
+        it "finds by id as an array of Moped::BSON::ObjectIds" do
+          Book.find([book.id]).should eql [book]
+        end
+
+        it "returns an empty array if given an empty array" do
+          Book.find([]).should eql []
+        end
       end
     end
 
@@ -61,6 +84,11 @@ module Mongoid
         dup.to_param.should eql "psychoanalysis-1"
       end
 
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = book.subjects.create(:name => "4ea0389f0364313d79104fb3")
+        bad.slugs.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
       it "does not update slug if slugged fields have not changed" do
         subject.save
         subject.to_param.should eql "psychoanalysis"
@@ -71,9 +99,28 @@ module Mongoid
         subject.to_param.should eql "psychoanalysis"
       end
 
-      it "finds by slug" do
-        book.subjects.find_by_slug(subject.to_param).should eql subject
+      context "using find" do
+        it "finds by id as string" do
+          book.subjects.find(subject.id.to_s).should eql subject
+        end
+
+        it "finds by id as array of strings" do
+          book.subjects.find([subject.id.to_s]).should eql [subject]
+        end
+
+        it "finds by id as Moped::BSON::ObjectId" do
+          book.subjects.find(subject.id).should eql subject
+        end
+
+        it "finds by id as an array of Moped::BSON::ObjectIds" do
+          book.subjects.find([subject.id]).should eql [subject]
+        end
+
+        it "returns an empty array if given an empty array" do
+          book.subjects.find([]).should eql []
+        end
       end
+
     end
 
     context "when the object is embedded in another embedded object" do
@@ -104,6 +151,11 @@ module Mongoid
         dup.to_param.should eql "jane-smith-1"
       end
 
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = relationship.partners.create(:name => "4ea0389f0364313d79104fb3")
+        bad.slugs.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
       it "does not update slug if slugged fields have not changed" do
         partner.save
         partner.to_param.should eql "jane-smith"
@@ -120,9 +172,28 @@ module Mongoid
         lover.to_param.should eql partner.to_param
       end
 
-      it "finds by slug" do
-        relationship.partners.find_by_slug(partner.to_param).should eql partner
+      context "using find" do
+        it "finds by id as string" do
+          relationship.partners.find(partner.id.to_s).should eql partner
+        end
+
+        it "finds by id as array of strings" do
+          relationship.partners.find([partner.id.to_s]).should eql [partner]
+        end
+
+        it "finds by id as Moped::BSON::ObjectId" do
+          relationship.partners.find(partner.id).should eql partner
+        end
+
+        it "finds by id as an array of Moped::BSON::ObjectIds" do
+          relationship.partners.find([partner.id]).should eql [partner]
+        end
+
+        it "returns an empty array if given an empty array" do
+          relationship.partners.find([]).should eql []
+        end
       end
+
     end
 
     context "when the slug is composed of multiple fields" do
@@ -157,15 +228,17 @@ module Mongoid
         dup2.to_param.should eql "gilles-deleuze-2"
       end
 
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = Author.create(:first_name => "4ea0389f0364",
+                            :last_name => "313d79104fb3")
+        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
       it "does not update slug if slugged fields have changed but generated slug is identical" do
         author.last_name = "DELEUZE"
         author.save
         author.to_param.should eql "gilles-deleuze"
       end
-
-      it "finds by slug" do
-        Author.find_by_slug("gilles-deleuze").should eql author
-      end
     end
 
     context "when :as is passed as an argument" do
@@ -174,12 +247,20 @@ module Mongoid
       end
 
       it "sets an alternative slug field name" do
-        person.should respond_to(:permalink)
-        person.permalink.should eql "john-doe"
+        person.should respond_to(:_slugs)
+        person.slugs.should eql ["john-doe"]
+      end
+
+      it 'defines #slug' do
+        person.should respond_to :slugs
       end
 
-      it "finds by slug" do
-        Person.find_by_permalink("john-doe").should eql person
+      it 'defines #slug_changed?' do
+        person.should respond_to :_slugs_changed?
+      end
+
+      it 'defines #slug_was' do
+        person.should respond_to :_slugs_was
       end
     end
 
@@ -206,15 +287,7 @@ module Mongoid
       end
 
       it "saves the old slug in the owner's history" do
-        book.slug_history.should include("book-title")
-      end
-
-      it "returns the document for the old slug" do
-        Book.find_by_slug("book-title").should == book
-      end
-
-      it "returns the document for the new slug" do
-        Book.find_by_slug("other-book-title").should == book
+        book.slugs.should include("book-title")
       end
 
       it "generates a unique slug by appending a counter to duplicate text" do
@@ -222,10 +295,15 @@ module Mongoid
         dup.to_param.should eql "book-title-1"
       end
 
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = Book.create(:title => "4ea0389f0364313d79104fb3")
+        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
       it "ensures no duplicate values are stored in history" do
         book.update_attributes :title => 'Book Title'
         book.update_attributes :title => 'Foo'
-        book.slug_history.find_all { |slug| slug == 'book-title' }.size.should eql 1
+        book.slugs.find_all { |slug| slug == 'book-title' }.size.should eql 1
       end
     end
 
@@ -250,6 +328,12 @@ module Mongoid
         dup.to_param.should eql "gilles-deleuze-1"
       end
 
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = book.authors.create(:first_name => "4ea0389f0364",
+                                  :last_name => "313d79104fb3")
+        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
       context "with an irregular association name" do
         let(:character) do
           # well we've got to make up something... :-)
@@ -285,11 +369,11 @@ module Mongoid
         end
 
         it "allows using the slug" do
-          subject2.slug.should == "a-subject"
+          subject2.slugs.should include("a-subject")
         end
 
         it "removes the slug from the old owner's history" do
-          subject1.slug_history.should_not include("a-subject")
+          subject1.slugs.should_not include("a-subject")
         end
       end
     end
@@ -309,11 +393,17 @@ module Mongoid
         dup = Magazine.create(:title  => "Big Weekly", :publisher_id => "abc123")
         dup.to_param.should eql "big-weekly-1"
       end
+
+      it "does not allow a Moped::BSON::ObjectId as use for a slug" do
+        bad = Magazine.create(:title  => "4ea0389f0364313d79104fb3", :publisher_id => "abc123")
+        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
     end
 
     context "when #slug is given a block" do
       let(:caption) do
-        Caption.create(:identity => "Edward Hopper (American, 1882-1967)",
+        Caption.create(:my_identity => "Edward Hopper (American, 1882-1967)",
                        :title    => "Soir Bleu, 1914",
                        :medium   => "Oil on Canvas")
       end
@@ -329,14 +419,10 @@ module Mongoid
       end
 
       it "does not change slug if slugged fields have changed but generated slug is identical" do
-        caption.identity = "Edward Hopper"
+        caption.my_identity = "Edward Hopper"
         caption.save
         caption.to_param.should eql "edward-hopper-soir-bleu-1914"
       end
-
-      it "finds by slug" do
-        Caption.find_by_slug(caption.to_param).should eql caption
-      end
     end
 
     context "when slugged field contains non-ASCII characters" do
@@ -365,59 +451,54 @@ module Mongoid
       end
     end
 
-    context "when :index is passed as an argument" do
+    context "when indexes are created" do
       before do
-        Book.collection.drop_indexes
-        Author.collection.drop_indexes
-      end
-
-      it "defines an index on the slug in top-level objects" do
+        Author.create_indexes
         Book.create_indexes
-        Book.collection.index_information.should have_key "slug_1"
       end
 
-      context "when slug is scoped by a reference association" do
-        it "defines a non-unique index" do
-          Author.create_indexes
-          Author.index_information["slug_1"]["unique"].should be_false
-        end
+      after do
+        Author.remove_indexes
+        Book.remove_indexes
       end
 
       context "when slug is not scoped by a reference association" do
+        it "defines an index on the slug" do
+          Book.index_options.should have_key( :_slugs => 1 )
+        end
+
         it "defines a unique index" do
-          Book.create_indexes
-          Book.index_information["slug_1"]["unique"].should be_true
+          Book.index_options[ :_slugs => 1 ][:unique].should be_true
         end
       end
-    end
 
-    context "when :index is not passed as an argument" do
-      it "does not define an index on the slug" do
-        Person.create_indexes
-        Person.collection.index_information.should_not have_key "permalink_1"
+      context "when slug is scoped by a reference association" do
+        it "does not define an index on the slug" do
+          Author.index_options.should_not have_key(:_slugs => 1 )
+        end
       end
     end
-    
+
     context "when :reserve is passed" do
       it "does not use the the reserved slugs" do
         friend1 = Friend.create(:name => "foo")
-        friend1.slug.should_not eql("foo")
-        friend1.slug.should eql("foo-1")
+        friend1.slugs.should_not eql("foo")
+        friend1.slugs.should include("foo-1")
 
         friend2 = Friend.create(:name => "bar")
-        friend2.slug.should_not eql("bar")
-        friend2.slug.should eql("bar-1")
+        friend2.slugs.should_not eql("bar")
+        friend2.slugs.should include("bar-1")
 
         friend3 = Friend.create(:name => "en")
-        friend3.slug.should_not eql("en")
-        friend3.slug.should eql("en-1")
+        friend3.slugs.should_not eql("en")
+        friend3.slugs.should include("en-1")
       end
 
       it "should start with concatenation -1" do
         friend1 = Friend.create(:name => "foo")
-        friend1.slug.should eql("foo-1")
+        friend1.slugs.should include("foo-1")
         friend2 = Friend.create(:name => "foo")
-        friend2.slug.should eql("foo-2")
+        friend2.slugs.should include("foo-2")
       end
     end
 
@@ -425,112 +506,264 @@ module Mongoid
       it "scopes by the superclass" do
         book = Book.create(:title => "Anti Oedipus")
         comic_book = ComicBook.create(:title => "Anti Oedipus")
-        comic_book.slug.should_not eql(book.slug)
+        comic_book.slugs.should_not eql(book.slugs)
       end
     end
 
     context "when slug defined on alias of field" do
       it "should use accessor, not alias" do
         pseudonim  = Alias.create(:author_name => "Max Stirner")
-        pseudonim.slug.should eql("max-stirner")
+        pseudonim.slugs.should include("max-stirner")
       end
     end
 
-    describe ".by_slug scope" do
-      let!(:author) { book.authors.create(:first_name => "Gilles", :last_name  => "Deleuze") }
-
-      it "returns an empty array if no document is found" do
-        book.authors.by_slug("never-heard-of").should == []
+    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(:title  => "A Subject", :book => book) }
+      let!(:subject2) { Subject.create(:title  => "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
 
-      it "returns an array containing the document if it is found" do
-        book.authors.by_slug(author.slug).should == [author]
-      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
 
-    describe ".find_by_slug" do
-      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+        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
 
-      it "returns nil if no document is found" do
-        Book.find_by_slug(:title => "Anti Oedipus").should be_nil
+        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
 
-      it "returns the document if it is found" do
-        Book.find_by_slug(book.slug).should == book
+      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 Thousand Plateaus") }
+      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(:title  => "A Subject", :book => book) }
+      let!(:subject2) { Subject.create(:title  => "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
 
-      it "raises a Mongoid::Errors::DocumentNotFound error if no document is found" do
-        lambda {
-          Book.find_by_slug!(:title => "Anti Oedipus")
-        }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        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
 
-      it "returns the document when it is found" do
-        Book.find_by_slug!(book.slug).should == book
-      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 "when #to_param is called on an existing record with no slug" do
-      before do
-        Book.collection.insert(:title => "Proust and Signs")
+        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
 
-      it "generates the missing slug" do
-        book = Book.first
-        book.to_param
-        book.reload.slug.should eql "proust-and-signs"
+      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
 
-    describe ".for_unique_slug_for" do
-      it "returns the unique slug" do
-        Book.find_unique_slug_for("A Thousand Plateaus").should eq("a-thousand-plateaus")
+    describe "#to_param" do
+      context "when called on an existing record with no slug" do
+        before do
+          Book.collection.insert(:title => "Proust and Signs")
+        end
+
+        it "generates the missing slug" do
+          book = Book.first
+          book.to_param
+          book.reload.slugs.should include("proust-and-signs")
+        end
       end
+    end
 
-      it "returns the unique slug with a counter if necessary" do
+    describe "#_slugs_changed?" do
+      before do
         Book.create(:title => "A Thousand Plateaus")
-        Book.find_unique_slug_for("A Thousand Plateaus").should eq("a-thousand-plateaus-1")
       end
 
-      it "returns the unique slug as if it were the provided object" do
-        book = Book.create(:title => "A Thousand Plateaus")
-        Book.find_unique_slug_for("A Thousand Plateaus", :model => book).should eq("a-thousand-plateaus")
+      let(:book) { Book.first }
+
+      it "is initially unchanged" do
+        book._slugs_changed?.should be_false
+      end
+
+      it "tracks changes" do
+        book.slugs = ["Anti Oedipus"]
+        book._slugs_changed?.should be_true
       end
     end
 
-    describe "#find_unique_slug_for" do
-      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+    describe "when regular expression matches, but document does not" do
+      let!(:book_1) { Book.create(:title => "book-1") }
+      let!(:book_2) { Book.create(:title => "book") }
+      let!(:book_3) { Book.create(:title => "book") }
 
-      it "returns the unique slug" do
-        book.find_unique_slug_for("Anti Oedipus").should eq("anti-oedipus")
+      it "book_2 should have the user supplied title without -1 after it" do
+        book_2.to_param.should eql "book"
       end
 
-      it "returns the unique slug with a counter if necessary" do
-        Book.create(:title => "Anti Oedipus")
-        book.find_unique_slug_for("Anti Oedipus").should eq("anti-oedipus-1")
+      it "book_3 should have a generated slug" do
+        book_3.to_param.should eql "book-2"
       end
     end
 
     context "when the slugged field is set manually" do
       context "when it set to a non-empty string" do
         it "respects the provided slug" do
-          book = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
+          book = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
           book.to_param.should eql "not-what-you-expected"
         end
-        
+
         it "ensures uniqueness" do
-          book1 = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
-          book2 = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
+          book1 = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
+          book2 = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
           book2.to_param.should eql "not-what-you-expected-1"
         end
-        
+
         it "updates the slug when a new one is passed in" do
-          book = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
-          book.slug = "not-it-either"
+          book = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
+          book.slugs = ["not-it-either"]
           book.save
           book.to_param.should eql "not-it-either"
         end
@@ -538,7 +771,7 @@ module Mongoid
 
       context "when it is set to an empty string" do
         it "generate a new one" do
-          book = Book.create(:title => "A Thousand Plateaus", :slug => "")
+          book = Book.create(:title => "A Thousand Plateaus")
           book.to_param.should eql "a-thousand-plateaus"
         end
       end