mongoid-slug 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: ae9c5f1b269558e56ea27b2c659cc14d4670b886
-  data.tar.gz: bd270a6a2320c369d822dfb7836ea2a13d85db01
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzVhMTg3OTVmNzYyZDVmNWQ1MGQxYTNiMDYyZDUzMDhkMTFiNjNkOA==
+  data.tar.gz: !binary |-
+    MDNjMmJjZTI4MDE3Njk1NThhYjg4ZTZjNmEwYzE4NzVkMjA3ZTUwNg==
 SHA512:
-  metadata.gz: 9c662ebc338efef83a34c6d509c2c012e1404b50ddf9337a8570e27c76ef8ee5e8c2e0eae6ba871bcd669042fee6b3f69576213073726a5f45f5be2e84c9eaac
-  data.tar.gz: 63d767317c4169410246110ea16942ced927e773c7ec94ea83bef62a1d2004a46fa2ce3c9d65ea94a5ef63fad6b2e0f3fe391e4af162a7a5a67dd112a9593a36
+  metadata.gz: !binary |-
+    NWIzMWQzYTFlNTNhNDcwY2IwN2RhM2M0M2Q5OGVkNTg1MjUzOTM1ODA5N2Rh
+    ZTA0NjQ0ODk0MGI5MDMzNmM4Y2I0ZDAzZWIxYzM3ZmVjOTZiYTA3NGJhZjJi
+    YmQyOWQxZjkwZmVmYTBkOWM4MTMxMTAzYjRhZDc2MDdhMDBiYzA=
+  data.tar.gz: !binary |-
+    MTBkMDU5NDRlYjkxY2MyNDdjMTI1OWY4NThkYTkyNTRmMzUyZmY2ZDU4ODVl
+    MjU2YjNjMTRkZThiNmU3OWRmNGQ0ZTEyZTkxZTFkNDQ2ZTJkMmI2YjJmMTgx
+    OWQxNDEwYTQ5OTYzYzI3ZDk3MTlkMWFlNThjNTcyODJmZTI0Yjc=

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012 Hakan Ensari
+Copyright (c) 2010-2015 Hakan Ensari & Contributors
 
 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,14 +1,12 @@
-*IMPORTANT:*  If you are upgrading to Mongoid Slug 1.0.0 please migrate in accordance with the instructions in https://github.com/digitalplaywright/mongoid-slug/wiki/How-to-upgrade-to-1.0.0-or-newer.
-Mongoid Slug 1.0.0  stores the slugs in a single field _slugs of array type, and all previous slugs must be migrated.
-
 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], supporting 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](https://github.com/rsl/stringex), supporting non-Latin characters.
 
-[![Build Status](https://secure.travis-ci.org/digitalplaywright/mongoid-slug.png)](http://travis-ci.org/digitalplaywright/mongoid-slug) [![Dependency Status](https://gemnasium.com/digitalplaywright/mongoid-slug.png)](https://gemnasium.com/digitalplaywright/mongoid-slug) [![Code Climate](https://codeclimate.com/github/digitalplaywright/mongoid-slug.png)](https://codeclimate.com/github/digitalplaywright/mongoid-slug)
+[![Build Status](https://secure.travis-ci.org/digitalplaywright/mongoid-slug.png)](http://travis-ci.org/digitalplaywright/mongoid-slug)
+[![Gem Version](https://badge.fury.io/rb/mongoid-slug.svg)](http://badge.fury.io/rb/mongoid-slug)
+[![Dependency Status](https://gemnasium.com/digitalplaywright/mongoid-slug.png)](https://gemnasium.com/digitalplaywright/mongoid-slug)
+[![Code Climate](https://codeclimate.com/github/digitalplaywright/mongoid-slug.png)](https://codeclimate.com/github/digitalplaywright/mongoid-slug)
 
 Installation
 ------------
@@ -72,7 +70,7 @@ post = Post.find 'a-thousand-plateaus' # Finds by slugs
 post = Post.find '50b1386a0482939864000001' # Finds by bson ids
 => ...
 ```
-[Read here] [4] for all available options.
+[Examine slug.rb](lib/mongoid/slug.rb) for all available options.
 
 Custom Slug Generation
 -------
@@ -254,7 +252,7 @@ PS! A migration is needed to use Mongoid localized fields for documents that was
 feature was off. Anything else will cause errors.
 
 Custom Find Strategies
---------------
+----------------------
 
 By default find will search for the document by the id field if the provided id
 looks like a BSON::ObjectId, and it will otherwise find by the _slugs field. However,
@@ -303,6 +301,7 @@ Mongoid::Paranoia Support
 
 The [Mongoid::Paranoia](http://github.com/simi/mongoid-paranoia) gem adds "soft-destroy" functionality to Mongoid documents.
 Mongoid::Slug contains special handling for Mongoid::Paranoia:
+
 - When destroying a paranoid document, the slug will be unset from the database.
 - When restoring a paranoid document, the slug will be rebuilt. Note that the new slug may not match the old one.
 - When resaving a destroyed paranoid document, the slug will remain unset in the database.
@@ -317,17 +316,18 @@ end
 ```
 
 The following variants of Mongoid Paranoia are officially supported:
+
 * Mongoid 3 built-in Mongoid::Paranoia
-* Mongoid 4 gem http://github.com/simi/mongoid-paranoia
+* Mongoid 4 or 5 gem http://github.com/simi/mongoid_paranoia
+
+
+Contributing
+------------
 
-Mongoid 4 gem "mongoid-paranoia" (http://github.com/haihappen/mongoid-paranoia)
-is not officially supported but should also work.
+Mongoid-slug is work of [many of contributors](https://github.com/digitalplaywright/mongoid-slug/graphs/contributors). You're encouraged to submit [pull requests](https://github.com/digitalplaywright/mongoid-slug/pulls), [propose features, ask questions and discuss issues](https://github.com/digitalplaywright/mongoid-slug/issues). See [CONTRIBUTING](CONTRIBUTING.md) for details.
 
+Copyright & License
+-------------------
 
-References
-----------
+Copyright (c) 2010-2015 Hakan Ensari & Contributors, see [LICENSE](LICENSE) for details.
 
-[1]: https://github.com/rsl/stringex/
-[2]: https://secure.travis-ci.org/hakanensari/mongoid-slug.png
-[3]: http://travis-ci.org/hakanensari/mongoid-slug
-[4]: https://github.com/digitalplaywright/mongoid-slug/blob/master/lib/mongoid/slug.rb

data/lib/mongoid/slug.rb

@@ -5,6 +5,7 @@ require 'mongoid/slug/index'
 require 'mongoid/slug/paranoia'
 require 'mongoid/slug/unique_slug'
 require 'mongoid/slug/slug_id_strategy'
+require 'mongoid-compatibility'
 
 module Mongoid
   # Slugs your Mongoid model.
@@ -59,8 +60,8 @@ module Mongoid
         options = fields.extract_options!
 
         self.slug_scope            = options[:scope]
-        self.reserved_words        = options[:reserve] || Set.new(["new", "edit"])
-        self.slugged_attributes    = fields.map &:to_s
+        self.reserved_words        = options[:reserve] || Set.new(%w(new edit))
+        self.slugged_attributes    = fields.map(&:to_s)
         self.history               = options[:history]
         self.by_model_type         = options[:by_model_type]
 
@@ -69,7 +70,7 @@ module Mongoid
 
         # Set index
         unless embedded?
-          index(*Mongoid::Slug::Index.build_index(self.slug_scope_key, self.by_model_type))
+          index(*Mongoid::Slug::Index.build_index(slug_scope_key, by_model_type))
         end
 
         #-- Why is it necessary to customize the slug builder?
@@ -84,7 +85,7 @@ module Mongoid
         if options[:permanent]
           set_callback :create, :before, :build_slug
         else
-          set_callback :save, :before, :build_slug, :if => :slug_should_be_rebuilt?
+          set_callback :save, :before, :build_slug, if: :slug_should_be_rebuilt?
         end
 
         # If paranoid document:
@@ -93,11 +94,11 @@ module Mongoid
         # - recreate the slug on restore
         # - force reset the slug when saving a destroyed paranoid document, to ensure it stays unset in the database
         if is_paranoid_doc?
-          self.send(:include, Mongoid::Slug::Paranoia) unless self.respond_to?(:before_restore)
+          send(:include, Mongoid::Slug::Paranoia) unless self.respond_to?(:before_restore)
           set_callback :destroy, :after,  :unset_slug!
           set_callback :restore, :before, :set_slug!
-          set_callback :save,    :before, :reset_slug!, :if => :paranoid_deleted?
-          set_callback :save,    :after,  :clear_slug!, :if => :paranoid_deleted?
+          set_callback :save,    :before, :reset_slug!, if: :paranoid_deleted?
+          set_callback :save,    :after,  :clear_slug!, if: :paranoid_deleted?
         end
       end
 
@@ -109,8 +110,8 @@ module Mongoid
       #
       # @return [ Array<Document>, Document ] Whether the document is paranoid
       def slug_scope_key
-        return nil unless self.slug_scope
-        self.reflect_on_association(self.slug_scope).try(:key) || self.slug_scope
+        return nil unless slug_scope
+        reflect_on_association(slug_scope).try(:key) || slug_scope
       end
 
       # Find documents by slugs.
@@ -135,7 +136,8 @@ module Mongoid
       end
 
       def queryable
-        scope_stack.last || Criteria.new(self) # Use Mongoid::Slug::Criteria for slugged documents.
+        scope = Mongoid::Compatibility::Version.mongoid5? ? Threaded.current_scope : scope_stack.last
+        scope || Criteria.new(self) # Use Mongoid::Slug::Criteria for slugged documents.
       end
 
       # Indicates whether or not the document includes Mongoid::Paranoia
@@ -171,19 +173,19 @@ module Mongoid
     end
 
     def apply_slug
-      _new_slug = find_unique_slug
+      new_slug = find_unique_slug
 
-      #skip slug generation and use Mongoid id
-      #to find document instead
-      return true if _new_slug.size == 0
+      # skip slug generation and use Mongoid id
+      # to find document instead
+      return true if new_slug.size == 0
 
       # avoid duplicate slugs
-      self._slugs.delete(_new_slug) if self._slugs
+      _slugs.delete(new_slug) if _slugs
 
-      if !!self.history && self._slugs.is_a?(Array)
-        append_slug(_new_slug)
+      if !!history && _slugs.is_a?(Array)
+        append_slug(new_slug)
       else
-        self._slugs = [_new_slug]
+        self._slugs = [new_slug]
       end
     end
 
@@ -194,7 +196,7 @@ module Mongoid
     # Mongoid 3 (two args) and Mongoid 4 (hash arg)
     def set_slug!
       build_slug
-      self.method(:set).arity == 1 ? set({_slugs: self._slugs}) : set(:_slugs, self._slugs)
+      method(:set).arity == 1 ? set(_slugs: _slugs) : set(:_slugs, _slugs)
     end
 
     # Atomically unsets the slug field in the database. It is important to unset
@@ -228,7 +230,7 @@ module Mongoid
 
     # @return [Boolean] Whether the slug requires to be rebuilt
     def slug_should_be_rebuilt?
-      (new_record? or _slugs_changed? or slugged_attributes_changed?) and !paranoid_deleted?
+      (new_record? || _slugs_changed? || slugged_attributes_changed?) && !paranoid_deleted?
     end
 
     # Indicates whether or not the document has been deleted in paranoid fashion
@@ -236,7 +238,7 @@ module Mongoid
     #
     # @return [Boolean] Whether or not the document has been deleted in paranoid fashion
     def paranoid_deleted?
-      !!(self.class.is_paranoid_doc? and self.deleted_at != nil)
+      !!(self.class.is_paranoid_doc? && !deleted_at.nil?)
     end
 
     def slugged_attributes_changed?
@@ -252,17 +254,17 @@ module Mongoid
     # @return [String] the slug, or nil if the document does not have a slug.
     def slug
       return _slugs.last if _slugs
-      return _id.to_s
+      _id.to_s
     end
 
     def slug_builder
-      _cur_slug = nil
-      if new_with_slugs? or persisted_with_slug_changes?
-        #user defined slug
-        _cur_slug = _slugs.last
+      cur_slug = nil
+      if new_with_slugs? || persisted_with_slug_changes?
+        # user defined slug
+        cur_slug = _slugs.last
       end
-      #generate slug if the slug is not user defined or does not exist
-      _cur_slug || pre_slug_string
+      # generate slug if the slug is not user defined or does not exist
+      cur_slug || pre_slug_string
     end
 
     def self.mongoid3?
@@ -271,16 +273,16 @@ module Mongoid
 
     private
 
-    def append_slug(_slug)
+    def append_slug(value)
       if localized?
         # This is necessary for the scenario in which the slugged locale is not yet present
         # but the default locale is. In this situation, self._slugs falls back to the default
         # which is undesired
-        current_slugs = self._slugs_translations.fetch(I18n.locale.to_s, [])
-        current_slugs << _slug
-        self._slugs_translations = self._slugs_translations.merge(I18n.locale.to_s => current_slugs)
+        current_slugs = _slugs_translations.fetch(I18n.locale.to_s, [])
+        current_slugs << value
+        self._slugs_translations = _slugs_translations.merge(I18n.locale.to_s => current_slugs)
       else
-        self._slugs << _slug
+        _slugs << value
       end
     end
 
@@ -289,29 +291,31 @@ module Mongoid
       if localized?
         # We need to check if slugs are present for the locale without falling back
         # to a default
-        new_record? and _slugs_translations.fetch(I18n.locale.to_s, []).any?
+        new_record? && _slugs_translations.fetch(I18n.locale.to_s, []).any?
       else
-        new_record? and _slugs.present?
+        new_record? && _slugs.present?
       end
     end
 
     # Returns true if object has been persisted and has changes in the slug
     def persisted_with_slug_changes?
       if localized?
-        changes = self._slugs_change
-        return (persisted? and false) if changes.nil?
+        changes = _slugs_change
+        return (persisted? && false) if changes.nil?
 
         # ensure we check for changes only between the same locale
         original = changes.first.try(:fetch, I18n.locale.to_s, nil)
         compare = changes.last.try(:fetch, I18n.locale.to_s, nil)
-        persisted? and original != compare
+        persisted? && original != compare
       else
-        persisted? and _slugs_changed?
+        persisted? && _slugs_changed?
       end
     end
 
     def localized?
-      self.fields['_slugs'].options[:localize] rescue false
+      fields['_slugs'].options[:localize]
+    rescue
+      false
     end
 
     # Return all possible locales for model
@@ -319,15 +323,15 @@ module Mongoid
     # doing something crazy, but at the same time we need a fallback in case the model doesn't
     # have any localized attributes at all (extreme edge case).
     def all_locales
-      locales = self.slugged_attributes
-                    .map{|attr| self.send("#{attr}_translations").keys if self.respond_to?("#{attr}_translations")}
-                    .flatten.compact.uniq
+      locales = slugged_attributes
+                .map { |attr| send("#{attr}_translations").keys if self.respond_to?("#{attr}_translations") }
+                .flatten.compact.uniq
       locales = I18n.available_locales if locales.empty?
       locales
     end
 
     def pre_slug_string
-      self.slugged_attributes.map { |f| self.send f }.join ' '
+      slugged_attributes.map { |f| send f }.join ' '
     end
   end
 end

data/lib/mongoid/slug/criteria.rb

@@ -60,13 +60,13 @@ module Mongoid
       # 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}
+      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) : ->(_id) { false }
       end
 
       # a string will not look like a slug if it looks like a legal BSON::ObjectId
-      def objectid_slug_strategy id
+      def objectid_slug_strategy(id)
         if Mongoid::Slug.mongoid3?
           Moped::BSON::ObjectId.legal? id
         else
@@ -75,20 +75,23 @@ module Mongoid
       end
 
       # a string will always look like a slug
-      def string_slug_strategy id
+      def string_slug_strategy(_id)
         true
       end
 
-
       def for_slugs(slugs)
-        #_translations
-        localized = (@klass.fields['_slugs'].options[:localize] rescue false)
+        # _translations
+        localized = (begin
+                       @klass.fields['_slugs'].options[:localize]
+                     rescue
+                       false
+                     end)
         if localized
           def_loc = I18n.default_locale
           query = { '$in' => slugs }
-          where({'$or' => [{ _slugs: query }, { "_slugs.#{def_loc}" => query }]}).limit(slugs.length)
+          where({ '$or' => [{ _slugs: query }, { "_slugs.#{def_loc}" => query }] }).limit(slugs.length)
         else
-          where({ _slugs: { '$in' => slugs } }).limit(slugs.length)
+          where(_slugs: { '$in' => slugs }).limit(slugs.length)
         end
       end
 
@@ -102,7 +105,7 @@ module Mongoid
         missing_slugs = slugs - result.map(&:slugs).flatten
 
         if !missing_slugs.blank? && Mongoid.raise_not_found_error
-          raise Errors::DocumentNotFound.new(klass, slugs, missing_slugs)
+          fail Errors::DocumentNotFound.new(klass, slugs, missing_slugs)
         end
       end
     end

data/lib/mongoid/slug/index.rb

@@ -1,26 +1,23 @@
 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}
+        fields  = { _slugs: 1 }
         options = {}
 
-        if scope_key
-          fields.merge!({scope_key => 1})
-        end
+        fields.merge!(scope_key => 1) if scope_key
 
         if by_model_type
-          fields.merge!({_type: 1})
+          fields.merge!(_type: 1)
         else
-          options.merge!({unique: true, sparse: true})
+          options.merge!(unique: true, sparse: true)
         end
 
-        return [fields, options]
+        [fields, options]
       end
     end
   end

data/lib/mongoid/slug/paranoia.rb

@@ -1,13 +1,11 @@
 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

data/lib/mongoid/slug/slug_id_strategy.rb

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

data/lib/mongoid/slug/unique_slug.rb

@@ -8,7 +8,7 @@ module Mongoid
       class SlugState
         attr_reader :last_entered_slug, :existing_slugs, :existing_history_slugs, :sorted_existing
 
-        def initialize slug, documents, pattern
+        def initialize(slug, documents, pattern)
           @slug = slug
           @documents = documents
           @pattern = pattern
@@ -21,7 +21,7 @@ module Mongoid
             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 })
+            existing_history_slugs.push(*history_slugs.first(history_slugs.length - 1).find_all { |cur_slug| cur_slug =~ @pattern })
           end
         end
 
@@ -40,19 +40,19 @@ module Mongoid
 
         def sort_existing_slugs
           # remove the slug part and leave the absolute integer part and sort
-          re = %r(^#{Regexp.escape(@slug)})
+          re = /^#{Regexp.escape(@slug)}/
           @sorted_existing = existing_slugs.map do |s|
-            s.sub(re,'').to_i.abs
+            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
+            slug: @slug,
+            existing_slugs: existing_slugs,
+            last_entered_slug: last_entered_slug,
+            existing_history_slugs: existing_history_slugs,
+            sorted_existing: sorted_existing
           }
         end
       end
@@ -62,12 +62,12 @@ module Mongoid
       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
+                     :check_against_id, :reserved_words, :url_builder, :collection_name,
+                     :embedded?, :reflect_on_all_associations, :by_model_type
 
-      def initialize model
+      def initialize(model)
         @model = model
-        @_slug = ""
+        @_slug = ''
         @state = nil
       end
 
@@ -75,40 +75,40 @@ module Mongoid
         @model.respond_to?(:relation_metadata) ? @model.relation_metadata : @model.metadata
       end
 
-      def find_unique attempt = nil
+      def find_unique(attempt = nil)
         MUTEX_FOR_SLUG.synchronize do
           @_slug = if attempt
-            attempt.to_url
-          else
-            url_builder.call(model)
-          end
+                     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?
@@ -120,9 +120,7 @@ module Mongoid
       end
 
       def uniqueness_scope
-
-        if slug_scope &&
-            metadata = reflect_on_association(slug_scope)
+        if slug_scope && (metadata = reflect_on_association(slug_scope))
 
           parent = model.send(metadata.name)
 
@@ -141,7 +139,7 @@ module Mongoid
           return model._parent.send(parent_metadata.inverse_of || self.metadata.name)
         end
 
-        #unless embedded or slug scope, return the deepest document superclass
+        # 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