fino 1.1.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a89fc5426c11c8a579d0e95b04ec8d5deb836a35f217f9e321f3f0a0b94eab7d
-  data.tar.gz: 61140c5d0665b59a2ce86cf723d1f026757e90e8e21cd4cbe6c488f6c8f6d96d
+  metadata.gz: c5692873000111c2c668cdf3dd509fb4bdd9d2f3935b467158686739e8e9cc9f
+  data.tar.gz: 8416e04110ddf6ef6dd4e110e32806ca3b711dd2a13fa13c7bc18cbece91443d
 SHA512:
-  metadata.gz: da686fb13de3413f15900c5b710a76d77ced5cb5a9861df0fe293db51c601cd4975193b9208aff6c1e0dac48ed176255019bcbca4e17340249215a25dc029b59
-  data.tar.gz: d8bc6812eb4f39493ea31ef986418010ec0d12dc022efa0a38b590769876e19b399f9124527bb47caf553adfe4eac30df660a1c4f1b2d2e19ed6a4fd2c3b2063
+  metadata.gz: 99dd798252bd649378504426f0b7c13857a3258501642244b5b110428c0bcfa9abce3266c698be1993722f9643e5897e8e2548fe501d9694fc6f0c205321de12
+  data.tar.gz: 9c2f6594f6453f818121e5e273ecc9ed91ff2c85a37c7eedbe82fdd6e2646e36b27f2074b16c5759e6a523003c880aea394785d3c26b599e8178dfd04ad9a57b

data/lib/fino/cache/memory.rb

@@ -48,6 +48,10 @@ class Fino::Cache::Memory
     expire_if_needed
   end
 
+  def delete(key)
+    hash.delete(key)
+  end
+
   private
 
   attr_reader :hash, :expirator

data/lib/fino/library.rb

@@ -7,12 +7,12 @@ class Fino::Library
     @configuration = configuration
   end
 
-  def value(setting_name, at: nil)
-    setting(setting_name, at: at).value
+  def value(setting_name, at: nil, **context)
+    setting(setting_name, at: at).value(**context)
   end
 
-  def values(*setting_names, at: nil)
-    settings(*setting_names, at: at).map(&:value)
+  def values(*setting_names, at: nil, **context)
+    settings(*setting_names, at: at).map { |s| s.value(**context) }
   end
 
   def setting(setting_name, at: nil)
@@ -34,17 +34,35 @@ class Fino::Library
     pipeline.read_multi(setting_definitions)
   end
 
-  def set(**setting_names_to_values)
-    at = setting_names_to_values.delete(:at)
+  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) || {}
+    raw_variants = data.delete(:variants) || {}
 
-    setting_names_to_values.each do |setting_name, value|
-      setting_definition = build_setting_definition(setting_name, at: at)
+    setting_name, raw_value = data.first
+    setting_definition = build_setting_definition(setting_name, at: at)
+    value = setting_definition.type_class.deserialize(raw_value)
 
-      pipeline.write(
-        setting_definition,
-        setting_definition.type_class.deserialize(value)
-      )
+    variants = raw_variants.map do |percentage, value|
+      Fino::Variant.new(percentage, setting_definition.type_class.deserialize(value))
     end
+
+    variants.prepend(
+      Fino::Variant.new(100.0 - variants.sum(&:percentage), Fino::Variant::CONTROL)
+    )
+
+    pipeline.write(
+      setting_definition,
+      value,
+      raw_overrides.transform_values { |v| setting_definition.type_class.deserialize(v) },
+      variants
+    )
   end
 
   def slice(**mapping)
@@ -57,6 +75,11 @@ class Fino::Library
     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

data/lib/fino/pipe/cache.rb

@@ -22,13 +22,10 @@ class Fino::Pipe::Cache
     end
   end
 
-  def write(setting_definition, value)
-    pipe.write(setting_definition, value)
+  def write(setting_definition, value, **context)
+    pipe.write(setting_definition, value, **context)
 
-    cache.write(
-      setting_definition.key,
-      setting_definition.type_class.build(setting_definition, value)
-    )
+    cache.delete(setting_definition.key)
   end
 
   private

data/lib/fino/pipe/storage.rb

@@ -17,8 +17,8 @@ class Fino::Pipe::Storage
     end
   end
 
-  def write(setting_definition, value)
-    adapter.write(setting_definition, value)
+  def write(setting_definition, value, overrides, variants)
+    adapter.write(setting_definition, value, overrides, variants)
   end
 
   private
@@ -27,11 +27,14 @@ 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_variants = adapter.fetch_raw_variants_from(raw_adapter_data)
 
     setting_definition.type_class.build(
       setting_definition,
       raw_value,
-      **raw_adapter_data
+      scoped_raw_values,
+      raw_variants
     )
   end
 end

data/lib/fino/pipe.rb

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

data/lib/fino/setting.rb

@@ -14,22 +14,37 @@ module Fino::Setting
       raise NotImplementedError
     end
 
-    def build(setting_definition, raw_value, *options)
+    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,
-        raw_value.equal?(Fino::EMPTINESS) ? setting_definition.options[:default] : deserialize(raw_value),
-        *options
+        value,
+        scoped_values,
+        variants
       )
     end
   end
 
-  attr_reader :definition, :value
+  attr_reader :definition, :variants
 
-  def initialize(definition, value, **options)
+  def initialize(definition, value, scoped_values = {}, variants = [])
     @definition = definition
     @value = value
-
-    @options = options
+    @scoped_values = scoped_values
+    @variants = variants
   end
 
   def name
@@ -40,6 +55,41 @@ module Fino::Setting
     definition.key
   end
 
+  def value(**context)
+    return @value unless (scope = context[:for])
+
+    scoped_values.fetch(scope.to_s) do
+      return @value if variants.empty?
+
+      variant = variant(for: scope)
+      result = variant_id_to_value.fetch(variant.id, @value)
+
+      return @value if result == Fino::Variant::CONTROL
+
+      result
+    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
+  end
+
+  def scope_overrides
+    scoped_values
+  end
+
   def type
     definition.type
   end
@@ -69,9 +119,15 @@ module Fino::Setting
       "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
 end

data/lib/fino/variant.rb

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

data/lib/fino/variant_picker.rb

@@ -0,0 +1,27 @@
+# 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

data/lib/fino/version.rb

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

data/lib/fino.rb

@@ -25,7 +25,9 @@ module Fino
                    :setting,
                    :settings,
                    :slice,
-                   :set
+                   :set,
+                   :define_variants,
+                   :variant
 
     module_function
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fino
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.3.0
 platform: ruby
 authors:
 - Egor Iskrenkov
@@ -54,6 +54,8 @@ files:
 - 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: