slugifiable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d06633ba0907f8ee400648856e3d8dbc95fc647be40d60780ae01ebbb6eeb7d3
-  data.tar.gz: d40cae2d3fc081af04bd6fac08ea8640d8174c1e59b07652c92bab72eb8a18ca
+  metadata.gz: e9f707db7b8e857da8289a7e17754261aa3dd4b06b517673b983936cc449e530
+  data.tar.gz: 36144ba06043096a3ead2aa5e3728a3c6c0f54bf9be15c27d085e944d47a1b76
 SHA512:
-  metadata.gz: 39dfad3e03b4cfef9946a929c5fe21585f2aab1ef1922d2f13ad8d10d6d4b732e3eaf6d4dcff545d9664d0395909fa6fa5e40a92801627625ef4034467b93bd9
-  data.tar.gz: 8b726b22d56141b633f415460f8a8f8e7042379bc06aebb383f15360914b294bf29a0fffe2aa5e97e25577dab3e962d2b221bf7f18ab0d8822437f77ca97bfef
+  metadata.gz: 848886284f316ccb3086afcb268ddf09bf136c040a055c353fa4492021d578e439367ce137d471334a339fb43ff2997271267b2c0668d25f7654803cd4e73cad
+  data.tar.gz: 984f18e9268a0fff5b64f3e8d28e654c2586fa99c02f2199134bbac798cb311e68e5714b17c22ef6583eae75f51cce22b209ac08791d973dbe7f71a2e8830645

data/README.md

@@ -77,6 +77,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 +161,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-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/lib/slugifiable/model.rb

@@ -28,6 +28,10 @@ module Slugifiable
     DEFAULT_SLUG_STRING_LENGTH = 11
     DEFAULT_SLUG_NUMBER_LENGTH = 6
 
+    # 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,11 +40,14 @@ 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)
@@ -54,7 +61,7 @@ module Slugifiable
     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)
@@ -74,11 +81,48 @@ module Slugifiable
     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
@@ -96,13 +140,21 @@ 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
+        random_suffix = compute_slug_as_number
+        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 to ensure uniqueness
+      if attempts == MAX_SLUG_GENERATION_ATTEMPTS
+        slug_candidate = "#{base_slug}-#{Time.current.to_i}"
       end
 
       slug_candidate

data/lib/slugifiable/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: slugifiable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - rameerez
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2025-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -49,7 +48,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 +62,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