mongoid_slug 0.4.7 → 0.5.0

data/README.md

@@ -1,19 +1,16 @@
 Mongoid Slug
 ============
 
-Mongoid Slug generates a URL slug or permalink based on a field or set of fields in a Mongoid model.
+Mongoid Slug generates a URL slug or permalink based on one or more fields in a Mongoid model. It sits on top of [stringex](https://github.com/rsl/stringex) and works with non-Latin characters.
 
-Install
--------
+Quick Start
+---------------
 
-To install mongoid_slug, add it to your Gemfile:
+First, add mongoid_slug to your Gemfile:
 
     gem 'mongoid_slug', :require => 'mongoid/slug'
 
-Usage
------
-
-Here's a book that embeds many authors:
+Say you have a book that embeds many authors. You can set up slugs for both resources like this:
 
     class Book
       include Mongoid::Document
@@ -32,36 +29,28 @@ Here's a book that embeds many authors:
       embedded_in :book, :inverse_of => :authors
     end
 
-The finders in our controllers should look like:
+In your controller, you can use the `find_by_slug` helper:
 
     def find_book
-      @book = Book.where(:slug => params[:id]).first
+      Book.find_by_slug(params[:book_id])
     end
 
-    def find_book_and_author
-      @book = Book.where(:slug => params[:book_id]).first
-      @author = @book.authors.where(:slug => params[:id]).first
+    def find_author
+      @book.authors.find_by_slug(params[:id])
     end
 
-If you are wondering why I did not include a *find_by_slug* helper, [read on](http://groups.google.com/group/mongoid/browse_thread/thread/5905589e108d7cc0?pli=1).
-
 To demo some more functionality in the console:
 
     >> book = Book.create(:title => "A Thousand Plateaus")
     >> book.to_param
     "a-thousand-plateaus"
-    >> book.update_attributes(:title => "Anti Oedipus")
+    >> book.title = "Anti Oedipus"
+    >> book.save
     >> book.to_param
     "anti-oedipus"
-    >> Book.where(:slug => 'anti-oedipus').first
-    #<Book _id: 4c23b1f7faa4a7479a000009, slug: "anti-oedipus", title: "Anti Oedipus">
     >> author = book.authors.create(:first_name => "Gilles", :last_name => "Deleuze")
     >> author.to_param
     => "gilles-deleuze"
     >> author.update_attributes(:first => "Félix", :last_name => "Guattari")
     >> author.to_param
-    => "félix-guattari"
-    >> book.authors.where(:slug => 'felix-guattari).first
-    => #<Author _id: 4c31e362faa4a7050e000003, slug: "félix-guattari", last_name: "Guattari", first_name: "Félix">
-
-See [sample models in specs]("http://github.com/papercavalier/mongoid-slug/tree/master/spec/models/") for various configuration options.
+    => "felix-guattari"

data/lib/mongoid/slug/version.rb

@@ -1,5 +1,5 @@
 module Mongoid #:nodoc:
   module Slug
-    VERSION = "0.4.7"
+    VERSION = "0.5.0"
   end
 end

data/lib/mongoid/slug.rb

@@ -1,76 +1,65 @@
 #encoding: utf-8
+require 'stringex'
+
 module Mongoid #:nodoc:
 
-  # Generates a URL slug/permalink based on fields in a Mongoid model
+  # Generates a URL slug or permalink based on one or more fields in a Mongoid
+  # model.
   module Slug
     extend ActiveSupport::Concern
 
     included do
-      cattr_accessor :slug_name, :slugged_fields, :slug_scoped
+      cattr_accessor :slug_name, :slugged_fields
     end
 
     module ClassMethods
 
-      # Set a field or a number of fields as source of slug
-      def slug(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
+      # Sets one ore more fields as source of slug.
+      #
+      # By default, the name of the field that stores the slug is "slug". Pass an
+      # alternative name with the :as option.
+      #
+      # If you wish the slug to be permanent once created, set :permanent to true.
+      def slug(*fields)
+        options = fields.extract_options!
 
-        self.slug_name = options[:as] || :slug
-        self.slug_scoped = options[:scoped] || false
-        self.slugged_fields = args
+        self.slug_name      = options[:as] || :slug
+        self.slugged_fields = fields
 
         field slug_name
 
-        if slug_scoped
-          index slug_name
-        else
-          index slug_name, :unique => true
-        end
-
         if options[:permanent]
           before_create :generate_slug
         else
           before_save :generate_slug
         end
       end
+
+      # Finds the document with the specified slug or returns nil.
+      def find_by_slug(slug)
+        where(slug_name => slug).first rescue nil
+      end
     end
 
     def to_param
-      self.send slug_name
+      self.send(slug_name)
     end
 
     private
 
-    def find_(slug, stack=[])
-      if embedded?
-        if slug_scoped && stack.empty?
-          _parent.send(association_name).where( slug_name => slug ).to_a
-        else
-          stack << association_name
-          _parent.send :find_, slug, stack
-        end
-      else
-        stack.reverse!
-        path = (stack + [slug_name]).join(".")
-        found = collection.find(path => slug).to_a
-    
-        stack.each do |name|
-          if found.any?
-            found = found.first.send(name).to_a
-          end
-        end
-    
-        found
-      end
+    attr_reader :slug_counter
+
+    def build_slug
+      ("#{slug_base} #{slug_counter}").to_url
     end
 
-    def find_unique_slug(suffix='')
-      slug = ("#{slug_base} #{suffix}").parameterize
-      if find_(slug).reject{ |doc| doc.id == self.id }.empty?
+    def find_unique_slug
+      slug = build_slug
+      if unique_slug?(slug)
         slug
       else
-        suffix = suffix.blank? ? '1' : "#{suffix.to_i + 1}"
-        find_unique_slug(suffix)
+        increment_slug_counter
+        find_unique_slug
       end
     end
 
@@ -80,14 +69,31 @@ module Mongoid #:nodoc:
       end
     end
 
+    def increment_slug_counter
+      @slug_counter = (slug_counter.to_i + 1).to_s
+    end
+
     def slug_base
-      self.class.slugged_fields.collect{ |field| self.send(field) }.join(" ")
+      self.class.slugged_fields.map do |field|
+        self.send(field)
+      end.join(" ")
     end
 
     def slugged_fields_changed?
       self.class.slugged_fields.any? do |field|
-        self.send(field.to_s + '_changed?')
+        self.send("#{field}_changed?")
       end
     end
+
+    def unique_slug?(slug)
+      if embedded?
+        _parent.send(association_name)
+      else
+        self.class
+      end.
+        where(slug_name => slug).
+        reject { |doc| doc.id == self.id }.
+        empty?
+    end
   end
 end

data/spec/models/book.rb

@@ -2,9 +2,7 @@ class Book
   include Mongoid::Document
   include Mongoid::Slug
   field :title
-  field :isbn
   slug  :title
-  embeds_one :publisher
   embeds_many :subjects
   references_many :authors
 end

data/spec/models/{baz.rb → partner.rb}

@@ -1,8 +1,7 @@
-class Baz
+class Partner
   include Mongoid::Document
   include Mongoid::Slug
   field :name
-  field :other
   slug  :name
-  embedded_in :bar, :inverse_of => :bazes
+  embedded_in :relationship, :inverse_of => :partners
 end

data/spec/models/person.rb

@@ -2,6 +2,6 @@ class Person
   include Mongoid::Document
   include Mongoid::Slug
   field :name
-  field :age, :type => Integer
-  slug  :name, :as => :permalink
+  slug  :name, :as => :permalink, :permanent => true
+  embeds_many :relationships
 end

data/spec/models/relationship.rb

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

data/spec/mongoid/slug_spec.rb

@@ -2,317 +2,198 @@
 require "spec_helper"
 
 module Mongoid
-
   describe Slug do
+    let!(:book) do
+      Book.create(:title => "A Thousand Plateaus")
+    end
 
-    let(:book) { Book.create(:title => "A Thousand Plateaus", :isbn => "9789245242475") }
-
-    context "when document is root" do
-
-      it "generates slug" do
-        book.to_param.should eql book.title.parameterize
-      end
-
-      it "updates slug" do
-        book.update_attributes(:title => "Anti Oedipus")
-        book.to_param.should eql "Anti Oedipus".parameterize
-      end
-
-      it "generates a unique slug" do
-        similar_book = Book.create(:title => book.title)
-        similar_book.to_param.should_not eql book.to_param
+    context "when the object is top-level" do
+      it "generates a slug" do
+        book.to_param.should eql "a-thousand-plateaus"
       end
 
-      it "appends a counter when slug is not unique" do
-        similar_book = Book.create(:title => book.title)
-        similar_book.to_param.should match /\d$/
+      it "updates the slug" do
+        book.title = "Anti Oedipus"
+        book.save
+        book.to_param.should eql "anti-oedipus"
       end
 
-      it "does not append a counter when slug is unique" do
-        book.to_param.should_not match /\d$/
+      it "generates a unique slug by appending a counter to duplicate text" do
+        dup = Book.create(:title => book.title)
+        dup.to_param.should eql "a-thousand-plateaus-1"
       end
 
       it "does not update slug if slugged fields have not changed" do
-        former_slug = book.to_param
-        book.update_attributes(:isbn => "9785545858118")
-        book.to_param.should eql former_slug
+        book.save
+        book.to_param.should eql "a-thousand-plateaus"
       end
 
-      it "does not update slug if slugged fields have changed but generated slug is the same" do
-        former_slug = book.to_param
-        book.update_attributes(:title => "A thousand plateaus")
-        book.to_param.should eql former_slug
+      it "does not change slug if slugged fields have changed but generated slug is identical" do
+        book.title = "a thousand plateaus"
+        book.save
+        book.to_param.should eql "a-thousand-plateaus"
       end
 
       it "finds by slug" do
-        Book.where(:slug => book.to_param).first.should eql book
+        Book.find_by_slug(book.to_param).should eql book
       end
-
     end
 
-    context "when document is an embedded has-many" do
-
-      let(:subject) { book.subjects.create(:name => "Psychoanalysis") }
-
-      it "generates slug" do
-        subject.to_param.should eql(subject.name.parameterize)
+    context "when the object is embedded" do
+      let(:subject) do
+        book.subjects.create(:name => "Psychoanalysis")
       end
 
-      it "updates slug" do
-        subject.update_attributes(:name => "Schizoanalysis")
-        subject.to_param.should eql "Schizoanalysis".parameterize
+      it "generates a slug" do
+        subject.to_param.should eql "psychoanalysis"
       end
 
-      it "generates a unique slug" do
-        similar_subject = book.subjects.create(:model => subject.name)
-        similar_subject.to_param.should_not eql subject.to_param
+      it "updates the slug" do
+        subject.name = "Schizoanalysis"
+        subject.save
+        subject.to_param.should eql "schizoanalysis"
       end
 
-      it "appends a counter when slug is not unique" do
-        similar_subject = book.subjects.create(:name => subject.name)
-        similar_subject.to_param.should match /\d$/
-      end
-
-      it "does not append a counter when slug is unique" do
-        subject.to_param.should_not match /\d$/
+      it "generates a unique slug by appending a counter to duplicate text" do
+        dup = book.subjects.create(:name => subject.name)
+        dup.to_param.should eql 'psychoanalysis-1'
       end
 
       it "does not update slug if slugged fields have not changed" do
-        former_slug = subject.to_param
-        subject.update_attributes(:description => "Lorem ipsum dolor sit amet")
-        subject.to_param.should eql former_slug
+        subject.save
+        subject.to_param.should eql "psychoanalysis"
       end
 
-      it "does not update slug if slugged fields have changed but generated slug is the same" do
-        former_slug = subject.to_param
-        subject.update_attributes(:title => "PSYCHOANALYSIS")
-        subject.to_param.should eql former_slug
+      it "does not change slug if slugged fields have changed but generated slug is identical" do
+        subject.name = "PSYCHOANALYSIS"
+        subject.to_param.should eql "psychoanalysis"
       end
 
       it "finds by slug" do
-        book.subjects.where(:slug => subject.to_param).first.should eql subject
+        book.subjects.find_by_slug(subject.to_param).should eql subject
       end
-
     end
 
-    context "when document is an embedded has-one" do
-
-      let(:publisher) { book.create_publisher(:name => "OUP") }
-
-      it "generates slug" do
-        publisher.to_param.should eql(publisher.name.parameterize)
-      end
-
-      it "updates slug" do
-        publisher.update_attributes(:name => "Harvard UP")
-        publisher.to_param.should eql "Harvard UP".parameterize
+    context "when the object is embedded in another embedded object" do
+      let(:person) do
+        Person.create(:name => "John Doe")
       end
 
-      it "does not update slug if slugged fields have not changed" do
-        former_slug = publisher.to_param
-        publisher.update_attributes(:year => 2001)
-        publisher.to_param.should eql former_slug
+      let(:relationship) do
+        person.relationships.create(:name => "Engagement")
       end
 
-      it "does not update slug if slugged fields have changed but generated slug is the same" do
-        former_slug = publisher.to_param
-        publisher.update_attributes(:name => "oup")
-        publisher.to_param.should eql former_slug
+      let(:partner) do
+        relationship.partners.create(:name => "Jane Smith")
       end
 
-    end
-
-    context "when the slug is composed of multiple fields" do
-
-      let(:author) { Author.create(:first_name => "Gilles", :last_name => "Deleuze") }
-
-      it "generates slug" do
-        author.to_param.should eql("Gilles Deleuze".parameterize)
+      it "generates a slug" do
+        partner.to_param.should eql "jane-smith"
       end
 
-      it "updates slug" do
-        author.update_attributes(:first_name => "Félix", :last_name => "Guattari")
-        author.to_param.should eql "Félix Guattari".parameterize
+      it "updates the slug" do
+        partner.name = "Jane Doe"
+        partner.save
+        partner.to_param.should eql "jane-doe"
       end
 
-      it "generates a unique slug" do
-        similar_author = Author.create(:first_name => author.first_name,
-                                       :last_name => author.last_name)
-        similar_author.to_param.should_not eql author.to_param
+      it "generates a unique slug by appending a counter to duplicate text" do
+        dup = relationship.partners.create(:name => partner.name)
+        dup.to_param.should eql "jane-smith-1"
       end
 
-      it "appends a counter when slug is not unique" do
-        similar_author = Author.create(:first_name => author.first_name,
-                                       :last_name => author.last_name)
-        similar_author.to_param.should match /\d$/
+      it "does not update slug if slugged fields have not changed" do
+        partner.save
+        partner.to_param.should eql "jane-smith"
       end
 
-      it "does not append a counter when slug is unique" do
-        author.to_param.should_not match /\d$/
+      it "does not change slug if slugged fields have changed but generated slug is identical" do
+        partner.name = "JANE SMITH"
+        partner.to_param.should eql "jane-smith"
       end
 
-      it "does not update slug if slugged fields have changed but generated slug is the same" do
-        former_slug = author.to_param
-        author.update_attributes(:first_name => "gilles", :last_name => "DELEUZE")
-        author.to_param.should eql former_slug
+      it "scopes by parent object" do
+        affair = person.relationships.create(:name => "Affair")
+        lover = affair.partners.create(:name => partner.name)
+        lover.to_param.should eql partner.to_param
       end
 
       it "finds by slug" do
-        author
-        Author.where(:slug => "gilles-deleuze").first.should eql author
+        relationship.partners.find_by_slug(partner.to_param).should eql partner
       end
-
     end
 
-    context "when the document is embedded in another embedded document" do
-
-      let(:foo) { Foo.create(:name => "foo") }
-      let(:bar) { foo.bars.create(:name => "bar") }
-      let(:baz) do
-        bar.bazes.create(:name => "baz")
-        Foo.first.bars.first.bazes.first # Better to be paranoid and reload from db
-      end
-
-      it "generates slug" do
-        baz.to_param.should eql(baz.name.parameterize)
-      end
-
-      it "updates slug" do
-        baz.update_attributes(:name => "lorem")
-        baz.to_param.should eql "lorem".parameterize
-      end
-
-      it "generates a unique slug" do
-        similar_baz = bar.bazes.create(:name => baz.name)
-        similar_baz.to_param.should_not eql baz.to_param
+    context "when the slug is composed of multiple fields" do
+      let!(:author) do
+        Author.create(
+          :first_name => "Gilles",
+          :last_name  => "Deleuze")
       end
 
-      it "appends a counter when slug is not unique" do
-        similar_baz = bar.bazes.create(:name => baz.name)
-        similar_baz.to_param.should match /\d$/
+      it "generates a slug" do
+        author.to_param.should eql "gilles-deleuze"
       end
 
-      it "does not append a counter when slug is unique" do
-        baz.to_param.should_not match /\d$/
+      it "updates the slug" do
+        author.first_name = "Félix"
+        author.last_name  = "Guattari"
+        author.save
+        author.to_param.should eql "felix-guattari"
       end
 
-      it "does not update slug if slugged fields have not changed" do
-        former_slug = baz.to_param
-        baz.update_attributes(:other => "Lorem ipsum dolor sit amet")
-        baz.to_param.should eql former_slug
+      it "generates a unique slug by appending a counter to duplicate text" do
+        dup = Author.create(
+          :first_name => author.first_name,
+          :last_name  => author.last_name)
+        dup.to_param.should eql 'gilles-deleuze-1'
       end
 
-      it "does not update slug if slugged fields have changed but generated slug is the same" do
-        former_slug = baz.to_param
-        baz.update_attributes(:name => "BAZ")
-        baz.to_param.should eql former_slug
+      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
-        bar.bazes.where(:slug => baz.to_param).first.should eql baz
+        Author.find_by_slug("gilles-deleuze").should eql author
       end
-
     end
 
-    context "when the slug field name is customized" do
-
-      let(:person) { Person.create(:name => "John Doe") }
-
-      it "sets the slug field name" do
-        person.respond_to?(:permalink).should be_true
-        person.send(:permalink).should eql "john-doe"
-      end
-
-      it "generates slug" do
-        person.to_param.should eql(person.name.parameterize)
-      end
-
-      it "updates slug" do
-        person.update_attributes(:name => "Jane Doe")
-        person.to_param.should eql "Jane Doe".parameterize
-      end
-
-      it "generates a unique slug" do
-        similar_person = Person.create(:name => person.name)
-        similar_person.to_param.should_not eql person.to_param
-      end
-
-      it "appends a counter when slug is not unique" do
-        similar_person = Person.create(:name => person.name)
-        similar_person.to_param.should match /\d$/
-      end
-
-      it "does not append a counter when slug is unique" do
-        person.to_param.should_not match /\d$/
-      end
-
-      it "does not update slug if slugged fields have not changed" do
-        former_slug = person.to_param
-        person.update_attributes(:age => 31)
-        person.to_param.should eql former_slug
-      end
-
-      it "does not update slug if slugged fields have changed but generated slug is the same" do
-        former_slug = person.to_param
-        person.update_attributes(:name => "JOHN DOE")
-        person.to_param.should eql former_slug
+    context "when the field name for the slug is set with the :as option" do
+      let(:person) do
+        Person.create(:name => "John Doe")
       end
 
-      it "finds by slug" do
-        Person.where(:permalink => person.to_param).first.should eql person
+      it "sets the slug field name" do
+        person.should respond_to(:permalink)
+        person.permalink.should eql "john-doe"
       end
-
     end
 
-    describe "#find_" do
-
-      let(:foo) { Foo.create(:name => "foo") }
-      let(:bar) { foo.bars.create(:name => "bar") }
-      let(:baz) { bar.bazes.create(:name => "baz") }
-
-      it "finds duplicate slug of a root document" do
-        foo.send(:find_, foo.to_param).count.should eql 1
+    context "when slug is set to be permanent with the :permanent option" do
+      let(:person) do
+        Person.create(:name => "John Doe")
       end
 
-      it "finds duplicate slug of an embedded document" do
-        bar.send(:find_, bar.to_param).count.should eql 1
+      it "does not change the slug when the slugged fields are updated" do
+        person.name = "Jane Doe"
+        person.save
+        person.to_param.should eql "john-doe"
       end
-
-      it "finds duplicate slug of a deeply-embedded document" do
-        baz.send(:find_, baz.to_param).count.should eql 1
-      end
-
     end
-  
-    context "when slug is scoped" do
 
-      let(:foo) { Foo.create(:name => "foo") }
-      let(:sar) { foo.sars.create(:name => "sar") }
-      let(:foo2) { Foo.create(:name => "foo") }
-    
-      it "generates a unique slug inside the same parent object" do
-        similar_sar = foo.sars.create(:name => sar.name)
-        similar_sar.to_param.should_not eql sar.to_param
-      end
-    
-      it "generates the same slug in different parent object" do
-        other_sar = foo2.sars.create(:name => sar.name)
-        other_sar.to_param.should eql sar.to_param
-      end
-
-    end
-
-    context "when slug is permanent" do
+    it "works with non-Latin characters" do
+      book.title = "Капитал"
+      book.save
+      book.to_param.should eql "kapital"
 
-      let(:permanent) { Permanent.create(:title => "This is a nodding song") }
-
-      it "doesn't change slug when document is updated" do
-        permanent.update_attributes(:title => "This is not a nodding song")
-        permanent.to_param.should eql "This is a nodding song".parameterize
-      end
+      book.title = "Ελλάδα"
+      book.save
+      book.to_param.should eql "ellada"
 
+      book.title = "中文"
+      book.save
+      book.to_param.should eql 'zhong-wen'
     end
-
   end
-
 end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require "bundler/setup"
 
 require "database_cleaner"
 require "mongoid"
+require "stringex"
 require "rspec"
 
 Mongoid.configure do |config|

metadata

@@ -1,22 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: mongoid_slug
 version: !ruby/object:Gem::Version 
-  hash: 1
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 7
-  version: 0.4.7
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
-- Hakan Ensari
-- Gerhard Lazu
+- Paper Cavalier
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-10-31 01:00:00 +01:00
+date: 2010-12-28 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,65 +25,76 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 62196421
         segments: 
         - 2
         - 0
         - 0
         - beta
-        - 19
-        version: 2.0.0.beta.19
+        - 20
+        version: 2.0.0.beta.20
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: bson_ext
+  name: stringex
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 17
         segments: 
         - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
         - 1
         - 1
-        version: 1.1.1
+        - 5
+        version: 1.1.5
   type: :development
-  version_requirements: *id002
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: database_cleaner
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
         segments: 
         - 0
         - 6
         - 0
         version: 0.6.0
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 13
         segments: 
         - 2
+        - 3
         - 0
-        - 1
-        version: 2.0.1
+        version: 2.3.0
   type: :development
-  version_requirements: *id004
-description: Generates a URL slug or permalink based on fields in a Mongoid model.
+  version_requirements: *id005
+description: Mongoid Slug generates a URL slug or permalink based on one or more fields in a Mongoid model.
 email: 
 - code@papercavalier.com
 executables: []
@@ -100,19 +109,15 @@ files:
 - LICENSE
 - README.md
 - spec/models/author.rb
-- spec/models/bar.rb
-- spec/models/baz.rb
 - spec/models/book.rb
-- spec/models/foo.rb
-- spec/models/permanent.rb
+- spec/models/partner.rb
 - spec/models/person.rb
-- spec/models/publisher.rb
-- spec/models/sar.rb
+- spec/models/relationship.rb
 - spec/models/subject.rb
 - spec/mongoid/slug_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
-homepage: http://github.com/papercavalier/mongoid_slug
+homepage: http://github.com/papercavalier/mongoid-slug
 licenses: []
 
 post_install_message: 
@@ -125,7 +130,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -134,7 +138,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -144,17 +147,13 @@ rubyforge_project: mongoid_slug
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Generates a URL slug or permalink
+summary: Generates a URL slug
 test_files: 
 - spec/models/author.rb
-- spec/models/bar.rb
-- spec/models/baz.rb
 - spec/models/book.rb
-- spec/models/foo.rb
-- spec/models/permanent.rb
+- spec/models/partner.rb
 - spec/models/person.rb
-- spec/models/publisher.rb
-- spec/models/sar.rb
+- spec/models/relationship.rb
 - spec/models/subject.rb
 - spec/mongoid/slug_spec.rb
 - spec/spec_helper.rb

data/spec/models/bar.rb

@@ -1,8 +0,0 @@
-class Bar
-  include Mongoid::Document
-  include Mongoid::Slug
-  field :name
-  slug  :name
-  embeds_many :bazes, :class_name => "Baz"
-  embedded_in :foo, :inverse_of => :bars
-end

data/spec/models/foo.rb

@@ -1,8 +0,0 @@
-class Foo
-  include Mongoid::Document
-  include Mongoid::Slug
-  field :name
-  slug  :name
-  embeds_many :bars
-  embeds_many :sars
-end

data/spec/models/permanent.rb

@@ -1,6 +0,0 @@
-class Permanent
-  include Mongoid::Document
-  include Mongoid::Slug
-  field :title
-  slug :title, :permanent => true
-end

data/spec/models/publisher.rb

@@ -1,9 +0,0 @@
-class Publisher
-  include Mongoid::Document
-  include Mongoid::Slug
-  field :name
-  field :year, :type => Integer
-  field :place
-  slug  :name
-  embedded_in :book, :inverse_of => :publisher
-end

data/spec/models/sar.rb

@@ -1,7 +0,0 @@
-class Sar
-  include Mongoid::Document
-  include Mongoid::Slug
-  field :name
-  slug  :name, :scoped => true
-  embedded_in :foo, :inverse_of => :bars
-end