mongoid-slug 6.0.0 → 6.0.1

data/lib/mongoid/slug/criteria.rb

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

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

@@ -1,45 +1,67 @@
-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
+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,9 @@
-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
+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,3 @@
-Mongoid::Fields.option(:slug_id_strategy) do |_model, field, value|
-  field.options[:slug_id_strategy] = value
-end
+Mongoid::Fields.option(:slug_id_strategy) do |_model, field, value|
+  field.options[:slug_id_strategy] = value
+end

data/lib/mongoid/slug/unique_slug.rb

@@ -1,173 +1,173 @@
-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 = []
-          regexp_pattern = Regexp.new(@pattern)
-          @documents.each do |doc|
-            history_slugs = doc._slugs
-            next if history_slugs.nil?
-            existing_slugs.push(*history_slugs.find_all { |cur_slug| cur_slug =~ regexp_pattern })
-            last_entered_slug.push(*history_slugs.last) if history_slugs.last =~ regexp_pattern
-            existing_history_slugs.push(*history_slugs.first(history_slugs.length - 1).find_all { |cur_slug| cur_slug =~ regexp_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 = /^#{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, :slug_reserved_words, :slug_url_builder, :collection_name,
-                     :embedded?, :reflect_on_all_associations, :reflect_on_all_association,
-                     :slug_by_model_type, :slug_max_length
-
-      def initialize(model)
-        @model = model
-        @_slug = ''
-        @state = nil
-      end
-
-      def metadata
-        if @model.respond_to?(:_association)
-          @model.send(:_association)
-        elsif @model.respond_to?(:relation_metadata)
-          @model.relation_metadata
-        else
-          @model.metadata
-        end
-      end
-
-      def find_unique(attempt = nil)
-        MUTEX_FOR_SLUG.synchronize do
-          @_slug = if attempt
-                     attempt.to_url
-                   else
-                     slug_url_builder.call(model)
-                   end
-
-          @_slug = @_slug[0...slug_max_length] if slug_max_length
-
-          where_hash = {}
-          where_hash[:_slugs.all] = [regex_for_slug]
-          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
-
-          where_hash[:_type] = model.try(:read_attribute, :_type) if slug_by_model_type
-
-          @state = SlugState.new @_slug, uniqueness_scope.unscoped.where(where_hash), escaped_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 slug_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 escaped_pattern
-        "^#{Regexp.escape(@_slug)}(?:-(\\d+))?$"
-      end
-
-      # Regular expression that matches slug, slug-1, ... slug-n
-      # If slug_name field was indexed, MongoDB will utilize that
-      # index to match /^.../ pattern.
-      # Use Regexp::Raw to avoid the multiline option when querying the server.
-      def regex_for_slug
-        if embedded? || Mongoid::Compatibility::Version.mongoid3? || Mongoid::Compatibility::Version.mongoid4?
-          Regexp.new(escaped_pattern)
-        else
-          BSON::Regexp::Raw.new(escaped_pattern)
-        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 = if Mongoid::Compatibility::Version.mongoid7_or_newer?
-                              reflect_on_all_association(:embedded_in)[0]
-                            else
-                              reflect_on_all_associations(:embedded_in)[0]
-                            end
-          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
-        appropriate_class = appropriate_class.superclass while appropriate_class.superclass.include?(Mongoid::Document)
-        appropriate_class
-      end
-    end
-  end
-end
+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 = []
+          regexp_pattern = Regexp.new(@pattern)
+          @documents.each do |doc|
+            history_slugs = doc._slugs
+            next if history_slugs.nil?
+            existing_slugs.push(*history_slugs.find_all { |cur_slug| cur_slug =~ regexp_pattern })
+            last_entered_slug.push(*history_slugs.last) if history_slugs.last =~ regexp_pattern
+            existing_history_slugs.push(*history_slugs.first(history_slugs.length - 1).find_all { |cur_slug| cur_slug =~ regexp_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 = /^#{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, :slug_reserved_words, :slug_url_builder, :collection_name,
+                     :embedded?, :reflect_on_all_associations, :reflect_on_all_association,
+                     :slug_by_model_type, :slug_max_length
+
+      def initialize(model)
+        @model = model
+        @_slug = ''
+        @state = nil
+      end
+
+      def metadata
+        if @model.respond_to?(:_association)
+          @model.send(:_association)
+        elsif @model.respond_to?(:relation_metadata)
+          @model.relation_metadata
+        else
+          @model.metadata
+        end
+      end
+
+      def find_unique(attempt = nil)
+        MUTEX_FOR_SLUG.synchronize do
+          @_slug = if attempt
+                     attempt.to_url
+                   else
+                     slug_url_builder.call(model)
+                   end
+
+          @_slug = @_slug[0...slug_max_length] if slug_max_length
+
+          where_hash = {}
+          where_hash[:_slugs.all] = [regex_for_slug]
+          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
+
+          where_hash[:_type] = model.try(:read_attribute, :_type) if slug_by_model_type
+
+          @state = SlugState.new @_slug, uniqueness_scope.unscoped.where(where_hash), escaped_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 slug_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 escaped_pattern
+        "^#{Regexp.escape(@_slug)}(?:-(\\d+))?$"
+      end
+
+      # Regular expression that matches slug, slug-1, ... slug-n
+      # If slug_name field was indexed, MongoDB will utilize that
+      # index to match /^.../ pattern.
+      # Use Regexp::Raw to avoid the multiline option when querying the server.
+      def regex_for_slug
+        if embedded? || Mongoid::Compatibility::Version.mongoid3? || Mongoid::Compatibility::Version.mongoid4?
+          Regexp.new(escaped_pattern)
+        else
+          BSON::Regexp::Raw.new(escaped_pattern)
+        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 = if Mongoid::Compatibility::Version.mongoid7_or_newer?
+                              reflect_on_all_association(:embedded_in)[0]
+                            else
+                              reflect_on_all_associations(:embedded_in)[0]
+                            end
+          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
+        appropriate_class = appropriate_class.superclass while appropriate_class.superclass.include?(Mongoid::Document)
+        appropriate_class
+      end
+    end
+  end
+end