mongoid-slug 7.0.0 → 7.1.0

data/lib/mongoid/slug/unique_slug.rb

@@ -1,172 +1,204 @@
-# frozen_string_literal: true
-
-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.grep(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).grep(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 } # rubocop:disable Style/CaseEquality
-
-          # 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?
-          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 = reflect_on_all_association(: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
-        appropriate_class = appropriate_class.superclass while appropriate_class.superclass.include?(Mongoid::Document)
-        appropriate_class
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+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.grep(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).grep(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
+          @sorted_existing = existing_slugs.map do |s|
+            s.delete_prefix(@slug).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
+
+          Array(slug_scope).each do |individual_scope|
+            next unless reflect_on_association(individual_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[individual_scope] = model.try(:read_attribute, individual_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 } # rubocop:disable Style/CaseEquality
+
+          # 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?
+          Regexp.new(escaped_pattern)
+        else
+          BSON::Regexp::Raw.new(escaped_pattern)
+        end
+      end
+
+      def uniqueness_scope
+        if embedded?
+          parent_metadata = reflect_on_all_association(:embedded_in)[0]
+          return model._parent.send(parent_metadata.inverse_of || metadata.name)
+        end
+
+        # If slug_scope is present, we need to handle whether it's a single scope or multiple scopes.
+        if slug_scope
+          # We'll track individual scope results in an array.
+          scope_results = []
+
+          Array(slug_scope).each do |individual_scope|
+            next unless (metadata = reflect_on_association(individual_scope))
+
+            # For each scope, we identify its association metadata and fetch the parent record.
+            parent = model.send(metadata.name)
+
+            # It's important to handle nil cases if the parent record doesn't exist.
+            if parent.nil?
+              # You might want to handle this scenario differently based on your application's logic.
+              next
+            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
+            next unless parent.respond_to?(inverse)
+
+            # Add the associated records of the parent (based on the inverse) to our results.
+            scope_results << parent.send(inverse)
+          end
+
+          # After iterating through all scopes, we need to decide how to combine the results (if there are multiple).
+          # This part depends on how your application should treat multiple scopes.
+          # Here, we'll simply return the first non-empty scope result as an example.
+          scope_results.each do |result|
+            return result if result.present? # or any other logic for selecting among multiple scope results
+          end
+
+          # If we reach this point, it means no valid parent scope was found (all were nil or didn't match the
+          # conditions).
+          # You might want to raise an error, return a default scope, or handle this scenario based on your
+          # application's logic.
+          # For this example, we're returning the model's class as a default.
+          return model.class
+        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

data/lib/mongoid/slug/version.rb

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
-
-module Mongoid # :nodoc:
-  module Slug
-    VERSION = '7.0.0'
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid # :nodoc:
+  module Slug
+    VERSION = '7.1.0'
+  end
+end