fino-solid 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2a58a6b231e01407c065d6512bf369ff01b59cf31e8a4572a0f5b10c6f713ae1
+  data.tar.gz: 60a3d6bcceb5803271a61756aa0c466ebc3463e4356143118438d145427084d0
+SHA512:
+  metadata.gz: 11e09a0f69092545b9ff9c97f47e55660c823d4774aa34f878bb6a2f15db4669b7bf9974479a3c8a93ec301071942673ec0204d42d998f75fac0ec97aba3be2c
+  data.tar.gz: bab475d8c0590a1475fa096b25f60d161c2f0acd4fba7dfed42ad72e2c8a8233470cb1556286917c44b53f3571f17f53a94fc7aa0ef54d0a34ab4f1b5f755336

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Egor Iskrenkov
+
+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,196 @@
+# Fino
+
+⚠️ Fino in active development phase at wasn't properly battle tested in production just yet. Give us a star and stay tuned for Production test results and new features
+
+Fino is a dynamic settings engine for Ruby and Rails
+
+## Usage
+
+### Define settings via DSL
+
+```ruby
+require "fino-redis"
+
+Fino.configure do
+  adapter do
+    Fino::Redis::Adapter.new(
+      Redis.new(**Rails.application.config_for(:redis))
+    )
+  end
+
+  cache { Fino::Cache::Memory.new(expires_in: 3.seconds) }
+
+  settings do
+    setting :maintenance_mode, :boolean, default: false
+
+    setting :api_rate_limit,
+            :integer,
+            default: 1000,
+            description: "Maximum API requests per minute per user to prevent abuse"
+
+    section :openai, label: "OpenAI" do
+      setting :model,
+              :string,
+              default: "gpt-5",
+              description: "OpenAI model"
+
+      setting :temperature,
+              :float,
+              default: 0.7,
+              description: "Model temperature"
+    end
+
+    section :feature_toggles, label: "Feature Toggles" do
+      setting :new_ui, :boolean, default: true
+      setting :beta_functionality, :boolean, default: false
+    end
+
+    section :my_micro_service, label: "My Micro Service" do
+      setting :http_read_timeout, :integer, default: 200 # in ms
+      setting :http_open_timeout, :integer, default: 100 # in ms
+    end
+  end
+end
+```
+
+### Work with settings
+
+```ruby
+Fino.value(:model, at: :openai) #=> "gpt-5"
+Fino.value(:temperature, at: :openai) #=> 0.7
+
+Fino.values(:model, :temperature, at: :openai) #=> ["gpt-4", 0.7]
+
+Fino.set(model: "gpt-5", at: :openai)
+Fino.value(:model, at: :openai) #=> "gpt-5"
+```
+
+### Overrides
+
+```ruby
+Fino.value(:model, at: :openai) #=> "gpt-5"
+
+Fino.set(model: "gpt-5", at: :openai, overrides: { "qa" => "our_local_model_not_to_pay_to_sam_altman" })
+
+Fino.value(:model, at: :openai) #=> "gpt-5"
+Fino.value(:model, at: :openai, for: "qa") #=> "our_local_model_not_to_pay_to_sam_altman"
+```
+
+### A/B testing
+
+```ruby
+Fino.value(:model, at: :openai) #=> "gpt-5"
+
+# "gpt-5" becomes the control variant value and a 20.0% variant is created with value "gpt-6"
+Fino.set(model: "gpt-5", at: :openai, variants: { 20.0 => "gpt-6" })
+
+Fino.setting(:model, at: :openai).experiment.variant(for: "user_1") #=> #<Fino::AbTesting::Variant percentage: 20.0, value: "gpt-6">
+
+# Picked variant is sticked to the user
+Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
+Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
+
+Fino.value(:model, at: :openai, for: "user_2") #=> "gpt-5"
+```
+
+## Rails integration
+
+Fino easily integrates with Rails. Just add the gem to your Gemfile:
+
+```
+gem "fino-rails", require: false
+```
+
+to get built-in UI engine for your settings!
+
+### UI engine
+
+Mount Fino Rails engine in your `config/routes.rb`:
+
+```ruby
+Rails.application.routes.draw do
+  mount Fino::Rails::Engine, at: "/fino"
+end
+```
+
+### Configuration
+
+```ruby
+Rails.application.configure do
+  config.fino.instrument = true
+  config.fino.log = true
+  config.fino.cache_within_request = false
+  config.fino.preload_before_request = true
+end
+```
+
+<img width="1493" height="676" alt="Screenshot 2025-09-19 at 13 09 06" src="https://github.com/user-attachments/assets/19b6147a-e18c-41cf-aac7-99111efcc9d5" />
+
+<img width="1775" height="845" alt="Screenshot 2025-09-19 at 13 09 33" src="https://github.com/user-attachments/assets/c0010abd-285d-43d0-ae5d-ce0edb781309" />
+
+## Performance tweaks
+
+1. In Memory cache
+
+   Fino provides in-memory settings caching functionality which will store settings received from adaper in memory for
+   a very quick access. As this kind of cache is not distributed between machines, but belongs to each process
+   separately, it's impossible to invalidate all at once, so be aware that setting update application time will depend
+   on cache TTL you configure
+
+   ```ruby
+   Fino.configure do
+     # ...
+     cache { Fino::Cache::Memory.new(expires_in: 3.seconds) }
+     # ...
+   end
+   ```
+
+2. Request scoped cache
+
+   When using Fino in Rails context it's possible to cache settings within request, in current thread storage. This is
+   safe way to cache settings as it's lifetime is limited, thus it is enabled by default
+
+   ```ruby
+   Rails.application.configure do
+     config.fino.cache_within_request = true
+   end
+   ```
+
+3. Preloading
+
+   In Rails context it is possible to tell Fino to preload multiple settings before processing request in a single
+   adapter call. Preloading is recommended for requests that use multiple different settings in their logic
+
+   ```ruby
+   # Preload all settings
+   Rails.application.configure do
+     config.fino.preload_before_request = true
+   end
+
+   # Preload specific subset of settings depending on request
+   Rails.application.configure do
+     config.fino.preload_before_request = ->(request) {
+       case request.path
+       when "request/using/all/settings"
+         true
+       when "request/not/using/settings"
+         false
+       when "request/using/specific/settings"
+         [
+           :api_rate_limit,
+           openai: [:model, :temperature]
+         ]
+       end
+     }
+   end
+   ```
+
+## Releasing
+
+`rake release`
+
+## Contributing
+
+1. Fork it
+2. Do contribution
+6. Create Pull Request into this repo

data/lib/fino/solid/README.md

@@ -0,0 +1,284 @@
+# Fino::Solid
+
+ActiveRecord adapter for [Fino](https://github.com/eiskrenkov/fino) settings engine, inspired by solid_queue.
+
+## Features
+
+- **Database-backed persistence** using ActiveRecord
+- **Efficient read performance** with single-table design
+- **Multi-database support** (SQLite, PostgreSQL, MySQL)
+- **Rails integration** with migration generators
+- **Supports all Fino features**: overrides, A/B testing, sections
+- **Thread-safe** and production-ready
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "fino-solid"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Setup
+
+### Rails Applications
+
+1. Generate the migration:
+
+```bash
+bin/rails generate fino:solid:install
+```
+
+2. Run the migration:
+
+```bash
+bin/rails db:migrate
+```
+
+3. Configure Fino to use the Solid adapter:
+
+```ruby
+# config/initializers/fino.rb
+require "fino-solid"
+
+Fino.configure do
+  adapter { Fino::Solid::Adapter.new }
+
+  settings do
+    setting :maintenance_mode, :boolean, default: false
+    # ... your settings
+  end
+end
+```
+
+### Non-Rails Applications
+
+1. Create the migration manually:
+
+```ruby
+class CreateFinoSettings < ActiveRecord::Migration[7.0]
+  def change
+    create_table :fino_settings do |t|
+      t.string :key, null: false
+      t.text :data
+      t.timestamps
+    end
+
+    add_index :fino_settings, :key, unique: true
+  end
+end
+```
+
+2. Configure the adapter:
+
+```ruby
+require "fino-solid"
+require "active_record"
+
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: "db/fino.sqlite3"
+)
+
+Fino.configure do
+  adapter { Fino::Solid::Adapter.new }
+
+  settings do
+    # ... your settings
+  end
+end
+```
+
+## Configuration
+
+### Multi-Database Setup
+
+If you're using Rails multi-database configuration (like solid_queue), you can configure Fino::Solid to use a specific database:
+
+```ruby
+# config/initializers/fino.rb
+Fino::Solid.configure do
+  self.connects_to = { database: { writing: :settings } }
+end
+```
+
+Then configure your database.yml:
+
+```yaml
+production:
+  primary:
+    <<: *default
+    database: my_app_production
+  settings:
+    <<: *default
+    database: my_app_settings_production
+    migrations_paths: db/settings_migrate
+```
+
+## Database Schema
+
+The adapter uses a simple, efficient single-table design:
+
+```ruby
+create_table :fino_settings do |t|
+  t.string :key, null: false      # "api_rate_limit" or "openai/model"
+  t.text :data                    # JSON: {"v": "value", "s/scope/v": "override", ...}
+  t.timestamps
+end
+
+add_index :fino_settings, :key, unique: true
+```
+
+### Data Structure
+
+Settings are stored as JSON with this structure:
+
+```json
+{
+  "v": "serialized_value",
+  "s/qa/v": "override_for_qa_scope",
+  "s/admin/v": "override_for_admin_scope",
+  "v/20.0/v": "variant_value_for_20_percent",
+  "v/30.0/v": "variant_value_for_30_percent"
+}
+```
+
+This mirrors the Redis adapter structure for consistency.
+
+## Performance
+
+### Read Performance
+
+- **Single setting**: 1 query (`SELECT * FROM fino_settings WHERE key = ?`)
+- **Multiple settings**: 1 query (`SELECT * FROM fino_settings WHERE key IN (?, ?, ?)`)
+- **All settings**: 1 query (`SELECT * FROM fino_settings`)
+
+### Write Performance
+
+- Uses ActiveRecord's `upsert` for atomic write operations
+- Single transaction per setting update
+
+### Optimization Tips
+
+1. **Use in-memory cache** to reduce database queries:
+
+```ruby
+Fino.configure do
+  adapter { Fino::Solid::Adapter.new }
+  cache { Fino::Cache::Memory.new(expires_in: 3.seconds) }
+end
+```
+
+2. **Batch reads** with `read_multi`:
+
+```ruby
+# In Rails:
+Fino.values(:maintenance_mode, :api_rate_limit)  # 1 query instead of 2
+```
+
+3. **Preload settings** in Rails:
+
+```ruby
+Rails.application.configure do
+  config.fino.preload_before_request = true
+end
+```
+
+## Supported Databases
+
+- **SQLite** 3.38+ (with JSON support)
+- **PostgreSQL** 9.4+ (with JSON/JSONB)
+- **MySQL** 5.7+ (with JSON support)
+
+## Examples
+
+### Basic Usage
+
+```ruby
+# Set a value
+Fino.set(api_rate_limit: 1000)
+
+# Read a value
+Fino.value(:api_rate_limit)  # => 1000
+```
+
+### With Overrides
+
+```ruby
+# Set value with scope overrides
+Fino.set(
+  api_rate_limit: 1000,
+  overrides: {
+    "premium" => 5000,
+    "enterprise" => 10000
+  }
+)
+
+# Read with scope
+Fino.value(:api_rate_limit)                    # => 1000
+Fino.value(:api_rate_limit, for: "premium")    # => 5000
+Fino.value(:api_rate_limit, for: "enterprise") # => 10000
+```
+
+### With A/B Testing
+
+```ruby
+# Create an experiment
+Fino.set(
+  api_rate_limit: 1000,
+  variants: {
+    20.0 => 2000,  # 20% of users get 2000
+    30.0 => 3000   # 30% of users get 3000
+  }
+  # Remaining 50% get control value (1000)
+)
+
+# Users are deterministically assigned to variants
+Fino.value(:api_rate_limit, for: "user_123")  # => 2000 (always same)
+Fino.value(:api_rate_limit, for: "user_456")  # => 1000 (control)
+```
+
+## Comparison with Redis Adapter
+
+| Feature | Fino::Solid | Fino::Redis |
+|---------|-------------|-------------|
+| Persistence | SQL Database | Redis |
+| Read Performance | Excellent (indexed) | Excellent (in-memory) |
+| Write Performance | Good (ACID) | Excellent |
+| Durability | ACID compliant | Depends on Redis config |
+| Multi-database | Native support | Namespace support |
+| Backup/Restore | Standard DB tools | Redis tools |
+| Query Flexibility | SQL available | Limited |
+| Setup Complexity | Low (Rails) | Medium |
+
+## Testing
+
+The gem includes comprehensive integration tests using shared examples:
+
+```bash
+# Run Solid adapter tests
+bundle exec rspec spec/integration/solid_adapter_spec.rb
+
+# Test all databases
+DATABASE=sqlite bundle exec rspec spec/integration/solid_adapter_spec.rb
+DATABASE=postgresql bundle exec rspec spec/integration/solid_adapter_spec.rb
+DATABASE=mysql bundle exec rspec spec/integration/solid_adapter_spec.rb
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+MIT

data/lib/fino/solid/adapter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Fino
+  module Solid
+    class Adapter
+      include Fino::Adapter
+
+      SCOPE_PREFIX = "s"
+      VARIANT_PREFIX = "v"
+      VALUE_KEY = "v"
+
+      def read(setting_key)
+        setting = Fino::Solid::Setting.find_by(key: setting_key)
+        setting&.data || {}
+      end
+
+      def read_multi(setting_keys)
+        settings_by_key = Fino::Solid::Setting.where(key: setting_keys).index_by(&:key)
+
+        setting_keys.map { |key| settings_by_key[key]&.data || {} }
+      end
+
+      def write(setting_definition, value, overrides, variants)
+        serialize_value = ->(raw_value) { setting_definition.type_class.serialize(raw_value) }
+
+        data = { VALUE_KEY => serialize_value.call(value) }
+
+        overrides.each do |scope, scope_value|
+          data["#{SCOPE_PREFIX}/#{scope}/#{VALUE_KEY}"] = serialize_value.call(scope_value)
+        end
+
+        variants.each do |variant|
+          next if variant.value == Fino::AbTesting::Variant::CONTROL_VALUE
+
+          data["#{VARIANT_PREFIX}/#{variant.percentage}/#{VALUE_KEY}"] = serialize_value.call(variant.value)
+        end
+
+        Fino::Solid::Setting.upsert(
+          { key: setting_definition.key, data: data },
+          unique_by: :key
+        )
+      end
+
+      def read_persisted_setting_keys
+        Fino::Solid::Setting.pluck(:key)
+      end
+
+      def clear(setting_key)
+        Fino::Solid::Setting.where(key: setting_key).delete_all > 0
+      end
+
+      def fetch_value_from(raw_adapter_data)
+        raw_adapter_data.key?(VALUE_KEY) ? raw_adapter_data.delete(VALUE_KEY) : Fino::EMPTINESS
+      end
+
+      def fetch_raw_overrides_from(raw_adapter_data)
+        raw_adapter_data.each_with_object({}) do |(key, value), memo|
+          next unless key.start_with?("#{SCOPE_PREFIX}/")
+
+          scope = key.split("/", 3)[1]
+          memo[scope] = value
+        end
+      end
+
+      def fetch_raw_variants_from(raw_adapter_data)
+        raw_adapter_data.each_with_object([]) do |(key, value), memo|
+          next unless key.start_with?("#{VARIANT_PREFIX}/")
+
+          percentage = key.split("/", 3)[1]
+
+          memo << { percentage: percentage.to_f, value: value }
+        end
+      end
+    end
+  end
+end

data/lib/fino/solid/generators/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Installs Fino::Solid adapter by creating necessary database migration.
+
+Example:
+    bin/rails generate fino:solid:install
+
+    This will create:
+        db/migrate/[timestamp]_create_fino_settings.rb

data/lib/fino/solid/generators/install/install_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Fino
+  module Solid
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        include ::ActiveRecord::Generators::Migration
+
+        source_root File.expand_path("templates", __dir__)
+
+        def copy_migration
+          migration_template "create_fino_settings.rb.tt", File.join(db_migrate_path, "create_fino_settings.rb")
+        end
+
+        private
+
+        def db_migrate_path
+          "db/migrate"
+        end
+      end
+    end
+  end
+end

data/lib/fino/solid/generators/install/templates/create_fino_settings.rb.tt

@@ -0,0 +1,12 @@
+class CreateFinoSettings < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :fino_settings do |t|
+      t.string :key, null: false
+      t.text :data
+
+      t.timestamps
+    end
+
+    add_index :fino_settings, :key, unique: true
+  end
+end

data/lib/fino/solid/railtie.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Fino
+  module Solid
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/fino/solid/record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fino
+  module Solid
+    class Record < ActiveRecord::Base
+      self.abstract_class = true
+
+      connects_to(**Fino::Solid.connects_to) if Fino::Solid.connects_to
+    end
+  end
+end

data/lib/fino/solid/setting.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fino
+  module Solid
+    class Setting < Record
+      self.table_name = "fino_settings"
+
+      serialize :data, coder: JSON
+
+      validates :key, presence: true, uniqueness: true
+    end
+  end
+end

data/lib/fino/solid.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Fino
+  module Solid
+    mattr_accessor :connects_to
+
+    class << self
+      def configure(&block)
+        instance_eval(&block)
+      end
+    end
+  end
+end
+
+require "fino/solid/record"
+require "fino/solid/setting"
+require "fino/solid/adapter"
+require "fino/solid/railtie" if defined?(Rails::Railtie)
+
+if defined?(Rails) && defined?(Rails::Generators)
+  require "rails/generators"
+  require_relative "solid/generators/install/install_generator"
+end

data/lib/fino/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Fino
+  VERSION = "1.4.0"
+  REQUIRED_RUBY_VERSION = ">= 3.0.0"
+end

data/lib/fino-solid.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "fino"
+require "fino/solid"

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: fino-solid
+version: !ruby/object:Gem::Version
+  version: 1.4.0
+platform: ruby
+authors:
+- Egor Iskrenkov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fino
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+email:
+- egor@iskrenkov.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fino-solid.rb
+- lib/fino/solid.rb
+- lib/fino/solid/README.md
+- lib/fino/solid/adapter.rb
+- lib/fino/solid/generators/install/USAGE
+- lib/fino/solid/generators/install/install_generator.rb
+- lib/fino/solid/generators/install/templates/create_fino_settings.rb.tt
+- lib/fino/solid/railtie.rb
+- lib/fino/solid/record.rb
+- lib/fino/solid/setting.rb
+- lib/fino/version.rb
+homepage: https://github.com/eiskrenkov/fino
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/eiskrenkov/fino
+  bug_tracker_uri: https://github.com/eiskrenkov/fino/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.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: ActiveRecord adapter for Fino settings engine
+test_files: []