encoded_id 1.0.0.rc5 → 1.0.0.rc7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b93ebfafa557cd45d9158fa850a474cb3f56de3255b650aeed11bbc131b67ed2
-  data.tar.gz: a3a9feb5004a637c6190ea3d969e03de6066d3b94e7b9b54d8be1c639b8b17af
+  metadata.gz: c94c4fae6354b78328fed94361c666d7df2cf7e797cd1523db2db6e7a57e3d81
+  data.tar.gz: d65c032660d6894da1c81bec5156a9f733ea02d56631b6cc199ed82dcdd1eb24
 SHA512:
-  metadata.gz: 3f06797187a84df0d6436868d82d9d096220e88e9087bad13a78cc766e09681ffdd1db73daa7f9af90288e988b0e4034881b1fc0f7c9129bc6b64a9b8e332589
-  data.tar.gz: 764f505dfb1209bb358784906cfc648bdfee6cf58d79fb5872105d1234ff2839d072b3e899176f4e765f69caccabc00d9d105c9bf484ce2ccf170fdc594c7f44
+  metadata.gz: 6c6a510d660bc34709dc4442dcfd14d63320b79b79f595de8dea225d21379cd859d7473ecab83e137c557fca0f3bf3ceaf0c3074efe98434c5743bb3d0d8387a
+  data.tar.gz: f7724cf6109b4dfd25729bf7c974c496864525e46de58141bba0bf74ae69ce165d8c6549a6a0ab23325dd0c0fbd6386d40815573be3cfc5ca59dd3fa50a83dc6

data/CHANGELOG.md

@@ -1,12 +1,67 @@
 ## [Unreleased]
 
-## [2.0.0.alpha1] - unreleased
+- nothing yet
+
+## [1.0.0] - unreleased
+
+- First stable release!
+
+**Important!!: `:sqids` are not compatible with `:hashids`, DO NOT CHANGE FROM ONE TO THE OTHER AFTER GOING LIVE.**
+
+## [1.0.0.rc7] - 2025-11-19
 
 ### Breaking changes
 
-- `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. Generation of the encoded ID is 1.5 times faster and uses less memory.
+- `ReversibleId` now no longer downcases the encodedid input string by default on decode, ie the `decode` option `downcase` is now `false`. This can be configured via the Rails configuration `downcase_on_decode` option.  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
+- `Encoders` classes no longer expose `encode_hex` and `decode_hex` as they worked differently to the similarly named methods on ReversibleId
+- Rails generator now needs you to specify which encoding algorithm you are using
 
-## [1.0.0] - unreleased
+### Added (Rails integration)
+
+- `encoded_id_options` class method to override `encoded_id` configuration on a model by model basis
+- Blocklist application "modes". User can decide if the blocklist checks should be applied in situations 
+  where very long encoded IDs are likely and hence block word collisions are undesirably likely.
+
+### Changed
+
+- Blocklists are now pre-filtered to the encoder alphabet to avoid testing words which cannot be created by that alphabet anyway.
+- Updates to inline RBS type signatures
+- Documentation updates
+
+## [1.0.0.rc6] - 2025-11-17
+
+### Breaking changes
+
+- Empty array inputs will now raise `InvalidInputError`
+
+### Added
+
+- 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.
+
+### 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
 
@@ -48,3 +103,44 @@
 ## [0.1.0] - 2022-10-11
 
 - Initial release
+
+## Rails Integration History
+
+## [0.6.2] - 2023-02-09
+
+- Fix `encoded_id` memoization clearing when record is duplicated
+
+## [0.6.1] - 2023-02-09
+
+- Fix `#encoded_id` to return nil if `#id` is nil
+- Ensure `encoded_id` memoization is cleared when record is duplicated, or id changes
+
+## [0.6.0] - 2022-12-21
+
+- Rename mixin to `Model`
+- Introduce optional mixins for overriding `#to_param`
+
+## [0.5.0] - 2022-12-21
+
+- `name_for_encoded_id_slug` no longer uses the return value from name but rather just uses the `class` `name`.
+- If you want to change the name used in the slug, override `name_for_encoded_id_slug`
+
+## [0.4.0] - 2022-12-18
+
+- Refactor internals, remove any methods not actually related to creating `encoded_id`, (eg `slugged_id` was removed).
+
+## [0.3.1] - 2022-12-15
+
+- Fix default config
+
+## [0.3.0] - 2022-12-15
+
+- Updates gem `encoded_id` dependency and fixes configuration
+
+## [0.2.0] - 2022-12-14
+
+- No notes...
+
+## [0.1.0] - 2022-11-17
+
+- Initial release of Rails integration

data/README.md

@@ -1,334 +1,136 @@
-# EncodedId
+# EncodedId and EncodedId::Rails
 
-Encode numerical or hex IDs into obfuscated strings that can be used in URLs. 
+![Coverage](badges/coverage_badge_total.svg)
+![RubyCritic](badges/rubycritic_badge_score.svg)
 
-```ruby
-coder = ::EncodedId::ReversibleId.new(salt: my_salt)
-coder.encode(123)
-# => "p5w9-z27j"
-coder.encode_hex("10f8c")
-# => "w72a-y0az"
-```
-
-The obfuscated strings are reversible (they decode them back into the original IDs). 
-
-Also supports encoding multiple IDs at once.
-
-```ruby
-my_salt = "salt!"
-coder = ::EncodedId::ReversibleId.new(salt: my_salt)
-
-# One of more values can be encoded
-coder.encode([78, 45])
-# => "z2j7-0dmw"
-
-# The encoded string can then be reversed back into the original IDs
-coder.decode("z2j7-0dmw")
-# => [78, 45]
-
-# The decoder can be resilient to easily confused characters
-coder.decode("z2j7-Odmw") # (note the capital 'o' instead of zero)
-# => [78, 45]
-```
-
-## Features
-
-* 🔄 encoded IDs are reversible (uses Hashids, the old site is here https://github.com/hashids/hashids.github.io))
-* 👥 supports multiple IDs encoded in one encoded string (eg `7aq6-0zqw` decodes to `[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
-* 🤓 encoded string can be split into groups of letters to improve human-readability
-  - eg `nft9hr834htu` as `nft9-hr83-4htu`
-* 🥽 supports limits on length to prevent resource exhaustion on encoding and decoding
-* configured with sensible defaults
-
-I aim for 100% test coverage and have fuzz tested quite extensively. But please report any issues!
-
-### Experimental
-
-* support for encoding of hex strings (eg UUIDs), including multiple IDs encoded in one string
-
-### Performance and benchmarking
-
-This gem uses a custom HashId implementation that is significantly faster and more memory-efficient than the original `hashids` gem. 
-
-For detailed benchmarks and performance metrics, see the [Custom HashId Implementation](#custom-hashid-implementation) section at the end of this README.
-
-
-### Rails support `encoded_id-rails`
-
-To use with **Rails** check out the [`encoded_id-rails`](https://github.com/stevegeek/encoded_id-rails) gem.
-
-```ruby
-class User < ApplicationRecord
-  include EncodedId::WithEncodedId
-end
-
-User.find_by_encoded_id("p5w9-z27j")
-# => #<User id: 78>
-```
-
-### Note on security of encoded IDs (hashids)
-
-**Encoded IDs are not secure**. It maybe possible to reverse them via brute-force. They are meant to be used in URLs as 
-an obfuscation. The algorithm is not an encryption.
-
-Please read more on https://hashids.org/
-
-## Compare to alternate Gems
-
-- https://github.com/excid3/prefixed_ids
-- https://github.com/namick/obfuscate_id
-- https://github.com/norman/friendly_id
-- https://github.com/SPBTV/with_uid
-
-## Installation
-
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add encoded_id
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install encoded_id
-
-## `EncodedId::ReversibleId.new`
-
-To create an instance of the encoder/decoder use `.new` with the `salt` option:
-
-```ruby
-coder = EncodedId::ReversibleId.new(
-  # The salt is required
-  salt: ...,
-  # And then the following options are optional
-  length: 8, 
-  split_at: 4, 
-  split_with: "-",
-  alphabet: EncodedId::Alphabet.modified_crockford,
-  hex_digit_encoding_group_size: 4 # Experimental
-)
-```
-
-Note the `salt` value is required and should be a string of some length (greater than 3 characters). This is used to generate the encoded string. 
-
-It will need to be the same value when decoding the string back into the original ID. If the salt is changed, the encoded
-strings will be different and possibly decode to different IDs.
-
-### Options
-
-The encoded ID is configurable. The following can be changed:
-
-- the length, eg 8 characters for `p5w9-z27j`
-- the alphabet used in it (min 16 characters)
-- and the number of characters to split the output into and the separator
-
-### `length`
-
-`length`: the minimum length of the encoded string. The default is 8 characters.
-
-The actual length of the encoded string can be longer if the inputs cannot be represented in the minimum length.
-
-### `max_length`
-
-`max_length`: the maximum length of the encoded string. The default is 128 characters.
-
-The maximum length represents both the longest encoded string that will be generated and also a limit on
-the maximum input length that will be decoded. If the encoded string exceeds `max_length` then a
-`EncodedIdLengthError` will be raised. If the input exceeds `max_length` then a `InvalidInputError` will
-be raised. If `max_length` is set to `nil`, then no validation, even using the default will be performed.
-
-### `max_inputs_per_id`
-
-`max_inputs_per_id`: the maximum amount of IDs to be encoded together. The default is 32.
-
-This maximum amount is used to limit:
-- the length of array input passed to `encode`
-- the length of integer array encoded in hex string(s) passed to `encode_hex` function.
-`InvalidInputError` wil be raised when array longer than `max_inputs_per_id` is provided.
-
-### `alphabet`
-
-`alphabet`: the alphabet used in the encoded string. By default, it uses a variation of the Crockford reduced character set (https://www.crockford.com/base32.html).
+`encoded_id` lets you encode numerical or hex IDs into obfuscated strings that can be used in URLs. 
 
-`alphabet` must be an instance of `EncodedId::Alphabet`.
+`encoded_id-rails` is a Rails integration that provides additional features for using `encoded_id` with ActiveRecord models.
 
-The default alphabet is `EncodedId::Alphabet.modified_crockford`.
+It's one of the most, if not _the_ most, feature complete gem of its kind!
 
-To create a new alphabet, use `EncodedId::Alphabet.new`:
+👉 **Full documentation available at [encoded-id.onrender.com](https://encoded-id.onrender.com)**
 
-```ruby
-alphabet = EncodedId::Alphabet.new("0123456789abcdef")
-```
+## Key Features
 
-`EncodedId::Alphabet.new(characters, equivalences)`
+* 🔄 **Reversible** - Encoded IDs can be decoded back to the original values
+* 👥 **Multiple IDs** - Encode multiple numeric IDs in one string
+* 🚀 **Choose your encoding** - Supports `Sqids` (default) and `Hashids`, 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
+* 🤬 **Blocklist filtering** - Built-in word blocklist support with configurable modes and optional default lists
 
-**characters**
+### Rails Integration Features
 
-`characters`: the characters of the alphabet. Can be a string or array of strings.
+* 🏷️ **ActiveRecord integration** - Use with ActiveRecord models
+* 🔑 **Per-model configuration** - Use custom salt and encoding settings per model
+* 💅 **Slugged IDs** - URL-friendly slugs like `my-product--p5w9-z27j`
+* 🔖 **Annotated IDs** - Model type indicators like `user_p5w9-z27j` (default behavior)
+* 🔍 **Finder methods** - `find_by_encoded_id`, `find_by_encoded_id!`, `find_all_by_encoded_id`, `where_encoded_id`
+* 🛣️ **URL params** - `to_param` automatically uses encoded IDs
+* 🔒 **Safe defaults** - Limits on encoded ID lengths to prevent CPU and memory-intensive encode/decodes when used in URLs
+* 💾 **Persistence** - Optional database persistence for efficient lookups
 
-Note that the `characters` of the alphabet must be at least 16 _unique_ characters long and must not contain any
-whitespace characters.
 
+## Quick Example
 
 ```ruby
-alphabet = EncodedId::Alphabet.new("ςερτυθιοπλκξηγφδσαζχψωβνμ")
-coder = ::EncodedId::ReversibleId.new(salt: my_salt, alphabet: alphabet)
+# Using Hashids encoder (requires salt)
+coder = ::EncodedId::ReversibleId.hashid(salt: "my-salt")
 coder.encode(123)
-# => "πφλχ-ψησω"
-```
-
-Note that larger alphabets can result in shorter encoded strings (but remember that `length` specifies the minimum length
-of the encoded string).
+# => "m3pm-8anj"
 
-**equivalences**
+# The encoded strings are reversible
+coder.decode("m3pm-8anj")
+# => [123]
 
-You can optionally pass an appropriate character `equivalences` mapping. This is used to map easily confused characters 
-to their counterpart. 
+# Supports encoding multiple IDs at once
+coder.encode([78, 45])
+# => "ny9y-sd7p"
 
-`equivalences`: a hash of characters keys, with their equivalent alphabet character mapped to in the values. 
+# Using Sqids encoder (default, no salt required)
+sqids_coder = ::EncodedId::ReversibleId.sqids
+sqids_coder.encode(123)
+# => (encoded value varies)
 
-Note that the characters to be mapped:
-- must not be in the alphabet, 
-- must map to a character that is in the alphabet.
+# Can also be used with ActiveRecord models
+class User < ApplicationRecord
+  include EncodedId::Rails::Model
 
-`nil` is the default value which means no equivalences are used.
+  # Optional: define method to provide slug for encoded ID
+  def name_for_encoded_id_slug
+    full_name
+  end
+end
 
-```ruby
-alphabet = EncodedId::Alphabet.new("!@#$%^&*()+-={}", {"_" => "-"})
-coder = ::EncodedId::ReversibleId.new(salt: my_salt, alphabet: alphabet)
-coder.encode(123)
-# => "}*^(-^}*="
+# 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"
 ```
 
-### `split_at` and `split_with`
-
-For readability, the encoded string can be split into groups of characters. 
-
-`split_at`: specifies the number of characters to split the encoded string into. Defaults to 4. 
-
-`split_with`: specifies the separator to use between the groups. Default is `-`.
-
-Set either to `nil` to disable splitting.
-
-### `hex_digit_encoding_group_size`
-
-**Experimental**
+## Standalone Gem
 
-`hex_digit_encoding_group_size`: specifies the number of hex digits to encode in a group. Defaults to 4. Can be
-between 1 and 32.
 
-Can be used to control the size of the encoded string when encoding hex strings. Larger values will result in shorter
-encoded strings for long inputs, and shorter values will result in shorter encoded strings for smaller inputs.
-
-But note that bigger values will also result in larger markers that separate the groups so could end up increasing
-the encoded string length undesirably.
-
-See below section `Using with hex strings` for more details.
-
-## `EncodedId::ReversibleId#encode`
-
-`#encode(id)`: where `id` is an integer or array of integers to encode.
-
-```ruby
-coder.encode(123)
-# => "p5w9-z27j"
+```bash
+# Add to Gemfile
+bundle add encoded_id
 
-# One of more values can be encoded
-coder.encode([78, 45])
-# => "z2j7-0dmw"
+# Or install directly
+gem install encoded_id
 ```
 
-## `EncodedId::ReversibleId#decode`
-
-`#decode(encoded_id)`: where `encoded_id` is a string to decode.
+See the [EncodedId API](https://encoded-id.onrender.com/docs/encoded_id/api) documentation for more details.
 
-```ruby
-# The encoded string can then be reversed back into the original IDs
-coder.decode("z2j7-0dmw")
-# => [78, 45]
-```
+## Rails Integration Gem
 
-## Using with hex strings
-
-**Experimental** (subject to incompatible changes in future versions)
+```bash
+# Add to Gemfile
+bundle add encoded_id-rails
 
-```ruby
-# Hex input strings are also supported
-coder.encode_hex("10f8c")
-# => "w72a-y0az"
+# Then run the generator
+rails g encoded_id:rails:install
 ```
 
-When encoding hex strings, the input is split into groups of hex digits, and each group is encoded separately as its
-integer equivalent. In other words the input is converted into an array of integers and encoded as normal with the
-`encode` method.
+See the [Rails Integration](https://encoded-id.onrender.com/docs/encoded_id_rails) documentation for more details.
 
-eg with `hex_digit_encoding_group_size=1` and inpu `f1`, is split into `f` and `1`, and then encoded as `15` and `1` 
-respectively, ie `encode` is called with `[15, 1]`.
+## Security Note
 
-To encode multiple hex inputs the encoded string contains markers to indicate the start of a new hex input. This
-marker is equal to an integer value which is 1 larger than the maximum value the hex digit encoding group size can
-represent (ie it is `2^(hex_digit_encoding_group_size * 4)`).
+**Encoded IDs are not secure**. They are meant to provide obfuscation, not encryption. Do not use them as a security mechanism.
 
-So for a hex digit encoding group size of 4 (ie group max value is `0xFFFF`), the marker is `65536`
+As of version 1.0.0, `Sqids` is the default encoder. `Hashids` is still supported but is officially deprecated by the Hashids project in favor of Sqids.
 
-For example with `hex_digit_encoding_group_size=1` for the inputs `f1` and `e2` encoded together, the 
-actual encoded integer array is `[15, 1, 16, 14, 2]`.
+Read more about the security implications: [Hashids expose salt value](https://www.sjoerdlangkemper.nl/2023/11/25/hashids-expose-salt-value/) (note: this specifically applies to Hashids encoder)
 
-### `EncodedId::ReversibleId#encode_hex`
+## Compare to Alternate Gems
 
-`encode_hex(hex_string)` , where `hex_string` is a string of hex digits or an array of hex strings.
+- [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)
 
-```ruby
-# UUIDs will result in long output strings...
-coder.encode_hex("9a566b8b-8618-42ab-8db7-a5a0276401fd")
-# => "5jjy-c8d9-hxp2-qsve-rgh9-rxnt-7nb5-tve7-bf84-vr"
-# 
-# but there is an option to help reduce this... 
-coder = ::EncodedId::ReversibleId.new(salt: my_salt, hex_digit_encoding_group_size: 32)
-coder.encode_hex("9a566b8b-8618-42ab-8db7-a5a0276401fd")
-# => "vr7m-qra8-m5y6-dkgj-5rqr-q44e-gp4a-52"
-```
+For a detailed comparison, see the [Compared to Other Gems](https://encoded-id.onrender.com/docs/compared-to) documentation page.
 
-### `EncodedId::ReversibleId#decode_hex`
+## Documentation
 
-`decode_hex(encoded_id)` , where the output is an array of hex strings.
+Visit [encoded-id.onrender.com](https://encoded-id.onrender.com) for comprehensive documentation including:
 
-```ruby
-coder.decode_hex("5jjy-c8d9-hxp2-qsve-rgh9-rxnt-7nb5-tve7-bf84-vr")
-# => ["9a566b8b-8618-42ab-8db7-a5a0276401fd"]
-```
+- [EncodedId Core Guide](https://encoded-id.onrender.com/docs/encoded_id/) - Installation, configuration, examples, and advanced topics
+- [EncodedId Rails Guide](https://encoded-id.onrender.com/docs/encoded_id_rails/) - Rails integration, configuration, and examples
+- [EncodedId Core API Reference](https://encoded-id.onrender.com/docs/encoded_id/api)
+- [Rails Integration API Reference](https://encoded-id.onrender.com/docs/encoded_id_rails/api)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. 
-
-Run `bin/console` for an interactive prompt that will allow you to experiment.
-
-### Running tests
-
-Run `bundle exec rake test` to run the tests.
-
-### Type check
+After checking out the repo, run `bin/setup` to install dependencies. Run `bundle exec rake test` to run the tests.
 
-First install RBS dependencies:
-
-```bash
-rbs collection install
-```
-
-Then run:
-
-```bash
-steep check
-```
+Run benchmarks with `bin/benchmark <type>` where type is one of: `ips`, `memory`, `comparison`, `profile`, `flamegraph`, or `stress_decode`.
 
-## See also
+### Documentation
 
-- https://hashids.org
-- https://www.crockford.com/base32.html
+Run `bundle exec rake website:build` to build or `bundle exec rake website:serve` to preview locally.
 
 ## Contributing
 
@@ -336,49 +138,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/steveg
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Custom HashId Implementation
-
-Internally, `encoded_id` uses its own HashId implementation (`EncodedId::HashId`) instead of the original `hashids` gem. This custom implementation was created to improve both performance and memory usage. 
-
-Recent benchmarks show significant improvements:
-
-### Performance Comparison
-
-```
-| Test                      | Hashids (i/s) | EncodedId::HashId (i/s) | Speedup |
-| ------------------------- | ------------ | --------------------- | ------- |
-| #encode - 1 ID            |  131,000.979 |           197,586.231 |   1.51x |
-| #decode - 1 ID            |   65,791.334 |            92,425.571 |   1.40x |
-| #encode - 10 IDs          |   13,773.355 |            20,669.715 |   1.50x |
-| #decode - 10 IDs          |    6,911.872 |             9,990.078 |   1.45x |
-| #encode w YJIT - 1 ID     |  265,764.969 |           877,551.362 |   3.30x |
-| #decode w YJIT - 1 ID     |  130,154.837 |           348,000.817 |   2.67x |
-| #encode w YJIT - 10 IDs   |   27,966.457 |           100,461.237 |   3.59x |
-| #decode w YJIT - 10 IDs   |   14,187.346 |            43,974.011 |   3.10x |
-| #encode w YJIT - 1000 IDs |      268.140 |             1,077.855 |   4.02x |
-| #decode w YJIT - 1000 IDs |      136.217 |               464.579 |   3.41x |
-```
-
-With YJIT enabled, the performance improvements are even more significant, with up to 4x faster operation for large inputs.
-
-### Memory Usage Comparison
-
-```
-| Test                | Implementation   | Allocated Memory | Allocated Objects | Memory Reduction |
-| ------------------- | ---------------- | ---------------- | ----------------- | ---------------- |
-| encode small input  | Hashids          |          7.28 KB |               120 |                - |
-|                     | EncodedId::HashId |            920 B |                 6 |           87.66% |
-| encode large input  | Hashids          |        403.36 KB |              5998 |                - |
-|                     | EncodedId::HashId |          8.36 KB |               104 |           97.93% |
-| decode large input  | Hashids          |        366.88 KB |              5761 |                - |
-|                     | EncodedId::HashId |         14.63 KB |               264 |           96.01% |
-```
-
-The memory usage improvements are dramatic, with up to 98% reduction in memory allocation for large inputs.
-
-Run `bin/are_we_fast_yet` and `bin/memory_profile` in your environment to see the current performance difference.
-
-## keywords
-hash ID, friendly ID, obfuscate ID, rails, ActiveRecord, model, slug, vanity URL, friendly URL
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).