active_record_pretty_key 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa0c741c251d8d3acde833ff8620ffbea369f74544d1feda3507684596d327de
-  data.tar.gz: 9be0117695b9d2268c7ba3e930a28983ea50fb19326ce5aabfc6e914bda3c8c5
+  metadata.gz: defcd22218e95c247f2e0a177c016feb952f473cc236e5c0d3ec637323b909c6
+  data.tar.gz: ffaf93a43f824d0612806c5b3924174ee0e4bfc4aa4f35aa9d4a04d506413956
 SHA512:
-  metadata.gz: 4bd0c1ac8f56f770bd90e010467f3aae5e345f316554d657ef7086b7ff288825a5b9a2545c261c495bede196445b54f0566b5d8dd8d8e53ba17926f3bce167aa
-  data.tar.gz: 6c3e23c905e21f50d625dd22b84d26232f99222d473d79afc4f89e05db2ccc2f4830ccc8a6f1910fe4b5da5e00da733fc98c66664ce741c5a65341a2b38fa2b0
+  metadata.gz: a81a35ffd83be05b4fd2918731a3fbdec9d2dd532500af0c8a6fe75eb433c13f7b771c26091f58ef2a1c8986d5db5e9d78edd4e95b27d807e6f6a77bef385b95
+  data.tar.gz: dcdbdfcd838af938bff255dbb7a3304fac2a8e6929a6356128e7874ddf3e408d851c55c4d6e343d694d5c9128f00362aa3cd348630bbd612398268ce08aa4a86

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project 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).
+
+## [0.2.0] - 2026-11-07
+
+### Fixed
+- Custom Sqids alphabet from Rails credentials is now read lazily on first use; previously it was read when the gem loaded (before `Rails.application` exists) and silently ignored
+- PostgreSQL ticket generation uses `nextval()` and no longer holds a row lock on the tickets table for the duration of the caller's transaction
+- MySQL via the Trilogy adapter is now supported; previously it fell through to a fallback that could hand out duplicate IDs under concurrency
+- SQLite ticket generation uses the connection-scoped `last_insert_rowid()` instead of reading the last row
+- `generate_pretty_key` is now public, as documented, and returns the record's key
+- MySQL ticket generation no longer deadlocks under concurrency: concurrent `REPLACE INTO` statements deadlock on InnoDB, so it now uses `UPDATE ... SET id = LAST_INSERT_ID(id + 1)`
+- MySQL tickets are allocated on a dedicated connection pool and commit independently of the caller's transaction, so creates no longer wait for each other's transactions to commit
+- Ticket generation no longer leaves the thread's database connection checked out on Rails 7.2+
+- Requiring the gem no longer loads `ActiveRecord::Base` early (before the app's ActiveRecord configuration is applied)
+- `ActiveRecordPrettyKey::VERSION` is now defined when the gem is required
+- Install generator uses Rails' migration numbering and refuses to create a duplicate migration; the generated migration can be rolled back
+
+### Changed
+- Unsupported database adapters now raise `ActiveRecordPrettyKey::Error` instead of using an unsafe fallback
+- README: corrected security claims and documented that the alphabet must not change once records exist
+- Requires Ruby 3.0+ (as the `sqids` dependency always has), ActiveRecord 6.1 – 8.x and, for MySQL, 8.0+
+- On MySQL, each process may open up to `pool` additional connections for ticket generation
+- Gem releases require RubyGems MFA; README, LICENSE and CHANGELOG are now packaged
+- Development: specs run against SQLite, PostgreSQL, MySQL (mysql2 and Trilogy) on Ruby 3.3, 3.4 and 4.0 in CI; added `bin/console`; fixed `bin/setup` and `bin/build`
+
+### Removed
+- Broken `Thorfile` and `bin/active_record_pretty_key` executable (neither could load the generator), and the `thor` dependency
+
+## [0.1.1] - 2025-08-25
+
+### Fixed
+- Fixed Gemspec homepage
+
+## [0.1.0] - 2025-08-25
+
+### Added
+- Initial gem structure
+- Basic concern `ActiveRecordPrettyKey::Concern` module for ActiveRecord models
+- `generate_pretty_key` instance method
+- RSpec test suite
+- Development tools and scripts

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Noreaster Group, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,224 @@
+# ActiveRecordPrettyKey
+
+A Ruby gem for generating and managing pretty, human-readable keys in ActiveRecord models. 
+
+The gem automatically generates pretty keys by creating unique integer "tickets" and encoding them with the [Sqids](https://github.com/sqids/sqids-ruby) library to produce short, URL-safe string identifiers. Keys are generated before saving records, ensuring both uniqueness and consistency.
+
+**Examples:** `BnJe`, `xK4m`, `Qp7R`, `vN2f8` — short, memorable IDs perfect for URLs like `/posts/xK4m`
+
+Inspired by:
+- [Flickr Ticket Servers: Distributed Unique Primary Keys on the Cheap](https://code.flickr.net/2010/02/08/ticket-servers-distributed-unique-primary-keys-on-the-cheap/)
+- [Hashids](https://github.com/peterhellberg/hashids.rb)
+
+## Why Pretty Keys?
+
+| Feature | Regular Primary Keys | UUID7 | Pretty Keys |
+|---------|---------------------|-------|-------------|
+| **Human Readable** | ✅ Sequential numbers (1, 2, 3...) | ❌ Long, random strings | ✅ Short, memorable strings |
+| **In Order** | ✅ Yes |  ✅ Yes |  ❌ No |
+| **URL Friendly** | ✅ Simple and clean | ❌ Long and unwieldy | ✅ Short and clean |
+| **Guessability** | ❌ Sequential, easily enumerated | ✅ Hard to guess | ⚠️ Obfuscated, not secret (see [Security](#security)) |
+| **Length** | ✅ Very short | ❌ Very long (36 chars) | ✅ Short (4+ chars, grows slowly) |
+| **Collision Risk** | ✅ None (auto-increment) | ✅ Extremely low | ✅ None (ticket database table) |
+
+Pretty keys offer a middle ground between auto-incrementing integers and UUIDs — short, human-readable identifiers that don't expose your raw row IDs.
+
+## Requirements
+
+- Ruby 3.0+
+- Rails / ActiveRecord 6.1 – 8.x
+- PostgreSQL (incl. PostGIS), MySQL 8.0+ (`mysql2` or `trilogy` adapter) or SQLite. Other databases raise `ActiveRecordPrettyKey::Error`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_pretty_key'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install active_record_pretty_key
+```
+
+## Usage
+
+### Setup
+
+First, run the generator to create the required tickets table:
+
+```bash
+rails generate active_record_pretty_key:install
+```
+
+This creates a `create_pretty_key_tickets` migration for the single-row `pretty_key_tickets` table that hands out unique ticket numbers. Run it with `rails db:migrate`.
+
+### Customizing or Randomizing the Sqids Alphabet
+
+A custom Sqids alphabet can be configured in Rails credentials:
+
+```yaml
+sqids:
+  alphabet: "ENwUpVBslGq25afc6i0hyD4tnjxRY31Wouz7HFTeMKgSbmPZvJ9ALXCQdrkI8O"
+```
+
+This can be used to configure a randomized alphabet to obfuscate object IDs. The alphabet is read from credentials the first time a key is generated.
+
+> **Warning:** Choose the alphabet before you create any records and never change it afterwards. Existing keys are stored as strings, so a new alphabet can encode a new ticket number to a key that already exists, causing primary key collisions.
+
+To generate a shuffled alphabet:
+```ruby
+require 'sqids'
+puts Sqids::DEFAULT_ALPHABET.split('').shuffle.join
+```
+
+### Creating Models
+
+Pretty keys require that your model use a string primary key:
+```ruby
+class CreatePosts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :posts, id: :string do |t|
+      t.string :title
+
+      t.timestamps
+    end
+  end
+end
+```
+
+You may choose to configure ActiveRecord to always generate migrations with a string primary key:
+```ruby
+  # application.rb
+
+  # Default string primary key in migrations for use with Sqids
+  config.generators do |generate|
+    generate.orm :active_record, primary_key_type: :string
+  end
+```
+
+### Including the Concern
+
+Include the concern in your ApplicationRecord to use everywhere:
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+  include ActiveRecordPrettyKey::Concern
+end
+```
+
+OR
+
+Include the concern on a model by model basis:
+```ruby
+class Post < ApplicationRecord
+  include ActiveRecordPrettyKey::Concern
+end
+```
+
+### Generating Keys
+
+Keys are generated automatically before a record is created:
+```ruby
+post = Post.create(title: "My Awesome Post")
+post.id
+# => "BnJe"
+```
+
+Or the generation helper can be called manually. It returns the record's key, and does not replace a key that is already set:
+```ruby
+post = Post.new(title: "My Awesome Post")
+post.generate_pretty_key
+# => "9LW9"
+
+post.save!
+```
+
+Because keys are generated in a `before_create` callback, which runs *after* validation, don't add `validates :id, presence: true`. If you need the key during validation, generate it first:
+```ruby
+class Post < ApplicationRecord
+  include ActiveRecordPrettyKey::Concern
+  before_validation :generate_pretty_key, on: :create
+end
+```
+
+### Associations
+
+Every column that refers to a pretty-keyed record must also be a string, including foreign keys and polymorphic `*_id` columns:
+```ruby
+create_table :comments, id: :string do |t|
+  t.references :post, type: :string, foreign_key: true
+  t.references :commentable, polymorphic: true, type: :string
+end
+```
+
+### Active Storage
+
+For the same reason, Active Storage's polymorphic `record_id` column must be a string:
+```ruby
+class FixAttachmentsFks < ActiveRecord::Migration[8.0]
+  def change
+    change_column :active_storage_attachments, :record_id, :string, null: false
+  end
+end
+```
+
+### How tickets are generated
+
+Keys are generated inside the record's save transaction. A ticket number is never handed out twice, even if that transaction rolls back, and generating one doesn't hold locks until it commits:
+
+- **PostgreSQL** uses a sequence (`nextval`), which takes no locks and is not rolled back.
+- **MySQL** uses a dedicated connection pool for the tickets table, so each ticket commits immediately on its own, separately from your transaction. The pool is created on first use with the same settings as your application's pool, so each process may open up to `pool` additional database connections; account for this in your database's `max_connections`.
+- **SQLite** allows only one writer at a time, so tickets are generated in your transaction and **rolled back with it**. A key that was read inside a transaction that then rolled back (for example, passed to a job or API before the rollback) can be given to a later record. Use keys outside a transaction only once it has committed.
+
+If the ticket row is missing, for example in a database created from `schema.rb` with `db:schema:load` or `db:prepare`, it is recreated automatically.
+
+## Security
+
+Pretty keys are **obfuscated, not encrypted**. Each key is an encoded, globally sequential ticket number:
+
+- With the default alphabet, anyone can decode a key back to its ticket number (e.g. `Sqids.new(min_length: 4).decode("gbHJ") # => [2]`) and generate the keys before and after it.
+- A shuffled alphabet makes this harder, but it is not a cryptographic secret and should not be treated as one.
+- Because the ticket counter is shared across all models, decoded keys reveal roughly how many records your application has created and how quickly.
+
+Never rely on a key being unguessable for authorization. Always check that the current user is allowed to access the record.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies and run the specs. Run `bundle exec rspec` to run the tests, and `bin/console` for an interactive prompt with an in-memory database and a `Post` model.
+
+The specs use in-memory SQLite by default. To run them against another database, install its driver group and set `DB` (and optionally `DATABASE_URL`):
+
+```bash
+docker run -d --rm -p 5432:5432 -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=pretty_key_test postgres:17
+BUNDLE_WITH=postgresql bundle install
+DB=postgresql bundle exec rspec
+
+docker run -d --rm -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -e MYSQL_DATABASE=pretty_key_test mysql:8.4
+BUNDLE_WITH=mysql bundle install
+DB=mysql2 bundle exec rspec   # or DB=trilogy
+```
+
+CI runs the suite against all four adapters.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in the `VERSION` file, 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). Releases require RubyGems multi-factor authentication.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/noreastergroup/active_record_pretty_key. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/noreastergroup/active_record_pretty_key/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveRecordPrettyKey project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/noreastergroup/active_record_pretty_key/blob/main/CODE_OF_CONDUCT.md).

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/active_record_pretty_key/concern.rb

@@ -8,16 +8,15 @@ module ActiveRecordPrettyKey
       before_create :generate_pretty_key
     end
 
-    private
-
+    # Assigns a pretty key to the primary key if it is a string column and
+    # not already set. Returns the primary key value, or nil when the model's
+    # primary key is not a single string column.
     def generate_pretty_key
-      pk_attribute = self.class.primary_key
-      return if pk_attribute.nil? || self.class.attribute_types[pk_attribute].nil? || self.class.attribute_types[pk_attribute].type != :string
-
-      # Ensure PrettyKeyTicket is available
-      return unless defined?(ActiveRecordPrettyKey::PrettyKeyTicket)
+      pk = self.class.primary_key
+      return unless pk.is_a?(String) && self.class.type_for_attribute(pk).type == :string
 
-      self.assign_attributes(pk_attribute => ActiveRecordPrettyKey::PrettyKeyTicket.next_sqid) unless self.attributes[pk_attribute].present?
+      self[pk] = ActiveRecordPrettyKey::PrettyKeyTicket.next_sqid if self[pk].blank?
+      self[pk]
     end
   end
 end

data/lib/active_record_pretty_key/pretty_key_ticket.rb

@@ -1,43 +1,137 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
+require "concurrent/atomic/atomic_fixnum"
+
 module ActiveRecordPrettyKey
   class PrettyKeyTicket < ActiveRecord::Base
     self.table_name = "pretty_key_tickets"
-    @sqids = Sqids.new(
-      min_length: 4,
-      alphabet: defined?(Rails) && Rails.application.respond_to?(:credentials) ?
-                (Rails.application.credentials.dig(:sqids, :alphabet) || Sqids::DEFAULT_ALPHABET) :
-                Sqids::DEFAULT_ALPHABET,
-    )
-
-    # Generate a new unique ID that works with PostgreSQL, MySQL, and SQLite
-    def self.next_id
-      transaction do
-        # Detect database type
-        adapter = connection.adapter_name.downcase
-
-        if [ "postgresql", "postgis" ].include?(adapter)
-          # PostgreSQL approach
-          result = connection.execute(
-            "INSERT INTO pretty_key_tickets (stub) VALUES ('a')
-             ON CONFLICT (stub) DO UPDATE SET id = currval('pretty_key_tickets_id_seq')
-             RETURNING id"
-          )
-          result[0]["id"]
-        elsif [ "mysql", "mysql2" ].include?(adapter)
-          # MySQL approach
-          connection.execute("REPLACE INTO pretty_key_tickets (stub) VALUES ('a');")
-          connection.execute("SELECT LAST_INSERT_ID()").first[0]
-        else
-          # SQLite approach (and fallback for others)
-          connection.execute("REPLACE INTO pretty_key_tickets (stub) VALUES ('a');")
-          last.id
+
+    MIN_LENGTH = 4
+    MYSQL_DEADLOCK_ATTEMPTS = 5
+
+    @ticket_connection_pools = Concurrent::Map.new
+    @ticket_connection_count = Concurrent::AtomicFixnum.new
+
+    class << self
+      # Generate a new unique integer ID.
+      #
+      # This is usually called inside the caller's transaction (a model's
+      # save). An issued ID must never be handed out again, even if that
+      # transaction rolls back, and allocation must not hold locks until the
+      # caller commits:
+      # - PostgreSQL: nextval() is non-transactional and takes no row locks.
+      # - MySQL: UPDATE ... SET id = LAST_INSERT_ID(id + 1), the sequence
+      #   emulation pattern from the MySQL manual. (Flickr's REPLACE INTO relies
+      #   on MyISAM; on InnoDB concurrent REPLACEs deadlock.) An UPDATE is
+      #   transactional, so it runs on a dedicated autocommit connection: it
+      #   commits immediately and its row lock is released straight away.
+      # - SQLite: REPLACE + last_insert_rowid(). SQLite allows a single writer,
+      #   so a second connection would deadlock with the caller's transaction;
+      #   the ticket is rolled back along with the caller's transaction.
+      #
+      # Every query bypasses the Rails query cache: a cached
+      # `SELECT nextval(...)` would hand out the same ID twice.
+      #
+      # Connections are borrowed with connection_pool.with_connection, which
+      # reuses the thread's current connection (and so its transaction).
+      # Calling `connection` instead would, on Rails 7.2+, keep the connection
+      # checked out by the thread after the caller is done with it.
+      def next_id
+        id = connection_pool.with_connection do |conn|
+          case conn.adapter_name.downcase
+          when "postgresql", "postgis"
+            conn.uncached { conn.select_value("SELECT nextval(#{conn.quote(sequence_name)})") }
+          when "mysql", "mysql2", "trilogy"
+            ticket_connection_pool.with_connection { |ticket_conn| ticket_conn.uncached { mysql_next_id(ticket_conn) } }
+          when "sqlite", "sqlite3"
+            conn.uncached do
+              conn.execute("REPLACE INTO #{quoted_table_name} (stub) VALUES ('a')")
+              conn.select_value("SELECT last_insert_rowid()")
+            end
+          else
+            raise ActiveRecordPrettyKey::Error,
+                  "Unsupported database adapter #{conn.adapter_name.inspect}; " \
+                  "supported adapters are PostgreSQL, PostGIS, MySQL (mysql2/trilogy) and SQLite"
+          end
         end
+
+        Integer(id)
+      end
+
+      # Connection pool used only for MySQL ticket allocation, separate from
+      # the application's pool so allocations commit independently of the
+      # caller's transaction. One pool per database config (so multiple
+      # databases and shards each get their own), created on first use with
+      # the same settings, including pool size, as the application's pool.
+      # Registered through establish_connection so Rails manages it (e.g.
+      # discarding it after fork); the pool object is used directly so it
+      # works regardless of the caller's connected_to role or shard.
+      def ticket_connection_pool
+        db_config = connection_db_config
+        @ticket_connection_pools.compute_if_absent(db_config.configuration_hash) do
+          # establish_connection needs a named class to own the pool
+          owner = Class.new(ActiveRecord::Base) { self.abstract_class = true }
+          ActiveRecordPrettyKey.const_set("TicketConnection#{@ticket_connection_count.increment}", owner)
+          owner.establish_connection(db_config)
+        end
+      end
+
+      def next_sqid
+        sqids.encode([ next_id ])
+      end
+
+      # Built lazily so Rails credentials are available. The gem is loaded by
+      # Bundler.require before Rails.application exists, so reading credentials
+      # at class-load time would silently fall back to the default alphabet.
+      def sqids
+        @sqids ||= Sqids.new(min_length: MIN_LENGTH, alphabet: alphabet)
       end
-    end
 
-    def self.next_sqid
-      @sqids.encode([ self.next_id ])
+      def alphabet
+        configured =
+          if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+            ::Rails.application.credentials.dig(:sqids, :alphabet)
+          end
+
+        configured.presence || Sqids::DEFAULT_ALPHABET
+      end
+
+      private
+
+      def mysql_next_id(conn)
+        attempts = 0
+        begin
+          attempts += 1
+          mysql_allocate(conn)
+        rescue ActiveRecord::Deadlocked
+          # Each statement runs in its own autocommit transaction, so the
+          # deadlock victim issued nothing and can safely be retried. (Not if
+          # something, e.g. a test harness, opened a transaction around it.)
+          retry if attempts < MYSQL_DEADLOCK_ATTEMPTS && !conn.transaction_open?
+          raise
+        end
+      end
+
+      def mysql_allocate(conn)
+        update = "UPDATE #{quoted_table_name} SET id = LAST_INSERT_ID(id + 1) WHERE stub = 'a'"
+
+        if conn.update(update).zero?
+          # The row seeded by the install migration is missing, e.g. in a
+          # database built from schema.rb (db:schema:load, db:prepare, test
+          # databases). Create it; IGNORE covers a concurrent insert. MySQL 8
+          # moves the AUTO_INCREMENT counter past values set by UPDATE, so the
+          # new row can't start below IDs that were already issued. Concurrent
+          # INSERT IGNORE and UPDATE can deadlock here; the caller retries.
+          conn.execute("INSERT IGNORE INTO #{quoted_table_name} (stub) VALUES ('a')")
+
+          if conn.update(update).zero?
+            raise ActiveRecordPrettyKey::Error, "Could not create the ticket row in #{table_name}"
+          end
+        end
+
+        conn.select_value("SELECT LAST_INSERT_ID()")
+      end
     end
   end
 end

data/lib/active_record_pretty_key.rb

@@ -2,12 +2,18 @@
 
 require "active_record"
 require "active_support/concern"
+require "active_support/lazy_load_hooks"
 require "sqids"
-require_relative "active_record_pretty_key/pretty_key_ticket"
+require_relative "active_record_pretty_key/version"
 require_relative "active_record_pretty_key/concern"
-# require_relative "active_record_pretty_key/version"
-
 
 module ActiveRecordPrettyKey
   class Error < StandardError; end
 end
+
+# PrettyKeyTicket subclasses ActiveRecord::Base. Defining it when the gem is
+# required would load ActiveRecord::Base before the application's
+# config.active_record settings are applied, so wait for ActiveRecord to load.
+ActiveSupport.on_load(:active_record) do
+  require_relative "active_record_pretty_key/pretty_key_ticket"
+end

data/lib/generators/active_record_pretty_key/install/install_generator.rb

@@ -1,23 +1,25 @@
 # frozen_string_literal: true
 
 require "rails/generators"
+require "rails/generators/active_record"
 
 module ActiveRecordPrettyKey
   module Generators
     class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
       source_root File.expand_path("templates", __dir__)
-      desc "Creates the tickets table migration for active_record_pretty_key"
+      desc "Creates the pretty_key_tickets table migration for active_record_pretty_key"
 
-      def create_migration
-        template "create_tickets.erb", "db/migrate/#{Time.now.utc.strftime("%Y%m%d%H%M%S")}_create_pretty_key_tickets.rb"
+      def create_migration_file
+        migration_template "create_pretty_key_tickets.rb.erb",
+                           File.join(db_migrate_path, "create_pretty_key_tickets.rb")
       end
 
       private
 
       def migration_version
-        if ActiveRecord::VERSION::MAJOR >= 5
-          "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-        end
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
       end
     end
   end

data/lib/generators/active_record_pretty_key/install/templates/{create_tickets.erb → create_pretty_key_tickets.rb.erb}

@@ -5,7 +5,9 @@ class CreatePrettyKeyTickets < ActiveRecord::Migration<%= migration_version %>
     end
     add_index :pretty_key_tickets, :stub, unique: true
 
-    # Seed initial value
-    execute "INSERT INTO pretty_key_tickets (stub) VALUES ('a')"
+    # Seed the single ticket row (dropped along with the table on rollback)
+    up_only do
+      execute "INSERT INTO pretty_key_tickets (stub) VALUES ('a')"
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_pretty_key
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Stuart Yamartino
@@ -16,28 +16,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: sqids
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +64,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 description: ActiveRecordPrettyKey provides functionality to generate and manage pretty,
   human-readable keys for ActiveRecord models.
 email:
@@ -75,13 +73,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
+- README.md
 - VERSION
 - lib/active_record_pretty_key.rb
 - lib/active_record_pretty_key/concern.rb
 - lib/active_record_pretty_key/pretty_key_ticket.rb
 - lib/active_record_pretty_key/version.rb
 - lib/generators/active_record_pretty_key/install/install_generator.rb
-- lib/generators/active_record_pretty_key/install/templates/create_tickets.erb
+- lib/generators/active_record_pretty_key/install/templates/create_pretty_key_tickets.rb.erb
 homepage: https://github.com/noreastergroup/active_record_pretty_key
 licenses:
 - MIT
@@ -89,6 +90,8 @@ metadata:
   homepage_uri: https://github.com/noreastergroup/active_record_pretty_key
   source_code_uri: https://github.com/noreastergroup/active_record_pretty_key
   changelog_uri: https://github.com/noreastergroup/active_record_pretty_key/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/noreastergroup/active_record_pretty_key/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -96,14 +99,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A gem for generating pretty keys in ActiveRecord models
 test_files: []