mongoid_slug 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ce4dfe55677a1b8cb8d39718cf595933dd7eae7
-  data.tar.gz: 799033738af175e6233c03268c73bafe0d17a259
+  metadata.gz: ae9fab25b8db6880157df5b1fcab5608336cfe9e
+  data.tar.gz: e8cd36c3abc7acb9b1850e17feff903d4c965743
 SHA512:
-  metadata.gz: 50ff4db23d6243bb38678fc957d369ff8277607503a1c301d4841a8c835c93925100187549451d550cf4fea6b27b698e700de48962d12b9c5d0d3497fbb0c218
-  data.tar.gz: 56d4bb715d1977746ebcf7c7ca94f58040e3d083028dcaeff7b15fc9963ef256fd20fafbdcf2d9ccff51596a21da53b96efee562be13666b68d9777bad87f814
+  metadata.gz: 21ee51edcd378221ba9057a806d4d3c609df8704a1c297145e3c72c8439d0a4266e4947faed5f8b8d487042b73bdd7759cab0618e001f5c2d957123d331509fc
+  data.tar.gz: 0a11a12f37b1b45a855ba89ca854b16adb71e184db4ca2c1a5799e9c50c511acd700807551a432f8224c4d29c912357e35b5576dccc13a29e9391e30f691f7f2

data/README.md

@@ -8,7 +8,7 @@ Mongoid Slug generates a URL slug or permalink based on one or more fields in a
 Mongoid model. It sits idly on top of [stringex] [1], supporting non-Latin
 characters.
 
-[![Build Status](https://secure.travis-ci.org/digitalplaywright/mongoid-slug.png)](http://travis-ci.org/digitalplaywright/mongoid-slug)
+[![Build Status](https://secure.travis-ci.org/digitalplaywright/mongoid-slug.png)](http://travis-ci.org/digitalplaywright/mongoid-slug) [![Dependency Status](https://gemnasium.com/digitalplaywright/mongoid-slug.png)](https://gemnasium.com/digitalplaywright/mongoid-slug) [![Code Climate](https://codeclimate.com/github/digitalplaywright/mongoid-slug.png)](https://codeclimate.com/github/digitalplaywright/mongoid-slug)
 
 Installation
 ------------
@@ -235,13 +235,13 @@ Specifying an array of custom reserved words will overwrite these defaults.
 Localize Slug
 --------------
 
-The slug can be localized: 
+The slug can be localized:
 
 ```ruby
 class PageSlugLocalize
   include Mongoid::Document
   include Mongoid::Slug
-  
+
   field :title, localize: true
   slug  :title, localize: true
 end
@@ -250,7 +250,7 @@ end
 This feature is built upon Mongoid localized fields, so fallbacks and localization
 works as documented in the Mongoid manual.
 
-PS! A migration is needed to use Mongoid localized fields for documents that was created when this 
+PS! A migration is needed to use Mongoid localized fields for documents that was created when this
 feature was off. Anything else will cause errors.
 
 Custom Find Strategies

data/lib/mongoid/slug.rb

@@ -64,7 +64,7 @@ module Mongoid
             scope_key = (metadata = self.reflect_on_association(slug_scope)) ? metadata.key : slug_scope
             if options[:by_model_type] == true
               # Add _type to the index to fix polymorphism
-              index({ _type: 1, scope_key => 1, _slugs: 1}, {unique: true})
+              index({ _type: 1, scope_key => 1, _slugs: 1})
             else
               index({scope_key => 1, _slugs: 1}, {unique: true})
             end
@@ -72,7 +72,7 @@ module Mongoid
           else
             # Add _type to the index to fix polymorphism
             if options[:by_model_type] == true
-              index({_type: 1, _slugs: 1}, {unique: true})
+              index({_type: 1, _slugs: 1})
             else
               index({_slugs: 1}, {unique: true})
             end
@@ -130,22 +130,39 @@ module Mongoid
     #
     # @return [true]
     def build_slug
+      if localized?
+        begin
+          orig_locale = I18n.locale
+          all_locales = self.slugged_attributes
+                            .map{|attr| self.send("#{attr}_translations").keys}.flatten.uniq
+          all_locales.each do |target_locale|
+            I18n.locale = target_locale
+            set_slug
+          end
+        ensure
+          I18n.locale = orig_locale
+        end
+      else
+        set_slug
+      end
+      true
+    end
+
+    def set_slug
       _new_slug = find_unique_slug
 
       #skip slug generation and use Mongoid id
       #to find document instead
       return true if _new_slug.size == 0
 
+      # avoid duplicate slugs
       self._slugs.delete(_new_slug) if self._slugs
 
       if !!self.history && self._slugs.is_a?(Array)
-        self._slugs << _new_slug
+        append_slug(_new_slug)
       else
         self._slugs = [_new_slug]
       end
-
-      true
-
     end
 
     # Finds a unique slug, were specified string used to generate a slug.
@@ -181,16 +198,61 @@ module Mongoid
 
     def slug_builder
       _cur_slug = nil
-      if (new_record? and _slugs.present?) or (persisted? and _slugs_changed?)
+      if new_with_slugs? or persisted_with_slug_changes?
         #user defined slug
-        _cur_slug =  _slugs.last
+        _cur_slug = _slugs.last
       end
       #generate slug if the slug is not user defined or does not exist
       _cur_slug || pre_slug_string
     end
 
+
+
     private
 
+    def append_slug(_slug)
+      if localized?
+        # This is necessary for the scenario in which the slugged locale is not yet present
+        # but the default locale is. In this situation, self._slugs falls back to the default
+        # which is undesired
+        current_slugs = self._slugs_translations.fetch(I18n.locale.to_s, [])
+        current_slugs << _slug
+        self._slugs_translations = self._slugs_translations.merge(I18n.locale.to_s => current_slugs)
+      else
+        self._slugs << _slug
+      end
+    end
+
+    # Returns true if object is a new record and slugs are present
+    def new_with_slugs?
+      if localized?
+        # We need to check if slugs are present for the locale without falling back
+        # to a default
+        new_record? and _slugs_translations.fetch(I18n.locale.to_s, []).any?
+      else
+        new_record? and _slugs.present?
+      end
+    end
+
+    # Returns true if object has been persisted and has changes in the slug
+    def persisted_with_slug_changes?
+      if localized?
+        changes = self._slugs_change
+        return (persisted? and false) if changes.nil?
+
+        # ensure we check for changes only between the same locale
+        original = changes.first.try(:fetch, I18n.locale.to_s, nil)
+        compare = changes.last.try(:fetch, I18n.locale.to_s, nil)
+        persisted? and original != compare
+      else
+        persisted? and _slugs_changed?
+      end
+    end
+
+    def localized?
+      self.fields['_slugs'].options[:localize] rescue false
+    end
+
     def pre_slug_string
       self.slugged_attributes.map { |f| self.send f }.join ' '
     end

data/lib/mongoid/slug/unique_slug.rb

@@ -80,7 +80,7 @@ module Mongoid
         # Regular expression that matches slug, slug-1, ... slug-n
         # If slug_name field was indexed, MongoDB will utilize that
         # index to match /^.../ pattern.
-        pattern = /^#{Regexp.escape(_slug)}(?:-(\d+))?$/
+        pattern = /^#{Regexp.escape(@_slug)}(?:-(\d+))?$/
 
         where_hash = {}
         where_hash[:_slugs.all] = [pattern]
@@ -96,13 +96,13 @@ module Mongoid
           where_hash[:_type] = model.try(:read_attribute, :_type)
         end
 
-        @state = SlugState.new _slug, uniqueness_scope.unscoped.where(where_hash), pattern
+        @state = SlugState.new @_slug, uniqueness_scope.unscoped.where(where_hash), pattern
 
         # do not allow a slug that can be interpreted as the current document id
-        @state.include_slug unless model.class.look_like_slugs?([_slug])
+        @state.include_slug unless model.class.look_like_slugs?([@_slug])
 
         # make sure that the slug is not equal to a reserved word
-        @state.include_slug if reserved_words.any? { |word| word === _slug }
+        @state.include_slug if reserved_words.any? { |word| word === @_slug }
 
         # only look for a new unique slug if the existing slugs contains the current slug
         # - e.g if the slug 'foo-2' is taken, but 'foo' is available, the user can use 'foo'.
@@ -110,7 +110,7 @@ module Mongoid
           highest = @state.highest_existing_counter
           @_slug += "-#{highest.succ}"
         end
-        _slug
+        @_slug
       end
 
       def uniqueness_scope

data/lib/mongoid/slug/version.rb

@@ -1,5 +1,5 @@
 module Mongoid #:nodoc:
   module Slug
-    VERSION = '3.1.1'
+    VERSION = '3.1.2'
   end
 end

data/spec/models/page_slug_localized.rb

@@ -1,4 +1,4 @@
-class PageSlugLocalize
+class PageSlugLocalized
   include Mongoid::Document
   include Mongoid::Slug
   field :title, localize: true

data/spec/models/page_slug_localized_history.rb

@@ -1,4 +1,4 @@
-class PageSlugLocalizeHistory
+class PageSlugLocalizedHistory
   include Mongoid::Document
   include Mongoid::Slug
   field :title, localize: true

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

@@ -544,7 +544,7 @@ module Mongoid
           end
 
           it "defines a unique index" do
-            BookPolymorphic.index_options[ :_type => 1, :_slugs => 1 ][:unique].should be_true
+            BookPolymorphic.index_options[ :_type => 1, :_slugs => 1 ][:unique].should_not be_true
           end
         end
 
@@ -642,192 +642,6 @@ module Mongoid
       end
     end
 
-    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
-
     describe "#to_param" do
       context "when called on a new record" do
         let(:book) { Book.new }
@@ -938,11 +752,16 @@ module Mongoid
     end
 
     context "slug can be localized" do
-      it "generate a new slug for each localization" do
-        old_locale = I18n.locale
+      before(:each) do
+        @old_locale = I18n.locale
+      end
 
-        # Using a default locale of en.
-        page = PageSlugLocalize.new
+      after(:each) do
+        I18n.locale = @old_locale
+      end
+
+      it "generates a new slug for each localization" do
+        page = PageSlugLocalized.new
         page.title = "Title on English"
         page.save
         page.slug.should eql "title-on-english"
@@ -950,31 +769,19 @@ module Mongoid
         page.title = "Title on Netherlands"
         page.save
         page.slug.should eql "title-on-netherlands"
-
-        # Set locale back to english
-        I18n.locale = old_locale
       end
 
       it "returns _id if no slug" do
-        old_locale = I18n.locale
-
-        # Using a default locale of en.
-        page = PageSlugLocalize.new
+        page = PageSlugLocalized.new
         page.title = "Title on English"
         page.save
         page.slug.should eql "title-on-english"
         I18n.locale = :nl
         page.slug.should eql page._id.to_s
-
-        # Set locale back to english
-        I18n.locale = old_locale
       end
 
       it "fallbacks if slug not localized yet" do
-        old_locale = I18n.locale
-
-        # Using a default locale of en.
-        page = PageSlugLocalize.new
+        page = PageSlugLocalized.new
         page.title = "Title on English"
         page.save
         page.slug.should eql "title-on-english"
@@ -988,20 +795,14 @@ module Mongoid
         page.slug.should eql "title-on-english"
         fallback_slug = page.slug
 
-        fallback_page = PageSlugLocalize.find(fallback_slug) rescue nil
+        fallback_page = PageSlugLocalized.find(fallback_slug) rescue nil
         fallback_page.should eq(page)
 
-        # Set locale back to english
-        I18n.locale = old_locale
-
         # Restore fallback for next tests
         ::I18n.fallbacks[:nl] = [ :nl ]
       end
 
-      it "returns default slug if not localized" do
-        old_locale = I18n.locale
-
-        # Using a default locale of en.
+      it "returns a default slug if not localized" do
         page = PageLocalize.new
         page.title = "Title on English"
         page.save
@@ -1011,19 +812,88 @@ module Mongoid
         page.slug.should eql "title-on-english"
         page.save
         page.slug.should eql "title-on-netherlands"
+      end
+
+      it "slugs properly when translations are set directly" do
+        page = PageSlugLocalized.new
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs" do
+        old_locale = I18n.locale
 
+        # Using a default locale of en.
+        page = PageSlugLocalized.new
+        page.title = "Title on English"
+        page.save
+        I18n.locale = "nl"
+        page.title = "Title on Netherlands"
+        page.save
+        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
 
-        # Set locale back to english
         I18n.locale = old_locale
+        page.title = "Title on English"
+        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs when one has changed" do
+        old_locale = I18n.locale
+
+        # Using a default locale of en.
+        page = PageSlugLocalized.new
+        page.title = "Title on English"
+        page.save
+        I18n.locale = "nl"
+        page.title = "Title on Netherlands"
+        page.save
+        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+
+        I18n.locale = old_locale
+        page.title = "Modified Title on English"
+        page.save
+        page.title_translations.should == {"en" => "Modified Title on English",
+                                           "nl" => "Title on Netherlands"}
+        page["_slugs"].should == {"en" => ["modified-title-on-english"],
+                                  "nl" => ["title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs when transactions are set directly" do
+        page = PageSlugLocalized.new
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs when transactions are set directly and one has changed" do
+        page = PageSlugLocalized.new
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page.title_translations = {"en" => "Modified Title on English",
+                                   "nl" => "Title on Netherlands"}
+        page.save
+        page["_slugs"].should == {"en" => ["modified-title-on-english"],
+                                  "nl" => ["title-on-netherlands"]}
       end
     end
 
     context "slug can be localized when using history" do
+      before(:each) do
+        @old_locale = I18n.locale
+      end
+
+      after(:each) do
+        I18n.locale = @old_locale
+      end
+
       it "generate a new slug for each localization and keep history" do
         old_locale = I18n.locale
 
-        # Using a default locale of en.
-        page = PageSlugLocalizeHistory.new
+        page = PageSlugLocalizedHistory.new
         page.title = "Title on English"
         page.save
         page.slug.should eql "title-on-english"
@@ -1041,31 +911,19 @@ module Mongoid
         page.save
         page.slug.should eql "modified-title-on-netherlands"
         page.slug.should include("title-on-netherlands")
-
-        # Set locale back to english
-        I18n.locale = old_locale
       end
 
       it "returns _id if no slug" do
-        old_locale = I18n.locale
-
-        # Using a default locale of en.
-        page = PageSlugLocalizeHistory.new
+        page = PageSlugLocalizedHistory.new
         page.title = "Title on English"
         page.save
         page.slug.should eql "title-on-english"
         I18n.locale = :nl
         page.slug.should eql page._id.to_s
-
-        # Set locale back to english
-        I18n.locale = old_locale
       end
 
       it "fallbacks if slug not localized yet" do
-        old_locale = I18n.locale
-
-        # Using a default locale of en.
-        page = PageSlugLocalizeHistory.new
+        page = PageSlugLocalizedHistory.new
         page.title = "Title on English"
         page.save
         page.slug.should eql "title-on-english"
@@ -1079,12 +937,79 @@ module Mongoid
         page.slug.should eql "title-on-english"
         fallback_slug = page.slug
 
-        fallback_page = PageSlugLocalizeHistory.find(fallback_slug) rescue nil
+        fallback_page = PageSlugLocalizedHistory.find(fallback_slug) rescue nil
         fallback_page.should eq(page)
+      end
+
+      it "slugs properly when translations are set directly" do
+        page = PageSlugLocalizedHistory.new
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page.title_translations = {"en" => "Modified Title on English",
+                                   "nl" => "Modified Title on Netherlands"}
+        page.save
+        page["_slugs"].should == {"en" => ["title-on-english", "modified-title-on-english"],
+                                  "nl" => ["title-on-netherlands", "modified-title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs" do
+        old_locale = I18n.locale
+
+        # Using a default locale of en.
+        page = PageSlugLocalizedHistory.new
+        page.title = "Title on English"
+        page.save
+        I18n.locale = "nl"
+        page.title = "Title on Netherlands"
+        page.save
+        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
 
-        # Set locale back to english
         I18n.locale = old_locale
+        page.title = "Title on English"
+        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
       end
+
+      it "does not produce duplicate slugs when one has changed" do
+        old_locale = I18n.locale
+
+        # Using a default locale of en.
+        page = PageSlugLocalizedHistory.new
+        page.title = "Title on English"
+        page.save
+        I18n.locale = "nl"
+        page.title = "Title on Netherlands"
+        page.save
+        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+
+        I18n.locale = old_locale
+        page.title = "Modified Title on English"
+        page.save
+        page.title_translations.should == {"en" => "Modified Title on English",
+                                           "nl" => "Title on Netherlands"}
+        page["_slugs"].should == {"en" => ["title-on-english", "modified-title-on-english"],
+                                  "nl" => ["title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs when transactions are set directly" do
+        page = PageSlugLocalizedHistory.new
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+      end
+
+      it "does not produce duplicate slugs when transactions are set directly and one has changed" do
+        page = PageSlugLocalizedHistory.new
+        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page.title_translations = {"en" => "Modified Title on English", "nl" => "Title on Netherlands"}
+        page.save
+        page["_slugs"].should == {"en" => ["title-on-english", "modified-title-on-english"],
+                                  "nl" => ["title-on-netherlands"]}
+      end
+
     end
 
     context "Mongoid paranoia with mongoid slug model" do
@@ -1092,7 +1017,7 @@ module Mongoid
       let(:paranoid_doc) {ParanoidDocument.create!(:title => "slug")}
 
       it "returns paranoid_doc for correct slug" do
-        expect(ParanoidDocument.find(paranoid_doc.slug)).to eq(paranoid_doc)
+        ParanoidDocument.find(paranoid_doc.slug).should eq(paranoid_doc)
       end
 
       it "raises for deleted slug" do
@@ -1103,11 +1028,8 @@ module Mongoid
       it "returns paranoid_doc for correct restored slug" do
         paranoid_doc.delete
         ParanoidDocument.deleted.first.restore
-        expect(ParanoidDocument.find(paranoid_doc.slug)).to eq(paranoid_doc)
+        ParanoidDocument.find(paranoid_doc.slug).should eq(paranoid_doc)
       end
-
-
-
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_slug
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Andreas Saebjoernsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-11 00:00:00.000000000 Z
+date: 2013-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -160,6 +160,7 @@ files:
 - spec/models/string_id.rb
 - spec/models/subject.rb
 - spec/models/without_slug.rb
+- spec/mongoid/criteria_spec.rb
 - spec/mongoid/slug_spec.rb
 - spec/mongoid/slug_spec.rb.b00
 - spec/spec_helper.rb
@@ -210,6 +211,8 @@ test_files:
 - spec/models/string_id.rb
 - spec/models/subject.rb
 - spec/models/without_slug.rb
+- spec/mongoid/criteria_spec.rb
 - spec/mongoid/slug_spec.rb
 - spec/mongoid/slug_spec.rb.b00
 - spec/spec_helper.rb
+has_rdoc: