mongoid-slug 6.0.0 → 7.0.0

data/lib/mongoid/slug/criteria.rb

@@ -1,107 +1,111 @@
-module Mongoid
-  module Slug
-    class Criteria < Mongoid::Criteria
-      # Find the matching 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'
-        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)
-        Mongoid::Compatibility::ObjectId.legal?(id)
-      end
-
-      # a string will always look like a slug
-      def string_slug_strategy(_id)
-        true
-      end
-
-      def for_slugs(slugs)
-        # _translations
-        localized = (begin
-                       @klass.fields['_slugs'].options[:localize]
-                     rescue StandardError
-                       false
-                     end)
-        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
-        return unless !missing_slugs.blank? && Mongoid.raise_not_found_error
-        raise Errors::DocumentNotFound.new(klass, slugs, missing_slugs)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid
+  module Slug
+    class Criteria < Mongoid::Criteria
+      # Find the matching 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"
+        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)
+        BSON::ObjectId.legal?(id)
+      end
+
+      # a string will always look like a slug
+      def string_slug_strategy(_id)
+        true
+      end
+
+      def for_slugs(slugs)
+        # _translations
+        localized = (begin
+          @klass.fields['_slugs'].options[:localize]
+        rescue StandardError
+          false
+        end)
+        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
+        return unless !missing_slugs.blank? && Mongoid.raise_not_found_error
+
+        raise Errors::DocumentNotFound.new(klass, slugs, missing_slugs)
+      end
+    end
+  end
+end

data/lib/mongoid/slug/{index.rb → index_builder.rb}

@@ -1,45 +1,69 @@
-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)
-        # The order of field keys is intentional.
-        # See: http://docs.mongodb.org/manual/core/index-compound/
-        fields = {}
-        fields[:_type] = 1       if by_model_type
-        fields[scope_key] = 1 if scope_key
-        fields[:_slugs] = 1
-
-        # By design, we use the unique index constraint when possible to enforce slug uniqueness.
-        # When migrating legacy data to Mongoid slug, the _slugs field may be null on many records,
-        # hence we set the sparse index option to ignore these from the unique index.
-        # See: http://docs.mongodb.org/manual/core/index-sparse/
-        #
-        # There are three edge cases where the index must not be unique:
-        #
-        # 1) Legacy tables with `scope_key`. The sparse indexes on compound keys (scope + _slugs) are
-        #    whenever ANY of the key values are present (e.g. when scope is set and _slugs is unset),
-        #    and collisions will occur when multiple records have the same scope but null slugs.
-        #
-        # 2) Single Table Inheritance (`by_model_type`). MongoDB creates indexes on the parent collection,
-        #    irrespective of how STI is defined in Mongoid, i.e. ANY child index will be applied to EVERY child.
-        #    This can cause collisions using various combinations of scopes.
-        #
-        # In the future, MongoDB may implement partial indexes or improve sparse index behavior.
-        # See: https://jira.mongodb.org/browse/SERVER-785
-        #      https://jira.mongodb.org/browse/SERVER-13780
-        #      https://jira.mongodb.org/browse/SERVER-10403
-        options = {}
-        unless scope_key || by_model_type
-          options[:unique] = true
-          options[:sparse] = true
-        end
-
-        [fields, options]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid
+  module Slug
+    module IndexBuilder
+      extend self
+
+      # Creates indexes on a document for a given slug scope
+      #
+      # @param [ Mongoid::Document ] doc The document on which to create the index(es)
+      # @param [ String or Symbol ] scope_key The optional scope key for the index(es)
+      # @param [ Boolean ] by_model_type Whether or not to use single table inheritance
+      # @param [ Boolean or Array ] localize The locale for localized index field
+      #
+      # @return [ Array(Hash, Hash) ] the indexable fields and index options.
+      def build_indexes(doc, scope_key = nil, by_model_type = false, locales = nil)
+        if locales.is_a?(Array)
+          locales.each { |locale| build_index(doc, scope_key, by_model_type, locale) }
+        else
+          build_index(doc, scope_key, by_model_type, locales)
+        end
+      end
+
+      private
+
+      def build_index(doc, scope_key = nil, by_model_type = false, locale = nil)
+        # The order of field keys is intentional.
+        # See: http://docs.mongodb.org/manual/core/index-compound/
+        fields = {}
+        fields[:_type] = 1 if by_model_type
+        fields[scope_key] = 1 if scope_key
+
+        locale = ::I18n.default_locale if locale.is_a?(TrueClass)
+        if locale
+          fields[:"_slugs.#{locale}"] = 1
+        else
+          fields[:_slugs] = 1
+        end
+
+        # By design, we use the unique index constraint when possible to enforce slug uniqueness.
+        # When migrating legacy data to Mongoid slug, the _slugs field may be null on many records,
+        # hence we set the sparse index option to ignore these from the unique index.
+        # See: http://docs.mongodb.org/manual/core/index-sparse/
+        #
+        # There are three edge cases where the index must not be unique:
+        #
+        # 1) Legacy tables with `scope_key`. The sparse indexes on compound keys (scope + _slugs) are
+        #    whenever ANY of the key values are present (e.g. when scope is set and _slugs is unset),
+        #    and collisions will occur when multiple records have the same scope but null slugs.
+        #
+        # 2) Single Table Inheritance (`by_model_type`). MongoDB creates indexes on the parent collection,
+        #    irrespective of how STI is defined in Mongoid, i.e. ANY child index will be applied to EVERY child.
+        #    This can cause collisions using various combinations of scopes.
+        #
+        # In the future, MongoDB may implement partial indexes or improve sparse index behavior.
+        # See: https://jira.mongodb.org/browse/SERVER-785
+        #      https://jira.mongodb.org/browse/SERVER-13780
+        #      https://jira.mongodb.org/browse/SERVER-10403
+        options = {}
+        unless scope_key || by_model_type
+          options[:unique] = true
+          options[:sparse] = true
+        end
+
+        doc.index(fields, options)
+      end
+    end
+  end
+end

data/lib/mongoid/slug/railtie.rb

@@ -1,9 +1,11 @@
-module Mongoid
-  module Slug
-    class Railtie < Rails::Railtie
-      rake_tasks do
-        Dir[File.join(File.dirname(__FILE__), '../../tasks/*.rake')].each { |f| load f }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid
+  module Slug
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        Dir[File.join(File.dirname(__FILE__), '../../tasks/*.rake')].each { |f| load f }
+      end
+    end
+  end
+end

data/lib/mongoid/slug/slug_id_strategy.rb

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