slugifiable 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f376f3d8ed6b225b61c6bd96cf207d4fb90970a7e138bd0685571225fe750343
-  data.tar.gz: 8d77cb7631dd2e4b7eb7be4b15e1d2fd1d0b3bcb6ddfabfcf0c505d776d50ddd
+  metadata.gz: 230e7c9d0a24d77af781a78aed46daf46d404aa942572c4fab12f592fd24b3f7
+  data.tar.gz: ab8007017ef1f1ae5ecf563efb5a188e9a10150f5d861f9fc352d1b7f9023026
 SHA512:
-  metadata.gz: ae99e80bff43688ca9402bb2b09074a0df88c685be8974d4120b5772f648b77d583c0cae3631dbbaee711a6477f51706499337c08fa3d46cfa0ba8888b05f4d5
-  data.tar.gz: ec724965c4aed46aa09207ef3a2cc0e761466c6097efc871ff0190d05b2833a207ee6afeb6150ca04da970036f727946c25252c574fbde4f9200779634c51d7d
+  metadata.gz: 4649bfbb6dc0864f4397942a1f62621c437a09dd1b3b056194d5c0e82a54fbf9bd42deb48aaf5ea5da4cc16916568bdb2491c3a0fad1b8ddcfa465315cb7d52c
+  data.tar.gz: db9186508f938faf89e8ca4781929e53a1e45aaea006c24a3663bec97a9c80e285b8be6dbef125d6f344de62afb2084f91c5c1177e04bedaf99744226e00c33a

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.3.0] - 2026-02-19
+
+- Fixed race condition: retry with new random suffix on `RecordNotUnique` instead of crashing
+- Added PostgreSQL-safe savepoints for retry logic
+- Added support for NOT NULL slug columns (see README for setup)
+- Changed `set_slug` to use `save!` instead of `save` (raises on validation errors)
+- `before_create` and `after_create` callbacks re-run on retry — keep them idempotent
+
 ## [0.2.0] - 2026-01-16
 
 - Added a full Minitest test suite

data/README.md

@@ -80,9 +80,53 @@ 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.
+### Nullable vs NOT NULL Slug Columns
+
+**Nullable columns (default, simpler):**
+```ruby
+# migration
+add_column :products, :slug, :string
+add_index :products, :slug, unique: true
+
+# model
+class Product < ApplicationRecord
+  include Slugifiable::Model
+  generate_slug_based_on :name
+end
+```
+
+**NOT NULL columns (requires `before_validation` setup):**
+```ruby
+# migration
+add_column :products, :slug, :string, null: false
+add_index :products, :slug, unique: true
+
+# model
+class Product < ApplicationRecord
+  include Slugifiable::Model
+  generate_slug_based_on :name
+
+  before_validation :ensure_slug_present, on: :create
+
+  private
+
+  def ensure_slug_present
+    self.slug = compute_slug if slug.blank?
+  end
+end
+```
+
+> [!NOTE]
+> When using NOT NULL slug columns, `slugifiable` handles race conditions automatically. If two processes try to create records with the same slug simultaneously, the second one will retry with a new random suffix.
+
+> [!CAUTION]
+> For NOT NULL slug columns, retries re-run the `around_create` callback chain. If a slug collision happens, your `before_create` callbacks will run again. Keep `before_create` callbacks idempotent (or move side effects to `after_create`/background jobs).
+
+> [!NOTE]
+> Retry handling is DB-constraint-driven (`RecordNotUnique`), not validation-driven. A validation-layer race that raises `RecordInvalid` will bubble up.
+
+> [!NOTE]
+> Slug collision detection matches errors containing `slug`/`_on_slug`. If your index uses a custom name that does not include those patterns, retries will not trigger and the exception will bubble up.
 
 If you're generating slugs based off the model `id`, you can also set a desired length:
 ```ruby

data/lib/slugifiable/model.rb

@@ -33,11 +33,12 @@ module Slugifiable
     # 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
+    # Maximum number of attempts to generate a unique slug before raising.
+    # Also used by generate_unique_slug for EXISTS? check loop (with timestamp fallback).
     MAX_SLUG_GENERATION_ATTEMPTS = 10
 
     included do
+      around_create :retry_create_on_slug_unique_violation
       after_create :set_slug
       after_find :update_slug_if_nil
       validates :slug, uniqueness: true
@@ -138,6 +139,53 @@ module Slugifiable
 
     private
 
+    # S1: around_create retry for NOT NULL slug columns (pre-INSERT collision)
+    # S2: Uses savepoint (requires_new: true) for PostgreSQL compatibility
+    # S4: Skips overhead when slug column is nullable (no INSERT-time collision possible)
+    def retry_create_on_slug_unique_violation
+      return yield unless slug_persisted? && slug_column_not_null?
+
+      with_slug_retry(for_insert: true) do |attempts|
+        # `around_create` retries can re-enter create callbacks. Set a fresh slug
+        # before retrying so pre-insert slug strategies don't reuse a collided value.
+        self.slug = compute_slug if attempts.positive?
+        yield
+      end
+    end
+
+    # S3: Shared retry helper with savepoints for both paths
+    # PostgreSQL requires savepoints: without them, retry fails with
+    # "current transaction is aborted, commands ignored until end"
+    def with_slug_retry(for_insert: false)
+      attempts = 0
+      begin
+        self.class.transaction(requires_new: true) { yield(attempts) }
+      rescue ActiveRecord::RecordNotUnique => e
+        raise unless slug_unique_violation?(e)
+        raise if for_insert && persisted? # Already inserted; don't retry whole create
+
+        attempts += 1
+        raise if attempts >= MAX_SLUG_GENERATION_ATTEMPTS # S6: Raise on exhaustion
+
+        retry
+      end
+    end
+
+    # S4: Optimization guard - skip savepoint wrapper when slug is nullable
+    def slug_column_not_null?
+      return false unless self.class.respond_to?(:columns_hash)
+      column = self.class.columns_hash["slug"]
+      column && !column.null
+    end
+
+    # S5: Detect slug unique violations across PostgreSQL/MySQL/SQLite
+    # Pattern matches: "slug" as word boundary OR "_on_slug" (index naming convention)
+    # Safe false-negative for custom index names (error bubbles up instead of silent retry)
+    def slug_unique_violation?(error)
+      message = error.message.to_s.downcase
+      message.match?(/\bslug\b|_on_slug\b/)
+    end
+
     def normalize_length(length, default, max)
       length = length.to_i
       return default if length <= 0
@@ -170,7 +218,7 @@ module Slugifiable
 
       # 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
+      if attempts >= MAX_SLUG_GENERATION_ATTEMPTS
         slug_candidate = "#{base_slug}-#{Time.current.to_i}-#{SecureRandom.random_number(1000)}"
       end
 
@@ -218,15 +266,25 @@ module Slugifiable
       self.class.method_defined?(:slug) || self.class.private_method_defined?(:slug)
     end
 
+    # S1: after_create retry for nullable slug columns (post-INSERT collision)
+    # S2: Uses savepoint via with_slug_retry for PostgreSQL compatibility
     def set_slug
       return unless slug_persisted?
+      return unless slug.blank?
 
-      self.slug = compute_slug if id_changed? || slug.blank?
-      self.save
+      with_slug_retry do |_attempts|
+        self.slug = compute_slug
+        save!
+      end
     end
 
+    # S7: Non-bang save for after_find repair path to avoid read-time exceptions
+    # This path handles legacy records that may have nil slugs
     def update_slug_if_nil
-      set_slug if slug_persisted? && self.slug.nil?
+      return unless slug_persisted? && slug.nil?
+
+      self.slug = compute_slug
+      save # Non-bang: read operations should not raise
     end
 
   end

data/lib/slugifiable/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: slugifiable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - rameerez
 bindir: exe
 cert_chain: []
-date: 2026-01-16 00:00:00.000000000 Z
+date: 2026-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails