sqlite_crypto 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81485ab3edd90e39dd41fb1c55ebf1342628a233d69f7adc6e52c04f1f507c6f
+  data.tar.gz: de617f3d572a0113e0d82f372c8b775c1920d3c1637ae3f19ab32d4dd92446fc
+SHA512:
+  metadata.gz: 633d6fe21b1507f46af710c4732ffd18822ecc8639de6a625dbd9f0e03a2d032c461241279a834affab5f9008cf52b3364983506d2819176820b30392c53ad2b
+  data.tar.gz: f98d8c7b022ba486f0125802651e1fb40f68bf413b4291b527349b9b4bd4c8683c99faca49eeafb9246668a84e8db543291d93fd38652006d8d91b3737edb621

data/CHANGELOG.md

@@ -0,0 +1,67 @@
+# 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).
+
+## [1.0.0] - 2025-12-20
+
+### Added
+- **Type System**: Custom UUID and ULID ActiveRecord types for SQLite adapter
+  - UUID type with validation (36-character hyphenated format)
+  - ULID type with time-sortable validation (26-character format)
+  - Shared Type::Base class for DRY implementation
+- **Migration Helpers**: DSL methods for migrations
+  - `t.uuid()` and `t.ulid()` for column definitions
+  - Automatic foreign key type detection for `references`/`belongs_to`
+  - Support for `id: :uuid` and `id: :ulid` shorthand syntax in create_table
+  - `:to_table` option support for non-standard table names
+- **Schema Dumper Integration**: Clean schema.rb output
+  - Outputs `id: :uuid` instead of `id: { type: :string, limit: 36 }`
+  - Outputs `id: :ulid` instead of `id: { type: :string, limit: 26 }`
+  - Preserves standard integer primary keys unchanged
+- **Model Extensions**: ActiveRecord class methods for automatic UUID/ULID generation
+  - `generates_uuid(attribute, unique: false)` - Auto-generates SecureRandom.uuid on create
+  - `generates_ulid(attribute, unique: false)` - Auto-generates time-sortable ULID on create
+  - Optional uniqueness validation with `unique: true` parameter
+  - Preserves existing values (uses `||=` to avoid overwriting)
+  - Available to all ActiveRecord models via concern
+- **Rails Integration**: Full Railtie implementation
+  - Type registration for SQLite3 adapter
+  - Schema dumper prepending with proper load order
+  - Migration helpers loading
+  - Model extensions loading after database initialization
+- **Testing Infrastructure**:
+  - Comprehensive test suite with 99.01% code coverage (58 examples)
+  - Unit tests for UUID/ULID types with validation
+  - Integration tests for real-world migration scenarios
+  - Model extension tests covering generation, validation, and edge cases
+  - Performance benchmarks comparing Integer vs UUID vs ULID
+  - Support for Rails 7.1, 7.2, 8.0, and 8.1
+  - Security audit with bundle-audit in CI
+- **Performance Benchmarks**: Comprehensive benchmarking suite
+  - Insert performance comparison
+  - Query performance benchmarks (find, where)
+  - Storage requirement analysis
+  - ID format demonstrations
+  - Use case recommendations with real-world examples
+  - Security implications documentation
+- **Documentation**: Professional README with badges, examples, and benchmarks
+  - 99.01% test coverage badge
+  - Ruby/Rails compatibility matrix
+  - Complete usage examples for all features
+  - Migration guide for existing applications
+  - Benchmark results and recommendations
+  - Security considerations
+  - Branch protection rules and contribution guidelines
+
+### Changed
+- Improved pluralization handling using Rails' built-in `pluralize` method
+- Refactored type system with shared Type::Base class
+- Organized specs: separated integration tests from unit tests
+
+### Fixed
+- Rails version compatibility for migrations (supports Rails 7.1 through 8.1)
+- Schema dumper prepend timing by loading sqlite3_adapter explicitly
+- ULID foreign key detection with proper table name pluralization

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bartosz Ozdoba
+
+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,295 @@
+# SQLite crypto
+
+[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/bart-oz/sqlite_crypto/releases)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
+[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](https://github.com/bart-oz/sqlite_crypto/actions)
+[![Coverage](https://img.shields.io/badge/coverage-99.01%25-brightgreen.svg)](https://github.com/bart-oz/sqlite_crypto/actions)
+[![Status](https://img.shields.io/badge/status-active-success.svg)](https://github.com/bart-oz/sqlite_crypto)
+
+Seamless UUID and ULID primary key support for Rails with SQLite3.
+
+### ID Format Comparison
+
+```
+INTEGER:  1, 2, 3, ... (sequential, guessable)
+UUID:     550e8400-e29b-41d4-a716-446655440000 (random, 36 chars)
+ULID:     01ARZ3NDEKTSV4RRFFQ69G5FAV (time-sortable, 26 chars)
+```
+
+## Why Use UUID/ULID Instead of Integer IDs?
+
+|  | **Integer** | **UUID** | **ULID** |
+|---|-------------|----------|----------|
+| **Performance** | Baseline | +2-5% slower | +5-10% slower |
+| **Storage** | 8 bytes | 36 bytes (4.5x) | 26 bytes (3.2x) |
+| **Security** | Guessable | Random | Random |
+| **Collisions** | ⚠️ High in distributed systems | Virtually impossible | Virtually impossible |
+| **Sortable** | Sequential | Random | Time-based |
+| **Distributed** | Needs coordination | Generate anywhere | Generate anywhere |
+
+**Performance testing**: Run `bundle exec rspec --tag performance` to benchmark on your hardware. Specs test scaling from 100 → 10,000 records across inserts, queries, updates, and deletes.
+
+## Gem Compatibility
+
+| Ruby Version | Rails 7.1 | Rails 7.2 | Rails 8.0 | Rails 8.1 |
+|--------------|-----------|-----------|-----------|-----------|
+| 3.1          | ✅        | ✅        | ❌        | ❌        |
+| 3.2          | ✅        | ✅        | ✅        | ✅        |
+| 3.3          | ✅        | ✅        | ✅        | ✅        |
+| 3.4          | ✅        | ✅        | ✅        | ✅        |
+
+**Recommended**: Ruby 3.3+ with Rails 8.0+
+
+**Support Policy**: Actively maintained with updates for new Ruby and Rails versions.
+
+## Features
+
+* UUID primary keys with automatic validation
+* ULID primary keys with time-sortable validation
+* Migration DSL helpers (`t.uuid`, `t.ulid`)
+* Automatic foreign key type detection
+* Model extensions for UUID/ULID generation
+* Clean schema.rb output
+* Zero configuration required
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "sqlite_crypto"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+That's it! No generators or configuration needed.
+
+## Usage
+
+### UUID Primary Keys
+
+```ruby
+class CreateUsers < ActiveRecord::Migration[8.1]
+  def change
+    create_table :users, id: :uuid do |t|
+      t.string :email
+      t.string :name
+      t.timestamps
+    end
+  end
+end
+```
+
+### ULID Primary Keys
+
+```ruby
+class CreatePosts < ActiveRecord::Migration[8.1]
+  def change
+    create_table :posts, id: :ulid do |t|
+      t.string :title
+      t.text :content
+      t.timestamps
+    end
+  end
+end
+```
+
+### UUID/ULID Columns
+
+```ruby
+class AddTrackingIds < ActiveRecord::Migration[8.1]
+  def change
+    change_table :orders do |t|
+      t.uuid :external_id
+      t.ulid :tracking_number
+    end
+  end
+end
+```
+
+### Foreign Keys (Automatic Detection)
+
+The gem automatically detects UUID/ULID primary keys and creates matching foreign keys:
+
+```ruby
+# Users table has UUID primary key
+create_table :users, id: :uuid do |t|
+  t.string :name
+end
+
+# Posts automatically get varchar(36) user_id foreign key
+create_table :posts do |t|
+  t.references :user  # Automatically creates varchar(36) foreign key!
+  t.string :title
+end
+```
+
+Works with ULID too:
+
+```ruby
+# Categories table has ULID primary key
+create_table :categories, id: :ulid do |t|
+  t.string :name
+end
+
+# Articles automatically get varchar(26) category_id foreign key
+create_table :articles do |t|
+  t.references :category  # Automatically creates varchar(26) foreign key!
+  t.string :title
+end
+```
+
+### Custom Table Names
+
+Use `:to_table` option for non-standard table names:
+
+```ruby
+create_table :posts do |t|
+  t.references :author, to_table: :users  # Uses users table's UUID type
+  t.string :title
+end
+```
+
+### Model Extensions (Auto-Generate UUIDs/ULIDs)
+
+Automatically generate UUID or ULID values for any column:
+
+```ruby
+class User < ApplicationRecord
+  # Generate UUID for 'token' column on create
+  generates_uuid :token
+end
+
+class Order < ApplicationRecord
+  # Generate ULID for 'reference' column with uniqueness validation
+  generates_ulid :reference, unique: true
+end
+```
+
+**Features:**
+- `generates_uuid(attribute, unique: false)` - Generates SecureRandom.uuid
+- `generates_ulid(attribute, unique: false)` - Generates time-sortable ULID
+- `unique: true` - Adds uniqueness validation
+- Preserves existing values (won't overwrite if already set)
+- Works with any string column, not just primary keys
+
+**Example migration:**
+
+```ruby
+class AddTokenToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_column :users, :token, :string, limit: 36
+    add_index :users, :token, unique: true
+  end
+end
+```
+
+### Schema Output
+
+Your `db/schema.rb` will be clean and readable:
+
+```ruby
+create_table "users", id: :uuid, force: :cascade do |t|
+  t.string "email"
+  t.timestamps
+end
+
+create_table "posts", force: :cascade do |t|
+  t.string "user_id", limit: 36  # Clean foreign key
+  t.string "title"
+end
+```
+
+## How It Works
+
+1. **Type Registration**: Registers `:uuid` and `:ulid` types with ActiveRecord for SQLite3
+2. **Validation**: UUIDs validate 36-char format, ULIDs validate 26-char format
+3. **Migration Helpers**: `t.uuid()` and `t.ulid()` methods in migrations
+4. **Smart References**: `t.references` detects parent table's primary key type
+5. **Model Extensions**: `generates_uuid` and `generates_ulid` for automatic generation
+6. **Schema Dumper**: Outputs clean `id: :uuid` instead of verbose type definitions
+
+## Requirements
+
+- Rails 7.1+ (tested on 7.1, 7.2, 8.0, 8.1)
+- Ruby 3.1+
+- SQLite3
+
+## Migrating Existing Apps
+
+### New Tables Only (Recommended)
+
+The safest approach is to use UUID/ULID only for new tables:
+
+```ruby
+# Existing tables keep integer IDs
+# users: id (integer)
+# posts: id (integer), user_id (integer)
+
+# New tables use UUID/ULID
+create_table :invoices, id: :uuid do |t|
+  t.references :user  # Still integer (auto-detected from users table)
+  t.decimal :amount
+end
+
+create_table :sessions, id: :ulid do |t|
+  t.references :user  # Still integer
+  t.string :token
+end
+```
+
+## Advanced Patterns
+
+### ID Prefixes (Optional)
+
+For Stripe-style prefixed IDs (`inv_`, `usr_`, etc.), add to your models:
+
+```ruby
+class Invoice < ApplicationRecord
+  before_create :generate_prefixed_id
+
+  private
+
+  def generate_prefixed_id
+    self.id = "inv_#{SecureRandom.uuid}" if id.nil?
+  end
+end
+```
+
+### Mixing Types
+
+You can use different primary key types in the same app:
+
+```ruby
+create_table :users, id: :uuid do |t|
+  t.string :email
+end
+
+create_table :sessions, id: :ulid do |t|
+  t.string :token
+end
+
+create_table :logs do |t|  # Standard integer ID
+  t.string :message
+end
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec standardrb
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+MIT License - see [LICENSE.txt](LICENSE.txt)

data/lib/sqlite_crypto/migration_helpers.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/sqlite3_adapter"
+
+module SqliteCrypto
+  module MigrationHelpers
+    module TableDefinition
+      def uuid(name, **options)
+        column(name, :uuid, **options)
+      end
+
+      def ulid(name, **options)
+        column(name, :ulid, **options)
+      end
+    end
+
+    module References
+      def references(*args, **options)
+        ref_name = args.first
+        ref_table = options.delete(:to_table) || ref_name.to_s.pluralize
+
+        if (primary_key_type = detect_primary_key_type(ref_table))
+          options[:type] ||= :string
+          options[:limit] ||= (primary_key_type == :uuid) ? 36 : 26
+        end
+
+        super
+      end
+
+      alias_method :belongs_to, :references
+
+      private
+
+      def detect_primary_key_type(table_name)
+        conn = @conn || @base || (respond_to?(:connection) ? connection : nil)
+        return nil unless conn&.table_exists?(table_name)
+
+        pk_column = find_primary_key_column(table_name, conn)
+        return nil unless pk_column
+
+        case pk_column.sql_type.downcase
+        when "varchar(36)", "uuid" then :uuid
+        when "varchar(26)", "ulid" then :ulid
+        end
+      end
+
+      def find_primary_key_column(table_name, conn)
+        pk_name = conn.primary_key(table_name)
+        return nil unless pk_name
+
+        conn.columns(table_name).find { |c| c.name == pk_name }
+      end
+    end
+  end
+end
+
+# Extend ActiveRecord classes
+ActiveRecord::ConnectionAdapters::SQLite3::TableDefinition.include(SqliteCrypto::MigrationHelpers::TableDefinition)
+ActiveRecord::ConnectionAdapters::SQLite3::TableDefinition.prepend(SqliteCrypto::MigrationHelpers::References)
+ActiveRecord::ConnectionAdapters::Table.include(SqliteCrypto::MigrationHelpers::TableDefinition)
+ActiveRecord::ConnectionAdapters::Table.prepend(SqliteCrypto::MigrationHelpers::References)

data/lib/sqlite_crypto/model_extensions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "ulid"
+
+module SqliteCrypto
+  module ModelExtensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def generates_uuid(attribute, unique: false)
+        before_create do
+          self[attribute] ||= SecureRandom.uuid
+        end
+
+        validates attribute, uniqueness: true if unique
+      end
+
+      def generates_ulid(attribute, unique: false)
+        before_create do
+          self[attribute] ||= ULID.generate.to_s
+        end
+
+        validates attribute, uniqueness: true if unique
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include(SqliteCrypto::ModelExtensions) if defined?(ActiveRecord::Base)

data/lib/sqlite_crypto/railtie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "sqlite_crypto/type/uuid"
+require "sqlite_crypto/type/ulid"
+
+module SqliteCrypto
+  class Railtie < ::Rails::Railtie
+    # Configuration namespace for users to set options
+    config.sqlite_crypto = ActiveSupport::OrderedOptions.new
+
+    initializer "sqlite_crypto.register_types" do
+      ActiveRecord::Type.register(:uuid, SqliteCrypto::Type::Uuid, adapter: :sqlite3)
+      ActiveRecord::Type.register(:ulid, SqliteCrypto::Type::ULID, adapter: :sqlite3)
+    end
+
+    initializer "sqlite_crypto.schema_dumper", after: "active_record.initialize_database" do
+      require "active_record/connection_adapters/sqlite3_adapter"
+      require "sqlite_crypto/schema_dumper"
+      ActiveRecord::ConnectionAdapters::SQLite3::SchemaDumper.prepend(SqliteCrypto::SchemaDumper)
+    end
+
+    initializer "sqlite_crypto.migration_helpers", after: "active_record.initialize_database" do
+      require "sqlite_crypto/migration_helpers"
+    end
+
+    initializer "sqlite_crypto.model_extensions", after: "active_record.initialize_database" do
+      require "sqlite_crypto/model_extensions"
+    end
+  end
+end

data/lib/sqlite_crypto/schema_dumper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SqliteCrypto
+  module SchemaDumper
+    private
+
+    def column_spec_for_primary_key(column)
+      return super unless column.name == "id" && column.type == :string
+
+      case column.limit
+      when 36 then {id: :uuid}
+      when 26 then {id: :ulid}
+      else super
+      end
+    end
+  end
+end

data/lib/sqlite_crypto/type/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SqliteCrypto
+  module Type
+    class Base < ActiveRecord::Type::String
+      def deserialize(value)
+        return if value.nil?
+        cast(value)
+      end
+
+      def cast(value)
+        return if value.nil?
+        return value if value.is_a?(String) && valid?(value)
+
+        if value.respond_to?(:to_s)
+          str = value.to_s
+          return str if valid?(str)
+        end
+
+        raise ArgumentError, "Invalid #{type.upcase}: #{value.inspect}"
+      end
+
+      def serialize(value)
+        cast(value)
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        cast(raw_old_value) != cast(new_value)
+      end
+
+      private
+
+      def valid?(value)
+        raise NotImplementedError, "Subclasses must implement #valid?"
+      end
+    end
+  end
+end

data/lib/sqlite_crypto/type/ulid.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "sqlite_crypto/type/base"
+
+module SqliteCrypto
+  module Type
+    class ULID < Base
+      def type
+        :ulid
+      end
+
+      private
+
+      def valid?(value)
+        value.match?(/^[0-7][0-9A-Z]{25}$/i)
+      end
+    end
+  end
+end

data/lib/sqlite_crypto/type/uuid.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "sqlite_crypto/type/base"
+
+module SqliteCrypto
+  module Type
+    class Uuid < Base
+      def type
+        :uuid
+      end
+
+      private
+
+      def valid?(value)
+        value.match?(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
+      end
+    end
+  end
+end

data/lib/sqlite_crypto/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SqliteCrypto
+  VERSION = "1.0.0"
+  RUBY_MINIMUM_VERSION = "3.1.0"
+  RAILS_MINIMUM_VERSION = "7.1.0"
+end

data/lib/sqlite_crypto.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "sqlite_crypto/version"
+require "sqlite_crypto/railtie" if defined?(Rails)
+require "sqlite_crypto/schema_dumper" if defined?(ActiveRecord)
+
+module SqliteCrypto
+  class Error < StandardError; end
+
+  def self.load_extensions
+    # Placeholder for future extension loading logic
+  end
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: sqlite_crypto
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- BartOz
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: ulid
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: A lightweight, modular gem providing transparent UUID/ULID primary key
+  configuration for Rails applications using SQLite.
+email:
+- bartek.ozdoba@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/sqlite_crypto.rb
+- lib/sqlite_crypto/migration_helpers.rb
+- lib/sqlite_crypto/model_extensions.rb
+- lib/sqlite_crypto/railtie.rb
+- lib/sqlite_crypto/schema_dumper.rb
+- lib/sqlite_crypto/type/base.rb
+- lib/sqlite_crypto/type/ulid.rb
+- lib/sqlite_crypto/type/uuid.rb
+- lib/sqlite_crypto/version.rb
+homepage: https://github.com/bart-oz/sqlite_crypto
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Seamless UUID/ULID support for Rails 8 with SQLite
+test_files: []