mongoid_slug 1.0.1 → 2.0.0.pre

data/README.md

@@ -43,22 +43,35 @@ book = Book.find params[:book_id]
 
 Mongoid Slug will attempt to determine whether you want to find using the `slugs` field or the `_id` field by inspecting the supplied parameters.
 
-* If your document uses `BSON::ObjectId` identifiers, and all arguments passed to `find` are `String` and look like valid `BSON::ObjectId`, then Mongoid Slug will perform a find based on `_id`.
+* Mongoid Slug will perform a find based on `slugs` only if all arguments passed to `find` are of the type `String`
+* If your document uses `BSON::ObjectId` identifiers, and all arguments look like valid `BSON::ObjectId`, then Mongoid Slug will perform a find based on `_id`.
 * If your document uses any other type of identifiers, and all arguments passed to `find` are of the same type, then Mongoid Slug will perform a find based on `_id`.
-* Otherwise, if all arguments passed to `find` are of the type `String`, then Mongoid Slug will perform a find based on `slugs`.
+* If your document uses `String` identifiers and you want to be able find by slugs or ids, to get the correct behaviour, you should add a slug_id_strategy option to your _id field definition.  This option should return something that responds to `call` (a callable) and takes one string argument, e.g. a lambda.  This callable must return true if the string looks like one of your ids.
 
-To override this behaviour you may supply a hash of options as the final argument to `find` with the key `force_slugs` set to `true` or `false` as required. For example:
 
 ```ruby
 Book.fields['_id'].type
 => String
-book = Book.find 'a-thousand-plateaus' # Finds by _id
+book = Book.find 'a-thousand-plateaus' # Finds by slugs
 => ...
-book = Book.find 'a-thousand-plateaus', { force_slugs: true } # Finds by slugs
-=> ...
-```
 
+class Post
+  include Mongoid::Document
+  include Mongoid::Slug
+
+  field :_id, type: String, slug_id_strategy: lambda {|id| id.start_with?('....')}
 
+  field :name
+  slug  :name, :history => true
+end
+
+Post.fields['_id'].type
+=> String
+post = Post.find 'a-thousand-plateaus' # Finds by slugs
+=> ...
+post = Post.find '....1000/Plateus' # Finds by ids
+=> ...
+```
 [Read here] [4] for all available options.
 
 Custom Slug Generation
@@ -171,6 +184,20 @@ Friend.find('admin') # => nil
 friend.slug # => 'admin-1'
 ```
 
+Adhoc checking whether a string is unique on a per Model basis
+--------------------------------------------------------------
+
+Lets say you want to have a auto-suggest function on your GUI that could provide a preview of what the url or slug could be before the form to create the record was submitted.
+
+You can use the UniqueSlug class in your server side code to do this, e.g.
+
+```ruby
+title = params[:title]
+unique = Mongoid::Slug::UniqueSlug.new(Book.new).find_unique(title)
+...
+# return some representation of unique
+```
+
 [1]: https://github.com/rsl/stringex/
 [2]: https://secure.travis-ci.org/hakanensari/mongoid-slug.png
 [3]: http://travis-ci.org/hakanensari/mongoid-slug

data/lib/mongoid/slug.rb

@@ -15,8 +15,6 @@ module Mongoid
     end
 
     module ClassMethods
-
-
       # @overload slug(*fields)
       #   Sets one ore more fields as source of slug.
       #   @param [Array] fields One or more fields the slug should be based on.
@@ -51,10 +49,10 @@ module Mongoid
       def slug(*fields, &block)
         options = fields.extract_options!
 
-        self.slug_scope         = options[:scope]
-        self.reserved_words     = options[:reserve] || Set.new([:new, :edit])
-        self.slugged_attributes = fields.map &:to_s
-        self.history            = options[:history]
+        self.slug_scope            = options[:scope]
+        self.reserved_words        = options[:reserve] || Set.new([:new, :edit])
+        self.slugged_attributes    = fields.map &:to_s
+        self.history               = options[:history]
 
         unless embedded?
           if slug_scope
@@ -79,16 +77,12 @@ module Mongoid
         else
           set_callback :save, :before, :build_slug, :if => :slug_should_be_rebuilt?
         end
-
-
       end
 
       def look_like_slugs?(*args)
         with_default_scope.look_like_slugs?(*args)
       end
 
-
-
       # Find documents by slugs.
       #
       # A document matches if any of its slugs match one of the supplied params.
@@ -122,7 +116,7 @@ module Mongoid
     def build_slug
       _new_slug = find_unique_slug
       self._slugs.delete(_new_slug)
-      if self.history == true
+      if !!self.history
         self._slugs << _new_slug
       else
         self._slugs = [_new_slug]
@@ -130,89 +124,16 @@ module Mongoid
       true
     end
 
-
     # Finds a unique slug, were specified string used to generate a slug.
     #
     # Returned slug will the same as the specified string when there are no
     # duplicates.
     #
-    # @param [String] Desired slug
     # @return [String] A unique slug
     def find_unique_slug
-
-      _slug = self.url_builder.call(self)
-
-      # 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+))?$/
-
-      where_hash = {}
-      where_hash[:_slugs.all] = [pattern]
-      where_hash[:_id.ne]               = self._id
-
-      if slug_scope && self.reflect_on_association(slug_scope).nil?
-        # scope is not an association, so it's scoped to a local field
-        # (e.g. an association id in a denormalized db design)
-        where_hash[slug_scope]            = self.try(:read_attribute, slug_scope)
-
-      end
-
-      history_slugged_documents =
-          uniqueness_scope.
-              where(where_hash)
-
-      existing_slugs = []
-      existing_history_slugs = []
-      last_entered_slug = []
-      history_slugged_documents.each do |doc|
-        history_slugs = doc._slugs
-        next if history_slugs.nil?
-        existing_slugs.push(*history_slugs.find_all { |cur_slug| cur_slug =~ pattern })
-        last_entered_slug.push(*history_slugs.last) if history_slugs.last =~ pattern
-        existing_history_slugs.push(*history_slugs.first(history_slugs.length() -1).find_all { |cur_slug| cur_slug =~ pattern })
-      end
-
-      #do not allow a slug that can be interpreted as the current document id
-      existing_slugs << _slug unless self.class.look_like_slugs?([_slug])
-
-      #make sure that the slug is not equal to a reserved word
-      if reserved_words.any? { |word| word === _slug }
-        existing_slugs << _slug
-      end
-
-      #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'.
-      if existing_slugs.include? _slug
-        # If the only conflict is in the history of a document in the same scope,
-        # transfer the slug
-        if slug_scope && last_entered_slug.count == 0 && existing_history_slugs.count > 0
-          history_slugged_documents.each do |doc|
-            doc._slugs -= existing_history_slugs
-            doc.save
-          end
-          existing_slugs = []
-        end
-
-        if existing_slugs.count > 0
-          # Sort the existing_slugs in increasing order by comparing the
-          # suffix numbers:
-          # slug, slug-1, slug-2, ..., slug-n
-          existing_slugs.sort! do |a, b|
-            (pattern.match(a)[1] || -1).to_i <=>
-                (pattern.match(b)[1] || -1).to_i
-          end
-          max = existing_slugs.last.match(/-(\d+)$/).try(:[], 1).to_i
-
-          _slug += "-#{max + 1}"
-        end
-
-      end
-
-      _slug
+      UniqueSlug.new(self).find_unique
     end
 
-
     # @return [Boolean] Whether the slug requires to be rebuilt
     def slug_should_be_rebuilt?
       new_record? or _slugs_changed? or slugged_attributes_changed?
@@ -225,65 +146,29 @@ module Mongoid
     # @return [String] A string which Action Pack uses for constructing an URL
     # to this record.
     def to_param
-      unless _slugs.last
-        build_slug
-        save
-      end
+      slug || super
+    end
 
+    # @return [String] the slug, or nil if the document does not have a slug.
+    def slug
       _slugs.last
     end
-    alias_method :slug, :to_param
 
     def slug_builder
-
       _cur_slug = nil
       if (new_record? and _slugs.present?) or (persisted? and _slugs_changed?)
         #user defined slug
         _cur_slug =  _slugs.last
       end
-
       #generate slug if the slug is not user defined or does not exist
-      unless _cur_slug
-        self.slugged_attributes.map { |f| self.send f }.join ' '
-      else
-        _cur_slug
-      end
+      _cur_slug || pre_slug_string
     end
 
     private
 
-    def uniqueness_scope
-
-      if slug_scope &&
-          metadata = self.reflect_on_association(slug_scope)
-
-        parent = self.send(metadata.name)
-
-        # Make sure doc is actually associated with something, and that
-        # some referenced docs have been persisted to the parent
-        #
-        # TODO: we need better reflection for reference associations,
-        # like association_name instead of forcing collection_name here
-        # -- maybe in the forthcoming Mongoid refactorings?
-        inverse = metadata.inverse_of || collection_name
-        return parent.respond_to?(inverse) ? parent.send(inverse) : self.class
-
-      end
-
-      if self.embedded?
-        parent_metadata = reflect_on_all_associations(:embedded_in)[0]
-        return self._parent.send(parent_metadata.inverse_of || self.metadata.name)
-      end
-
-      #unless embedded or slug scope, return the deepest document superclass
-      appropriate_class = self.class
-      while appropriate_class.superclass.include?(Mongoid::Document)
-        appropriate_class = appropriate_class.superclass
-      end
-      appropriate_class
-
+    def pre_slug_string
+      self.slugged_attributes.map { |f| self.send f }.join ' '
     end
-
   end
 end
 

data/lib/mongoid/slug/criteria.rb

@@ -50,24 +50,34 @@ module Mongoid
         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
+        return false unless args.all? { |id| id.is_a?(String) }
+        id_field = @klass.fields['_id']
+        @slug_strategy ||= id_field.options[:slug_id_strategy] || build_slug_strategy(id_field.type)
+        args.none? { |id| @slug_strategy.call(id) }
       end
-      
+
       protected
 
+      # unless a :slug_id_strategy option is defined on the id field,
+      # use object_id or string strategy depending on the id_type
+      # otherwise default for all other id_types
+      def build_slug_strategy id_type
+        type_method = id_type.to_s.downcase.split('::').last + "_slug_strategy"
+        self.respond_to?(type_method) ? method(type_method) : lambda {|id| false}
+      end
+
+      # a string will not look like a slug if it looks like a legal ObjectId
+      def objectid_slug_strategy id
+        Moped::BSON::ObjectId.legal?(id)
+      end
+
+      # a string will always look like a slug
+      def string_slug_strategy id
+        true
+      end
+
+
       def for_slugs(slugs)
         where({ _slugs: { '$in' => slugs } }).limit(slugs.length)
       end
@@ -87,4 +97,4 @@ module Mongoid
       end
     end
   end
-end
+end

data/lib/mongoid/slug/slug_id_strategy.rb

@@ -0,0 +1,3 @@
+Mongoid::Fields.option(:slug_id_strategy) do |model, field, value|
+  field.options[:slug_id_strategy] = value
+end

data/lib/mongoid/slug/unique_slug.rb

@@ -0,0 +1,143 @@
+require 'forwardable'
+
+# Can use e.g. Mongoid::Slug::UniqueSlug.new(ModelClass.new).find_unique "slug-1" for auto-suggest ui
+module Mongoid
+  module Slug
+    class UniqueSlug
+
+      class SlugState
+        attr_reader :last_entered_slug, :existing_slugs, :existing_history_slugs, :sorted_existing
+
+        def initialize slug, documents, pattern
+          @slug = slug
+          @documents = documents
+          @pattern = pattern
+          @last_entered_slug = []
+          @existing_slugs = []
+          @existing_history_slugs = []
+          @sorted_existing = []
+          @documents.each do |doc|
+            history_slugs = doc._slugs
+            next if history_slugs.nil?
+            existing_slugs.push(*history_slugs.find_all { |cur_slug| cur_slug =~ @pattern })
+            last_entered_slug.push(*history_slugs.last) if history_slugs.last =~ @pattern
+            existing_history_slugs.push(*history_slugs.first(history_slugs.length() - 1).find_all { |cur_slug| cur_slug =~ @pattern })
+          end
+        end
+
+        def slug_included?
+          existing_slugs.include? @slug
+        end
+
+        def include_slug
+          existing_slugs << @slug
+        end
+
+        def highest_existing_counter
+          sort_existing_slugs
+          @sorted_existing.last || 0
+        end
+
+        def sort_existing_slugs
+          # remove the slug part and leave the absolute integer part and sort
+          re = %r(^#{Regexp.escape(@slug)})
+          @sorted_existing = existing_slugs.map do |s|
+            s.sub(re,'').to_i.abs
+          end.sort
+        end
+
+        def inspect
+          {
+            :slug                   => @slug,
+            :existing_slugs         => existing_slugs,
+            :last_entered_slug      => last_entered_slug,
+            :existing_history_slugs => existing_history_slugs,
+            :sorted_existing        => sorted_existing
+          }
+        end
+      end
+
+      extend Forwardable
+
+      attr_reader :model, :_slug
+
+      def_delegators :@model, :slug_scope, :reflect_on_association, :read_attribute,
+        :check_against_id, :reserved_words, :url_builder, :metadata,
+        :collection_name, :embedded?, :reflect_on_all_associations
+
+      def initialize model
+        @model = model
+        @_slug = ""
+        @state = nil
+      end
+
+      def find_unique attempt = nil
+        @_slug = if attempt
+          attempt.to_url
+        else
+          url_builder.call(model)
+        end
+        # 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+))?$/
+
+        where_hash = {}
+        where_hash[:_slugs.all] = [pattern]
+        where_hash[:_id.ne]     = model._id
+
+        if (scope = slug_scope) && reflect_on_association(scope).nil?
+          # scope is not an association, so it's scoped to a local field
+          # (e.g. an association id in a denormalized db design)
+          where_hash[scope] = model.try(:read_attribute, scope)
+        end
+
+        @state = SlugState.new _slug, uniqueness_scope.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])
+
+        # make sure that the slug is not equal to a reserved word
+        @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'.
+        if @state.slug_included?
+          highest = @state.highest_existing_counter
+          @_slug += "-#{highest.succ}"
+        end
+        _slug
+      end
+
+      def uniqueness_scope
+
+        if slug_scope &&
+            metadata = reflect_on_association(slug_scope)
+
+          parent = model.send(metadata.name)
+
+          # Make sure doc is actually associated with something, and that
+          # some referenced docs have been persisted to the parent
+          #
+          # TODO: we need better reflection for reference associations,
+          # like association_name instead of forcing collection_name here
+          # -- maybe in the forthcoming Mongoid refactorings?
+          inverse = metadata.inverse_of || collection_name
+          return parent.respond_to?(inverse) ? parent.send(inverse) : model.class
+        end
+
+        if embedded?
+          parent_metadata = reflect_on_all_associations(:embedded_in)[0]
+          return model._parent.send(parent_metadata.inverse_of || model.metadata.name)
+        end
+
+        #unless embedded or slug scope, return the deepest document superclass
+        appropriate_class = model.class
+        while appropriate_class.superclass.include?(Mongoid::Document)
+          appropriate_class = appropriate_class.superclass
+        end
+        appropriate_class
+      end
+    end
+  end
+end

data/lib/mongoid/slug/version.rb

@@ -1,5 +1,5 @@
 module Mongoid #:nodoc:
   module Slug
-    VERSION = '1.0.1'
+    VERSION = '2.0.0.pre'
   end
 end

data/lib/mongoid_slug.rb

@@ -2,3 +2,5 @@ require 'mongoid'
 require 'stringex'
 require 'mongoid/slug'
 require 'mongoid/slug/criteria'
+require 'mongoid/slug/unique_slug'
+require 'mongoid/slug/slug_id_strategy'

data/spec/models/entity.rb

@@ -0,0 +1,12 @@
+#encoding: utf-8
+class Entity
+  include Mongoid::Document
+  include Mongoid::Slug
+
+  field :_id, type: String, slug_id_strategy: UuidIdStrategy
+
+  field :name
+  field :user_edited_variation
+
+  slug  :user_edited_variation, :history => true
+end

data/spec/mongoid/slug_spec.rb

@@ -7,7 +7,58 @@ module Mongoid
       Book.create(:title => "A Thousand Plateaus")
     end
 
+    context "when option skip_id_check is used with UUID _id " do
+      let(:entity0) do
+        Entity.create(:_id => UUID.generate, :name => 'Pelham 1 2 3', :user_edited_variation => 'pelham-1-2-3')
+      end
+      let(:entity1) do
+        Entity.create(:_id => UUID.generate, :name => 'Jackson 5', :user_edited_variation => 'jackson-5')
+      end
+      let(:entity2) do
+        Entity.create(:_id => UUID.generate, :name => 'Jackson 5', :user_edited_variation => 'jackson-5')
+      end
+
+      it "generates a unique slug by appending a counter to duplicate text" do
+        entity0.to_param.should eql "pelham-1-2-3"
+
+        5.times{ |x|
+          dup = Entity.create(:_id => UUID.generate, :name => entity0.name, :user_edited_variation => entity0.user_edited_variation)
+          dup.to_param.should eql "pelham-1-2-3-#{x.succ}"
+        }
+      end
+
+      it "allows the user to edit the sluggable field" do
+        entity1.to_param.should eql "jackson-5"
+        entity2.to_param.should eql "jackson-5-1"
+        entity2.user_edited_variation = "jackson-5-indiana"
+        entity2.save
+        entity2.to_param.should eql "jackson-5-indiana"
+      end
+
+      it "allows users to edit the sluggable field" do
+        entity1.to_param.should eql "jackson-5"
+        entity2.to_param.should eql "jackson-5-1"
+        entity2.user_edited_variation = "jackson-5-indiana"
+        entity2.save
+        entity2.to_param.should eql "jackson-5-indiana"
+      end
+
+      it "it restores the slug if the editing user tries to use an existing slug" do
+        entity1.to_param.should eql "jackson-5"
+        entity2.to_param.should eql "jackson-5-1"
+        entity2.user_edited_variation = "jackson-5"
+        entity2.save
+        entity2.to_param.should eql "jackson-5-1"
+      end
+
+      it "does not force an appended counter on a plain string" do
+        entity = Entity.create(:_id => UUID.generate, :name => 'Adele', :user_edited_variation => 'adele')
+        entity.to_param.should eql "adele"
+      end
+    end
+
     context "when the object is top-level" do
+
       it "generates a slug" do
         book.to_param.should eql "a-thousand-plateaus"
       end
@@ -26,8 +77,9 @@ 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")
+        bson_id = Moped::BSON::ObjectId.new.to_s
+        bad = Book.create(:title => bson_id)
+        bad.slugs.should_not include(bson_id)
       end
 
       it "does not update slug if slugged fields have not changed" do
@@ -352,30 +404,6 @@ module Mongoid
           dup.to_param.should eql character.to_param
         end
       end
-
-      context "when using history and reusing a slug within the scope" do
-        let!(:subject1) do
-          book.subjects.create(:name => "A Subject")
-        end
-        let!(:subject2) do
-          book.subjects.create(:name => "Another Subject")
-        end
-
-        before(:each) do
-          subject1.name = "Something Else Entirely"
-          subject1.save
-          subject2.name = "A Subject"
-          subject2.save
-        end
-
-        it "allows using the slug" do
-          subject2.slugs.should include("a-subject")
-        end
-
-        it "removes the slug from the old owner's history" do
-          subject1.slugs.should_not include("a-subject")
-        end
-      end
     end
 
     context "when slug is scoped by one of the class's own fields" do
@@ -530,7 +558,7 @@ module Mongoid
       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 
+      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
@@ -704,15 +732,28 @@ module Mongoid
     end
 
     describe "#to_param" do
+      context "when called on a new record" do
+        let(:book) { Book.new }
+
+        it "should return nil" do
+          book.to_param.should be_nil
+        end
+
+        it "should not persist the record" do
+          book.to_param
+          book.should_not be_persisted
+        end
+      end
+
       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
+        it "should return the id" do
           book = Book.first
-          book.to_param
-          book.reload.slugs.should include("proust-and-signs")
+          book.to_param.should == book.id.to_s
+          book.reload.slugs.should be_empty
         end
       end
     end
@@ -767,6 +808,21 @@ module Mongoid
           book.save
           book.to_param.should eql "not-it-either"
         end
+
+        it "updates the slug when a new one is appended" do
+          book = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
+          book.slugs.push "not-it-either"
+          book.save
+          book.to_param.should eql "not-it-either"
+        end
+
+        it "updates the slug to a unique slug when a new one is appended" do
+          book1 = Book.create(:title => "Sleepyhead")
+          book2 = Book.create(:title => "A Thousand Plateaus")
+          book2.slugs.push "sleepyhead"
+          book2.save
+          book2.to_param.should eql "sleepyhead-1"
+        end
       end
 
       context "when it is set to an empty string" do

data/spec/spec_helper.rb

@@ -3,9 +3,17 @@ begin
 rescue LoadError
 end
 require 'rspec'
+require 'uuid'
+require "awesome_print"
 
 require File.expand_path '../../lib/mongoid_slug', __FILE__
 
+module Mongoid::Slug::UuidIdStrategy
+  def self.call id
+    id =~ /\A([0-9a-fA-F]){8}-(([0-9a-fA-F]){4}-){3}([0-9a-fA-F]){12}\z/
+  end
+end
+
 def database_id
     ENV['CI'] ? "mongoid_slug_#{Process.pid}" : 'mongoid_slug_test'
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_slug
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 2.0.0.pre
+  prerelease: 6
 platform: ruby
 authors:
 - Andreas Saebjoernsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-16 00:00:00.000000000 Z
+date: 2012-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -91,6 +91,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Mongoid URL slug or permalink generator
 email:
 - andy@cosemble.com
@@ -99,6 +131,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/mongoid/slug/criteria.rb
+- lib/mongoid/slug/slug_id_strategy.rb
+- lib/mongoid/slug/unique_slug.rb
 - lib/mongoid/slug/version.rb
 - lib/mongoid/slug.rb
 - lib/mongoid_slug.rb
@@ -109,6 +143,7 @@ files:
 - spec/models/author.rb
 - spec/models/book.rb
 - spec/models/caption.rb
+- spec/models/entity.rb
 - spec/models/friend.rb
 - spec/models/integer_id.rb
 - spec/models/magazine.rb
@@ -121,7 +156,7 @@ files:
 - spec/models/without_slug.rb
 - spec/mongoid/slug_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/digitalplaywright/mongoid-slug
+homepage: http://github.com/musicglue/mongoid-slug
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -136,9 +171,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: mongoid_slug
 rubygems_version: 1.8.24
@@ -151,6 +186,7 @@ test_files:
 - spec/models/author.rb
 - spec/models/book.rb
 - spec/models/caption.rb
+- spec/models/entity.rb
 - spec/models/friend.rb
 - spec/models/integer_id.rb
 - spec/models/magazine.rb