encoded_id-rails 1.0.0.rc1 → 1.0.0.rc7

data/lib/encoded_id/rails/configuration.rb

@@ -1,14 +1,47 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
     # Configuration class for initializer
     class Configuration
-      attr_accessor :salt, :character_group_size, :alphabet, :id_length
-      attr_accessor :slug_value_method_name, :annotation_method_name
-      attr_accessor :model_to_param_returns_encoded_id
-      attr_reader :group_separator, :slugged_id_separator, :annotated_id_separator
+      VALID_ENCODERS = [:hashids, :sqids].freeze
+      DEFAULT_ENCODER = :sqids
+
+      # @rbs @salt: String?
+      # @rbs @character_group_size: Integer
+      # @rbs @alphabet: ::EncodedId::Alphabet
+      # @rbs @id_length: Integer
+      # @rbs @slug_value_method_name: Symbol
+      # @rbs @annotation_method_name: Symbol
+      # @rbs @model_to_param_returns_encoded_id: bool
+      # @rbs @blocklist: ::EncodedId::Blocklist
+      # @rbs @blocklist_mode: Symbol
+      # @rbs @blocklist_max_length: Integer
+      # @rbs @group_separator: String
+      # @rbs @slugged_id_separator: String
+      # @rbs @annotated_id_separator: String
+      # @rbs @encoder: Symbol
+      # @rbs @downcase_on_decode: bool
 
+      attr_accessor :salt #: String?
+      attr_accessor :character_group_size #: Integer
+      attr_accessor :alphabet #: ::EncodedId::Alphabet
+      attr_accessor :id_length #: Integer
+      attr_accessor :slug_value_method_name #: Symbol
+      attr_accessor :annotation_method_name #: Symbol
+      attr_accessor :model_to_param_returns_encoded_id #: bool
+      attr_accessor :blocklist #: ::EncodedId::Blocklist
+      attr_accessor :blocklist_mode #: Symbol
+      attr_accessor :blocklist_max_length #: Integer
+      attr_accessor :downcase_on_decode #: bool
+      attr_reader :group_separator #: String
+      attr_reader :slugged_id_separator #: String
+      attr_reader :annotated_id_separator #: String
+      attr_reader :encoder #: Symbol
+
+      # @rbs () -> void
       def initialize
         @character_group_size = 4
         @group_separator = "-"
@@ -19,10 +52,25 @@ module EncodedId
         @annotation_method_name = :annotation_for_encoded_id
         @annotated_id_separator = "_"
         @model_to_param_returns_encoded_id = false
+        @encoder = DEFAULT_ENCODER
+        @blocklist = ::EncodedId::Blocklist.empty
+        @blocklist_mode = :length_threshold
+        @blocklist_max_length = 32
+        @downcase_on_decode = false
+        @salt = nil
+      end
+
+      # @rbs (Symbol value) -> Symbol
+      def encoder=(value)
+        unless VALID_ENCODERS.include?(value)
+          raise ArgumentError, "Encoder must be one of: #{VALID_ENCODERS.join(", ")}"
+        end
+        @encoder = value
       end
 
       # Perform validation vs alphabet on these assignments
 
+      # @rbs (String value) -> String
       def group_separator=(value)
         unless valid_separator?(value, alphabet)
           raise ArgumentError, "Group separator characters must not be part of the alphabet"
@@ -30,22 +78,30 @@ module EncodedId
         @group_separator = value
       end
 
+      # @rbs (String value) -> String
       def slugged_id_separator=(value)
-        if value.blank? || value == group_separator || !valid_separator?(value, alphabet)
-          raise ArgumentError, "Slugged ID separator characters must not be part of the alphabet or the same as the group separator"
-        end
+        validate_id_separator!(value, "Slugged ID")
         @slugged_id_separator = value
       end
 
+      # @rbs (String value) -> String
       def annotated_id_separator=(value)
+        validate_id_separator!(value, "Annotated ID")
+        @annotated_id_separator = value
+      end
+
+      private
+
+      # @rbs (String value, String separator_name) -> void
+      def validate_id_separator!(value, separator_name)
         if value.blank? || value == group_separator || !valid_separator?(value, alphabet)
-          raise ArgumentError, "Annotated ID separator characters must not be part of the alphabet or the same as the group separator"
+          raise ArgumentError, "#{separator_name} separator characters must not be part of the alphabet or the same as the group separator"
         end
-        @annotated_id_separator = value
       end
 
+      # @rbs (String separator, ::EncodedId::Alphabet characters) -> bool
       def valid_separator?(separator, characters)
-        separator.chars.none? { |v| characters.include?(v) }
+        separator.chars.none? { characters.include?(_1) }
       end
     end
   end

data/lib/encoded_id/rails/encoder_methods.rb

@@ -1,36 +1,59 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
+    # Provides methods for encoding and decoding IDs, extended into ActiveRecord models.
     module EncoderMethods
+      # @rbs!
+      #   interface _EncodedIdModel
+      #     def encoded_id_options: () -> Hash[Symbol, untyped]
+      #   end
+      # @rbs (Array[Integer] | Integer ids, ?Hash[Symbol, untyped] options) -> String
       def encode_encoded_id(ids, options = {})
         raise StandardError, "You must pass an ID or array of IDs" if ids.blank?
         encoded_id_coder(options).encode(ids)
       end
 
+      # @rbs (String slugged_encoded_id, ?Hash[Symbol, untyped] options) -> Array[Integer]?
       def decode_encoded_id(slugged_encoded_id, options = {})
         return if slugged_encoded_id.blank?
         raise StandardError, "You must pass a string encoded ID" unless slugged_encoded_id.is_a?(String)
-        annotated_encoded_id = SluggedIdParser.new(slugged_encoded_id, separator: EncodedId::Rails.configuration.slugged_id_separator).id
-        encoded_id = AnnotatedIdParser.new(annotated_encoded_id, separator: EncodedId::Rails.configuration.annotated_id_separator).id
+        config = EncodedId::Rails.configuration
+        annotated_encoded_id = SluggedIdParser.new(slugged_encoded_id, separator: config.slugged_id_separator).id
+        encoded_id = AnnotatedIdParser.new(annotated_encoded_id, separator: config.annotated_id_separator).id
         return if !encoded_id || encoded_id.blank?
         encoded_id_coder(options).decode(encoded_id)
       end
 
       # This can be overridden in the model to provide a custom salt
+      # @rbs return: String
       def encoded_id_salt
         # @type self: Class
         EncodedId::Rails::Salt.new(self, EncodedId::Rails.configuration.salt).generate!
       end
 
+      # @rbs (?Hash[Symbol, untyped] options) -> EncodedId::Rails::Coder
+      #   | (_EncodedIdModel self, ?Hash[Symbol, untyped] options) -> EncodedId::Rails::Coder
       def encoded_id_coder(options = {})
         config = EncodedId::Rails.configuration
+        # Merge model-level options with call-time options (call-time options take precedence)
+        # @type var model_options: Hash[Symbol, untyped]
+        model_options = respond_to?(:encoded_id_options) ? encoded_id_options : {} #: Hash[Symbol, untyped]
+        merged_options = model_options.merge(options)
+
         EncodedId::Rails::Coder.new(
-          salt: options[:salt] || encoded_id_salt,
-          id_length: options[:id_length] || config.id_length,
-          character_group_size: options.key?(:character_group_size) ? options[:character_group_size] : config.character_group_size,
-          alphabet: options[:alphabet] || config.alphabet,
-          separator: options.key?(:separator) ? options[:separator] : config.group_separator
+          salt: merged_options[:salt] || encoded_id_salt,
+          id_length: merged_options[:id_length] || config.id_length,
+          character_group_size: merged_options.key?(:character_group_size) ? merged_options[:character_group_size] : config.character_group_size,
+          alphabet: merged_options[:alphabet] || config.alphabet,
+          separator: merged_options.key?(:separator) ? merged_options[:separator] : config.group_separator,
+          encoder: merged_options[:encoder] || config.encoder,
+          blocklist: merged_options[:blocklist] || config.blocklist,
+          blocklist_mode: merged_options[:blocklist_mode] || config.blocklist_mode,
+          blocklist_max_length: merged_options[:blocklist_max_length] || config.blocklist_max_length,
+          downcase_on_decode: merged_options.key?(:downcase_on_decode) ? merged_options[:downcase_on_decode] : config.downcase_on_decode
         )
       end
     end

data/lib/encoded_id/rails/finder_methods.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
+    # Provides finder methods for locating records by their encoded IDs.
     module FinderMethods
+      # @rbs!
+      #   include ::EncodedId::Rails::EncoderMethods
+      #   include ActiveRecordFinders
+
       # Find by encoded ID and optionally ensure record ID is the same as constraint (can be slugged)
+      # @rbs (String encoded_id, ?with_id: Symbol?) -> untyped
       def find_by_encoded_id(encoded_id, with_id: nil)
         decoded_id = decode_encoded_id(encoded_id)
         return if decoded_id.nil? || decoded_id.blank?
@@ -13,6 +21,7 @@ module EncodedId
         record
       end
 
+      # @rbs (String encoded_id, ?with_id: Symbol?) -> untyped
       def find_by_encoded_id!(encoded_id, with_id: nil)
         decoded_id = decode_encoded_id(encoded_id)
         raise ActiveRecord::RecordNotFound if decoded_id.nil? || decoded_id.blank?
@@ -23,12 +32,14 @@ module EncodedId
         record
       end
 
+      # @rbs (String encoded_id) -> Array[untyped]?
       def find_all_by_encoded_id(encoded_id)
         decoded_ids = decode_encoded_id(encoded_id)
         return if decoded_ids.blank?
         where(id: decoded_ids).to_a
       end
 
+      # @rbs (String encoded_id) -> Array[untyped]
       def find_all_by_encoded_id!(encoded_id)
         decoded_ids = decode_encoded_id(encoded_id)
         raise ActiveRecord::RecordNotFound if decoded_ids.nil? || decoded_ids.blank?

data/lib/encoded_id/rails/model.rb

@@ -1,24 +1,70 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "active_record"
 require "encoded_id"
 
 module EncodedId
   module Rails
+    # Main module for adding encoded ID functionality to ActiveRecord models.
     module Model
+      # @rbs!
+      #   extend ::EncodedId::Rails::EncoderMethods
+      #   extend ::EncodedId::Rails::FinderMethods
+      #   extend ::EncodedId::Rails::QueryMethods
+      #
+      #
+      #   # Model attributes that must exist, plus related AR methods
+      #   def id: () -> Integer?
+
+      # @rbs @encoded_id_hash: String?
+      # @rbs @encoded_id: String?
+      # @rbs @slugged_encoded_id: String?
+      # @rbs @encoded_id_memoized_with_id: untyped
+
+      # @rbs (untyped base) -> void
       def self.included(base)
         base.extend(EncoderMethods)
         base.extend(FinderMethods)
         base.extend(QueryMethods)
+        base.extend(ClassMethods)
 
-        # Automatically include PathParam if configured to do so
+        # Conditionally include PathParam based on global configuration
         if EncodedId::Rails.configuration.model_to_param_returns_encoded_id
           base.include(EncodedId::Rails::PathParam)
         end
       end
 
-      attr_accessor :encoded_id_memoized_with_id
+      module ClassMethods
+        # Configure encoder options for this specific model
+        # @example
+        #   class MyModel < ApplicationRecord
+        #     include EncodedId::Rails::Model
+        #     encoded_id_config encoder: :hashids
+        #   end
+        #
+        # @rbs (**untyped options) -> void
+        def encoded_id_config(**options)
+          @encoded_id_options = options
+        end
+
+        # Walks up the inheritance chain to find options if not set on this class
+        # @rbs () -> Hash[Symbol, untyped]
+        def encoded_id_options
+          return @encoded_id_options if defined?(@encoded_id_options) && @encoded_id_options
+
+          if superclass.respond_to?(:encoded_id_options)
+            superclass.encoded_id_options
+          else
+            {}
+          end
+        end
+      end
+
+      attr_accessor :encoded_id_memoized_with_id #: untyped
 
+      # @rbs () -> void
       def clear_encoded_id_cache!
         [:@encoded_id_hash, :@encoded_id, :@slugged_encoded_id].each do |var|
           remove_instance_variable(var) if instance_variable_defined?(var)
@@ -26,10 +72,12 @@ module EncodedId
         self.encoded_id_memoized_with_id = nil
       end
 
+      # @rbs () -> void
       def check_and_clear_memoization
         clear_encoded_id_cache! if encoded_id_memoized_with_id && encoded_id_memoized_with_id != id
       end
 
+      # @rbs () -> String?
       def encoded_id_hash
         return unless id
         check_and_clear_memoization
@@ -39,27 +87,31 @@ module EncodedId
         @encoded_id_hash = self.class.encode_encoded_id(id)
       end
 
+      # @rbs () -> String?
       def encoded_id
         return unless id
         check_and_clear_memoization
         return @encoded_id if defined?(@encoded_id)
 
         encoded = encoded_id_hash
-        annotated_by = EncodedId::Rails.configuration.annotation_method_name
+        config = EncodedId::Rails.configuration
+        annotated_by = config.annotation_method_name
         return @encoded_id = encoded unless annotated_by && encoded
 
-        separator = EncodedId::Rails.configuration.annotated_id_separator
+        separator = config.annotated_id_separator
         self.encoded_id_memoized_with_id = id
         @encoded_id = EncodedId::Rails::AnnotatedId.new(id_part: encoded, annotation: send(annotated_by.to_s), separator: separator).annotated_id
       end
 
+      # @rbs () -> String?
       def slugged_encoded_id
         return unless id
         check_and_clear_memoization
         return @slugged_encoded_id if defined?(@slugged_encoded_id)
 
-        with = EncodedId::Rails.configuration.slug_value_method_name
-        separator = EncodedId::Rails.configuration.slugged_id_separator
+        config = EncodedId::Rails.configuration
+        with = config.slug_value_method_name
+        separator = config.slugged_id_separator
         encoded = encoded_id
         return unless encoded
 
@@ -67,6 +119,7 @@ module EncodedId
         @slugged_encoded_id = EncodedId::Rails::SluggedId.new(id_part: encoded, slug_part: send(with.to_s), separator: separator).slugged_id
       end
 
+      # @rbs (?untyped? options) -> untyped
       def reload(options = nil)
         result = super
         clear_encoded_id_cache!
@@ -80,7 +133,7 @@ module EncodedId
         name.underscore
       end
 
-      # By default trying to generate a slug without defining how will raise.
+      # By default, trying to generate a slug without defining how will raise.
       # You either override this method per model, pass an alternate method name to
       # #slugged_encoded_id or setup an alias to another model method in your ApplicationRecord class
       def name_for_encoded_id_slug

data/lib/encoded_id/rails/path_param.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "active_record"
 require "encoded_id"
 
 module EncodedId
   module Rails
+    # Overrides to_param to return the encoded ID for use in URLs.
     module PathParam
+      # Method provided by model
+      # @rbs!
+      #   def encoded_id: () -> String?
+
+      # @rbs () -> String
       def to_param
         encoded_id || raise(StandardError, "Cannot create path param for #{self.class.name} without an encoded id")
       end

data/lib/encoded_id/rails/persists.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
+    # Provides persistence of encoded IDs to database columns with validation and callbacks.
     module Persists
+      # @rbs (untyped base) -> void
       def self.included(base)
         base.extend ClassMethods
 
@@ -19,13 +23,37 @@ module EncodedId
       end
 
       module ClassMethods
+        # Encoder methods come from ::EncodedId::Rails::Model but thats not working with this pattern of defining class
+        # methods.
+        # @rbs!
+        #   include ::EncodedId::Rails::EncoderMethods
+
+        # @rbs (Integer id) -> String
         def encode_normalized_encoded_id(id)
           encode_encoded_id(id, character_group_size: nil)
         end
       end
 
+      # @rbs!
+      #   include ::ActiveRecord::Persistence
+      #
+      #   include ::EncodedId::Rails::Model
+      #
+      #   extend ClassMethods
+      #
+      #   # Model attributes that must exist, plus related AR methods
+      #   def id: () -> Integer?
+      #   def id_changed?: () -> bool
+      #   def prefixed_encoded_id: () -> String?
+      #   def prefixed_encoded_id=: (String?) -> String?
+      #   def normalized_encoded_id: () -> String?
+      #   def normalized_encoded_id=: (String?) -> String?
+      #   def clear_prefixed_encoded_id_change: () -> void
+      #   def clear_normalized_encoded_id_change: () -> void
+
       # On duplication we need to reset the encoded ID to nil as this new record will have a new ID.
-      # We need to also prevent these changes from marking the record as dirty.
+      # We also prevent these changes from marking the record as dirty.
+      # @rbs () -> untyped
       def dup
         copy = super
         copy.prefixed_encoded_id = nil
@@ -35,39 +63,57 @@ module EncodedId
         copy
       end
 
-      def set_normalized_encoded_id!
+      # @rbs () -> Integer
+      def resolved_id
         validate_id_for_encoded_id!
 
-        update_columns(normalized_encoded_id: self.class.encode_normalized_encoded_id(id), prefixed_encoded_id: encoded_id)
+        id #: Integer
       end
 
-      def update_normalized_encoded_id!
-        validate_id_for_encoded_id!
+      # @rbs () -> void
+      def set_normalized_encoded_id!
+        update_columns(normalized_encoded_id: self.class.encode_normalized_encoded_id(resolved_id), prefixed_encoded_id: encoded_id)
+      end
 
-        self.normalized_encoded_id = self.class.encode_normalized_encoded_id(id)
+      # @rbs () -> void
+      def update_normalized_encoded_id!
+        self.normalized_encoded_id = self.class.encode_normalized_encoded_id(resolved_id)
         self.prefixed_encoded_id = encoded_id
       end
 
+      # @rbs () -> void
       def check_encoded_id_persisted!
-        if normalized_encoded_id != self.class.encode_normalized_encoded_id(id)
-          raise StandardError, "The persisted encoded ID #{normalized_encoded_id} for #{self.class.name} is not the same as currently computing #{self.class.encode_normalized_encoded_id(id)}"
+        validate_id_for_encoded_id!
+
+        klass = self.class
+        klass_name = klass.name
+        encoded_from_current_id = klass.encode_normalized_encoded_id(resolved_id)
+
+        if normalized_encoded_id != encoded_from_current_id
+          raise StandardError, "The persisted encoded ID #{normalized_encoded_id} for #{klass_name} is not the same as currently computing #{encoded_from_current_id}"
         end
 
-        raise StandardError, "The persisted prefixed encoded ID (for #{self.class.name} with id: #{id}, normalized_encoded_id: #{normalized_encoded_id}) is not correct: it is #{prefixed_encoded_id} instead of #{encoded_id}" if prefixed_encoded_id != encoded_id
+        return if prefixed_encoded_id == encoded_id
+
+        raise StandardError, "The persisted prefixed encoded ID (for #{klass_name} with id: #{id}, normalized_encoded_id: #{normalized_encoded_id}) is not correct: it is #{prefixed_encoded_id} instead of #{encoded_id}"
       end
 
+      # @rbs () -> bool
       def should_update_normalized_encoded_id?
         id_changed? || (normalized_encoded_id.blank? && persisted?)
       end
 
+      # @rbs () -> void
       def validate_id_for_encoded_id!
         raise StandardError, "You cannot set the normalized ID of a record which is not persisted" if id.blank?
       end
 
+      # @rbs () -> void
       def prevent_update_of_normalized_encoded_id!
         raise ActiveRecord::ReadonlyAttributeError, "You cannot update the normalized encoded ID '#{normalized_encoded_id}' of a record #{self.class.name} #{id}, if you need to refresh it use set_normalized_encoded_id!"
       end
 
+      # @rbs () -> void
       def prevent_update_of_prefixed_encoded_id!
         raise ActiveRecord::ReadonlyAttributeError, "You cannot update the prefixed encoded ID '#{prefixed_encoded_id}' of a record #{self.class.name} #{id}, if you need to refresh it use set_normalized_encoded_id!"
       end

data/lib/encoded_id/rails/query_methods.rb

@@ -1,12 +1,29 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
+    # Provides query methods for finding records using encoded IDs in where clauses.
     module QueryMethods
-      def where_encoded_id(slugged_encoded_id)
-        decoded_id = decode_encoded_id(slugged_encoded_id)
-        raise ActiveRecord::RecordNotFound if decoded_id.nil?
-        where(id: decoded_id)
+      # Methods provided by other mixins/ActiveRecord
+      # @rbs!
+      #   def decode_encoded_id: (String) -> Array[Integer]?
+      #   def where: (**untyped) -> untyped
+
+      # @rbs (*String slugged_encoded_ids) -> untyped
+      def where_encoded_id(*slugged_encoded_ids)
+        slugged_encoded_ids = slugged_encoded_ids.flatten
+
+        raise ::ActiveRecord::RecordNotFound if slugged_encoded_ids.empty?
+
+        decoded_ids = slugged_encoded_ids.flat_map do |slugged_encoded_id|
+          decode_encoded_id(slugged_encoded_id).tap do |decoded_id|
+            raise ::ActiveRecord::RecordNotFound if decoded_id.nil?
+          end
+        end
+
+        where(id: decoded_ids)
       end
     end
   end

data/lib/encoded_id/rails/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module EncodedId
+  module Rails
+    # Railtie for Rails integration
+    class Railtie < ::Rails::Railtie
+      # initializer "encoded_id.rails.initialize" do
+      # end
+    end
+  end
+end

data/lib/encoded_id/rails/salt.rb

@@ -1,13 +1,21 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
+    # Generates a unique salt for encoding IDs based on the model class name.
     class Salt
+      # @rbs @klass: Class
+      # @rbs @salt: String
+
+      # @rbs (Class klass, String salt) -> void
       def initialize(klass, salt)
         @klass = klass
         @salt = salt
       end
 
+      # @rbs return: String
       def generate!
         unless @klass.respond_to?(:name) && @klass.name.present?
           raise ::StandardError, "The class must have a `name` to ensure encode id uniqueness. " \

data/lib/encoded_id/rails/slugged_id.rb

@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
-require "cgi"
+# rbs_inline: enabled
 
 module EncodedId
   module Rails
-    class SluggedId
+    # Represents an encoded ID with a slug prefix (e.g., "my-post--ABC123").
+    class SluggedId < CompositeIdBase
+      # @rbs (slug_part: String, id_part: String, ?separator: String) -> void
       def initialize(slug_part:, id_part:, separator: "--")
-        @slug_part = slug_part
-        @id_part = id_part
-        @separator = separator
+        super(first_part: slug_part, id_part: id_part, separator: separator)
       end
 
+      # @rbs return: String
       def slugged_id
-        unless @id_part.present? && @slug_part.present?
-          raise ::StandardError, "The model does not return a valid ID and/or slug"
-        end
-        "#{@slug_part.to_s.parameterize}#{CGI.escape(@separator)}#{@id_part}"
+        build_composite_id
+      end
+
+      private
+
+      # @rbs return: String
+      def invalid_id_error_message
+        "The model does not return a valid ID and/or slug"
       end
     end
   end

data/lib/encoded_id/rails/slugged_id_parser.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
   module Rails
+    # Parses a slugged ID into its slug and ID components.
     class SluggedIdParser
+      # @rbs @slug: String?
+      # @rbs @id: String
+
+      # @rbs (String slugged_id, ?separator: String) -> void
       def initialize(slugged_id, separator: "--")
         if separator && slugged_id.include?(separator)
           parts = slugged_id.split(separator)
@@ -13,7 +20,8 @@ module EncodedId
         end
       end
 
-      attr_reader :slug, :id
+      attr_reader :slug #: String?
+      attr_reader :id #: String
     end
   end
 end

data/lib/encoded_id/rails/slugged_path_param.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "active_record"
 require "encoded_id"
 
 module EncodedId
   module Rails
+    # Overrides to_param to return the slugged encoded ID for use in URLs.
     module SluggedPathParam
+      # Method provided by model
+      # @rbs!
+      #   def slugged_encoded_id: () -> String?
+
+      # @rbs () -> String
       def to_param
         slugged_encoded_id || raise(StandardError, "Cannot create path param for #{self.class.name} without an encoded id")
       end