fino 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5692873000111c2c668cdf3dd509fb4bdd9d2f3935b467158686739e8e9cc9f
-  data.tar.gz: 8416e04110ddf6ef6dd4e110e32806ca3b711dd2a13fa13c7bc18cbece91443d
+  metadata.gz: c47c47b3ab49c1eac2959185f67a6cc62e952936c7693f1e1d3d95843afaae88
+  data.tar.gz: da1f3fea78b8d9adbf58a3209c87e6c8acd717371dafe7618f9a2522e744fc0d
 SHA512:
-  metadata.gz: 99dd798252bd649378504426f0b7c13857a3258501642244b5b110428c0bcfa9abce3266c698be1993722f9643e5897e8e2548fe501d9694fc6f0c205321de12
-  data.tar.gz: 9c2f6594f6453f818121e5e273ecc9ed91ff2c85a37c7eedbe82fdd6e2646e36b27f2074b16c5759e6a523003c880aea394785d3c26b599e8178dfd04ad9a57b
+  metadata.gz: bbadb8e1f7f954e7c1f0d9d1a0d7f6455236e67c6dfdaad87a02b9659b3a130f4c7be93cad53f9c486fad6cecd335a308e696ee82b91b1404f2a7fa31048c15c
+  data.tar.gz: '0797cdb045a602b6f9b79ce8f772f7085c857d9addb3d664d74f3a3790676afe046b4c5d81ad4d6b2865b4c244b6debc7bc2ac6ed87cb255adf66fea4a57d9be'

data/README.md

@@ -1,6 +1,6 @@
 # Fino
 
-⚠️ Fino is under active development. API changes are possible ⚠️
+⚠️ 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
 
@@ -23,10 +23,15 @@ Fino.configure do
   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-4o",
+              default: "gpt-5",
               description: "OpenAI model"
 
       setting :temperature,
@@ -51,7 +56,7 @@ end
 ### Work with settings
 
 ```ruby
-Fino.value(:model, at: :openai) #=> "gpt-4o"
+Fino.value(:model, at: :openai) #=> "gpt-5"
 Fino.value(:temperature, at: :openai) #=> 0.7
 
 Fino.values(:model, :temperature, at: :openai) #=> ["gpt-4", 0.7]
@@ -60,12 +65,46 @@ Fino.set(model: "gpt-5", at: :openai)
 Fino.value(:model, at: :openai) #=> "gpt-5"
 ```
 
-### Manage settings via UI
+### Overrides
 
 ```ruby
-gem "fino-rails"
+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
@@ -74,4 +113,84 @@ Rails.application.routes.draw do
 end
 ```
 
-<img width="1229" height="641" alt="Screenshot 2025-09-04 at 16 01 51" src="https://github.com/user-attachments/assets/646df84c-c25b-4890-9637-c481e18c9bd4" />
+### 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/ab_testing/experiment.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Fino::AbTesting::Experiment
+  include Fino::PrettyInspectable
+
+  TOTAL_PERCENTAGE = 100.0
+
+  attr_reader :setting_definition
+
+  def initialize(setting_definition)
+    @setting_definition = setting_definition
+    @user_variants = []
+  end
+
+  def <<(variant)
+    @user_variants << variant
+
+    @variants = nil
+    @value_by_variant_id = nil
+  end
+
+  def variants
+    return @variants if @variants
+    return @variants = [] if @user_variants.empty?
+
+    @variants = [
+      Fino::AbTesting::Variant.new(
+        percentage: TOTAL_PERCENTAGE - @user_variants.sum(&:percentage),
+        value: Fino::AbTesting::Variant::CONTROL_VALUE
+      ),
+      *@user_variants
+    ]
+  end
+
+  def value(for:)
+    variant = variant(for: binding.local_variable_get(:for))
+
+    value_by_variant_id.fetch(
+      variant.id,
+      Fino::AbTesting::Variant::CONTROL_VALUE
+    )
+  end
+
+  def variant(for:)
+    Fino::AbTesting::VariantPicker.new(setting_definition).call(
+      variants,
+      binding.local_variable_get(:for)
+    )
+  end
+
+  private
+
+  def value_by_variant_id
+    @value_by_variant_id ||= variants.each_with_object({}) do |variant, memo|
+      memo[variant.id] = variant.value
+    end
+  end
+
+  def inspectable_attributes
+    {
+      variants: variants
+    }
+  end
+end

data/lib/fino/ab_testing/variant.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Fino::AbTesting::Variant
+  CONTROL_VALUE = Class.new do
+    def inspect
+      "Fino::AbTesting::Variant::CONTROL_VALUE"
+    end
+  end.new
+
+  include Fino::PrettyInspectable
+
+  attr_reader :id, :percentage, :value
+
+  def initialize(percentage:, value:)
+    @id = SecureRandom.uuid
+
+    @percentage = percentage.to_f
+    @value = value
+  end
+
+  private
+
+  def inspectable_attributes
+    {
+      percentage: percentage,
+      value: value
+    }
+  end
+end

data/lib/fino/ab_testing/variant_picker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+class Fino::AbTesting::VariantPicker
+  SCALING_FACTOR = 1_000
+
+  attr_reader :setting_definition
+
+  def initialize(setting_definition)
+    @setting_definition = setting_definition
+  end
+
+  def call(variants, scope)
+    return nil if variants.empty?
+
+    random = Zlib.crc32("#{setting_definition.key}#{scope}") % (100 * SCALING_FACTOR)
+    cumulative = 0
+
+    picked_variant = variants.sort_by(&:percentage).find do |variant|
+      cumulative += variant.percentage * SCALING_FACTOR
+      random <= cumulative
+    end
+
+    Fino.logger.debug { "Variant picked: #{picked_variant}" }
+
+    picked_variant
+  end
+end

data/lib/fino/adapter.rb

@@ -9,7 +9,19 @@ module Fino::Adapter
     raise NotImplementedError
   end
 
-  def write(setting_definition, value)
+  def write(setting_definition, value, overrides, variants)
+    raise NotImplementedError
+  end
+
+  def fetch_value_from(raw_adapter_data)
+    raise NotImplementedError
+  end
+
+  def fetch_raw_overrides_from(raw_adapter_data)
+    raise NotImplementedError
+  end
+
+  def fetch_raw_variants_from(raw_adapter_data)
     raise NotImplementedError
   end
 end

data/lib/fino/cache/memory.rb

@@ -9,15 +9,15 @@ class Fino::Cache::Memory
   end
 
   def exist?(key)
+    expire_if_ready
+
     hash.key?(key)
-  ensure
-    expire_if_needed
   end
 
   def read(key)
+    expire_if_ready
+
     hash[key]
-  ensure
-    expire_if_needed
   end
 
   def write(key, value)
@@ -25,14 +25,20 @@ class Fino::Cache::Memory
   end
 
   def fetch(key, &block)
+    raise ArgumentError, "no block provided to #{self.class.name}#fetch" unless block
+
+    expire_if_ready
+
     hash.fetch(key) do
       write(key, block.call)
     end
-  ensure
-    expire_if_needed
   end
 
-  def fetch_multi(keys, &block)
+  def fetch_multi(*keys, &block)
+    raise ArgumentError, "no block provided to #{self.class.name}#fetch_multi" unless block
+
+    expire_if_ready
+
     missing_keys = keys - hash.keys
 
     if missing_keys.any?
@@ -44,19 +50,21 @@ class Fino::Cache::Memory
     end
 
     hash.values_at(*keys)
-  ensure
-    expire_if_needed
   end
 
   def delete(key)
     hash.delete(key)
   end
 
+  def clear
+    hash.clear
+  end
+
   private
 
   attr_reader :hash, :expirator
 
-  def expire_if_needed
+  def expire_if_ready
     expirator&.when_ready do
       Fino.logger.debug { "Expiring all cache entries" }
       hash.clear

data/lib/fino/definition/section.rb

@@ -11,4 +11,13 @@ class Fino::Definition::Section
   def label
     options.fetch(:label, name.to_s.capitalize)
   end
+
+  def eql?(other)
+    self.class.eql?(other.class) && name == other.name
+  end
+  alias == eql?
+
+  def hash
+    name.hash
+  end
 end

data/lib/fino/definition/setting.rb

@@ -1,6 +1,17 @@
 # frozen_string_literal: true
 
 class Fino::Definition::Setting
+  TYPE_CLASSES = [
+    Fino::Settings::String,
+    Fino::Settings::Integer,
+    Fino::Settings::Float,
+    Fino::Settings::Boolean
+  ].freeze
+
+  SETTING_TYPE_TO_TYPE_CLASS_MAPPING = TYPE_CLASSES.each_with_object({}) do |klass, hash|
+    hash[klass.type_identifier] = klass
+  end.freeze
+
   attr_reader :setting_name, :section_definition, :type, :options
 
   def initialize(type:, setting_name:, section_definition: nil, **options)
@@ -10,20 +21,10 @@ class Fino::Definition::Setting
     @options = options
   end
 
-  def type_class # rubocop:disable Metrics/MethodLength
-    @type_class ||=
-      case type
-      when :string
-        Fino::Settings::String
-      when :integer
-        Fino::Settings::Integer
-      when :float
-        Fino::Settings::Float
-      when :boolean
-        Fino::Settings::Boolean
-      else
-        raise "Unknown type #{type}"
-      end
+  def type_class
+    @type_class ||= SETTING_TYPE_TO_TYPE_CLASS_MAPPING.fetch(type) do
+      raise ArgumentError, "Unknown setting type #{type}"
+    end
   end
 
   def default
@@ -43,4 +44,13 @@ class Fino::Definition::Setting
   def key
     @key ||= path.reverse.join("/")
   end
+
+  def eql?(other)
+    self.class.eql?(other.class) && key == other.key
+  end
+  alias == eql?
+
+  def hash
+    key.hash
+  end
 end

data/lib/fino/expirator.rb

@@ -23,6 +23,6 @@ class Fino::Expirator
   end
 
   def current_timestamp
-    Time.now.to_i
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
   end
 end

data/lib/fino/library.rb

@@ -34,12 +34,6 @@ class Fino::Library
     pipeline.read_multi(setting_definitions)
   end
 
-  def variant(setting_name, at: nil, for:)
-    setting(setting_name, at: at).variant(
-      for: binding.local_variable_get(:for)
-    )
-  end
-
   def set(**data)
     at = data.delete(:at)
     raw_overrides = data.delete(:overrides) || {}
@@ -49,43 +43,50 @@ class Fino::Library
     setting_definition = build_setting_definition(setting_name, at: at)
     value = setting_definition.type_class.deserialize(raw_value)
 
-    variants = raw_variants.map do |percentage, value|
-      Fino::Variant.new(percentage, setting_definition.type_class.deserialize(value))
-    end
+    overrides = raw_overrides.transform_values { |v| setting_definition.type_class.deserialize(v) }
 
-    variants.prepend(
-      Fino::Variant.new(100.0 - variants.sum(&:percentage), Fino::Variant::CONTROL)
-    )
+    experiment = Fino::AbTesting::Experiment.new(setting_definition)
+
+    raw_variants.map do |percentage, value|
+      experiment << Fino::AbTesting::Variant.new(
+        percentage: percentage,
+        value: setting_definition.type_class.deserialize(value)
+      )
+    end
 
     pipeline.write(
       setting_definition,
       value,
-      raw_overrides.transform_values { |v| setting_definition.type_class.deserialize(v) },
-      variants
+      overrides,
+      experiment.variants
     )
   end
 
-  def slice(**mapping)
-    setting_definitions = mapping.each_with_object([]) do |(section_name, setting_names), memo|
-      Array(setting_names).each do |setting_name|
-        memo << build_setting_definition(setting_name, at: section_name)
+  def slice(*settings)
+    setting_definitions = settings.each_with_object([]) do |symbol_or_hash, memo|
+      case symbol_or_hash
+      when Symbol
+        memo << build_setting_definition(symbol_or_hash)
+      when Hash
+        symbol_or_hash.each do |section_name, setting_names|
+          Array(setting_names).each do |setting_name|
+            memo << build_setting_definition(setting_name, at: section_name)
+          end
+        end
+      else
+        raise ArgumentError, "Settings to preload should be either symbols or hashes"
       end
     end
 
     pipeline.read_multi(setting_definitions)
   end
 
-  def set_variants(setting_name, at: nil, variants:)
-    setting_definition = build_setting_definition(setting_name, at: at)
-    pipeline.write_variants(setting_definition, variants)
-  end
-
   private
 
   attr_reader :configuration
 
   def build_setting_definition(setting_name, at: nil)
-    configuration.registry.setting_definition(setting_name.to_s, at&.to_s)
+    configuration.registry.setting_definition!(setting_name.to_s, at&.to_s)
   end
 
   def pipeline

data/lib/fino/pipe/cache.rb

@@ -15,15 +15,15 @@ class Fino::Pipe::Cache
   end
 
   def read_multi(setting_definitions)
-    cache.fetch_multi(setting_definitions.map(&:key)) do |missing_keys|
+    cache.fetch_multi(*setting_definitions.map(&:key)) do |missing_keys|
       uncached_setting_definitions = setting_definitions.filter { |sd| missing_keys.include?(sd.key) }
 
       missing_keys.zip(pipe.read_multi(uncached_setting_definitions))
     end
   end
 
-  def write(setting_definition, value, **context)
-    pipe.write(setting_definition, value, **context)
+  def write(setting_definition, value, overrides, variants)
+    pipe.write(setting_definition, value, overrides, variants)
 
     cache.delete(setting_definition.key)
   end

data/lib/fino/pipe/storage.rb

@@ -27,14 +27,9 @@ class Fino::Pipe::Storage
 
   def to_setting(setting_definition, raw_adapter_data)
     raw_value = adapter.fetch_value_from(raw_adapter_data)
-    scoped_raw_values = adapter.fetch_scoped_values_from(raw_adapter_data)
+    raw_overrides = adapter.fetch_raw_overrides_from(raw_adapter_data)
     raw_variants = adapter.fetch_raw_variants_from(raw_adapter_data)
 
-    setting_definition.type_class.build(
-      setting_definition,
-      raw_value,
-      scoped_raw_values,
-      raw_variants
-    )
+    Fino::SettingBuilder.new(setting_definition).call(raw_value, raw_overrides, raw_variants)
   end
 end

data/lib/fino/pipe.rb

@@ -13,7 +13,7 @@ module Fino::Pipe
     raise NotImplementedError
   end
 
-  def write(setting_definition, value, overrides = {}, variants = {})
+  def write(setting_definition, value, overrides, variants)
     raise NotImplementedError
   end
 

data/lib/fino/pretty_inspectable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fino::PrettyInspectable
+  def inspect
+    attributes = inspectable_attributes.map do |key, value|
+      "#{key}=#{value.inspect}"
+    end
+
+    "#<#{self.class.name} #{attributes.join(', ')}>"
+  end
+
+  def pretty_print(pp) # rubocop:disable Metrics/MethodLength
+    pp.object_group(self) do
+      pp.nest(1) do
+        pp.breakable
+        pp.seplist(inspectable_attributes, nil, :each) do |key, value|
+          pp.group do
+            pp.text key.to_s
+            pp.text ": "
+            pp.pp value
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def inspectable_attributes
+    raise NotImplementedError
+  end
+end

data/lib/fino/registry.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 class Fino::Registry
+  DuplicateSetting = Class.new(Fino::Error)
+  UnknownSetting = Class.new(Fino::Error)
+
   class DSL
     class SectionDSL
       def initialize(section_definition, registry)
@@ -46,22 +49,24 @@ class Fino::Registry
     end
   end
 
-  UnknownSetting = Class.new(Fino::Error)
-
   using Fino::Ext::Hash
 
   attr_reader :setting_definitions, :section_definitions
 
   def initialize
-    @setting_definitions = []
+    @setting_definitions = Set.new
     @setting_definitions_by_path = {}
 
-    @section_definitions = []
+    @section_definitions = Set.new
     @section_definitions_by_name = {}
   end
 
   def setting_definition(*path)
-    @setting_definitions_by_path.dig(*path.compact.reverse).tap do |definition|
+    @setting_definitions_by_path.dig(*path.compact.reverse.map(&:to_s))
+  end
+
+  def setting_definition!(*path)
+    setting_definition(*path).tap do |definition|
       raise UnknownSetting, "Unknown setting: #{path.compact.join('.')}" unless definition
     end
   end
@@ -82,13 +87,16 @@ class Fino::Registry
   end
 
   def register(setting_definition)
-    @setting_definitions << setting_definition
+    unless @setting_definitions.add?(setting_definition)
+      raise DuplicateSetting, "#{setting_definition.setting_name} is already registered at #{setting_definition.key}"
+    end
 
     @setting_definitions_by_path.deep_set(setting_definition, *setting_definition.path.map(&:to_s))
   end
 
   def register_section(section_definition)
-    @section_definitions << section_definition
-    @section_definitions_by_name.deep_set(section_definition, section_definition.name.to_s)
+    return unless @section_definitions.add?(section_definition)
+
+    @section_definitions_by_name[section_definition.name.to_s] = section_definition
   end
 end

data/lib/fino/setting.rb

@@ -1,11 +1,21 @@
 # frozen_string_literal: true
 
 module Fino::Setting
+  include Fino::PrettyInspectable
+
   def self.included(base)
     base.extend(ClassMethods)
   end
 
   module ClassMethods
+    def type_identifier=(identifier)
+      @type_identifier = identifier
+    end
+
+    def type_identifier
+      @type_identifier
+    end
+
     def serialize(value)
       raise NotImplementedError
     end
@@ -13,81 +23,36 @@ module Fino::Setting
     def deserialize(raw_value)
       raise NotImplementedError
     end
-
-    def build(setting_definition, raw_value, scoped_raw_values, raw_variants)
-      value = raw_value.equal?(Fino::EMPTINESS) ? setting_definition.options[:default] : deserialize(raw_value)
-      scoped_values = scoped_raw_values.transform_values { |v| deserialize(v) }
-
-      variants = raw_variants.map do |raw_variant|
-        Fino::Variant.new(
-          raw_variant.fetch(:percentage),
-          deserialize(raw_variant.fetch(:value))
-        )
-      end
-
-      variants.prepend(
-        Fino::Variant.new(percentage: 100.0 - variants.sum(&:percentage), value: Fino::Variant::CONTROL)
-      )
-
-      new(
-        setting_definition,
-        value,
-        scoped_values,
-        variants
-      )
-    end
   end
 
-  attr_reader :definition, :variants
+  attr_reader :definition, :global_value, :overrides, :experiment
 
-  def initialize(definition, value, scoped_values = {}, variants = [])
+  def initialize(definition, global_value, overrides = {}, experiment = nil)
     @definition = definition
-    @value = value
-    @scoped_values = scoped_values
-    @variants = variants
-  end
-
-  def name
-    definition.setting_name
-  end
-
-  def key
-    definition.key
+    @global_value = global_value
+    @overrides = overrides
+    @experiment = experiment
   end
 
   def value(**context)
-    return @value unless (scope = context[:for])
+    return global_value unless (scope = context[:for])
 
-    scoped_values.fetch(scope.to_s) do
-      return @value if variants.empty?
+    overrides.fetch(scope.to_s) do
+      return global_value unless experiment
 
-      variant = variant(for: scope)
-      result = variant_id_to_value.fetch(variant.id, @value)
+      value = experiment.value(for: scope)
+      return global_value if value == Fino::AbTesting::Variant::CONTROL_VALUE
 
-      return @value if result == Fino::Variant::CONTROL
-
-      result
+      value
     end
   end
 
-  def variant(for:)
-    Fino::VariantPicker.new(self).call(
-      binding.local_variable_get(:for)
-    )
-  end
-
-  def variant_id_to_value
-    @variant_id_to_value ||= variants.each_with_object({}) do |variant, memo|
-      memo[variant.id] = variant.value
-    end
-  end
-
-  def overriden_scopes
-    scoped_values.keys
+  def name
+    definition.setting_name
   end
 
-  def scope_overrides
-    scoped_values
+  def key
+    definition.key
   end
 
   def type
@@ -114,20 +79,17 @@ module Fino::Setting
     definition.description
   end
 
-  def inspect
-    attributes = [
-      "key=#{key.inspect}",
-      "type=#{type_class.inspect}",
-      "value=#{value.inspect}",
-      "overrides=#{@scoped_values.inspect}",
-      "variants=#{variants.inspect}",
-      "default=#{default.inspect}"
-    ]
-
-    "#<#{self.class.name} #{attributes.join(', ')}>"
-  end
-
   private
 
-  attr_reader :scoped_values
+  def inspectable_attributes
+    {
+      key: key,
+      type: type_class,
+      default: default,
+      global_value: global_value
+    }.tap do |attributes|
+      attributes[:overrides] = overrides if overrides.present?
+      attributes[:experiment] = experiment if experiment
+    end
+  end
 end

data/lib/fino/setting_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Fino::SettingBuilder
+  attr_reader :setting_definition
+
+  def initialize(setting_definition)
+    @setting_definition = setting_definition
+  end
+
+  def call(raw_value, raw_overrides, raw_variants)
+    global_value = deserialize_global_value(raw_value)
+    overrides = deserialize_overrides(raw_overrides)
+    experiment = deserialize_experiment(raw_variants)
+
+    setting_definition.type_class.new(
+      setting_definition,
+      global_value,
+      overrides,
+      experiment
+    )
+  end
+
+  private
+
+  def deserialize_global_value(raw_value)
+    return setting_definition.options[:default] if raw_value.equal?(Fino::EMPTINESS)
+
+    deserialize(raw_value)
+  end
+
+  def deserialize_overrides(raw_overrides)
+    raw_overrides.transform_values { |v| deserialize(v) }
+  end
+
+  def deserialize_experiment(raw_variants)
+    return if raw_variants.empty?
+
+    Fino::AbTesting::Experiment.new(setting_definition).tap do |experiment|
+      raw_variants.each do |raw_variant|
+        experiment << Fino::AbTesting::Variant.new(
+          percentage: raw_variant.fetch(:percentage),
+          value: deserialize(raw_variant.fetch(:value))
+        )
+      end
+    end
+  end
+
+  def deserialize(value)
+    setting_definition.type_class.deserialize(value)
+  end
+end

data/lib/fino/settings/boolean.rb

@@ -3,6 +3,8 @@
 class Fino::Settings::Boolean
   include Fino::Setting
 
+  self.type_identifier = :boolean
+
   class << self
     def serialize(value)
       value ? "1" : "0"

data/lib/fino/settings/float.rb

@@ -3,6 +3,8 @@
 class Fino::Settings::Float
   include Fino::Setting
 
+  self.type_identifier = :float
+
   class << self
     def serialize(value)
       value.to_s

data/lib/fino/settings/integer.rb

@@ -3,6 +3,8 @@
 class Fino::Settings::Integer
   include Fino::Setting
 
+  self.type_identifier = :integer
+
   class << self
     def serialize(value)
       value.to_s

data/lib/fino/settings/string.rb

@@ -3,6 +3,8 @@
 class Fino::Settings::String
   include Fino::Setting
 
+  self.type_identifier = :string
+
   class << self
     def serialize(value)
       value

data/lib/fino/version.rb

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

data/lib/fino.rb

@@ -4,12 +4,30 @@ require "forwardable"
 require "zeitwerk"
 
 module Fino
-  module Configurable
+  module Stateful
     def configure(&block)
       configuration.instance_eval(&block)
     end
 
-    private
+    def reset!
+      Thread.current[:fino_library] = nil
+
+      @registry = nil
+      @configuration = nil
+    end
+
+    def reconfigure(&block)
+      reset!
+      configure(&block)
+    end
+
+    def library
+      Thread.current[:fino_library] ||= Fino::Library.new(configuration)
+    end
+
+    def registry
+      @registry ||= Fino::Registry.new
+    end
 
     def configuration
       @configuration ||= Fino::Configuration.new(registry)
@@ -25,32 +43,20 @@ module Fino
                    :setting,
                    :settings,
                    :slice,
-                   :set,
-                   :define_variants,
-                   :variant
-
-    module_function
+                   :set
 
     def library
       raise NotImplementedError
     end
   end
 
-  extend Configurable
   extend SettingsAccessible
+  extend Stateful
 
   EMPTINESS = Object.new.freeze
 
   module_function
 
-  def library
-    Thread.current[:fino_library] ||= Fino::Library.new(configuration)
-  end
-
-  def registry
-    @registry ||= Fino::Registry.new
-  end
-
   def logger
     @logger ||= begin
       require "logger"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fino
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Egor Iskrenkov
@@ -32,6 +32,9 @@ files:
 - LICENSE
 - README.md
 - lib/fino.rb
+- lib/fino/ab_testing/experiment.rb
+- lib/fino/ab_testing/variant.rb
+- lib/fino/ab_testing/variant_picker.rb
 - lib/fino/adapter.rb
 - lib/fino/cache.rb
 - lib/fino/cache/memory.rb
@@ -47,15 +50,15 @@ files:
 - lib/fino/pipe/cache.rb
 - lib/fino/pipe/storage.rb
 - lib/fino/pipeline.rb
+- lib/fino/pretty_inspectable.rb
 - lib/fino/registry.rb
 - lib/fino/setting.rb
+- lib/fino/setting_builder.rb
 - lib/fino/settings/boolean.rb
 - lib/fino/settings/float.rb
 - lib/fino/settings/integer.rb
 - lib/fino/settings/section.rb
 - lib/fino/settings/string.rb
-- lib/fino/variant.rb
-- lib/fino/variant_picker.rb
 - lib/fino/version.rb
 homepage: https://github.com/eiskrenkov/fino
 licenses:

data/lib/fino/variant.rb

@@ -1,5 +0,0 @@
-
-Fino::Variant = Struct.new(:percentage, :value) do
-  def id = @id ||= SecureRandom.uuid
-end
-Fino::Variant::CONTROL = Object.new

data/lib/fino/variant_picker.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::VariantPicker
-  SCALING_FACTOR = 1_000
-
-  attr_reader :setting
-
-  def initialize(setting)
-    @setting = setting
-  end
-
-  def call(scope)
-    return nil if setting.variants.empty?
-
-    random = Zlib.crc32("#{setting.key}#{scope}") % (100 * SCALING_FACTOR)
-    cumulative = 0
-
-    picked_variant = setting.variants.sort_by(&:percentage).find do |variant|
-      cumulative += variant.percentage * SCALING_FACTOR
-      random <= cumulative
-    end
-
-    Fino.logger.debug { "Variant picked: #{picked_variant}" }
-
-    picked_variant
-  end
-end