mongoid-slug 4.0.0

data/lib/mongoid/slug/criteria.rb

@@ -0,0 +1,110 @@
+module Mongoid
+  module Slug
+    class Criteria < Mongoid::Criteria
+      # Find the matchind document(s) in the criteria for the provided ids or slugs.
+      #
+      # If the document _ids are of the type BSON::ObjectId, and all the supplied parameters are
+      # convertible to BSON::ObjectId (via BSON::ObjectId#from_string), finding will be
+      # performed via _ids.
+      #
+      # If the document has any other type of _id field, and all the supplied parameters are of the same
+      # type, finding will be performed via _ids.
+      #
+      # Otherwise finding will be performed via slugs.
+      #
+      # @example Find by an id.
+      #   criteria.find(BSON::ObjectId.new)
+      #
+      # @example Find by multiple ids.
+      #   criteria.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
+      #
+      # @example Find by a slug.
+      #   criteria.find('some-slug')
+      #
+      # @example Find by multiple slugs.
+      #   criteria.find([ 'some-slug', 'some-other-slug' ])
+      #
+      # @param [ Array<Object> ] args The ids or slugs to search for.
+      #
+      # @return [ Array<Document>, Document ] The matching document(s).
+      def find(*args)
+        look_like_slugs?(args.__find_args__) ? find_by_slug!(*args) : super
+      end
+
+      # Find the matchind document(s) in the criteria for the provided slugs.
+      #
+      # @example Find by a slug.
+      #   criteria.find('some-slug')
+      #
+      # @example Find by multiple slugs.
+      #   criteria.find([ 'some-slug', 'some-other-slug' ])
+      #
+      # @param [ Array<Object> ] args The slugs to search for.
+      #
+      # @return [ Array<Document>, Document ] The matching document(s).
+      def find_by_slug!(*args)
+        slugs = args.__find_args__
+        raise_invalid if slugs.any?(&:nil?)
+        for_slugs(slugs).execute_or_raise_for_slugs(slugs, args.multi_arged?)
+      end
+
+      def look_like_slugs?(args)
+        return false unless args.all? { |id| id.is_a?(String) }
+        id_field = @klass.fields['_id']
+        @slug_strategy ||= id_field.options[:slug_id_strategy] || build_slug_strategy(id_field.type)
+        args.none? { |id| @slug_strategy.call(id) }
+      end
+
+      protected
+
+      # unless a :slug_id_strategy option is defined on the id field,
+      # use object_id or string strategy depending on the id_type
+      # otherwise default for all other id_types
+      def build_slug_strategy id_type
+        type_method = id_type.to_s.downcase.split('::').last + "_slug_strategy"
+        self.respond_to?(type_method, true) ? method(type_method) : lambda {|id| false}
+      end
+
+      # a string will not look like a slug if it looks like a legal BSON::ObjectId
+      def objectid_slug_strategy id
+        if Mongoid::Slug.mongoid3?
+          Moped::BSON::ObjectId.legal? id
+        else
+          BSON::ObjectId.legal?(id)
+        end
+      end
+
+      # a string will always look like a slug
+      def string_slug_strategy id
+        true
+      end
+
+
+      def for_slugs(slugs)
+        #_translations
+        localized = (@klass.fields['_slugs'].options[:localize] rescue false)
+        if localized
+          def_loc = I18n.default_locale
+          query = { '$in' => slugs }
+          where({'$or' => [{ _slugs: query }, { "_slugs.#{def_loc}" => query }]}).limit(slugs.length)
+        else
+          where({ _slugs: { '$in' => slugs } }).limit(slugs.length)
+        end
+      end
+
+      def execute_or_raise_for_slugs(slugs, multi)
+        result = uniq
+        check_for_missing_documents_for_slugs!(result, slugs)
+        multi ? result : result.first
+      end
+
+      def check_for_missing_documents_for_slugs!(result, slugs)
+        missing_slugs = slugs - result.map(&:slugs).flatten
+
+        if !missing_slugs.blank? && Mongoid.raise_not_found_error
+          raise Errors::DocumentNotFound.new(klass, slugs, missing_slugs)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/slug/index.rb

@@ -0,0 +1,27 @@
+module Mongoid
+  module Slug
+    module Index
+
+      # @param [ String or Symbol ] scope_key The optional scope key for the index
+      # @param [ Boolean ] by_model_type Whether or not
+      #
+      # @return [ Array(Hash, Hash) ] the indexable fields and index options.
+      def self.build_index(scope_key = nil, by_model_type = false)
+        fields  = {_slugs: 1}
+        options = {}
+
+        if scope_key
+          fields.merge!({scope_key => 1})
+        end
+
+        if by_model_type
+          fields.merge!({_type: 1})
+        else
+          options.merge!({unique: true, sparse: true})
+        end
+
+        return [fields, options]
+      end
+    end
+  end
+end

data/lib/mongoid/slug/paranoia.rb

@@ -0,0 +1,22 @@
+module Mongoid
+  module Slug
+
+    # Lightweight compatibility shim which adds the :restore callback to
+    # older versions of Mongoid::Paranoia
+    module Paranoia
+      extend ActiveSupport::Concern
+
+      included do
+
+        define_model_callbacks :restore
+
+        def restore_with_callbacks
+          run_callbacks(:restore) do
+            restore_without_callbacks
+          end
+        end
+        alias_method_chain :restore, :callbacks
+      end
+    end
+  end
+end

data/lib/mongoid/slug/slug_id_strategy.rb

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

data/lib/mongoid/slug/unique_slug.rb

@@ -0,0 +1,153 @@
+require 'forwardable'
+
+# Can use e.g. Mongoid::Slug::UniqueSlug.new(ModelClass.new).find_unique "slug-1" for auto-suggest ui
+module Mongoid
+  module Slug
+    class UniqueSlug
+      MUTEX_FOR_SLUG = Mutex.new
+      class SlugState
+        attr_reader :last_entered_slug, :existing_slugs, :existing_history_slugs, :sorted_existing
+
+        def initialize slug, documents, pattern
+          @slug = slug
+          @documents = documents
+          @pattern = pattern
+          @last_entered_slug = []
+          @existing_slugs = []
+          @existing_history_slugs = []
+          @sorted_existing = []
+          @documents.each do |doc|
+            history_slugs = doc._slugs
+            next if history_slugs.nil?
+            existing_slugs.push(*history_slugs.find_all { |cur_slug| cur_slug =~ @pattern })
+            last_entered_slug.push(*history_slugs.last) if history_slugs.last =~ @pattern
+            existing_history_slugs.push(*history_slugs.first(history_slugs.length() - 1).find_all { |cur_slug| cur_slug =~ @pattern })
+          end
+        end
+
+        def slug_included?
+          existing_slugs.include? @slug
+        end
+
+        def include_slug
+          existing_slugs << @slug
+        end
+
+        def highest_existing_counter
+          sort_existing_slugs
+          @sorted_existing.last || 0
+        end
+
+        def sort_existing_slugs
+          # remove the slug part and leave the absolute integer part and sort
+          re = %r(^#{Regexp.escape(@slug)})
+          @sorted_existing = existing_slugs.map do |s|
+            s.sub(re,'').to_i.abs
+          end.sort
+        end
+
+        def inspect
+          {
+            :slug                   => @slug,
+            :existing_slugs         => existing_slugs,
+            :last_entered_slug      => last_entered_slug,
+            :existing_history_slugs => existing_history_slugs,
+            :sorted_existing        => sorted_existing
+          }
+        end
+      end
+
+      extend Forwardable
+
+      attr_reader :model, :_slug
+
+      def_delegators :@model, :slug_scope, :reflect_on_association, :read_attribute,
+        :check_against_id, :reserved_words, :url_builder, :collection_name,
+        :embedded?, :reflect_on_all_associations, :by_model_type
+
+      def initialize model
+        @model = model
+        @_slug = ""
+        @state = nil
+      end
+
+      def metadata
+        @model.respond_to?(:relation_metadata) ? @model.relation_metadata : @model.metadata
+      end
+
+      def find_unique attempt = nil
+        MUTEX_FOR_SLUG.synchronize do
+          @_slug = if attempt
+            attempt.to_url
+          else
+            url_builder.call(model)
+          end
+          # Regular expression that matches slug, slug-1, ... slug-n
+          # If slug_name field was indexed, MongoDB will utilize that
+          # index to match /^.../ pattern.
+          pattern = /^#{Regexp.escape(@_slug)}(?:-(\d+))?$/
+  
+          where_hash = {}
+          where_hash[:_slugs.all] = [pattern]
+          where_hash[:_id.ne]     = model._id
+  
+          if (scope = slug_scope) && reflect_on_association(scope).nil?
+            # scope is not an association, so it's scoped to a local field
+            # (e.g. an association id in a denormalized db design)
+            where_hash[scope] = model.try(:read_attribute, scope)
+          end
+  
+          if by_model_type == true
+            where_hash[:_type] = model.try(:read_attribute, :_type)
+          end
+  
+          @state = SlugState.new @_slug, uniqueness_scope.unscoped.where(where_hash), pattern
+  
+          # do not allow a slug that can be interpreted as the current document id
+          @state.include_slug unless model.class.look_like_slugs?([@_slug])
+  
+          # make sure that the slug is not equal to a reserved word
+          @state.include_slug if reserved_words.any? { |word| word === @_slug }
+  
+          # only look for a new unique slug if the existing slugs contains the current slug
+          # - e.g if the slug 'foo-2' is taken, but 'foo' is available, the user can use 'foo'.
+          if @state.slug_included?
+            highest = @state.highest_existing_counter
+            @_slug += "-#{highest.succ}"
+          end
+          @_slug
+        end
+      end
+
+      def uniqueness_scope
+
+        if slug_scope &&
+            metadata = reflect_on_association(slug_scope)
+
+          parent = model.send(metadata.name)
+
+          # Make sure doc is actually associated with something, and that
+          # some referenced docs have been persisted to the parent
+          #
+          # TODO: we need better reflection for reference associations,
+          # like association_name instead of forcing collection_name here
+          # -- maybe in the forthcoming Mongoid refactorings?
+          inverse = metadata.inverse_of || collection_name
+          return parent.respond_to?(inverse) ? parent.send(inverse) : model.class
+        end
+
+        if embedded?
+          parent_metadata = reflect_on_all_associations(:embedded_in)[0]
+          return model._parent.send(parent_metadata.inverse_of || self.metadata.name)
+        end
+
+        #unless embedded or slug scope, return the deepest document superclass
+        appropriate_class = model.class
+        while appropriate_class.superclass.include?(Mongoid::Document)
+          appropriate_class = appropriate_class.superclass
+        end
+        appropriate_class
+      end
+    end
+  end
+end

data/lib/mongoid/slug/version.rb

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

data/lib/mongoid_slug.rb

@@ -0,0 +1,2 @@
+# To be removed
+require 'mongoid/slug'

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

@@ -0,0 +1,9 @@
+class Article
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :brief
+  field :title
+  slug  :title, :brief do |doc|
+    [doc.title, doc.brief].reject(&:blank?).first
+  end
+end

data/spec/models/author.rb

@@ -0,0 +1,11 @@
+class Author
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :first_name
+  field :last_name
+  slug  :first_name, :last_name, :scope => :book
+  belongs_to :book
+  has_many :characters,
+           :class_name => 'Person',
+           :foreign_key => :author_id
+end

data/spec/models/author_polymorphic.rb

@@ -0,0 +1,11 @@
+class AuthorPolymorphic
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :first_name
+  field :last_name
+  slug  :first_name, :last_name, :scope => :book_polymorphic
+  belongs_to :book_polymorphic
+  has_many :characters,
+           :class_name => 'Person',
+           :foreign_key => :author_id
+end

data/spec/models/book.rb

@@ -0,0 +1,12 @@
+class Book
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title
+
+  slug  :title, :history => true
+  embeds_many :subjects
+  has_many :authors
+end
+
+class ComicBook < Book
+end

data/spec/models/book_polymorphic.rb

@@ -0,0 +1,12 @@
+class BookPolymorphic
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :title
+
+  slug  :title, :history => true, :by_model_type => true
+  embeds_many :subjects
+  has_many :author_polymorphics
+end
+
+class ComicBookPolymorphic < BookPolymorphic
+end

data/spec/models/caption.rb

@@ -0,0 +1,17 @@
+class Caption
+  include Mongoid::Document
+  include Mongoid::Slug
+  field :my_identity, :type => String
+  field :title
+  field :medium
+
+  # A fairly complex scenario, where we want to create a slug out of an
+  # my_identity field, which comprises name of artist and some more bibliographic
+  # info in parantheses, and the title of the work.
+  #
+  # We are only interested in the name of the artist so we remove the
+  # paranthesized details.
+  slug :my_identity, :title do |cur_object|
+    cur_object.slug_builder.gsub(/\s*\([^)]+\)/, '').to_url
+  end
+end

data/spec/models/entity.rb

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

data/spec/models/friend.rb

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

data/spec/models/incorrect_slug_persistence.rb

@@ -0,0 +1,9 @@
+class IncorrectSlugPersistence
+ include Mongoid::Document
+ include Mongoid::Slug
+
+ field :name
+ slug  :name, history: true
+
+ validates_length_of :name, :minimum => 4, :maximum => 5, :allow_blank => true
+end