opaque_id 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 016b3d2bbd7ae3af1ba38973c0b590164d7be1a4bd60a8c0e0379cfca1c9dc0f
-  data.tar.gz: 2924779f8769585995732ce79da51b8a1171c0b22fd33636c6476f77815adb44
+  metadata.gz: 4f3a94f08b1d9f3e21a513fe3f7ae6422c7288c2ccef38c78394209e835d264d
+  data.tar.gz: 114701a6d202fa5d41ac77da871f86ffc88182d54ffb58ea8ab2324bda177fee
 SHA512:
-  metadata.gz: 82206f53378e08c302fbb9bd56caf94238e3b0780b6a271732d00d04f0e7e37136c1c6c941ef58fe6c6fffd154c7ce1b82c0b12b76240d23399007d34d81a0bd
-  data.tar.gz: b5d588f50a7a2337b42fc4e021b9aef658cf3e9f92c64fe5c21c7bf901560d5575b48c05fe72edefa77112175357562b0497c4c3d2ba73dd23be2165b6eadd87
+  metadata.gz: 66f5027ec5599b164599a7c5f4d6bc6c7396787671ea7a2238bc95385482150bfb5b4e1341173264fc870af0b851d45c4faad6c9396519f96e11c00b5ff5978c
+  data.tar.gz: 50b3da266692f3b004d2c00f9a485d5bdfe0af51465dd4f87f5189d109cbfd3849c29a741ce4c3a4fb8565970594696e48467bf2e1fc8312b7356c7f1a87bd80

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.6.0"
+  ".": "1.7.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,96 @@ All notable changes to the OpaqueId gem will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.7.0](https://github.com/nyaggah/opaque_id/compare/opaque_id-v1.6.0...opaque_id/v1.7.0) (2025-10-04)
+
+
+### Features
+
+* add external links to sidebar using JavaScript ([cd77079](https://github.com/nyaggah/opaque_id/commit/cd770795936ca76633a18f80cba8482ec09db8e2))
+* add SLUG_LIKE_ALPHABET as default for URL-safe IDs ([1e52b17](https://github.com/nyaggah/opaque_id/commit/1e52b174d70ca72b74badf399401605b307e3604))
+* add Table of Contents to all documentation pages ([9472175](https://github.com/nyaggah/opaque_id/commit/94721752270211d5b7db460da61d79a8a81218b2))
+* complete Table of Contents implementation ([5b037e4](https://github.com/nyaggah/opaque_id/commit/5b037e42692803204bc4d8991b6d2e0c9639a05c))
+* implement dynamic copyright year ([b86cea6](https://github.com/nyaggah/opaque_id/commit/b86cea66e60939377c6b0a67c1d385c9bf4bece3))
+* improve documentation site theme and navigation ([304f845](https://github.com/nyaggah/opaque_id/commit/304f845a47397ea2a15f12d2c635144b39be431b))
+* improve generator API and add custom column configuration ([5c1a570](https://github.com/nyaggah/opaque_id/commit/5c1a5703dee269f6985d26096942c086787296f3))
+* initial release of OpaqueId gem v0.1.0 ([3a90274](https://github.com/nyaggah/opaque_id/commit/3a9027403552f8160e3aaf413d1e99ce8c63bbe4))
+* update defaults to slug-like alphabet and 18-char length ([ec76440](https://github.com/nyaggah/opaque_id/commit/ec764400b0f40a93784c70c7c99ec15a9e386d36))
+* update defaults to slug-like alphabet and length 18 ([87c978f](https://github.com/nyaggah/opaque_id/commit/87c978f3601270e990bc976344fd2113ba0573b3))
+
+
+### Bug Fixes
+
+* add frozen string literal comment to docs/Gemfile ([2d653a7](https://github.com/nyaggah/opaque_id/commit/2d653a7bbc071e67e94e63ebc1602768b8d04456))
+* add Release Please manifest and update workflow configuration ([f33ce6c](https://github.com/nyaggah/opaque_id/commit/f33ce6c96805b6c670cd1eedf5ebed2a46e8ffa6))
+* add required permissions for Release Please job ([cdf8d2b](https://github.com/nyaggah/opaque_id/commit/cdf8d2bfc5dbea9a9ec40411a988191ba91913fa))
+* configure just-the-docs theme for GitHub Pages compatibility ([c2fb96c](https://github.com/nyaggah/opaque_id/commit/c2fb96c46e99fd5287520e01c3bc2dd7bd5d4817))
+* correct aux_links configuration format ([61b3fb9](https://github.com/nyaggah/opaque_id/commit/61b3fb9441ce3cfc3cf30637c277d19135f89dab))
+* correct release-please tag format ([b4c31e5](https://github.com/nyaggah/opaque_id/commit/b4c31e5d0f4878878dd728e82fe9f5eb09ce5b82))
+* improve publish workflow trigger reliability ([9c6e240](https://github.com/nyaggah/opaque_id/commit/9c6e2402474d8ecf8a3f754a9f2ca149a63bf1d1))
+* improve statistical test reliability for CI ([c9b0d52](https://github.com/nyaggah/opaque_id/commit/c9b0d52fb4e9559aad489fcf58bdff1917d613a6))
+* remove unsupported Release Please configuration parameters ([e3b0d2a](https://github.com/nyaggah/opaque_id/commit/e3b0d2ac96b905316a78992004fae83423991632))
+* resolve CSS linting warnings ([d01e8c0](https://github.com/nyaggah/opaque_id/commit/d01e8c05628b7f2bd8b39a13325112168cf4e689))
+* resolve dependency version conflicts and improve test robustness ([af43e13](https://github.com/nyaggah/opaque_id/commit/af43e13393a452f11ce32bafb26a267d1460736c))
+* resolve TOC rendering and improve workflow configuration ([244d532](https://github.com/nyaggah/opaque_id/commit/244d5321e5b18091d8599bd772a28f5a30239c80))
+* update deprecated platform specifications in docs/Gemfile ([cf96134](https://github.com/nyaggah/opaque_id/commit/cf9613499150dd7152bff38aa8f8fe7ab9923eb5))
+* use correct aux_links format ([d4a4bc0](https://github.com/nyaggah/opaque_id/commit/d4a4bc0c11bc66b661034915b471ed762611d821))
+
+
+### Documentation
+
+* final cleanup of over-inflated claims ([795b5b0](https://github.com/nyaggah/opaque_id/commit/795b5b0071a098f718a40e84e81ceba4525b8d3b))
+* implement comprehensive documentation site with dark theme ([19cc9e3](https://github.com/nyaggah/opaque_id/commit/19cc9e30c584658559c5404a4518e871039cc223))
+* implement comprehensive documentation site with dark theme ([a249c6a](https://github.com/nyaggah/opaque_id/commit/a249c6ad2253439f0d070620a914ff87597cf7cb))
+* tone down over-inflated claims and remove unsubstantiated benchmarks ([6536b87](https://github.com/nyaggah/opaque_id/commit/6536b87f9a9c2049497328319641ff21368c6032))
+* tone down pretentious language in algorithms intro ([58c0caf](https://github.com/nyaggah/opaque_id/commit/58c0caf116228401b6218ec589a35b350d068b49))
+
+
+### Styles
+
+* improve code formatting in generator ([ce52021](https://github.com/nyaggah/opaque_id/commit/ce52021cd60e3594dc1ee34e5b96d48568008b5a))
+
+
+### Miscellaneous Chores
+
+* configure just-the-docs theme ([3dfcac8](https://github.com/nyaggah/opaque_id/commit/3dfcac88099e65e61931e558e9242050bdbf0bc9))
+* **main:** release 1.0.0 ([43282c5](https://github.com/nyaggah/opaque_id/commit/43282c5865aae3f136c9eaa49f013066a2359826))
+* **main:** release 1.0.0 ([b8271ad](https://github.com/nyaggah/opaque_id/commit/b8271ad43cf6fab4687276258f0105c06a87bff7))
+* **main:** release 1.0.1 ([4ee2e2c](https://github.com/nyaggah/opaque_id/commit/4ee2e2c69905e71d6c5048617af09b65cbb9e12a))
+* **main:** release 1.0.1 ([e6cd2f8](https://github.com/nyaggah/opaque_id/commit/e6cd2f8f8ff545ad3010598488f71956e36a88c5))
+* **main:** release 1.0.2 ([d5c7423](https://github.com/nyaggah/opaque_id/commit/d5c7423cf06ae7638d95cdd29b2631049efed727))
+* **main:** release 1.0.2 ([365dff8](https://github.com/nyaggah/opaque_id/commit/365dff87a044aa967906866d6ace8d1ccad08c78))
+* **main:** release opaque_id 1.1.0 ([df65c79](https://github.com/nyaggah/opaque_id/commit/df65c79d0efaee1dcd89b8af2f1b1c712c3cc2cd))
+* **main:** release opaque_id 1.1.0 ([e2a4ee0](https://github.com/nyaggah/opaque_id/commit/e2a4ee0fd2d31132bc5bc0de6b6115f3ceae8afb))
+* **main:** release opaque_id 1.2.0 ([1987b07](https://github.com/nyaggah/opaque_id/commit/1987b07b3db92216f3fbbe807c3ad66ca105866e))
+* **main:** release opaque_id 1.2.0 ([aacd20a](https://github.com/nyaggah/opaque_id/commit/aacd20aa5eaa1fe2fa76d89cc6bdab26214b744d))
+* **main:** release opaque_id 1.3.0 ([964b1b4](https://github.com/nyaggah/opaque_id/commit/964b1b421b1fac3fe43b15549e0e6b216b600357))
+* **main:** release opaque_id 1.3.0 ([76453ad](https://github.com/nyaggah/opaque_id/commit/76453ad18b2d2b81548e49dafb5dde6fb52abcca))
+* **main:** release opaque_id 1.4.0 ([6c3ccd1](https://github.com/nyaggah/opaque_id/commit/6c3ccd108b3eea0bbf0ac71fda4ccc0e47e97b95))
+* **main:** release opaque_id 1.4.0 ([3d9d818](https://github.com/nyaggah/opaque_id/commit/3d9d818b34771ad1ca729f3f9b443784a6965568))
+* **main:** release opaque_id 1.5.0 ([113af74](https://github.com/nyaggah/opaque_id/commit/113af74dda07330bf7108977147362385dc806ae))
+* **main:** release opaque_id 1.5.0 ([ff14fe9](https://github.com/nyaggah/opaque_id/commit/ff14fe92d94cf4ecbe5aaeb31ad6cd044bfa89d0))
+* **main:** release opaque_id 1.6.0 ([9c95d04](https://github.com/nyaggah/opaque_id/commit/9c95d0461bcca6e8eeccc4f985f7e993ba651bb3))
+* **main:** release opaque_id 1.6.0 ([74f09bd](https://github.com/nyaggah/opaque_id/commit/74f09bd860fc6f097140e1cc4efb4164407be30d))
+* remove tasks/ directory from source control ([e007ead](https://github.com/nyaggah/opaque_id/commit/e007ead90fa3fbb62ab17e334563e69899afb259))
+* sync version to 1.0.2 ([2f870c8](https://github.com/nyaggah/opaque_id/commit/2f870c89d486f0a5cda8ef37e5544c29c8fa2919))
+* update author name and GitHub URLs ([e911548](https://github.com/nyaggah/opaque_id/commit/e911548e89e1e60ac3281157059f7c7b812750bd))
+* update bundle and add Linux platform support ([661842f](https://github.com/nyaggah/opaque_id/commit/661842f0ba66ce36962bb11f75a1b0e35eb5a3e7))
+* update Gemfile.lock after dependency check ([058281f](https://github.com/nyaggah/opaque_id/commit/058281f6e07f3c9a1057c6fbeb0200bccf221558))
+
+
+### Code Refactoring
+
+* improve generator code quality and resolve RuboCop issues ([b658bbc](https://github.com/nyaggah/opaque_id/commit/b658bbcb29f6c0134f2bf256b24c5b3c2bccb265))
+* integrate Release Please into main CI workflow ([8a0b189](https://github.com/nyaggah/opaque_id/commit/8a0b189a8bfbfcc07275c9bdda3397ff367b2054))
+* simplify external links implementation ([5cb84c1](https://github.com/nyaggah/opaque_id/commit/5cb84c1e8952a0fd1aa4b9089b9ff11829dc397c))
+
+
+### Tests
+
+* add test for lowercase model names ([8ef4675](https://github.com/nyaggah/opaque_id/commit/8ef4675a0698d2cda054084360c9e80d956ddb14))
+* update tests for SLUG_LIKE_ALPHABET defaults ([d7296c7](https://github.com/nyaggah/opaque_id/commit/d7296c77b1b7a995e7a42b3ba546fdeb8e41c297))
+* update tests for SLUG_LIKE_ALPHABET defaults ([d1f8f26](https://github.com/nyaggah/opaque_id/commit/d1f8f26e7be80f6cbefc98563c0ffa45033372dc))
+
 ## [1.6.0](https://github.com/nyaggah/opaque_id/compare/opaque_id-v1.5.0...opaque_id/v1.6.0) (2025-10-03)
 
 

data/README.md

@@ -27,7 +27,7 @@ A simple Ruby gem for generating secure, opaque IDs for ActiveRecord models. Opa
 - [Configuration Options](#configuration-options)
   - [Configuration Details](#configuration-details)
 - [Built-in Alphabets](#built-in-alphabets)
-  - [`ALPHANUMERIC_ALPHABET` (Default)](#alphanumeric_alphabet-default)
+  - [`SLUG_LIKE_ALPHABET` (Default)](#slug_like_alphabet-default)
   - [`STANDARD_ALPHABET`](#standard_alphabet)
   - [Alphabet Comparison](#alphabet-comparison)
   - [Custom Alphabets](#custom-alphabets)
@@ -36,6 +36,7 @@ A simple Ruby gem for generating secure, opaque IDs for ActiveRecord models. Opa
   - [Fast Path Algorithm (64-character alphabets)](#fast-path-algorithm-64-character-alphabets)
   - [Unbiased Path Algorithm (other alphabets)](#unbiased-path-algorithm-other-alphabets)
   - [Algorithm Selection](#algorithm-selection)
+- [Performance & Benchmarks](#performance--benchmarks)
 - [Performance Benchmarks](#performance-benchmarks)
   - [Generation Speed (IDs per second)](#generation-speed-ids-per-second)
   - [Memory Usage](#memory-usage)
@@ -176,11 +177,11 @@ end
 
 # IDs are automatically generated on creation
 user = User.create!(name: "John Doe")
-puts user.opaque_id  # => "izkpm55j334u8x9y2"
+puts user.opaque_id  # => "izkpm55j334u8x9y2a"
 
 # Find by opaque ID
-user = User.find_by_opaque_id("izkpm55j334u8x9y2")
-user = User.find_by_opaque_id!("izkpm55j334u8x9y2")  # raises if not found
+user = User.find_by_opaque_id("izkpm55j334u8x9y2a")
+user = User.find_by_opaque_id!("izkpm55j334u8x9y2a")  # raises if not found
 ```
 
 ## Usage
@@ -197,7 +198,7 @@ OpaqueId defaults to generating **slug-like IDs** that are perfect for URLs and
 ```ruby
 # Default generation creates slug-like IDs
 id = OpaqueId.generate
-# => "izkpm55j334u8x9y2"  # Perfect for URLs and user selection
+# => "izkpm55j334u8x9y2a"  # Perfect for URLs and user selection
 
 # Compare to UUIDs
 uuid = SecureRandom.uuid
@@ -213,7 +214,7 @@ OpaqueId can be used independently of ActiveRecord for generating secure IDs in
 ```ruby
 # Generate with default settings (18 characters, slug-like)
 id = OpaqueId.generate
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 
 # Custom length
 id = OpaqueId.generate(size: 10)
@@ -248,7 +249,7 @@ class BackgroundJob
 end
 
 job_id = BackgroundJob.enqueue(ProcessDataJob, user_id: 123)
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 ```
 
 ##### Temporary File Names
@@ -347,7 +348,7 @@ class ApiLogger
 end
 
 request_id = ApiLogger.log_request("/api/users", { page: 1 })
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 ```
 
 ##### Batch Processing IDs
@@ -369,7 +370,7 @@ class BatchProcessor
 end
 
 batch_id = BatchProcessor.process_batch([1, 2, 3, 4, 5])
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 # => Processing item izkpm55j334u8x9y2_000: 1
 # => Processing item izkpm55j334u8x9y2_001: 2
 # => ...
@@ -436,7 +437,7 @@ end
 
 # Create a new post - opaque_id is automatically generated
 post = Post.create!(title: "Hello World", content: "This is my first post")
-puts post.opaque_id  # => "izkpm55j334u8x9y2"
+puts post.opaque_id  # => "izkpm55j334u8x9y2a"
 
 # Create multiple posts
 posts = Post.create!([
@@ -548,7 +549,7 @@ class Upload < ApplicationRecord
   self.opaque_id_purge_chars = ['/', '\\', ':', '*', '?', '"', '<', '>', '|']
 end
 
-# Generated filenames will look like: "izkpm55j334u8x9y2"
+# Generated filenames will look like: "izkpm55j334u8x9y2a"
 ```
 
 ##### Session Token Configuration
@@ -611,7 +612,7 @@ end
 
 ```ruby
 # Find by opaque ID (returns nil if not found)
-user = User.find_by_opaque_id("izkpm55j334u8x9y2")
+user = User.find_by_opaque_id("izkpm55j334u8x9y2a")
 if user
   puts "Found user: #{user.name}"
 else
@@ -619,7 +620,7 @@ else
 end
 
 # Find by opaque ID (raises ActiveRecord::RecordNotFound if not found)
-user = User.find_by_opaque_id!("izkpm55j334u8x9y2")
+user = User.find_by_opaque_id!("izkpm55j334u8x9y2a")
 puts "Found user: #{user.name}"
 
 # Use in controllers for public-facing URLs
@@ -667,14 +668,14 @@ rails generate opaque_id:install users --column-name=public_id
 
 OpaqueId provides comprehensive configuration options to customize ID generation behavior:
 
-| Option                           | Type            | Default                 | Description                                     | Example Usage                                           |
-| -------------------------------- | --------------- | ----------------------- | ----------------------------------------------- | ------------------------------------------------------- |
-| `opaque_id_column`               | `Symbol`        | `:opaque_id`            | Column name for storing the opaque ID           | `self.opaque_id_column = :public_id`                    |
-| `opaque_id_length`               | `Integer`       | `21`                    | Length of generated IDs                         | `self.opaque_id_length = 32`                            |
-| `opaque_id_alphabet`             | `String`        | `ALPHANUMERIC_ALPHABET` | Character set for ID generation                 | `self.opaque_id_alphabet = OpaqueId::STANDARD_ALPHABET` |
-| `opaque_id_require_letter_start` | `Boolean`       | `false`                 | Require ID to start with a letter               | `self.opaque_id_require_letter_start = true`            |
-| `opaque_id_purge_chars`          | `Array<String>` | `[]`                    | Characters to remove from generated IDs         | `self.opaque_id_purge_chars = ['0', 'O', 'I', 'l']`     |
-| `opaque_id_max_retry`            | `Integer`       | `3`                     | Maximum retry attempts for collision resolution | `self.opaque_id_max_retry = 10`                         |
+| Option                           | Type            | Default              | Description                                     | Example Usage                                           |
+| -------------------------------- | --------------- | -------------------- | ----------------------------------------------- | ------------------------------------------------------- |
+| `opaque_id_column`               | `Symbol`        | `:opaque_id`         | Column name for storing the opaque ID           | `self.opaque_id_column = :public_id`                    |
+| `opaque_id_length`               | `Integer`       | `18`                 | Length of generated IDs                         | `self.opaque_id_length = 32`                            |
+| `opaque_id_alphabet`             | `String`        | `SLUG_LIKE_ALPHABET` | Character set for ID generation                 | `self.opaque_id_alphabet = OpaqueId::STANDARD_ALPHABET` |
+| `opaque_id_require_letter_start` | `Boolean`       | `false`              | Require ID to start with a letter               | `self.opaque_id_require_letter_start = true`            |
+| `opaque_id_purge_chars`          | `Array<String>` | `[]`                 | Characters to remove from generated IDs         | `self.opaque_id_purge_chars = ['0', 'O', 'I', 'l']`     |
+| `opaque_id_max_retry`            | `Integer`       | `3`                  | Maximum retry attempts for collision resolution | `self.opaque_id_max_retry = 10`                         |
 
 ### Configuration Details
 
@@ -691,7 +692,7 @@ OpaqueId provides comprehensive configuration options to customize ID generation
 - **Performance**: Longer IDs are more secure but use more storage
 - **Examples**:
   - `6` → Short URLs: `"V1StGX"`
-  - `18` → Default: `"izkpm55j334u8x9y2"`
+  - `18` → Default: `"izkpm55j334u8x9y2a"`
   - `32` → API Keys: `"izkpm55j334u8x9y2abc1234def5678gh"`
 
 #### `opaque_id_alphabet`
@@ -710,7 +711,7 @@ OpaqueId provides comprehensive configuration options to customize ID generation
 - **Purpose**: Ensures IDs start with a letter for better readability
 - **Use Cases**: When IDs are user-facing or need to be easily readable
 - **Performance**: Slight overhead due to rejection sampling
-- **Example**: `true` → `"izkpm55j334u8x9y2"`, `false` → `"zkpm55j334u8x9y2"`
+- **Example**: `true` → `"izkpm55j334u8x9y2a"`, `false` → `"zkpm55j334u8x9y2a"`
 
 #### `opaque_id_purge_chars`
 
@@ -1667,6 +1668,27 @@ This software is provided "as is" without warranty of any kind, express or impli
 
 Everyone interacting in the OpaqueId project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/nyaggah/opaque_id/blob/main/CODE_OF_CONDUCT.md).
 
+## Performance & Benchmarks
+
+You can run benchmarks to test OpaqueId's performance and uniqueness characteristics on your system.
+
+**Quick Test:**
+
+```bash
+# Test 10,000 ID generation
+ruby -e "require 'opaque_id'; start=Time.now; 10000.times{OpaqueId.generate}; puts \"Generated 10,000 IDs in #{(Time.now-start).round(4)}s\""
+
+# Compare with SecureRandom (as mentioned in nanoid.rb issue #67)
+ruby -e "require 'opaque_id'; require 'securerandom'; puts 'OpaqueId: ' + OpaqueId.generate; puts 'SecureRandom: ' + SecureRandom.urlsafe_base64"
+```
+
+**Expected Results:**
+
+- **Performance**: 100,000+ IDs per second on modern hardware
+- **Uniqueness**: Zero collisions in practice (theoretical probability < 10^-16 for 1M IDs)
+
+For comprehensive benchmarks including collision tests, alphabet distribution analysis, and performance comparisons, see the [Benchmarks Guide](docs/benchmarks.md).
+
 ## Acknowledgements
 
 OpaqueId is heavily inspired by [nanoid.rb](https://github.com/radeno/nanoid.rb), which is a Ruby implementation of the original [NanoID](https://github.com/ai/nanoid) project. The core algorithm and approach to secure ID generation draws from the excellent work done by the NanoID team.

data/docs/api-reference.md

@@ -19,20 +19,20 @@ The main module for generating opaque IDs.
 
 ### Constants
 
-#### ALPHANUMERIC_ALPHABET
+#### SLUG_LIKE_ALPHABET
 
 Default alphabet for ID generation.
 
 ```ruby
-OpaqueId::ALPHANUMERIC_ALPHABET
-# => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+OpaqueId::SLUG_LIKE_ALPHABET
+# => "0123456789abcdefghijklmnopqrstuvwxyz"
 ```
 
 **Characteristics:**
 
-- **Length**: 62 characters
-- **Characters**: A-Z, a-z, 0-9
-- **Use case**: General purpose, URL-safe
+- **Length**: 36 characters
+- **Characters**: 0-9, a-z
+- **Use case**: URL-friendly, double-click selectable
 - **Performance**: Good
 
 #### STANDARD_ALPHABET

data/docs/benchmarks.md

@@ -0,0 +1,385 @@
+# OpaqueId Benchmarks
+
+This document provides benchmark scripts that you can run to test OpaqueId's performance and uniqueness characteristics on your own system.
+
+## Performance Benchmarks
+
+### SecureRandom Comparison Test
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+require 'securerandom'
+
+puts "OpaqueId vs SecureRandom Comparison"
+puts "=" * 50
+
+# Test different Ruby standard library methods
+methods = {
+  'OpaqueId.generate' => -> { OpaqueId.generate },
+  'SecureRandom.urlsafe_base64' => -> { SecureRandom.urlsafe_base64 },
+  'SecureRandom.urlsafe_base64(16)' => -> { SecureRandom.urlsafe_base64(16) },
+  'SecureRandom.hex(9)' => -> { SecureRandom.hex(9) },
+  'SecureRandom.alphanumeric(18)' => -> { SecureRandom.alphanumeric(18) }
+}
+
+count = 10000
+
+puts "Performance comparison (#{count} IDs each):"
+puts "-" * 50
+
+methods.each do |name, method|
+  start_time = Time.now
+  ids = count.times.map { method.call }
+  end_time = Time.now
+  duration = end_time - start_time
+  rate = (count / duration).round(0)
+
+  # Check uniqueness
+  unique_count = ids.uniq.length
+  collisions = count - unique_count
+
+  # Check characteristics
+  sample_id = ids.first
+  length = sample_id.length
+  has_uppercase = sample_id.match?(/[A-Z]/)
+  has_lowercase = sample_id.match?(/[a-z]/)
+  has_numbers = sample_id.match?(/[0-9]/)
+  has_special = sample_id.match?(/[^A-Za-z0-9]/)
+
+  puts "#{name.ljust(30)}: #{duration.round(4)}s (#{rate} IDs/sec)"
+  puts "  Length: #{length}, Collisions: #{collisions}"
+  puts "  Sample: '#{sample_id}'"
+  puts "  Chars: #{has_uppercase ? 'A-Z' : ''}#{has_lowercase ? 'a-z' : ''}#{has_numbers ? '0-9' : ''}#{has_special ? 'special' : ''}"
+  puts
+end
+
+puts "Comparison completed."
+```
+
+### Basic Performance Test
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+
+puts "OpaqueId Performance Benchmark"
+puts "=" * 40
+
+# Test different batch sizes
+[100, 1000, 10000, 100000].each do |count|
+  start_time = Time.now
+  count.times { OpaqueId.generate }
+  end_time = Time.now
+  duration = end_time - start_time
+  rate = (count / duration).round(0)
+
+  puts "#{count.to_s.rjust(6)} IDs: #{duration.round(4)}s (#{rate} IDs/sec)"
+end
+
+puts "\nPerformance test completed."
+```
+
+### Alphabet Performance Comparison
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+
+puts "Alphabet Performance Comparison"
+puts "=" * 40
+
+alphabets = {
+  'SLUG_LIKE_ALPHABET' => OpaqueId::SLUG_LIKE_ALPHABET,
+  'ALPHANUMERIC_ALPHABET' => OpaqueId::ALPHANUMERIC_ALPHABET,
+  'STANDARD_ALPHABET' => OpaqueId::STANDARD_ALPHABET
+}
+
+count = 10000
+
+alphabets.each do |name, alphabet|
+  start_time = Time.now
+  count.times { OpaqueId.generate(alphabet: alphabet) }
+  end_time = Time.now
+  duration = end_time - start_time
+  rate = (count / duration).round(0)
+
+  puts "#{name.ljust(20)}: #{duration.round(4)}s (#{rate} IDs/sec)"
+end
+
+puts "\nAlphabet comparison completed."
+```
+
+### Size Performance Test
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+
+puts "Size Performance Test"
+puts "=" * 40
+
+sizes = [8, 12, 18, 24, 32, 48, 64]
+count = 10000
+
+sizes.each do |size|
+  start_time = Time.now
+  count.times { OpaqueId.generate(size: size) }
+  end_time = Time.now
+  duration = end_time - start_time
+  rate = (count / duration).round(0)
+
+  puts "Size #{size.to_s.rjust(2)}: #{duration.round(4)}s (#{rate} IDs/sec)"
+end
+
+puts "\nSize performance test completed."
+```
+
+## Uniqueness Tests
+
+### Collision Probability Test
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+
+puts "Collision Probability Test"
+puts "=" * 40
+
+# Test different sample sizes
+[1000, 10000, 100000].each do |count|
+  puts "\nTesting #{count} IDs..."
+
+  start_time = Time.now
+  ids = count.times.map { OpaqueId.generate }
+  end_time = Time.now
+
+  unique_ids = ids.uniq
+  collisions = count - unique_ids.length
+  collision_rate = (collisions.to_f / count * 100).round(6)
+
+  puts "  Generated: #{count} IDs in #{(end_time - start_time).round(4)}s"
+  puts "  Unique: #{unique_ids.length} IDs"
+  puts "  Collisions: #{collisions} (#{collision_rate}%)"
+  puts "  Uniqueness: #{collision_rate == 0 ? '✅ Perfect' : '⚠️  Collisions detected'}"
+end
+
+puts "\nCollision test completed."
+```
+
+### Birthday Paradox Test
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+
+puts "Birthday Paradox Test"
+puts "=" * 40
+
+# Test the birthday paradox with different sample sizes
+# For 18-character slug-like alphabet (36 chars), we have 36^18 possible combinations
+# This is approximately 10^28, so collisions should be extremely rare
+
+sample_sizes = [1000, 10000, 50000, 100000]
+
+sample_sizes.each do |count|
+  puts "\nTesting #{count} IDs for birthday paradox..."
+
+  start_time = Time.now
+  ids = count.times.map { OpaqueId.generate }
+  end_time = Time.now
+
+  unique_ids = ids.uniq
+  collisions = count - unique_ids.length
+
+  # Calculate theoretical collision probability
+  # For 18-char slug-like alphabet: 36^18 ≈ 10^28 possible combinations
+  alphabet_size = 36
+  id_length = 18
+  total_possibilities = alphabet_size ** id_length
+
+  # Approximate birthday paradox probability
+  # P(collision) ≈ 1 - e^(-n(n-1)/(2*N)) where n=sample_size, N=total_possibilities
+  n = count
+  N = total_possibilities
+  theoretical_prob = 1 - Math.exp(-(n * (n - 1)) / (2.0 * N))
+
+  puts "  Sample size: #{count}"
+  puts "  Total possibilities: #{total_possibilities.to_s.reverse.gsub(/(\d{3})(?=.)/, '\1,').reverse}"
+  puts "  Theoretical collision probability: #{theoretical_prob.round(20)}"
+  puts "  Actual collisions: #{collisions}"
+  puts "  Result: #{collisions == 0 ? '✅ No collisions (as expected)' : '⚠️  Collisions detected'}"
+end
+
+puts "\nBirthday paradox test completed."
+```
+
+### Alphabet Distribution Test
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'opaque_id'
+
+puts "Alphabet Distribution Test"
+puts "=" * 40
+
+# Test that all characters in the alphabet are used roughly equally
+alphabet = OpaqueId::SLUG_LIKE_ALPHABET
+count = 100000
+
+puts "Testing distribution for #{alphabet.length}-character alphabet..."
+puts "Sample size: #{count} IDs"
+
+start_time = Time.now
+ids = count.times.map { OpaqueId.generate }
+end_time = Time.now
+
+# Count character frequency
+char_counts = Hash.new(0)
+ids.each do |id|
+  id.each_char { |char| char_counts[char] += 1 }
+end
+
+total_chars = ids.join.length
+expected_per_char = total_chars.to_f / alphabet.length
+
+puts "\nCharacter distribution:"
+puts "Character | Count | Expected | Deviation"
+puts "-" * 45
+
+alphabet.each_char do |char|
+  count = char_counts[char]
+  deviation = ((count - expected_per_char) / expected_per_char * 100).round(2)
+  puts "#{char.ljust(8)} | #{count.to_s.rjust(5)} | #{expected_per_char.round(1).to_s.rjust(8)} | #{deviation.to_s.rjust(6)}%"
+end
+
+# Calculate chi-square test for uniform distribution
+chi_square = alphabet.each_char.sum do |char|
+  observed = char_counts[char]
+  expected = expected_per_char
+  ((observed - expected) ** 2) / expected
+end
+
+puts "\nChi-square statistic: #{chi_square.round(4)}"
+puts "Distribution: #{chi_square < 30 ? '✅ Appears uniform' : '⚠️  May not be uniform'}"
+
+puts "\nDistribution test completed."
+```
+
+## Running the Benchmarks
+
+### Quick Performance Test
+
+```bash
+# Run basic performance test
+ruby -e "
+require 'opaque_id'
+puts 'OpaqueId Performance Test'
+puts '=' * 30
+[100, 1000, 10000].each do |count|
+  start = Time.now
+  count.times { OpaqueId.generate }
+  duration = Time.now - start
+  rate = (count / duration).round(0)
+  puts \"#{count.to_s.rjust(5)} IDs: #{duration.round(4)}s (#{rate} IDs/sec)\"
+end
+"
+```
+
+### Quick Uniqueness Test
+
+```bash
+# Run basic uniqueness test
+ruby -e "
+require 'opaque_id'
+puts 'OpaqueId Uniqueness Test'
+puts '=' * 30
+count = 10000
+ids = count.times.map { OpaqueId.generate }
+unique = ids.uniq
+collisions = count - unique.length
+puts \"Generated: #{count} IDs\"
+puts \"Unique: #{unique.length} IDs\"
+puts \"Collisions: #{collisions}\"
+puts \"Result: #{collisions == 0 ? 'Perfect uniqueness' : 'Collisions detected'}\"
+"
+```
+
+## Expected Results
+
+### Performance Expectations
+
+On a modern system, you should expect:
+
+- **100 IDs**: < 0.001s (100,000+ IDs/sec)
+- **1,000 IDs**: < 0.01s (100,000+ IDs/sec)
+- **10,000 IDs**: < 0.1s (100,000+ IDs/sec)
+- **100,000 IDs**: < 1s (100,000+ IDs/sec)
+
+### Uniqueness Expectations
+
+- **1,000 IDs**: 0 collisions (100% unique)
+- **10,000 IDs**: 0 collisions (100% unique)
+- **100,000 IDs**: 0 collisions (100% unique)
+- **1,000,000 IDs**: 0 collisions (100% unique)
+
+The theoretical collision probability for 1 million IDs is approximately 10^-16, making collisions virtually impossible in practice.
+
+## System Requirements
+
+These benchmarks require:
+
+- Ruby 2.7+ (for optimal performance)
+- OpaqueId gem installed
+- Sufficient memory for large sample sizes
+
+For the largest tests (100,000+ IDs), ensure you have at least 100MB of available memory.
+
+## Why Not Just Use SecureRandom?
+
+Ruby's `SecureRandom` already provides secure random generation. Here's how OpaqueId compares:
+
+### SecureRandom.urlsafe_base64 vs OpaqueId
+
+| Feature                      | SecureRandom.urlsafe_base64     | OpaqueId.generate            |
+| ---------------------------- | ------------------------------- | ---------------------------- |
+| **Length**                   | 22 characters (fixed)           | 18 characters (configurable) |
+| **Alphabet**                 | A-Z, a-z, 0-9, -, \_ (64 chars) | 0-9, a-z (36 chars)          |
+| **URL Safety**               | ✅ Yes                          | ✅ Yes                       |
+| **Double-click selectable**  | ❌ No (contains special chars)  | ✅ Yes (no special chars)    |
+| **Configurable length**      | ❌ No                           | ✅ Yes                       |
+| **Configurable alphabet**    | ❌ No                           | ✅ Yes                       |
+| **ActiveRecord integration** | ❌ Manual                       | ✅ Built-in                  |
+| **Rails generator**          | ❌ No                           | ✅ Yes                       |
+
+### When to Use Each
+
+**Use SecureRandom.urlsafe_base64 when:**
+
+- You need maximum entropy (22 chars vs 18)
+- You don't mind special characters (-, \_)
+- You don't need double-click selection
+- You're building a simple solution
+
+**Use OpaqueId when:**
+
+- You want slug-like IDs (no special characters)
+- You need double-click selectable IDs
+- You want configurable length and alphabet
+- You're using ActiveRecord models
+- You want consistent ID length (default: 18 characters)
+
+### Performance Comparison
+
+Run the [SecureRandom Comparison Test](#securerandom-comparison-test) to see how OpaqueId compares to various SecureRandom methods on your system.
+
+### Migration from nanoid.rb
+
+The nanoid.rb gem is [considered obsolete](https://github.com/radeno/nanoid.rb/issues/67) for Ruby 2.7+ because SecureRandom provides similar functionality. OpaqueId provides an alternative with different defaults and Rails integration.

data/docs/configuration.md

@@ -26,10 +26,10 @@ class User < ApplicationRecord
   # Custom column name
   self.opaque_id_column = :public_id
 
-  # Custom length (default: 21)
+  # Custom length (default: 18)
   self.opaque_id_length = 15
 
-  # Custom alphabet (default: ALPHANUMERIC_ALPHABET)
+  # Custom alphabet (default: SLUG_LIKE_ALPHABET)
   self.opaque_id_alphabet = OpaqueId::STANDARD_ALPHABET
 
   # Require letter start (default: false)
@@ -45,14 +45,14 @@ end
 
 ### Configuration Options Reference
 
-| Option                           | Type    | Default                 | Description                                   |
-| -------------------------------- | ------- | ----------------------- | --------------------------------------------- |
-| `opaque_id_column`               | Symbol  | `:opaque_id`            | Column name for storing the opaque ID         |
-| `opaque_id_length`               | Integer | `21`                    | Length of generated IDs                       |
-| `opaque_id_alphabet`             | String  | `ALPHANUMERIC_ALPHABET` | Character set for ID generation               |
-| `opaque_id_require_letter_start` | Boolean | `false`                 | Require IDs to start with a letter            |
-| `opaque_id_max_retry`            | Integer | `3`                     | Maximum retry attempts for collision handling |
-| `opaque_id_purge_chars`          | Array   | `[]`                    | Characters to exclude from generated IDs      |
+| Option                           | Type    | Default              | Description                                   |
+| -------------------------------- | ------- | -------------------- | --------------------------------------------- |
+| `opaque_id_column`               | Symbol  | `:opaque_id`         | Column name for storing the opaque ID         |
+| `opaque_id_length`               | Integer | `18`                 | Length of generated IDs                       |
+| `opaque_id_alphabet`             | String  | `SLUG_LIKE_ALPHABET` | Character set for ID generation               |
+| `opaque_id_require_letter_start` | Boolean | `false`              | Require IDs to start with a letter            |
+| `opaque_id_max_retry`            | Integer | `3`                  | Maximum retry attempts for collision handling |
+| `opaque_id_purge_chars`          | Array   | `[]`                 | Characters to exclude from generated IDs      |
 
 ## Global Configuration
 
@@ -97,12 +97,25 @@ end
 
 ### Built-in Alphabets
 
-#### ALPHANUMERIC_ALPHABET (Default)
+#### SLUG_LIKE_ALPHABET (Default)
+
+```ruby
+# Characters: 0-9, a-z (36 characters)
+# Use case: URL-safe, double-click selectable, no confusing characters
+# Example output: "izkpm55j334u8x9y2a"
+
+class User < ApplicationRecord
+  include OpaqueId::Model
+  self.opaque_id_alphabet = OpaqueId::SLUG_LIKE_ALPHABET
+end
+```
+
+#### ALPHANUMERIC_ALPHABET
 
 ```ruby
 # Characters: A-Z, a-z, 0-9 (62 characters)
 # Use case: General purpose, URL-safe
-# Example output: "V1StGXR8_Z5jdHi6B-myT"
+# Example output: "V1StGXR8Z5jdHi6BmyT"
 
 class User < ApplicationRecord
   include OpaqueId::Model
@@ -240,9 +253,9 @@ end
 # Now the methods use the custom column name
 user = User.create!(name: "John Doe")
 puts user.public_id
-# => "V1StGXR8_Z5jdHi6B-myT"
+# => "izkpm55j334u8x9y2a"
 
-user = User.find_by_public_id("V1StGXR8_Z5jdHi6B-myT")
+user = User.find_by_public_id("izkpm55j334u8x9y2a")
 ```
 
 ### Multiple Column Names
@@ -279,7 +292,7 @@ end
 # This will retry until it generates an ID starting with a letter
 user = User.create!(name: "John Doe")
 puts user.opaque_id
-# => "V1StGXR8_Z5jdHi6B-myT" (starts with 'V')
+# => "izkpm55j334u8x9y2a" (starts with 'i')
 ```
 
 ### Character Purging
@@ -295,7 +308,7 @@ end
 # Generated IDs will not contain these characters
 user = User.create!(name: "John Doe")
 puts user.opaque_id
-# => "V1StGXR8_Z5jdHi6B-myT" (no '0', 'O', 'l', 'I')
+# => "izkpm55j334u8x9y2a" (no '0', 'O', 'l', 'I')
 ```
 
 ## Collision Handling Configuration
@@ -496,8 +509,8 @@ class UserTest < ActiveSupport::TestCase
     user = User.new(name: "Test User")
 
     assert user.valid?
-    assert_equal 21, user.class.opaque_id_length
-    assert_equal OpaqueId::ALPHANUMERIC_ALPHABET, user.class.opaque_id_alphabet
+    assert_equal 18, user.class.opaque_id_length
+    assert_equal OpaqueId::SLUG_LIKE_ALPHABET, user.class.opaque_id_alphabet
   end
 
   test "opaque_id generation works with custom configuration" do
@@ -523,6 +536,7 @@ end
 
 ### 2. Select Suitable Alphabets
 
+- **SLUG_LIKE_ALPHABET** (default): URL-safe, double-click selectable, no confusing characters
 - **ALPHANUMERIC_ALPHABET**: General purpose, URL-safe
 - **STANDARD_ALPHABET**: Fastest generation, URL-safe
 - **Custom alphabets**: Specific requirements (numeric, hexadecimal, etc.)

data/docs/index.md

@@ -57,10 +57,10 @@ end
 
 # Create a user - opaque_id is automatically generated
 user = User.create!(name: "John Doe")
-puts user.opaque_id # => "izkpm55j334u8x9y2"
+puts user.opaque_id # => "izkpm55j334u8x9y2a"
 
 # Find by opaque_id
-user = User.find_by_opaque_id("izkpm55j334u8x9y2")
+user = User.find_by_opaque_id("izkpm55j334u8x9y2a")
 ```
 
 ## Why OpaqueId?
@@ -128,6 +128,24 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 This project follows an "open source, closed contribution" model. We welcome bug reports, feature requests, and documentation improvements through GitHub Issues.
 
+## Performance & Benchmarks
+
+You can run benchmarks to test OpaqueId's performance and uniqueness characteristics on your system.
+
+**Quick Test:**
+
+```bash
+# Test 10,000 ID generation
+ruby -e "require 'opaque_id'; start=Time.now; 10000.times{OpaqueId.generate}; puts \"Generated 10,000 IDs in #{(Time.now-start).round(4)}s\""
+```
+
+**Expected Results:**
+
+- **Performance**: 100,000+ IDs per second on modern hardware
+- **Uniqueness**: Zero collisions in practice (theoretical probability < 10^-16 for 1M IDs)
+
+For comprehensive benchmarks including collision tests, alphabet distribution analysis, and performance comparisons, see the [Benchmarks Guide](benchmarks.md).
+
 ## Acknowledgements
 
 - [nanoid.rb](https://github.com/radeno/nanoid.rb) - Original inspiration and reference implementation

data/docs/usage.md

@@ -22,11 +22,11 @@ OpaqueId can be used independently of ActiveRecord for generating secure, random
 ```ruby
 # Generate a default opaque ID (18 characters, slug-like)
 id = OpaqueId.generate
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 
 # Generate multiple IDs
 ids = 5.times.map { OpaqueId.generate }
-# => ["V1StGXR8_Z5jdHi6B-myT", "K8jH2mN9_pL3qR7sT1v", ...]
+# => ["izkpm55j334u8x9y2a", "k8jh2mn9pl3qr7st1v", ...]
 ```
 
 ### Custom Parameters
@@ -38,23 +38,27 @@ id = OpaqueId.generate(size: 10)
 
 # Custom alphabet
 id = OpaqueId.generate(alphabet: OpaqueId::STANDARD_ALPHABET)
-# => "izkpm55j334u8x9y2"
+# => "V1StGXR8_Z5jdHi6B-myT"
 
 # Both custom length and alphabet
 id = OpaqueId.generate(size: 15, alphabet: OpaqueId::STANDARD_ALPHABET)
-# => "izkpm55j334u8x9y"
+# => "V1StGXR8_Z5jdHi6B"
 ```
 
 ### Built-in Alphabets
 
 ```ruby
-# Alphanumeric alphabet (default) - A-Z, a-z, 0-9
+# Slug-like alphabet (default) - 0-9, a-z
+id = OpaqueId.generate(alphabet: OpaqueId::SLUG_LIKE_ALPHABET)
+# => "izkpm55j334u8x9y2a"
+
+# Alphanumeric alphabet - A-Z, a-z, 0-9
 id = OpaqueId.generate(alphabet: OpaqueId::ALPHANUMERIC_ALPHABET)
-# => "izkpm55j334u8x9y2"
+# => "V1StGXR8Z5jdHi6BmyT"
 
 # Standard alphabet - A-Z, a-z, 0-9, -, _
 id = OpaqueId.generate(alphabet: OpaqueId::STANDARD_ALPHABET)
-# => "izkpm55j334u8x9y2"
+# => "V1StGXR8_Z5jdHi6B-myT"
 ```
 
 ### Custom Alphabets
@@ -94,7 +98,7 @@ end
 # Create a new user - opaque_id is automatically generated
 user = User.create!(name: "John Doe", email: "john@example.com")
 puts user.opaque_id
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 
 # The ID is generated before the record is saved
 user = User.new(name: "Jane Smith")
@@ -103,17 +107,17 @@ puts user.opaque_id
 
 user.save!
 puts user.opaque_id
-# => "K8jH2mN9_pL3qR7sT1v" (generated on save)
+# => "k8jh2mn9pl3qr7st1va" (generated on save)
 ```
 
 ### Finder Methods
 
 ```ruby
 # Find by opaque_id (returns nil if not found)
-user = User.find_by_opaque_id("izkpm55j334u8x9y2")
+user = User.find_by_opaque_id("izkpm55j334u8x9y2a")
 
 # Find by opaque_id (raises exception if not found)
-user = User.find_by_opaque_id!("izkpm55j334u8x9y2")
+user = User.find_by_opaque_id!("izkpm55j334u8x9y2a")
 # => ActiveRecord::RecordNotFound if not found
 
 # Use in scopes
@@ -123,7 +127,7 @@ class User < ApplicationRecord
   scope :by_opaque_id, ->(id) { where(opaque_id: id) }
 end
 
-users = User.by_opaque_id("izkpm55j334u8x9y2")
+users = User.by_opaque_id("izkpm55j334u8x9y2a")
 ```
 
 ### Custom Column Names
@@ -139,9 +143,9 @@ end
 # Now the methods use the custom column name
 user = User.create!(name: "John Doe")
 puts user.public_id
-# => "izkpm55j334u8x9y2"
+# => "izkpm55j334u8x9y2a"
 
-user = User.find_by_public_id("V1StGXR8_Z5jdHi6B-myT")
+user = User.find_by_public_id("izkpm55j334u8x9y2a")
 ```
 
 ## Rails Generator
@@ -259,7 +263,7 @@ end
 # Create a user
 user = User.create!(name: "John Doe", email: "john@example.com")
 puts user.opaque_id
-# => "izkpm55j334u8x9y2" (starts with letter)
+# => "izkpm55j334u8x9y2a" (starts with letter)
 
 # Use in user profiles
 user_url(user.opaque_id)
@@ -273,7 +277,7 @@ user_url(user.opaque_id)
 ```ruby
 # Generate multiple IDs at once
 ids = 100.times.map { OpaqueId.generate }
-# => ["V1StGXR8_Z5jdHi6B-myT", "K8jH2mN9_pL3qR7sT1v", ...]
+# => ["izkpm55j334u8x9y2a", "k8jh2mn9pl3qr7st1va", ...]
 
 # Use in bulk operations
 users_data = ids.map.with_index do |id, index|

data/lib/generators/opaque_id/install_generator.rb

@@ -15,8 +15,12 @@ module OpaqueId
       class_option :column_name, type: :string, default: 'opaque_id',
                                  desc: 'Name of the column to add'
 
+      class_option :limit, type: :numeric, default: 21,
+                           desc: 'Column limit for the opaque_id string (default: 21)'
+
       def create_migration_file
         if model_name.present?
+          validate_limit_option
           table_name = model_name.tableize
           migration_template 'migration.rb.tt',
                              "db/migrate/add_opaque_id_to_#{table_name}.rb"
@@ -26,11 +30,20 @@ module OpaqueId
           say 'Usage: rails generate opaque_id:install ModelName', :red
           say 'Example: rails generate opaque_id:install User', :green
           say 'Example: rails generate opaque_id:install Post --column-name=public_id', :green
+          say 'Example: rails generate opaque_id:install Post --limit=25', :green
         end
       end
 
       private
 
+      def validate_limit_option
+        # Default OpaqueId length is 18, so limit should be at least that
+        return unless options[:limit] < 18
+
+        say "Warning: Column limit (#{options[:limit]}) is less than the default OpaqueId length (18).", :yellow
+        say 'Consider using --limit=21 or higher to avoid truncation issues.', :yellow
+      end
+
       def add_include_to_model
         model_path = "app/models/#{model_name.underscore}.rb"
 

data/lib/generators/opaque_id/templates/migration.rb.tt

@@ -1,6 +1,6 @@
-class AddOpaqueIdTo<%= table_name.camelize %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+class AddOpaqueIdTo<%= model_name.tableize.camelize %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-    add_column :<%= table_name %>, :<%= options[:column_name] %>, :string
-    add_index :<%= table_name %>, :<%= options[:column_name] %>, unique: true
+    add_column :<%= model_name.tableize %>, :<%= options[:column_name] %>, :string, limit: <%= options[:limit] %>
+    add_index :<%= model_name.tableize %>, :<%= options[:column_name] %>, unique: true
   end
 end

data/lib/opaque_id/model.rb

@@ -30,7 +30,7 @@ module OpaqueId
       end
 
       def opaque_id_length
-        @opaque_id_length ||= 21
+        @opaque_id_length ||= 18
       end
 
       def opaque_id_length=(value)
@@ -38,7 +38,7 @@ module OpaqueId
       end
 
       def opaque_id_alphabet
-        @opaque_id_alphabet ||= OpaqueId::ALPHANUMERIC_ALPHABET
+        @opaque_id_alphabet ||= OpaqueId::SLUG_LIKE_ALPHABET
       end
 
       def opaque_id_alphabet=(value)

data/lib/opaque_id/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpaqueId
-  VERSION = '1.6.0'
+  VERSION = '1.7.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opaque_id
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Joe Nyaggah
@@ -140,6 +140,7 @@ files:
 - docs/assets/css/custom.scss
 - docs/assets/images/favicon.svg
 - docs/assets/images/og-image.svg
+- docs/benchmarks.md
 - docs/configuration.md
 - docs/development.md
 - docs/getting-started.md