mongoid_slug 0.9.0 → 0.10.0

data/LICENSE

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

data/README.md

@@ -1,22 +1,25 @@
 Mongoid Slug
 ============
 
-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] and
-works with non-Latin characters.
+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.
 
-[![travis](https://secure.travis-ci.org/hakanensari/mongoid-slug.png)](http://travis-ci.org/hakanensari/mongoid-slug)
+[![travis] [2]] [3]
 
-Quick Start
------------
+Installation
+------------
 
-Add mongoid_slug to your Gemfile:
+Add to your Gemfile:
 
 ```ruby
 gem 'mongoid_slug'
 ```
 
-Set up some slugs:
+Usage
+-----
+
+Set up a slug:
 
 ```ruby
 class Book
@@ -24,34 +27,18 @@ class Book
   include Mongoid::Slug
 
   field :title
-  embeds_many :authors
-
   slug :title
 end
-
-class Author
-  include Mongoid::Document
-  include Mongoid::Slug
-
-  field :first
-  field :last
-  embedded_in :book, :inverse_of => :authors
-
-  slug :first, :last, :as => :name
-end
 ```
 
-In your controller, use available finders:
+Find a record by its slug:
 
 ```ruby
-# GET /books/a-thousand-plateaus/authors/gilles-deleuze
-author = Book.find_by_slug(params[:book_id]).
-              authors.
-              find_by_name(params[:id])
+# GET /books/a-thousand-plateaus
+book = Book.find_by_slug params[:book_id]
 ```
 
-[Read here] [2]
-for all available options.
+[Read here] [3] for all available options.
 
 Scoping
 -------
@@ -61,37 +48,89 @@ To scope a slug by a reference association, pass `:scope`:
 ```ruby
 class Company
   include Mongoid::Document
+  
   references_many :employees
 end
 
 class Employee
- include Mongoid::Document
- include Mongoid::Slug
- field :name
- slug  :name, :scope => :company
- referenced_in :company
+  include Mongoid::Document
+  include Mongoid::Slug
+  
+  field :name
+  referenced_in :company
+  
+  slug  :name, :scope => :company
 end
 ```
 
-In this example, if you create an employee without associating it with
-any company, the scope will fall back to the root employees collection.
+In this example, if you create an employee without associating it with any
+company, the scope will fall back to the root employees collection.
 
-Currently, if you have an irregular association name, you **must**
-specify the `:inverse_of` option on the other side of the assocation.
+Currently, if you have an irregular association name, you **must** specify the
+`:inverse_of` option on the other side of the assocation.
 
 Embedded objects are automatically scoped by their parent.
 
-If the value of `:scope` is not an association, it should be the name of a field within the model itself:
+The value of `:scope` can alternatively be a field within the model itself:
 
 ```ruby
 class Employee
- include Mongoid::Document
- include Mongoid::Slug
- field :name
- field :company_id
- slug  :name, :scope => :company_id
+  include Mongoid::Document
+  include Mongoid::Slug
+  
+  field :name
+  field :company_id
+  
+  slug  :name, :scope => :company_id
+end
+```
+
+History
+-------
+
+To specify that the history of a document should be kept track of, pass
+`:history` with a value of `true`.
+
+```ruby
+class Page
+  include Mongoid::Document
+  include Mongoid::Slug
+  
+  field :title
+  
+  slug :title, history: true
+end
+```
+
+The document will then be returned for any of the saved slugs:
+
+```ruby
+page = Page.new title: "Home"
+page.save
+page.update_attributes title: "Welcome"
+
+Page.find_by_slug("welcome") == Page.find_by_slug("home") #=> true
+```
+
+Reserved Slugs
+--------------
+
+Pass words you do not want to be slugged using the `reserve` option:
+
+```ruby
+class Friend
+  include Mongoid::Document
+
+  field :name
+  slug :name, reserve: ['admin', 'root']
 end
+
+friend = Friend.create name: 'admin'
+Friend.find_by_slug('admin') # => nil
+friend.slug # => 'admin-1'
 ```
 
 [1]: https://github.com/rsl/stringex/
-[2]: https://github.com/hakanensari/mongoid-slug/blob/master/lib/mongoid/slug.rb
+[2]: https://secure.travis-ci.org/hakanensari/mongoid-slug.png
+[3]: http://travis-ci.org/hakanensari/mongoid-slug
+[4]: https://github.com/hakanensari/mongoid-slug/blob/master/lib/mongoid/slug.rb

data/lib/mongoid/slug.rb

@@ -1,213 +1,353 @@
 require 'mongoid'
 require 'stringex'
 
-module Mongoid #:nodoc:
-
-  # The slug module helps you generate a URL slug or permalink based on
-  # one or more fields in a Mongoid model.
-  #
-  #    class Person
-  #      include Mongoid::Document
-  #      include Mongoid::Slug
-  #
-  #      field :name
-  #      slug :name
-  #    end
-  #
+module Mongoid
+  # The Slug module helps you generate 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_builder,
-                     :slugged_fields,
                      :slug_name,
-                     :slug_scope
+                     :slug_history_name,
+                     :slug_scope,
+                     :reserved_words_in_slug,
+                     :slugged_attributes
     end
 
     module ClassMethods
-
-      # Sets one ore more fields as source of slug.
-      #
-      # Takes a list of fields to slug and an optional options hash.
-      #
-      # The options hash respects the following members:
-      #
-      # * `:as`, which specifies name of the field that stores the
-      # slug. Defaults to `slug`.
-      #
-      # * `:scope`, which specifies a reference association to scope
-      # the slug by. Embedded documents are by default scoped by their
-      # parent.
-      #
-      # * `:permanent`, which specifies whether the slug should be
-      # immutable once created. Defaults to `false`.
+      # @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.
+      #   @yield If given, the block is used to build a custom slug.
       #
-      # * `:index`, which specifies whether an index should be defined
-      # for the slug. Defaults to `false` and has no effect if the
-      # document is embedded. Make sure you have a unique index on the
-      # slug of root documents to avoid the (very unlikely) race
-      # condition that would ensue if two documents with identical
-      # slugs were to be saved simultaneously.
+      # @overload slug(*fields, options) 
+      #   Sets one ore more fields as source of slug.
+      #   @param [Array] fields One or more fields the slug should be based on.
+      #   @param [Hash] options
+      #   @param options [String] :as The name of the field that stores the
+      #   slug. Defaults to `slug`.
+      #   @param options [Boolean] :history Whether a history of changes to
+      #   the slug should be retained. When searched by slug, the document now
+      #   matches both past and present slugs.
+      #   @param options [Boolean] :index Whether an index should be defined
+      #   on the slug field. Defaults to `false` and has no effect if the
+      #   document is embedded.
+      #   Make sure you have a unique index on the slugs of root documents to
+      #   avoid race conditions.
+      #   @param options [Boolean] :permanent Whether the slug should be
+      #   immutable. Defaults to `false`.
+      #   @param options [Array] :reserve` A list of reserved slugs
+      #   @param options :scope [Symbol] a reference association or field to
+      #   scope the slug by. Embedded documents are, by default, scoped by
+      #   their parent.
+      #   @yield If given, a block is used to build a slug.
       #
-      # Alternatively, this method can be given a block to build a
-      # custom slug out of the specified fields.
+      # @example A custom builder
+      #   class Person
+      #     include Mongoid::Document
+      #     include Mongoid::Slug
       #
-      # The block takes a single argument, the document itself, and
-      # should return a string that will serve as the base of the slug.
-      #
-      # Here, for instance, we slug an array field.
-      #
-      #     class Person
-      #      include Mongoid::Document
-      #      include Mongoid::Slug
-      #
-      #      field :names, :type => Array
-      #      slug :names do |doc|
-      #        doc.names.join(' ')
-      #      end
+      #     field :names, :type => Array
+      #     slug :names do |doc|
+      #       doc.names.join(' ')
+      #     end
+      #   end
       #
       def slug(*fields, &block)
-        options             = fields.extract_options!
-        self.slug_scope     = options[:scope]
-        self.slug_name      = options[:as] || :slug
-        self.slugged_fields = fields.map(&:to_s)
-
-        self.slug_builder =
-          if block_given?
-            block
-          else
-            lambda do |doc|
-              slugged_fields.map { |f| doc.read_attribute(f) }.
-                             join(' ')
-            end
-          end
+        options = fields.extract_options!
+        options[:history] = false if options[:permanent]
+
+        self.slug_scope             = options[:scope]
+        self.reserved_words_in_slug = options[:reserve] || []
+        self.slug_name              = options[:as] || :slug
+        self.slugged_attributes     = fields.map(&:to_s)
+        if options[:history] && !options[:permanent]
+          self.slug_history_name    = "#{self.slug_name}_history".to_sym
+        end
+
+        default_builder = lambda do |doc|
+          slugged_attributes.map { |f| doc.send f }.join ' '
+        end
+        self.slug_builder = block_given? ? block : default_builder
 
         field slug_name
 
+        if slug_history_name
+          field slug_history_name, :type => Array, :default => []
+        end
+
         if options[:index]
-          index(slug_name, :unique => !slug_scope)
+          index slug_name, :unique => !slug_scope
+          index slug_history_name if slug_history_name
         end
 
-        if options[:permanent]
-          before_create :generate_slug
-        else
-          before_save :generate_slug
+        set_callback options[:permanent] ? :create : :save, :before do |doc|
+          doc.build_slug if doc.slug_should_be_rebuilt?
         end
 
-        # Build a finder based on the slug name.
+        # Build a finder for slug.
         #
         # Defaults to `find_by_slug`.
         instance_eval <<-CODE
           def self.find_by_#{slug_name}(slug)
-            where(slug_name => slug).first
+            if slug_history_name
+              any_of({ slug_name => slug }, { slug_history_name => slug })
+            else
+              where(slug_name => slug)
+            end.first
           end
 
           def self.find_by_#{slug_name}!(slug)
-            where(slug_name => slug).first ||
-              raise(Mongoid::Errors::DocumentNotFound.new(self, slug))
+            self.find_by_#{slug_name}(slug) ||
+              raise(Mongoid::Errors::DocumentNotFound.new self, slug)
           end
         CODE
-      end
-    end
 
-    # Returns the slug.
-    def to_param
-      read_attribute(slug_name) || begin
-        generate_slug!
-        save
-        read_attribute(slug_name)
+        # Build a scope based on the slug name.
+        #
+        # Defaults to `by_slug`.
+        scope "by_#{slug_name}".to_sym, lambda { |slug|
+          if slug_history_name
+            any_of({ slug_name => slug }, { slug_history_name => slug })
+          else
+            where(slug_name => slug)
+          end
+        }
       end
-    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
+      # @param [Hash] options
+      # @param options [Symbol] :scope The scope that should be used to
+      # generate the slug, if the class creates scoped slugs. Defaults to
+      # `nil`.
+      # @param options [Constant] :model The model that the slug should be 
+      # generated for. This option overrides `:scope`, as the scope can now 
+      # be extracted from the model. Defaults to `nil`.
+      # @return [String] A unique slug
+      def find_unique_slug_for(desired_slug, options = {})
+        if slug_scope && self.reflect_on_association(slug_scope).nil?
+          scope_object    = uniqueness_scope(options[:model])
+          scope_attribute = options[:scope] || options[:model].try(:read_attribute, slug_scope)
+        else
+          scope_object = options[:scope] || uniqueness_scope(options[:model])
+          scope_attribute = nil
+        end
+        
+        excluded_id = options[:model]._id if options[:model]
+        
+        slug = desired_slug.to_url
+        
+        # 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+))?$/
 
-    private
+        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)
 
-    def find_unique_slug
-      # TODO: An epic method which calls for refactoring.
-      slug = slug_builder.call(self).to_url
-
-      # 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+))?$/
-
-      if slug_scope &&
-         self.class.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)
-        existing_slugs =
-          self.class.
-          only(slug_name).
-          where(slug_name  => pattern,
-                :_id.ne    => _id,
-                slug_scope => self[slug_scope])
-      else
-        existing_slugs =
-          uniqueness_scope.
-          only(slug_name).
-          where(slug_name => pattern, :_id.ne => _id)
-      end
+          where_hash = {}
+          where_hash[slug_name]  = pattern
+          where_hash[:_id.ne]    = excluded_id if excluded_id
+          where_hash[slug_scope] = scope_attribute
 
-      existing_slugs = existing_slugs.map do |obj|
-        obj.try(:read_attribute, slug_name)
-      end
+          existing_slugs =
+            deepest_document_superclass.
+            only(slug_name).
+            where(where_hash)
+        else
+          where_hash = {}
+          where_hash[slug_name] = pattern
+          where_hash[:_id.ne]   = excluded_id if excluded_id
+
+          existing_slugs =
+            scope_object.
+            only(slug_name).
+            where(where_hash)
+        end    
+
+        existing_slugs = existing_slugs.map do |doc|
+          doc.slug
+        end
+
+        if slug_history_name
+          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 = {}
+            where_hash[slug_history_name.all] = [pattern]
+            where_hash[:_id.ne]               = excluded_id if excluded_id
+            where_hash[slug_scope]            = scope_attribute
+
+            history_slugged_documents =
+              deepest_document_superclass.
+              where(where_hash)
+          else
+            where_hash = {}
+            where_hash[slug_history_name.all] = [pattern]
+            where_hash[:_id.ne]               = excluded_id if excluded_id
+
+            history_slugged_documents =
+              scope_object.
+              where(where_hash)
+          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
+          existing_history_slugs = []
+          history_slugged_documents.each do |doc|
+            history_slugs = doc.read_attribute(slug_history_name)
+            next if history_slugs.nil?
+            existing_history_slugs.push(*history_slugs.find_all { |slug| slug =~ pattern })
+          end
+
+          # If the only conflict is in the history of a document in the same scope,
+          # transfer the slug
+          if slug_scope && existing_slugs.count == 0 && existing_history_slugs.count > 0
+            history_slugged_documents.each do |doc|
+              doc_history_slugs = doc.read_attribute(slug_history_name)
+              next if doc_history_slugs.nil?
+              doc_history_slugs -= existing_history_slugs
+              doc.write_attribute(slug_history_name, doc_history_slugs)
+              doc.save
+            end
+            existing_history_slugs = []
+          end
+
+          existing_slugs += existing_history_slugs
+        end   
+
+        if reserved_words_in_slug.any? { |word| word === slug }
+          existing_slugs << slug
         end
-        max = existing_slugs.last.match(/-(\d+)$/).try(:[], 1).to_i
 
-        slug += "-#{max + 1}"
+        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
+
+        slug
       end
+      
+      private
+      
+      def uniqueness_scope(model = nil)  
+        if model
+          if slug_scope && (metadata = self.reflect_on_association(slug_scope))
+            parent = model.send(metadata.name)
 
-      slug
+            # 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
+          end
+          if embedded?
+            parent_metadata = reflect_on_all_associations(:embedded_in)[0]
+            return model._parent.send(parent_metadata.inverse_of || model.metadata.name)
+          end
+        end
+        deepest_document_superclass
+      end
+      
+      def deepest_document_superclass
+        appropriate_class = self
+        while appropriate_class.superclass.include?(Mongoid::Document)
+          appropriate_class = appropriate_class.superclass
+        end
+        appropriate_class
+      end
     end
 
-    def generate_slug
-      # Generate a slug for new records only if the slug was not set.
-      # If we're not a new record generate a slug if our slugged fields
-      # changed on us.
-      if (new_record? && !read_attribute(slug_name)) ||
-         (!new_record? && slugged_fields_changed?)
-        generate_slug!
+    # Builds a new slug.
+    #
+    # @return [true]
+    def build_slug
+      old = slug
+      write_attribute slug_name, find_unique_slug
+      
+      # @note I find it odd that we can't use `slug_was`, `slug_changed?`, or
+      # `read_attribute (slug_history_name)` here.
+
+      if slug_history_name && old && old != slug
+        self.send(slug_history_name).<<(old).uniq!
       end
+
+      true
     end
 
-    def generate_slug!
-      write_attribute(slug_name, find_unique_slug)
+    # 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_for(desired_slug)
+      self.class.find_unique_slug_for desired_slug, :model => self
     end
 
-    def slugged_fields_changed?
-      slugged_fields.any? { |f| attribute_changed?(f) }
+    # @return [Boolean] Whether the slug requires to be rebuilt
+    def slug_should_be_rebuilt?
+      new_record? or slug_changed? or slugged_attributes_changed?
     end
 
-    def uniqueness_scope
-      if slug_scope
-        metadata = self.class.reflect_on_association(slug_scope)
-        parent = self.send(metadata.name)
+    unless self.respond_to? :slug
+      def slug
+        read_attribute slug_name
+      end
 
-        # 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
-        parent.respond_to?(inverse) ? parent.send(inverse) : self.class
-      elsif embedded?
-        parent_metadata = reflect_on_all_associations(:embedded_in)[0]
-        _parent.send(parent_metadata.inverse_of || self.metadata.name)
-      else
-        appropriate_class = self.class
-        while appropriate_class.superclass.include?(Mongoid::Document)
-          appropriate_class = appropriate_class.superclass
-        end
-        appropriate_class
+      def slug_changed?
+        attribute_changed? slug_name
+      end
+
+      def slug_was
+        attribute_was slug_name
+      end
+    end
+
+    def slugged_attributes_changed?
+      slugged_attributes.any? { |f| attribute_changed? f }
+    end
+
+    # @return [String] A string which Action Pack uses for constructing an URL
+    # to this record.
+    def to_param
+      unless slug
+        build_slug
+        save
       end
+
+      slug
+    end
+    
+    private
+
+    def find_unique_slug
+      find_unique_slug_for user_defined_slug || slug_builder.call(self)
+    end
+
+    def user_defined_slug
+      slug if new_record? and slug.present? or slug_changed?
     end
   end
 end

data/lib/mongoid/slug/version.rb

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

data/spec/models/alias.rb

@@ -0,0 +1,6 @@
+class Alias
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :name, :as => :author_name
+  slug  :author_name
+end

data/spec/models/book.rb

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

data/spec/models/friend.rb

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

data/spec/models/subject.rb

@@ -2,6 +2,6 @@ class Subject
   include Mongoid::Document
   include Mongoid::Slug
   field :name
-  slug  :name
+  slug  :name, :scope => :book, :history => true
   embedded_in :book
 end

data/spec/mongoid/slug_spec.rb

@@ -58,7 +58,7 @@ module Mongoid
 
       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'
+        dup.to_param.should eql "psychoanalysis-1"
       end
 
       it "does not update slug if slugged fields have not changed" do
@@ -147,26 +147,25 @@ module Mongoid
         dup = Author.create(
           :first_name => author.first_name,
           :last_name  => author.last_name)
-        dup.to_param.should eql 'gilles-deleuze-1'
+        dup.to_param.should eql "gilles-deleuze-1"
 
         dup2 = Author.create(
           :first_name => author.first_name,
           :last_name  => author.last_name)
 
         dup.save
-        dup2.to_param.should eql 'gilles-deleuze-2'
+        dup2.to_param.should eql "gilles-deleuze-2"
       end
 
       it "does not update slug if slugged fields have changed but generated slug is identical" do
         author.last_name = "DELEUZE"
         author.save
-        author.to_param.should eql 'gilles-deleuze'
+        author.to_param.should eql "gilles-deleuze"
       end
 
       it "finds by slug" do
         Author.find_by_slug("gilles-deleuze").should eql author
       end
-
     end
 
     context "when :as is passed as an argument" do
@@ -196,6 +195,40 @@ module Mongoid
       end
     end
 
+    context "when :history is passed as an argument" do
+      let(:book) do
+        Book.create(:title => "Book Title")
+      end
+
+      before(:each) do
+        book.title = "Other Book Title"
+        book.save
+      end
+
+      it "saves the old slug in the owner's history" do
+        book.slug_history.should include("book-title")
+      end
+
+      it "returns the document for the old slug" do
+        Book.find_by_slug("book-title").should == book
+      end
+
+      it "returns the document for the new slug" do
+        Book.find_by_slug("other-book-title").should == book
+      end
+
+      it "generates a unique slug by appending a counter to duplicate text" do
+        dup = Book.create(:title => "Book Title")
+        dup.to_param.should eql "book-title-1"
+      end
+
+      it "ensures no duplicate values are stored in history" do
+        book.update_attributes :title => 'Book Title'
+        book.update_attributes :title => 'Foo'
+        book.slug_history.find_all { |slug| slug == 'book-title' }.size.should eql 1
+      end
+    end
+
     context "when slug is scoped by a reference association" do
       let(:author) do
         book.authors.create(:first_name => "Gilles", :last_name  => "Deleuze")
@@ -214,7 +247,7 @@ module Mongoid
         dup = book.authors.create(
           :first_name => author.first_name,
           :last_name  => author.last_name)
-        dup.to_param.should eql 'gilles-deleuze-1'
+        dup.to_param.should eql "gilles-deleuze-1"
       end
 
       context "with an irregular association name" do
@@ -235,46 +268,70 @@ 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.slug.should == "a-subject"
+        end
+
+        it "removes the slug from the old owner's history" do
+          subject1.slug_history.should_not include("a-subject")
+        end
+      end
     end
-    
+
     context "when slug is scoped by one of the class's own fields" do
       let!(:magazine) do
         Magazine.create(:title  => "Big Weekly", :publisher_id => "abc123")
       end
 
       it "should scope by local field" do
-        magazine.to_param.should eql 'big-weekly'
+        magazine.to_param.should eql "big-weekly"
         magazine2 = Magazine.create(:title => "Big Weekly", :publisher_id => "def456")
         magazine2.to_param.should eql magazine.to_param
       end
 
       it "should generate a unique slug by appending a counter to duplicate text" do
         dup = Magazine.create(:title  => "Big Weekly", :publisher_id => "abc123")
-        dup.to_param.should eql 'big-weekly-1'
+        dup.to_param.should eql "big-weekly-1"
       end
     end
 
-    context "when :slug is given a block" do
+    context "when #slug is given a block" do
       let(:caption) do
-        Caption.create(:identity => 'Edward Hopper (American, 1882-1967)',
-                       :title    => 'Soir Bleu, 1914',
-                       :medium   => 'Oil on Canvas')
+        Caption.create(:identity => "Edward Hopper (American, 1882-1967)",
+                       :title    => "Soir Bleu, 1914",
+                       :medium   => "Oil on Canvas")
       end
 
       it "generates a slug" do
-        caption.to_param.should eql 'edward-hopper-soir-bleu-1914'
+        caption.to_param.should eql "edward-hopper-soir-bleu-1914"
       end
 
       it "updates the slug" do
-        caption.title = 'Road in Maine, 1914'
+        caption.title = "Road in Maine, 1914"
         caption.save
         caption.to_param.should eql "edward-hopper-road-in-maine-1914"
       end
 
       it "does not change slug if slugged fields have changed but generated slug is identical" do
-        caption.identity = 'Edward Hopper'
+        caption.identity = "Edward Hopper"
         caption.save
-        caption.to_param.should eql 'edward-hopper-soir-bleu-1914'
+        caption.to_param.should eql "edward-hopper-soir-bleu-1914"
       end
 
       it "finds by slug" do
@@ -298,13 +355,13 @@ module Mongoid
       it "slugs Chinese characters" do
         book.title = "中文"
         book.save
-        book.to_param.should eql 'zhong-wen'
+        book.to_param.should eql "zhong-wen"
       end
 
       it "slugs non-ASCII Latin characters" do
-        book.title = 'Paul Cézanne'
+        book.title = "Paul Cézanne"
         book.save
-        book.to_param.should eql 'paul-cezanne'
+        book.to_param.should eql "paul-cezanne"
       end
     end
 
@@ -340,6 +397,29 @@ module Mongoid
         Person.collection.index_information.should_not have_key "permalink_1"
       end
     end
+    
+    context "when :reserve is passed" do
+      it "does not use the the reserved slugs" do
+        friend1 = Friend.create(:name => "foo")
+        friend1.slug.should_not eql("foo")
+        friend1.slug.should eql("foo-1")
+
+        friend2 = Friend.create(:name => "bar")
+        friend2.slug.should_not eql("bar")
+        friend2.slug.should eql("bar-1")
+
+        friend3 = Friend.create(:name => "en")
+        friend3.slug.should_not eql("en")
+        friend3.slug.should eql("en-1")
+      end
+
+      it "should start with concatenation -1" do
+        friend1 = Friend.create(:name => "foo")
+        friend1.slug.should eql("foo-1")
+        friend2 = Friend.create(:name => "foo")
+        friend2.slug.should eql("foo-2")
+      end
+    end
 
     context "when the object has STI" do
       it "scopes by the superclass" do
@@ -349,6 +429,25 @@ module Mongoid
       end
     end
 
+    context "when slug defined on alias of field" do
+      it "should use accessor, not alias" do
+        pseudonim  = Alias.create(:author_name => "Max Stirner")
+        pseudonim.slug.should eql("max-stirner")
+      end
+    end
+
+    describe ".by_slug scope" do
+      let!(:author) { book.authors.create(:first_name => "Gilles", :last_name  => "Deleuze") }
+
+      it "returns an empty array if no document is found" do
+        book.authors.by_slug("never-heard-of").should == []
+      end
+
+      it "returns an array containing the document if it is found" do
+        book.authors.by_slug(author.slug).should == [author]
+      end
+    end
+
     describe ".find_by_slug" do
       let!(:book) { Book.create(:title => "A Thousand Plateaus") }
 
@@ -386,11 +485,62 @@ module Mongoid
         book.reload.slug.should eql "proust-and-signs"
       end
     end
-    
-    context "when the slugged field is set upon creation" do
-      it "respects the provided slug and does not generate a new one" do
-        book = Book.create(:title => "A Thousand Plateaus", :slug => 'not-what-you-expected')
-        book.to_param.should eql "not-what-you-expected"
+
+    describe ".for_unique_slug_for" do
+      it "returns the unique slug" do
+        Book.find_unique_slug_for("A Thousand Plateaus").should eq("a-thousand-plateaus")
+      end
+
+      it "returns the unique slug with a counter if necessary" do
+        Book.create(:title => "A Thousand Plateaus")
+        Book.find_unique_slug_for("A Thousand Plateaus").should eq("a-thousand-plateaus-1")
+      end
+
+      it "returns the unique slug as if it were the provided object" do
+        book = Book.create(:title => "A Thousand Plateaus")
+        Book.find_unique_slug_for("A Thousand Plateaus", :model => book).should eq("a-thousand-plateaus")
+      end
+    end
+
+    describe "#find_unique_slug_for" do
+      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+
+      it "returns the unique slug" do
+        book.find_unique_slug_for("Anti Oedipus").should eq("anti-oedipus")
+      end
+
+      it "returns the unique slug with a counter if necessary" do
+        Book.create(:title => "Anti Oedipus")
+        book.find_unique_slug_for("Anti Oedipus").should eq("anti-oedipus-1")
+      end
+    end
+
+    context "when the slugged field is set manually" do
+      context "when it set to a non-empty string" do
+        it "respects the provided slug" do
+          book = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
+          book.to_param.should eql "not-what-you-expected"
+        end
+        
+        it "ensures uniqueness" do
+          book1 = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
+          book2 = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
+          book2.to_param.should eql "not-what-you-expected-1"
+        end
+        
+        it "updates the slug when a new one is passed in" do
+          book = Book.create(:title => "A Thousand Plateaus", :slug => "not-what-you-expected")
+          book.slug = "not-it-either"
+          book.save
+          book.to_param.should eql "not-it-either"
+        end
+      end
+
+      context "when it is set to an empty string" do
+        it "generate a new one" do
+          book = Book.create(:title => "A Thousand Plateaus", :slug => "")
+          book.to_param.should eql "a-thousand-plateaus"
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,12 +1,13 @@
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
-require "rspec"
+require 'pry'
+require 'rspec'
 
-require File.expand_path("../../lib/mongoid/slug", __FILE__)
+require File.expand_path('../../lib/mongoid/slug', __FILE__)
 
 Mongoid.configure do |config|
-  name = "mongoid_slug_test"
+  name = 'mongoid_slug_test'
   config.master = Mongo::Connection.new.db(name)
 end
 

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_slug
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
-- Paper Cavalier
+- Hakan Ensari
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-10 00:00:00.000000000 Z
+date: 2012-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70354887937940 !ruby/object:Gem::Requirement
+  requirement: &70314214792060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70354887937940
+  version_requirements: *70314214792060
 - !ruby/object:Gem::Dependency
   name: stringex
-  requirement: &70354887953780 !ruby/object:Gem::Requirement
+  requirement: &70314214791560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,32 @@ dependencies:
         version: '1.3'
   type: :runtime
   prerelease: false
-  version_requirements: *70354887953780
+  version_requirements: *70314214791560
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70314214791100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70314214791100
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70314214790640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *70314214790640
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70354887953320 !ruby/object:Gem::Requirement
+  requirement: &70314214790180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,22 +65,21 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *70354887953320
+  version_requirements: *70314214790180
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70354887952860 !ruby/object:Gem::Requirement
+  requirement: &70314214789720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.8'
   type: :development
   prerelease: false
-  version_requirements: *70354887952860
-description: Mongoid Slug generates a URL slug or permalink based on one or more fields
-  in a Mongoid model.
+  version_requirements: *70314214789720
+description: ! "      a                    \n      a    ."
 email:
-- code@papercavalier.com
+- hakan.ensari@papercavalier.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -68,10 +89,12 @@ files:
 - lib/mongoid_slug.rb
 - LICENSE
 - README.md
+- spec/models/alias.rb
 - spec/models/article.rb
 - spec/models/author.rb
 - spec/models/book.rb
 - spec/models/caption.rb
+- spec/models/friend.rb
 - spec/models/magazine.rb
 - spec/models/page.rb
 - spec/models/partner.rb
@@ -80,7 +103,7 @@ files:
 - spec/models/subject.rb
 - spec/mongoid/slug_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/papercavalier/mongoid-slug
+homepage: http://github.com/hakanensari/mongoid-slug
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -103,12 +126,14 @@ rubyforge_project: mongoid_slug
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Generates a URL slug
+summary: Generates a URL slug in a Mongoid model
 test_files:
+- spec/models/alias.rb
 - spec/models/article.rb
 - spec/models/author.rb
 - spec/models/book.rb
 - spec/models/caption.rb
+- spec/models/friend.rb
 - spec/models/magazine.rb
 - spec/models/page.rb
 - spec/models/partner.rb