mongoid_slug 0.4.6 → 0.4.7

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Hakan Ensari
+Copyright (c) 2010 Paper Cavalier
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -3,8 +3,15 @@ Mongoid Slug
 
 Mongoid Slug generates a URL slug or permalink based on a field or set of fields in a Mongoid model.
 
-Examples
---------
+Install
+-------
+
+To install mongoid_slug, add it to your Gemfile:
+
+    gem 'mongoid_slug', :require => 'mongoid/slug'
+
+Usage
+-----
 
 Here's a book that embeds many authors:
 
@@ -57,4 +64,4 @@ To demo some more functionality in the console:
     >> book.authors.where(:slug => 'felix-guattari).first
     => #<Author _id: 4c31e362faa4a7050e000003, slug: "félix-guattari", last_name: "Guattari", first_name: "Félix">
 
-`slug` takes `:as` and `:scoped` as arguments. See models in specs for more examples.
+See [sample models in specs]("http://github.com/papercavalier/mongoid-slug/tree/master/spec/models/") for various configuration options.

data/lib/mongoid/slug/version.rb

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

data/lib/mongoid/slug.rb

@@ -0,0 +1,93 @@
+#encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Generates a URL slug/permalink based on fields in a Mongoid model
+  module Slug
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :slug_name, :slugged_fields, :slug_scoped
+    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 : {}
+
+        self.slug_name = options[:as] || :slug
+        self.slug_scoped = options[:scoped] || false
+        self.slugged_fields = args
+
+        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
+    end
+
+    def to_param
+      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
+    end
+
+    def find_unique_slug(suffix='')
+      slug = ("#{slug_base} #{suffix}").parameterize
+      if find_(slug).reject{ |doc| doc.id == self.id }.empty?
+        slug
+      else
+        suffix = suffix.blank? ? '1' : "#{suffix.to_i + 1}"
+        find_unique_slug(suffix)
+      end
+    end
+
+    def generate_slug
+      if new_record? || slugged_fields_changed?
+        self.send("#{slug_name}=", find_unique_slug)
+      end
+    end
+
+    def slug_base
+      self.class.slugged_fields.collect{ |field| self.send(field) }.join(" ")
+    end
+
+    def slugged_fields_changed?
+      self.class.slugged_fields.any? do |field|
+        self.send(field.to_s + '_changed?')
+      end
+    end
+  end
+end

data/spec/models/permanent.rb

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

data/spec/mongoid/slug_spec.rb

@@ -0,0 +1,318 @@
+#encoding: utf-8
+require "spec_helper"
+
+module Mongoid
+
+  describe Slug do
+
+    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
+      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$/
+      end
+
+      it "does not append a counter when slug is unique" do
+        book.to_param.should_not match /\d$/
+      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
+      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
+      end
+
+      it "finds by slug" do
+        Book.where(:slug => book.to_param).first.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)
+      end
+
+      it "updates slug" do
+        subject.update_attributes(:name => "Schizoanalysis")
+        subject.to_param.should eql "Schizoanalysis".parameterize
+      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
+      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$/
+      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
+      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
+      end
+
+      it "finds by slug" do
+        book.subjects.where(:slug => subject.to_param).first.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
+      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
+      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
+      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)
+      end
+
+      it "updates slug" do
+        author.update_attributes(:first_name => "Félix", :last_name => "Guattari")
+        author.to_param.should eql "Félix Guattari".parameterize
+      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
+      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$/
+      end
+
+      it "does not append a counter when slug is unique" do
+        author.to_param.should_not match /\d$/
+      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
+      end
+
+      it "finds by slug" do
+        author
+        Author.where(:slug => "gilles-deleuze").first.should eql author
+      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
+      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$/
+      end
+
+      it "does not append a counter when slug is unique" do
+        baz.to_param.should_not match /\d$/
+      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
+      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
+      end
+
+      it "finds by slug" do
+        bar.bazes.where(:slug => baz.to_param).first.should eql baz
+      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
+      end
+
+      it "finds by slug" do
+        Person.where(:permalink => person.to_param).first.should eql person
+      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
+      end
+
+      it "finds duplicate slug of an embedded document" do
+        bar.send(:find_, bar.to_param).count.should eql 1
+      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
+
+      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
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,30 +1,21 @@
 require "rubygems"
 require "bundler/setup"
 
-require "rspec"
 require "database_cleaner"
 require "mongoid"
+require "rspec"
 
 Mongoid.configure do |config|
   name = "mongoid_slug_test"
   config.master = Mongo::Connection.new.db(name)
 end
 
-require File.expand_path("../../lib/mongoid_slug", __FILE__)
-Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |f| require f }
-
-DatabaseCleaner.orm = "mongoid"
-
-Rspec.configure do |config|
-  config.before(:all) do
-    DatabaseCleaner.strategy = :truncation
-  end
+require File.expand_path("../../lib/mongoid/slug", __FILE__)
 
-  config.before(:each) do
-    DatabaseCleaner.start
-  end
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |f| require f }
 
-  config.after(:each) do
-    DatabaseCleaner.clean
-  end
+Rspec.configure do |c|
+  c.before(:all)  { DatabaseCleaner.strategy = :truncation }
+  c.before(:each) { DatabaseCleaner.start }
+  c.after(:each)  { DatabaseCleaner.clean }
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mongoid_slug
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: false
   segments: 
   - 0
   - 4
-  - 6
-  version: 0.4.6
+  - 7
+  version: 0.4.7
 platform: ruby
 authors: 
 - Hakan Ensari
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 +01:00
+date: 2010-10-31 01:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,46 +27,97 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31098209
+        hash: 62196421
         segments: 
         - 2
         - 0
         - 0
         - beta
-        version: 2.0.0.beta
+        - 19
+        version: 2.0.0.beta.19
   type: :runtime
   version_requirements: *id001
-description: Mongoid Slug generates a URL slug/permalink based on fields in a Mongoid model.
-email: code@papercavalier.com
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 1
+        - 1
+        version: 1.1.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id003 !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
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id004
+description: Generates a URL slug or permalink based on fields in a Mongoid model.
+email: 
+- code@papercavalier.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.md
+extra_rdoc_files: []
+
 files: 
+- lib/mongoid/slug/version.rb
+- lib/mongoid/slug.rb
 - LICENSE
-- lib/mongoid_slug.rb
 - 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/person.rb
 - spec/models/publisher.rb
 - spec/models/sar.rb
 - spec/models/subject.rb
-- spec/mongoid_slug_spec.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: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -89,20 +140,21 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: mongoid_slug
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Generates a URL slug in a Mongoid model
+summary: Generates a URL slug or permalink
 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/person.rb
 - spec/models/publisher.rb
 - spec/models/sar.rb
 - spec/models/subject.rb
-- spec/mongoid_slug_spec.rb
+- spec/mongoid/slug_spec.rb
 - spec/spec_helper.rb

data/lib/mongoid_slug.rb

@@ -1,81 +0,0 @@
-# Generates a URL slug/permalink based on fields in a Mongoid model.
-module Mongoid::Slug
-  extend ActiveSupport::Concern
-
-  included do
-    cattr_accessor :slug_name, :slugged_fields, :slug_scoped
-  end
-
-  module ClassMethods #:nodoc:
-    # Set a field or a number of fields as source of slug
-    def slug(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      self.slug_name = options[:as] || :slug
-      self.slug_scoped = options[:scoped] || false
-      self.slugged_fields = args
-
-      field slug_name
-      if slug_scoped
-        index slug_name
-      else
-        index slug_name, :unique => true
-      end
-      before_save :generate_slug
-    end
-  end
-
-  def to_param
-    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
-  end
-
-  def find_unique_slug(suffix='')
-    slug = ("#{slug_base} #{suffix}").parameterize
-    if find_(slug).reject{ |doc| doc.id == self.id }.empty?
-      slug
-    else
-      suffix = suffix.blank? ? '1' : "#{suffix.to_i + 1}"
-      find_unique_slug(suffix)
-    end
-  end
-
-  def generate_slug
-    if new_record? || slugged_fields_changed?
-      self.send("#{slug_name}=", find_unique_slug)
-    end
-  end
-
-  def slug_base
-    self.class.slugged_fields.collect{ |field| self.send(field) }.join(" ")
-  end
-
-  def slugged_fields_changed?
-    self.class.slugged_fields.any? do |field|
-      self.send(field.to_s + '_changed?')
-    end
-  end
-end

data/spec/mongoid_slug_spec.rb

@@ -1,314 +0,0 @@
-#encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Slug do
-
-  before(:each) do
-    @book = Book.create(:title => "A Thousand Plateaus", :isbn => "9789245242475")
-  end
-
-  context "root document" 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
-    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$/
-    end
-
-    it "does not append a counter when slug is unique" do
-      @book.to_param.should_not match /\d$/
-    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
-    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
-    end
-
-    it "finds by slug" do
-      Book.where(:slug => @book.to_param).first.should eql @book
-    end
-
-  end
-
-  context "embedded has many" do
-
-    before(:each) do
-      @subject = @book.subjects.create(:name => "Psychoanalysis")
-    end
-
-    it "generates slug" do
-      @subject.to_param.should eql(@subject.name.parameterize)
-    end
-
-    it "updates slug" do
-      @subject.update_attributes(:name => "Schizoanalysis")
-      @subject.to_param.should eql "Schizoanalysis".parameterize
-    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
-    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$/
-    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
-    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
-    end
-
-    it "finds by slug" do
-      @book.subjects.where(:slug => @subject.to_param).first.should eql @subject
-    end
-
-  end
-
-  context "embedded has one" do
-
-    before(:each) do
-      @publisher = @book.create_publisher(:name => "OUP")
-    end
-
-    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
-    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
-    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
-    end
-
-  end
-
-  context "composite fields" do
-    before(:each) do
-      @author = Author.create(:first_name => "Gilles", :last_name => "Deleuze")
-    end
-
-    it "generates slug" do
-      @author.to_param.should eql("Gilles Deleuze".parameterize)
-    end
-
-    it "updates slug" do
-      @author.update_attributes(:first_name => "Félix", :last_name => "Guattari")
-      @author.to_param.should eql "Félix Guattari".parameterize
-    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
-    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$/
-    end
-
-    it "does not append a counter when slug is unique" do
-      @author.to_param.should_not match /\d$/
-    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
-    end
-
-    it "finds by slug" do
-      Author.where(:slug => "gilles-deleuze").first.should eql @author
-    end
-
-  end
-
-  context "deeply embedded relationships" do
-
-    before(:each) do
-      @foo = Foo.create(:name => "foo")
-      @bar = @foo.bars.create(:name => "bar")
-      @baz = @bar.bazes.create(:name => "baz")
-      @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
-    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$/
-    end
-
-    it "does not append a counter when slug is unique" do
-      @baz.to_param.should_not match /\d$/
-    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
-    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
-    end
-
-    it "finds by slug" do
-      @bar.bazes.where(:slug => @baz.to_param).first.should eql @baz
-    end
-
-  end
-
-  context ":as option" do
-
-    before(:each) do
-      @person = Person.create(:name => "John Doe")
-    end
-
-    it "should set 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
-    end
-
-    it "finds by slug" do
-      Person.where(:permalink => @person.to_param).first.should eql @person
-    end
-
-  end
-
-  context "#find_" do
-
-    before(:each) do
-      @foo = Foo.create(:name => "foo")
-      @bar = @foo.bars.create(:name => "bar")
-      @baz = @bar.bazes.create(:name => "baz")
-    end
-
-    it "finds duplicate slug of a root document" do
-      @foo.send(:find_, @foo.to_param).count.should eql 1
-    end
-
-    it "finds duplicate slug of an embedded document" do
-      @bar.send(:find_, @bar.to_param).count.should eql 1
-    end
-
-    it "finds duplicate slug of a deeply-embedded document" do
-      @baz.send(:find_, @baz.to_param).count.should eql 1
-    end
-
-  end
-  
-  context ":scoped option" do
-    before(:each) do
-      @foo = Foo.create(:name => "foo")
-      @sar = @foo.sars.create(:name => "sar")
-      @foo2 = Foo.create(:name => "foo")
-    end
-    
-    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
-
-end