encoded_id-rails 1.0.0.beta3 → 1.0.0.rc6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a38e6af88bf9343e2e4d22a82eb4c4d87766e962f3a8d330bf6aad1ad374639
-  data.tar.gz: 3ea6b28d604d3f728da545d324f50b12845f2feb9b7ed83c32349e002cdb6c93
+  metadata.gz: 45d2f2c1637f43c14a714d4051ec7a1692a8267234ea90c302da97872b2da7b0
+  data.tar.gz: 26030ffcef1dc8798d0919a68faf4ec5bb6d17c3a28730eee0d2bb1e9ecb8e3e
 SHA512:
-  metadata.gz: b03bc14efe460f8f479f109d32a4197c88cc85b72d87b7aa348e40057c4ae540728f5f3c383b943460ebbfdcfdd7e3173c363dbb423026386331fe17ea7e50e8
-  data.tar.gz: 5a6f16dc29c1c43450f278e08b7c82e597e13a70b4ea5183cbcc97d690307c6b847b5fef8cd594cb0f1396aca685beac78a8c427826b2003a1b2820b319793a3
+  metadata.gz: 05ca59de2b281917cb214cfaeb9a94c7453aba4a64d8e89ac484a583030839a192d5242a774bc511e78d6667c47d11bca27bb3a0b096aefa6c2aad3e3c39ad84
+  data.tar.gz: e3cc3563234d3c13d10f34c55cc77b14f3a7c55e3b391d679d5c2239f39b272cd3e4a02c614f0638a20db815d1c425fd58c334a3b842d0cdb8c88a2c26e6e655

data/CHANGELOG.md

@@ -1,31 +1,90 @@
 ## [Unreleased]
 
-## [1.0.0] - (in beta)
+## [2.0.0.alpha1] - unreleased
 
 ### Breaking changes
 
-- Ruby 2.7.x support dropped. The minimum supported Ruby version is now 3.0.0.
-- `#encoded_id` now defaults to returning an 'annotated' ID, one in which a prefix is added to the encoded ID to indicate 
-  the 'type' of the record the ID represents. This can be disabled. IDs generated by older versions of this gem will 
-  decode correctly. But not that IDs generated by this version onwards will not decode correctly by older versions of this 
-  gem so make sure to disable annotation if you need to support older versions of this gem.
-- `#name_for_encoded_id_slug` no longer provides a default implementation, it is up to the user to define this method,
-  or configure the gem to use a different method name.
-- `#slugged_encoded_id` no longer takes a `with:` parameter. To specify the name of the method to call to generate the
-  slug, use the `slug_value_method_name` configuration option.
+- `ReversibleId` now no longer downcases the encodedid input string by default on decode, ie the `decode` option `downcase` is now `false`. In a future release the `downcase` option will be removed.
+- The default encoding engine is now `:sqids` to reflect the official "deprecated" status of `Hashid`s (see https://sqids.org/faq#why-hashids) 
+- Ruby < 3.2 support dropped. The minimum supported Ruby version is now 3.2.0
+
+**Important!!: `:sqids` are not compatible with `:hashids`, DO NOT CHANGE FROM ONE TO THE OTHER AFTER GOING LIVE.**
+
+## [1.0.0.rc6] - 2025-11-17
+
+### Breaking changes
+
+- Empty array inputs will now raise `InvalidInputError`
 
 ### Added
 
-- `#encoded_id_hash` has been added to return only the encoded ID without an annotation prefix. If annotation is disabled, 
-  this method is basically an alias to `#encoded_id`.
-- `.find_all_by_encoded_id` has been added to return all records matching the given encoded ID. This will return all
-  matching records whose IDs are encoded in the encoded_id. Missing records are ignored.
-- `.find_all_by_encoded_id!` like `.find_all_by_encoded_id` but raises an `ActiveRecord::RecordNotFound` exception if
-  *any* of the records are not found.
+- Added support for [Sqids](https://sqids.org) as an alternative ID encoding engine. The default remains HashIds for backward compatibility. 
+- New encoder abstraction layer allows switching between HashIds and Sqids via the `encoder: :sqids` or `encoder: :hashids` parameter to `ReversibleId.new`.
+- Support for blocklists in both HashIds and Sqids encoders to prevent generating IDs containing specific words. Use the `blocklist` parameter with a `Set` or `Array` of strings to `ReversibleId.new`. For Hashids encodings, an error will be raised if a generated ID contains a blocklisted word. For Sqids a new ID is generated that does not contain the block word.
+
+### Added (Rails integration)
+
+- Merged `encoded_id-rails` gem into the monorepo
+- Support for configuring the encoder and blocklist options in Rails through the configuration class
+- `#encoded_id` now defaults to returning an 'annotated' ID, one in which a prefix is added to the encoded ID to indicate the 'type' of the record the ID represents. This can be disabled. IDs generated by older versions of this gem will decode correctly. But note that IDs generated by this version onwards will not decode correctly by older versions of this gem so make sure to disable annotation if you need to support older versions of this gem.
+- New `EncodedId::Rails::Persists` module which adds hooks to the model to persist the encoded ID to the DB (see docs).
+- `#encoded_id_hash` has been added to return only the encoded ID without an annotation prefix. If annotation is disabled, this method is basically an alias to `#encoded_id`.
+- `.find_all_by_encoded_id` has been added to return all records matching the given encoded ID. This will return all matching records whose IDs are encoded in the encoded_id. Missing records are ignored.
+- `.find_all_by_encoded_id!` like `.find_all_by_encoded_id` but raises an `ActiveRecord::RecordNotFound` exception if *any* of the records are not found.
+- `Configuration#model_to_param_returns_encoded_id` to allow `EncodedId::Rails::Model` inclusion to also bring in `EncodedId::Rails::PathParam` automatically.
 
-### Fixed
+### Changed (Rails integration)
+
+- `#name_for_encoded_id_slug` no longer provides a default implementation, it is up to the user to define this method, or configure the gem to use a different method name.
+- `#slugged_encoded_id` no longer takes a `with:` parameter. To specify the name of the method to call to generate the slug, use the `slug_value_method_name` configuration option.
+
+### Fixed (Rails integration)
 
 - `#decode_encoded_id` now raises if the encoded ID is not a string.
+- Handle more cases where a record held onto a memoized `encoded_id` even though its `id` had changed
+
+## [1.0.0.rc5] - 2025-04-09
+
+- `encoded_id` now uses its own implementation of `hashids` which is more efficient and has a smaller memory footprint. This massively reduces the GC churn in high-throughput applications. This is an implementation based on the original `hashids` gem but with many optimisations and improvements. Functionally it is identical to the original `hashids` gem.
+
+## [1.0.0.rc4] - 2024-04-29
+
+- Add an optional `max_inputs_per_id` argument to `ReversibleId`, thanks to [@avcwisesa](https://github.com/avcwisesa)
+- The option `split_with:` can also now be set to nil to disable splitting of the encoded ID string
+
+## [1.0.0.rc3] - 2023-10-23
+
+- Add an optional `max_length` argument to `ReversibleId`, thanks to [@jugglebird](https://github.com/jugglebird)
+- Alphabet validations to prevent whitespace and null chars
+- Add `Alphabet#to_a`, `Alphabet#to_s`, `Alphabet#size` and a custom `Alphabet#inspect`
+- Fixes to input validations
+- hashids are case-sensitive, as are `Alphabet`s, however `ReversibleId` was always `downcase`ing the encodedid input string on decode. A new option has been added to `decode` and `decode_hex`, `downcase`, which defaults to `true`. Thus, the default behaviour is unchanged, but you can opt out to allow mixed case encodedid decode. *Note:* In V2 this will default to `false`.
+
+## [1.0.0.rc2] - 2023-08-07
+
+- `Alphabet` now has `#include?` and `#unique_charaters` methods
+
+## [1.0.0.rc1] - 2023-08-06
+
+- Improved RBS definitions
+- Improved test coverage
+
+## [0.4.0] - 2022-12-04
+
+- Support custom 'split' character which must not be in the alphabet
+- Ability to provide a custom character equivalence mapping
+
+## [0.3.0] - 2022-10-12
+
+- Fix splitting of encoded ID string
+- Checks that integer values to be encoded are positive
+- Experimental support for encoding hex strings
+
+## [0.1.0] - 2022-10-11
+
+- Initial release
+
+## Rails Integration History
 
 ## [0.6.2] - 2023-02-09
 
@@ -64,4 +123,4 @@
 
 ## [0.1.0] - 2022-11-17
 
-- Initial release
+- Initial release of Rails integration

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022 Stephen Ierodiaconou
+Copyright (c) 2022-2024 Stephen Ierodiaconou
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,421 +1,130 @@
-# EncodedId::Rails (`encoded_id-rails`)
+# EncodedId and EncodedId::Rails
 
-`EncodedId::Rails` lets you turn numeric or hex **IDs into reversible and human friendly obfuscated strings**. The gem brings [EncodedId](https://github.com/stevegeek/encoded_id) to Rails and `ActiveRecord` models.
+![Coverage](badges/coverage_badge_total.svg)
+![RubyCritic](badges/rubycritic_badge_score.svg)
 
-You can use it in routes for example, to go from something like `/users/725` to `/users/bob-smith--usr_p5w9-z27j` with miminal effort.
+`encoded_id` lets you encode numerical or hex IDs into obfuscated strings that can be used in URLs. 
 
-## Features
+`encoded_id-rails` is a Rails integration that provides additional features for using `encoded_id` with ActiveRecord models.
 
-Under the hood it uses hashIds, but it offers more features.
+👉 **Full documentation available at [encoded-id.onrender.com](https://encoded-id.onrender.com)**
 
-- 🔄 encoded IDs are reversible (see [`encoded_id`](https://github.com/stevegeek/encoded_id))
-- 💅 supports slugged IDs (eg `my-cool-product-name--p5w9-z27j`) that are URL friendly (assuming your alphabet is too)
-- 🔖 supports annotated IDs to help identify the model the encoded ID belongs to (eg for a `User` the encoded ID might be `user_p5w9-z27j`) 
-- 👓 encoded string can be split into groups of letters to improve human-readability (eg `abcd-efgh`)
-- 👥 supports multiple IDs encoded in one encoded string (eg imagine the encoded ID `7aq60zqw` might decode to two IDs `[78, 45]`)
-- 🔡 supports custom alphabets for the encoded string (at least 16 characters needed)
-  - by default uses a variation of the Crockford reduced character set (https://www.crockford.com/base32.html) 
-  - easily confused characters (eg i and j, 0 and O, 1 and I etc) are mapped to counterpart characters, to 
-    help avoid common readability mistakes when reading/sharing
-  - build in profanity limitation
-
-The gem provides:
-
-- methods to mixin to ActiveRecord models which will allow you to encode and decode IDs, and find
-  or query by encoded IDs
-- sensible defaults to allow you to get started out of the box
+## Quick Example
 
 ```ruby
-class User < ApplicationRecord
-  include EncodedId::Model
-
-  # An optional slug for the encoded ID string. This is prepended to the encoded ID string, and is solely 
-  # to make the ID human friendly, or useful in URLs. It is not required for finding records by encoded ID.
-  def name_for_encoded_id_slug
-    full_name
-  end
-  
-  # An optional prefix on the encoded ID string to help identify the model it belongs to.
-  # Default is to use model's parameterized name, but can be overridden, or disabled.
-  # Note it is not required for finding records by encoded ID.
-  def annotation_for_encoded_id
-    "usr"
-  end
-end
-
-# You can find by the encoded ID
-user = User.find_by_encoded_id("p5w9-z27j") # => #<User id: 78>
-user.encoded_id                             # => "usr_p5w9-z27j"
-user.slugged_encoded_id                     # => "bob-smith--usr_p5w9-z27j"
-
-# You can find by a slugged & annotated encoded ID
-user == User.find_by_encoded_id("bob-smith--usr_p5w9-z27j") # => true
-
-# Encoded IDs can encode multiple IDs at the same time
-users = User.find_all_by_encoded_id("7aq60zqw") # => [#<User id: 78>, #<User id: 45>]
-```
-
-## Why this gem?
-
-With this gem you can easily obfuscate your IDs in your URLs, and still be able to find records by using
-the encoded IDs. The encoded IDs are meant to be somewhat human friendly, to make communication easier
-when sharing encoded IDs with other people. 
-
-* Hashids are reversible, no need to persist the generated Id
-* we don't override any AR methods. `encoded_id`s are intentionally **not interchangeable** with normal record `id`s 
-  (ie you can't use `.find` to find by encoded ID or record ID, you must be explicit)
-* we support slugged IDs (eg `my-amazing-product--p5w9-z27j`)
-* we support multiple model IDs encoded in one `EncodedId` (eg `7aq6-0zqw` might decode to `[78, 45]`)
-* the gem is configurable
-* encoded IDs can be stable across environments, or not (you can set the salt to different values per environment)
-
-
-## Coming in future (?)
-
-- support for UUIDs for IDs (which will be encoded as an array of integers)
-
-## Installation
+coder = ::EncodedId::ReversibleId.new(salt: "my-salt")
+coder.encode(123)
+# => "p5w9-z27j"
 
-Install the gem and add to the application's Gemfile by executing:
+# The encoded strings are reversible
+coder.decode("p5w9-z27j")
+# => [123]
 
-    $ bundle add encoded_id-rails
+# Supports encoding multiple IDs at once
+coder.encode([78, 45])
+# => "z2j7-0dmw"
 
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install encoded_id-rails
-
-Then run the generator to add the initializer:
-
-    rails g encoded_id:rails:install
-
-## Usage
-
-### Configuration
-
-The install generator will create an initializer file [`config/initializers/encoded_id.rb`](https://github.com/stevegeek/encoded_id-rails/blob/main/lib/generators/encoded_id/rails/templates/encoded_id.rb). It is documented
-and should be self-explanatory.
-
-You can configure:
-
-- a global salt needed to generate the encoded IDs (if you dont use a global salt, you can set a salt per model)
-- the size of the character groups in the encoded string (default is 4) 
-- the separator between the character groups (default is '-')
-- the alphabet used to generate the encoded string (default is a variation of the Crockford reduced character set)
-- the minimum length of the encoded ID string (default is 8 characters)
-
-### ActiveRecord model setup
-
-Include `EncodedId::Model` in your model and optionally specify a encoded id salt (or not if using a global one):
-
-```ruby
+# Can also be used with ActiveRecord models
 class User < ApplicationRecord
-  include EncodedId::Model
-
-  # and optionally the model's salt
-  def encoded_id_salt
-    "my-user-model-salt"
-  end
-
-  # ...
-end
-```
-
-### Optional mixins
-
-You can optionally include one of the following mixins to add default overrides to `#to_param`.
-
-- `EncodedId::PathParam`
-- `EncodedId::SluggedPathParam`
-
-This is so that an instance of the model can be used in path helpers and 
-return the encoded ID string instead of the record ID by default.
-
-```ruby
-class User < ApplicationRecord
-  include EncodedId::Model
-  include EncodedId::SluggedPathParam
-
+  include EncodedId::Rails::Model
+  
+  # Optional slug for the encoded ID
   def name_for_encoded_id_slug
     full_name
   end
 end
 
-user = User.create(full_name: "Bob Smith")
-Rails.application.routes.url_helpers.user_path(user) # => "/users/bob-smith--p5w9-z27j"
-```
-
-## Documentation
-
-### `.find_by_encoded_id`
-
-Like `.find` but accepts an encoded ID string instead of an ID. Will return `nil` if no record is found.
-
-```ruby
-user = User.find_by_encoded_id("p5w9-z27j")  # => #<User id: 78>
-user.encoded_id  # => "p5w9-z27j"
-```
-
-Note when an encoded ID string contains multiple IDs, this method will return the record for the first ID.
-
-### `.find_by_encoded_id!`
-
-Like `.find!` but accepts an encoded ID string instead of an ID. Raises `ActiveRecord::RecordNotFound` if no record is found.
-
-```ruby
-user = User.find_by_encoded_id!("p5w9-z27j")  # => #<User id: 78>
-
-# raises ActiveRecord::RecordNotFound
-user = User.find_by_encoded_id!("encoded-id-that-is-not-found")  # => ActiveRecord::RecordNotFound
-```
-
-Note when an encoded ID string contains multiple IDs, this method will return the record for the first ID.
-
-### `.find_all_by_encoded_id`
-
-Like `.find_by_encoded_id` but when an encoded ID string contains multiple IDs, 
-this method will return an array of records.
-
-### `.find_all_by_encoded_id!`
-
-Like `.find_by_encoded_id!` but when an encoded ID string contains multiple IDs, 
-this method will return an array of records.
-
-### `.where_encoded_id`
-
-A helper for creating relations. Decodes the encoded ID string before passing it to `.where`.
-
-```ruby
-encoded_id = User.encode_encoded_id([user1.id, user2.id])  # => "p5w9-z27j"
-User.where(active: true)
-  .where_encoded_id(encoded_id)
-  .map(&:name) # => ["Bob Smith", "Jane Doe"]
-```
-
-### `.encode_encoded_id`
-
-Encodes an ID or array of IDs into an encoded ID string.
-
-```ruby
-User.encode_encoded_id(78)  # => "p5w9-z27j"
-User.encode_encoded_id([78, 45])  # => "7aq6-0zqw"
-```
-
-### `.decode_encoded_id`
-
-Decodes an encoded ID string into an array of IDs.
-
-```ruby
-User.decode_encoded_id("p5w9-z27j")  # => [78]
-User.decode_encoded_id("7aq6-0zqw")  # => [78, 45]
-```
-
-### `.encoded_id_salt`
-
-Returns the salt used to generate the encoded ID string. If not defined, the global salt is used
-with `EncodedId::Rails::Salt` to generate a model specific one.
-
-```ruby
-User.encoded_id_salt  # => "User/the-salt-from-the-initializer"
-```
-
-Otherwise override this method to return a salt specific to the model.
-
-```ruby
-class User < ApplicationRecord
-  include EncodedId::Model
-
-  def encoded_id_salt
-    "my-user-model-salt"
-  end
-end
-
-User.encoded_id_salt  # => "my-user-model-salt"
-```
-
-### `#encoded_id_hash`
-
-Returns only the encoded 'hashId' part of the encoded ID for the record:
-
-```ruby
-user = User.create(name: "Bob Smith")
-user.encoded_id  # => "p5w9-z27j"
-```
-
-
-### `#encoded_id`
-
-Returns the encoded ID for the record, with an annotation (if it is enabled):
-
-```ruby
-user = User.create(name: "Bob Smith")
-user.encoded_id  # => "user_p5w9-z27j"
-```
-
-By default, the annotation comes from the underscored model name. However, you can change this by either:
-
-- overriding `#annotation_for_encoded_id` on the model
-- overriding `#annotation_for_encoded_id` on all models via your `ApplicationRecord`
-- change the method called to get the annotation via setting the `annotation_method_name` config options in your initializer
-- disable the annotation via setting the `annotation_method_name` config options in your initializer to `nil`
-
-
-Examples: 
-
-```ruby
-EncodedId::Rails.configuration.annotation_method_name = :name
-user.encoded_id  # => "bob_smith_p5w9-z27j"
-```
-
-```ruby
-EncodedId::Rails.configuration.annotation_method_name = nil
-user.encoded_id  # => "p5w9-z27j"
+# Find by encoded ID
+user = User.find_by_encoded_id("p5w9-z27j") # => #<User id: 78>
+user.encoded_id                             # => "user_p5w9-z27j"
+user.slugged_encoded_id                     # => "bob-smith--user_p5w9-z27j"
 ```
 
-```ruby
-class User < ApplicationRecord
-  include EncodedId::Model
-  
-  def annotation_for_encoded_id
-    "foo"
-  end
-end
-
-user = User.create(name: "Bob Smith")
-user.encoded_id  # => "foo_p5w9-z27j"
-```
+## Key Features
 
-Note that you can also configure the annotation separator via the `annotated_id_separator` config option in your initializer,
-but it must be set to a string that only contains character that are not part of the alphabet used to encode the ID.
+* 🔄 **Reversible** - Encoded IDs can be decoded back to the original values
+* 👥 **Multiple IDs** - Encode multiple numeric IDs in one string
+* 🚀 **Choose your encoding** - Supports `Hashids` and `Sqids` out of the box, or use your own custom encoder
+* 👓 **Human-readable** - Character grouping & character mappings of easily confused characters for better readability
+* 🔡 **Custom alphabets** - Use your preferred character set, or a provided default
+* 🚗 **Performance** - Uses an optimized `Hashids` encoder (compared to `hashids` gem) for better performance and less memory usage, and have pushed performance improvements to `Sqids` as well
+* 🤬 **Profanity blocking** - Built-in word blocklist support and optional default lists
 
-```ruby
-EncodedId::Rails.configuration.annotated_id_separator = "^^"
-user.encoded_id  # => "foo^^p5w9-z27j"
-```
+### Rails Integration Features
 
-### `#slugged_encoded_id`
+* 🏷️ **ActiveRecord integration** - Use with ActiveRecord models
+* 🔑 **Per-model salt** - Use a custom salt for encoding per model
+* 💅 **Slugged IDs** - URL-friendly slugs like `my-product--p5w9-z27j`
+* 🔖 **Annotated IDs** - Model type indicators like `user_p5w9-z27j`
+* 🔍 **Finder methods** - Find records using encoded IDs
+* 🛣️ **URL params** - `to_param` with encoded IDs
+* 🔒 **Safe defaults**: Limits on encoded ID lengths to prevent CPU and memory-intensive encode/decodes eg when used in URLs
+* 💾 **Persistence** - Optional database persistence for efficient lookups
 
-Use the `slugged_encoded_id` instance method to get the slugged version of the encoded ID for the record. 
 
-```ruby
-user = User.create(name: "Bob Smith")
-user.slugged_encoded_id  # => "bob-smith--p5w9-z27j"
-```
+## Standalone Gem
 
-Calls `#name_for_encoded_id_slug` on the record to get the slug part of the encoded ID.
-By default, `#name_for_encoded_id_slug` raises, and must be overridden, or configured via the `slug_value_method_name` config option in your initializer:
 
-```ruby
-class User < ApplicationRecord
-  include EncodedId::Model
-
-  # Assuming user has a name attribute
-  def name_for_encoded_id_slug
-    name
-  end
-end
-
-user = User.create(name: "Bob Smith")
-user.slugged_encoded_id  # => "bob-smith--p5w9-z27j"
-```
-
-You can optionally override this method to define your own slug:
-
-```ruby
-class User < ApplicationRecord
-  include EncodedId::Model
-
-  def name_for_encoded_id_slug
-    superhero_name
-  end
-end
+```bash
+# Add to Gemfile
+bundle add encoded_id
 
-user = User.create(superhero_name: "Super Dev")
-user.slugged_encoded_id  # => "super-dev--37nw-8nh7"
+# Or install directly
+gem install encoded_id
 ```
 
-Configure the method called by setting the `slug_value_method_name` config option in your initializer:
+See the [EncodedId API](https://encoded-id.onrender.com/docs/encoded_id/api) documentation for more details.
 
-```ruby
-EncodedId::Rails.configuration.slug_value_method_name = :name
-user.slugged_encoded_id  # => "bob-smith--p5w9-z27j"
-```
+## Rails Integration Gem
 
-Note that you can also configure the slug separator via the `slugged_id_separator` config option in your initializer,
-but it must be set to a string that only contains character that are not part of the alphabet used to encode the ID.
+```bash
+# Add to Gemfile
+bundle add encoded_id-rails
 
-```ruby
-EncodedId::Rails.configuration.annotated_id_separator = "***"
-user.encoded_id  # => "bob-smith***p5w9-z27j"
+# Then run the generator
+rails g encoded_id:rails:install
 ```
 
-## To use on all models
+See the [Rails Integration](https://encoded-id.onrender.com/docs/encoded_id_rails) documentation for more details.
 
-Simply add the mixin to your `ApplicationRecord`:
+## Security Note
 
-```ruby
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-  include EncodedId::Model
+**Encoded IDs are not secure**. They are meant to provide obfuscation, not encryption. Do not use them as a security mechanism.
 
-  ...
-end
-```
+## Compare to Alternate Gems
 
-However, I recommend you only use it on the models that need it.
+- [prefixed_ids](https://github.com/excid3/prefixed_ids)
+- [obfuscate_id](https://github.com/namick/obfuscate_id)
+- [friendly_id](https://github.com/norman/friendly_id)
+- [with_uid](https://github.com/SPBTV/with_uid)
+- [bullet_train-obfuscates_id](https://github.com/bullet-train-co/bullet_train-core/blob/main/bullet_train-obfuscates_id/app/models/concerns/obfuscates_id.rb)
 
-## Example usage for a route and controller
+For a detailed comparison, see the [Compared to Other Gems](https://encoded-id.onrender.com/docs/compared-to) documentation page.
 
-```ruby
-# Route
-resources :users, param: :encoded_id, only: [:show]
-```
+## Documentation
 
-```ruby
-# Model
-class User < ApplicationRecord
-  include EncodedId::Model
-  include EncodedId::PathParam
-end
-```
+Visit [encoded-id.onrender.com](https://encoded-id.onrender.com) for comprehensive documentation including:
 
-```ruby
-# Controller
-class UsersController < ApplicationController
-  def show
-    @user = User.find_by_encoded_id!(params[:encoded_id])
-  end
-end
-```
-
-```erb 
-<%= link_to "User", user_path %>
-```
+- [EncodedId Core API](https://encoded-id.onrender.com/docs/encoded_id/api)
+- [Rails Integration API](https://encoded-id.onrender.com/docs/encoded_id_rails/api)
+- [Configuration Options](https://encoded-id.onrender.com/docs/encoded_id/configuration)
+- [Examples](https://encoded-id.onrender.com/docs/encoded_id/examples)
+- [Advanced Topics](https://encoded-id.onrender.com/docs/advanced-topics)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-### Type check
-
-First install dependencies:
+After checking out the repo, run `bin/setup` to install dependencies. Run `bundle exec rake test` to run the tests.
 
-```bash
-rbs collection install
-```
-
-Then run:
+Run benchmarks with `bin/benchmark <type>` where type is one of: `ips`, `memory`, `comparison`, `profile`, `flamegraph`, or `stress_decode`.
 
-```bash
-steep check
-```
+### Documentation
 
+Run `bundle exec rake website:build` to build or `bundle exec rake website:serve` to preview locally.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/stevegeek/encoded_id-rails.
+Bug reports and pull requests are welcome on GitHub at https://github.com/stevegeek/encoded_id.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).