slugifiable 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d06633ba0907f8ee400648856e3d8dbc95fc647be40d60780ae01ebbb6eeb7d3
-  data.tar.gz: d40cae2d3fc081af04bd6fac08ea8640d8174c1e59b07652c92bab72eb8a18ca
+  metadata.gz: f376f3d8ed6b225b61c6bd96cf207d4fb90970a7e138bd0685571225fe750343
+  data.tar.gz: 8d77cb7631dd2e4b7eb7be4b15e1d2fd1d0b3bcb6ddfabfcf0c505d776d50ddd
 SHA512:
-  metadata.gz: 39dfad3e03b4cfef9946a929c5fe21585f2aab1ef1922d2f13ad8d10d6d4b732e3eaf6d4dcff545d9664d0395909fa6fa5e40a92801627625ef4034467b93bd9
-  data.tar.gz: 8b726b22d56141b633f415460f8a8f8e7042379bc06aebb383f15360914b294bf29a0fffe2aa5e97e25577dab3e962d2b221bf7f18ab0d8822437f77ca97bfef
+  metadata.gz: ae99e80bff43688ca9402bb2b09074a0df88c685be8974d4120b5772f648b77d583c0cae3631dbbaee711a6477f51706499337c08fa3d46cfa0ba8888b05f4d5
+  data.tar.gz: ec724965c4aed46aa09207ef3a2cc0e761466c6097efc871ff0190d05b2833a207ee6afeb6150ca04da970036f727946c25252c574fbde4f9200779634c51d7d

data/.simplecov

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# SimpleCov configuration file (auto-loaded before test suite)
+# This keeps test_helper.rb clean and follows best practices
+
+SimpleCov.start do
+  # Use SimpleFormatter for terminal-only output (no HTML generation)
+  formatter SimpleCov::Formatter::SimpleFormatter
+
+  # Track coverage for the lib directory (gem source code)
+  add_filter "/test/"
+
+  # Track the lib and app directories
+  track_files "{lib,app}/**/*.rb"
+
+  # Enable branch coverage for more detailed metrics
+  enable_coverage :branch
+
+  # Set minimum coverage threshold to prevent coverage regression
+  minimum_coverage line: 90, branch: 90
+
+  # Disambiguate parallel test runs
+  command_name "Job #{ENV['TEST_ENV_NUMBER']}" if ENV['TEST_ENV_NUMBER']
+end
+
+# Print coverage summary to terminal after tests complete
+SimpleCov.at_exit do
+  SimpleCov.result.format!
+  puts "\n" + "=" * 60
+  puts "COVERAGE SUMMARY"
+  puts "=" * 60
+  puts "Line Coverage:   #{SimpleCov.result.covered_percent.round(2)}%"
+  puts "Branch Coverage: #{SimpleCov.result.coverage_statistics[:branch]&.percent&.round(2) || 'N/A'}%"
+  puts "=" * 60
+end

data/AGENTS.md

@@ -0,0 +1,5 @@
+# AGENTS.md
+
+This file provides guidance to AI Agents (like OpenAI's Codex, Cursor Agent, Claude Code, etc) when working with code in this repository.
+
+Please go ahead and read the full context for this project at `.cursor/rules/0-overview.mdc` and `.cursor/rules/1-quality.mdc` now. Also read the README for a good overview of the project.

data/Appraisals

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Note: Rails < 7.2 is not compatible with Ruby 3.4
+# (Logger became a bundled gem in Ruby 3.4, and only Rails 7.2+ handles this)
+# See: https://stdgems.org/logger/
+
+# Test against Rails 7.2 (minimum version compatible with Ruby 3.4)
+appraise "rails-7.2" do
+  gem "rails", "~> 7.2.0"
+end
+
+# Test against Rails 8.0
+appraise "rails-8.0" do
+  gem "rails", "~> 8.0.0"
+end
+
+# Test against Rails 8.1 (latest)
+appraise "rails-8.1" do
+  gem "rails", "~> 8.1.2"
+end

data/CHANGELOG.md

@@ -1,4 +1,18 @@
+## [0.2.0] - 2026-01-16
+
+- Added a full Minitest test suite
+- Fixed `respond_to?(:slug)` returning false for models using method_missing by implementing `respond_to_missing?`
+- Fixed collision resolution generating identical suffixes by switching from id-based deterministic suffixes to SecureRandom-based random suffixes
+- Fixed length parameter edge cases (zero, negative, very large values) by adding length validation and clamping via `normalize_length` method
+- Fixed timestamp fallback to include random suffix for additional uniqueness guarantee
+- Added length validation constants (`MAX_HEX_STRING_LENGTH`, `MAX_NUMBER_LENGTH`) to prevent invalid length values
+
+## [0.1.1] - 2024-03-21
+
+- Slugs can be now generated based off methods that return a string, not just based off attributes
+- Enhanced collision resolution strategy so that it doesn't get stuck in infinite loops
+- Added comprehensive test suite
+
 ## [0.1.0] - 2024-10-30
 
 - Initial release
-

data/CLAUDE.md

@@ -0,0 +1,5 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+Please go ahead and read the full context for this project at `.cursor/rules/0-overview.mdc` and `.cursor/rules/1-quality.mdc` now. Also read the README for a good overview of the project.

data/README.md

@@ -1,8 +1,11 @@
-# 🐌 `slugifiable` - Rails gem to generate SEO-friendly slugs
+# 🐌 `slugifiable` - Generate SEO-optimized URL slugs
 
-[![Gem Version](https://badge.fury.io/rb/slugifiable.svg)](https://badge.fury.io/rb/slugifiable)
+[![Gem Version](https://badge.fury.io/rb/slugifiable.svg)](https://badge.fury.io/rb/slugifiable) [![Build Status](https://github.com/rameerez/slugifiable/workflows/Tests/badge.svg)](https://github.com/rameerez/slugifiable/actions)
 
-Automatically generates unique slugs for your Rails' model records, so you can expose SEO-friendly URLs.
+> [!TIP]
+> **🚀 Ship your next Rails app 10x faster!** I've built **[RailsFast](https://railsfast.com/?ref=slugifiable)**, a production-ready Rails boilerplate template that comes with everything you need to launch a software business in days, not weeks. Go [check it out](https://railsfast.com/?ref=slugifiable)!
+
+Ruby gem to automatically generate unique slugs for your Rails' model records, so you can expose SEO-friendly URLs.
 
 Example:
 ```
@@ -77,6 +80,10 @@ Product.first.slug
 
 If your model has a `slug` attribute in the database, `slugifiable` will automatically generate a slug for that model upon instance creation, and save it to the DB.
 
+> [!IMPORTANT]
+> Your `slug` attribute **SHOULD NOT** have `null: false` in the migration / database. If it does, `slugifiable` will not be able to save the slug to the database, and will raise an error like `ERROR:  null value in column "slug" of relation "posts" violates not-null constraint (PG::NotNullViolation)`
+> This is because records are created without a slug, and the slug is generated later.
+
 If you're generating slugs based off the model `id`, you can also set a desired length:
 ```ruby
 class Product < ApplicationRecord
@@ -157,12 +164,56 @@ Product.first.slug
 => "big-red-backpack"
 ```
 
+You can also use instance methods to generate more complex slugs. This is useful when you need to combine multiple attributes:
+```ruby
+class Event < ApplicationRecord
+  include Slugifiable::Model
+  belongs_to :location
+  
+  generate_slug_based_on :title_with_location
+
+  # The method can return any string - slugifiable will handle the parameterization
+  def title_with_location
+    if location.present?
+      "#{title} #{location.city} #{location.region}"  # Returns raw string, slugifiable parameterizes it
+    else
+      title
+    end
+  end
+end
+```
+
+This will generate slugs like:
+```ruby
+Event.first.slug
+=> "my-awesome-event-new-york"  # Automatically parameterized
+```
+
 There may be collisions if two records share the same name – but slugs should be unique! To resolve this, when this happens, `slugifiable` will append a unique string at the end to make the slug unique:
 ```ruby
 Product.first.slug
 => "big-red-backpack-321678"
 ```
 
+## Testing
+
+The gem includes a comprehensive test suite that covers:
+
+- Default slug generation behavior
+- Attribute-based slug generation
+- Method-based slug generation (including private/protected methods)
+- Collision resolution and uniqueness handling
+- Special cases and edge conditions
+
+To run the tests:
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+The test suite uses SQLite3 in-memory database and requires no additional setup.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,4 +1,12 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-task default: %i[]
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/gemfiles/rails_7.2.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rails", "~> 7.2.0"
+
+group :development, :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "rack-test"
+  gem "simplecov", require: false
+  gem "sqlite3", ">= 2.1"
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.0.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rails", "~> 8.0.0"
+
+group :development, :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "rack-test"
+  gem "simplecov", require: false
+  gem "sqlite3", ">= 2.1"
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.1.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rails", "~> 8.1.2"
+
+group :development, :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "rack-test"
+  gem "simplecov", require: false
+  gem "sqlite3", ">= 2.1"
+end
+
+gemspec path: "../"

data/lib/slugifiable/model.rb

@@ -28,6 +28,15 @@ module Slugifiable
     DEFAULT_SLUG_STRING_LENGTH = 11
     DEFAULT_SLUG_NUMBER_LENGTH = 6
 
+    # SHA256 produces 64 hex characters
+    MAX_HEX_STRING_LENGTH = 64
+    # 10^18 fits safely in a 64-bit integer
+    MAX_NUMBER_LENGTH = 18
+
+    # Maximum number of attempts to generate a unique slug
+    # before falling back to timestamp-based suffix
+    MAX_SLUG_GENERATION_ATTEMPTS = 10
+
     included do
       after_create :set_slug
       after_find :update_slug_if_nil
@@ -36,25 +45,32 @@ module Slugifiable
 
     class_methods do
       def generate_slug_based_on(strategy, options = {})
+        # Remove previous definition if it exists to avoid warnings
+        remove_method(:generate_slug_based_on) if method_defined?(:generate_slug_based_on)
+
+        # Define the method that returns the strategy
         define_method(:generate_slug_based_on) do
           [strategy, options]
         end
       end
-
     end
 
     def method_missing(missing_method, *args, &block)
-      if missing_method.to_s == "slug" && !self.methods.include?(:slug)
+      if missing_method.to_s == "slug" && !has_slug_method?
         compute_slug
       else
         super
       end
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s == "slug" && !has_slug_method? || super
+    end
+
     def compute_slug
       strategy, options = determine_slug_generation_method
 
-      length = options[:length] if options.is_a?(Hash) || nil
+      length = options[:length] if options.is_a?(Hash)
 
       if strategy == :compute_slug_based_on_attribute
         self.send(strategy, options)
@@ -64,29 +80,72 @@ module Slugifiable
     end
 
     def compute_slug_as_string(length = DEFAULT_SLUG_STRING_LENGTH)
-      length ||= DEFAULT_SLUG_STRING_LENGTH
+      length = normalize_length(length, DEFAULT_SLUG_STRING_LENGTH, MAX_HEX_STRING_LENGTH)
       (Digest::SHA2.hexdigest self.id.to_s).first(length)
     end
 
     def compute_slug_as_number(length = DEFAULT_SLUG_NUMBER_LENGTH)
-      length ||= DEFAULT_SLUG_NUMBER_LENGTH
+      length = normalize_length(length, DEFAULT_SLUG_NUMBER_LENGTH, MAX_NUMBER_LENGTH)
       generate_random_number_based_on_id_hex(length)
     end
 
     def compute_slug_based_on_attribute(attribute_name)
-      return compute_slug_as_string unless self.attributes.include?(attribute_name.to_s)
-
-      base_slug = self.send(attribute_name)&.to_s&.strip&.parameterize
-      base_slug = base_slug.presence || generate_random_number_based_on_id_hex
-
+      # This method generates a slug from either:
+      # 1. A database column (e.g. generate_slug_based_on :title)
+      # 2. An instance method (e.g. generate_slug_based_on :title_with_location)
+      #
+      # Priority:
+      # - Database columns take precedence over methods with the same name
+      # - Falls back to methods if no matching column exists
+      # - Falls back to ID-based slug if neither exists
+      #
+      # Flow:
+      # 1. Check if source exists (DB column first, then method)
+      # 2. Get raw value
+      # 3. Parameterize (convert "My Title" -> "my-title")
+      # 4. Ensure uniqueness
+      # 5. Fallback to random number if anything fails
+
+      # First check if we can get a value from the database
+      has_attribute = self.attributes.include?(attribute_name.to_s)
+
+      # Only check for methods if no DB attribute exists
+      # We check all method types to be thorough
+      responds_to_method = !has_attribute && (
+        self.class.method_defined?(attribute_name) ||
+        self.class.private_method_defined?(attribute_name) ||
+        self.class.protected_method_defined?(attribute_name)
+      )
+
+      # If we can't get a value from either source, fallback to using the record's ID
+      return compute_slug_as_string unless has_attribute || responds_to_method
+
+      # Get and clean the raw value (e.g. "  My Title  " -> "My Title")
+      # Works for both DB attributes and methods thanks to Ruby's send
+      raw_value = self.send(attribute_name)
+      return generate_random_number_based_on_id_hex if raw_value.nil?
+
+      # Convert to URL-friendly format
+      # e.g. "My Title" -> "my-title"
+      base_slug = raw_value.to_s.strip.parameterize
+      return generate_random_number_based_on_id_hex if base_slug.blank?
+
+      # Handle duplicate slugs by adding a random suffix if needed
+      # e.g. "my-title" -> "my-title-123456"
       unique_slug = generate_unique_slug(base_slug)
       unique_slug.presence || generate_random_number_based_on_id_hex
     end
 
     private
 
+    def normalize_length(length, default, max)
+      length = length.to_i
+      return default if length <= 0
+      [length, max].min
+    end
+
     def generate_random_number_based_on_id_hex(length = DEFAULT_SLUG_NUMBER_LENGTH)
-      length ||= DEFAULT_SLUG_NUMBER_LENGTH
+      length = normalize_length(length, DEFAULT_SLUG_NUMBER_LENGTH, MAX_NUMBER_LENGTH)
       ((Digest::SHA2.hexdigest(id.to_s)).hex % (10 ** length))
     end
 
@@ -96,13 +155,23 @@ module Slugifiable
       return slug_candidate unless slug_persisted?
 
       # Collision resolution logic:
+      # Try up to MAX_SLUG_GENERATION_ATTEMPTS times with random suffixes
+      # This prevents infinite loops while still giving us good odds
+      # of finding a unique slug
+      attempts = 0
+
+      while self.class.exists?(slug: slug_candidate) && attempts < MAX_SLUG_GENERATION_ATTEMPTS
+        attempts += 1
+        # Use SecureRandom for truly random suffixes during collision resolution
+        # This ensures each attempt tries a different suffix
+        random_suffix = SecureRandom.random_number(10 ** DEFAULT_SLUG_NUMBER_LENGTH)
+        slug_candidate = "#{base_slug}-#{random_suffix}"
+      end
 
-      count = 0
-
-      while self.class.exists?(slug: slug_candidate)
-        count += 1
-        # slug_candidate = "#{base_slug}-#{count}"
-        slug_candidate = "#{base_slug}-#{compute_slug_as_number}"
+      # If we couldn't find a unique slug after MAX_SLUG_GENERATION_ATTEMPTS,
+      # append timestamp + random to ensure uniqueness
+      if attempts == MAX_SLUG_GENERATION_ATTEMPTS
+        slug_candidate = "#{base_slug}-#{Time.current.to_i}-#{SecureRandom.random_number(1000)}"
       end
 
       slug_candidate
@@ -133,7 +202,7 @@ module Slugifiable
             return [DEFAULT_SLUG_GENERATION_STRATEGY, options]
           end
         elsif strategy.key?(:attribute)
-          return [:compute_slug_based_on_attribute, strategy[:attribute], options]
+          return [:compute_slug_based_on_attribute, strategy[:attribute]]
         end
       end
 
@@ -141,7 +210,12 @@ module Slugifiable
     end
 
     def slug_persisted?
-      self.methods.include?(:slug) && self.attributes.include?("slug")
+      has_slug_method? && self.attributes.include?("slug")
+    end
+
+    def has_slug_method?
+      # Check if slug method exists from ActiveRecord (not from method_missing)
+      self.class.method_defined?(:slug) || self.class.private_method_defined?(:slug)
     end
 
     def set_slug

data/lib/slugifiable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slugifiable
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/slugifiable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 require_relative "slugifiable/version"
 require_relative "slugifiable/model"
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: slugifiable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - rameerez
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2026-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -33,10 +32,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".simplecov"
+- AGENTS.md
+- Appraisals
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- gemfiles/rails_7.2.gemfile
+- gemfiles/rails_8.0.gemfile
+- gemfiles/rails_8.1.gemfile
 - lib/slugifiable.rb
 - lib/slugifiable/model.rb
 - lib/slugifiable/version.rb
@@ -49,7 +55,6 @@ metadata:
   homepage_uri: https://github.com/rameerez/slugifiable
   source_code_uri: https://github.com/rameerez/slugifiable
   changelog_uri: https://github.com/rameerez/slugifiable/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -64,8 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Easily generate unique and SEO optimized slugs for your Rails ActiveRecord
   model records, based on any attribute