Class: Fino::Solid::Adapter

Inherits:
Object
  • Object
show all
Includes:
Adapter
Defined in:
lib/fino/solid/adapter.rb

Constant Summary collapse

SCOPE_PREFIX = 
"s"
VARIANT_PREFIX = 
"v"
VALUE_KEY = 
"v"

Instance Method Summary collapse

Instance Method Details

#clear(setting_key) ⇒ Object

rubocop:disable Naming/PredicateMethod



48
49
50
 
# File 'lib/fino/solid/adapter.rb', line 48

def clear(setting_key) # rubocop:disable Naming/PredicateMethod
  Fino::Solid::Setting.where(key: setting_key).delete_all.positive?
end

#clear_ab_testing_conversions(setting_key) ⇒ Object 



91
92
93
 
# File 'lib/fino/solid/adapter.rb', line 91

def clear_ab_testing_conversions(setting_key)
  Fino::Solid::Conversion.where(setting_key: setting_key).delete_all
end

#fetch_raw_overrides_from(raw_adapter_data) ⇒ Object 



56
57
58
59
60
61
62
63
 
# File 'lib/fino/solid/adapter.rb', line 56

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.delete_prefix("#{SCOPE_PREFIX}/").delete_suffix("/#{VALUE_KEY}")
    memo[scope] = value
  end
end

#fetch_raw_variants_from(raw_adapter_data) ⇒ Object 



95
96
97
98
99
100
101
102
103
 
# File 'lib/fino/solid/adapter.rb', line 95

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

#fetch_value_from(raw_adapter_data) ⇒ Object 



52
53
54
 
# File 'lib/fino/solid/adapter.rb', line 52

def fetch_value_from(raw_adapter_data)
  raw_adapter_data.key?(VALUE_KEY) ? raw_adapter_data.delete(VALUE_KEY) : Fino::EMPTINESS
end

#read(setting_key) ⇒ Object 



12
13
14
15
 
# File 'lib/fino/solid/adapter.rb', line 12

def read(setting_key)
  setting = Fino::Solid::Setting.find_by(key: setting_key)
  setting&.data || {}
end

#read_ab_testing_conversions(setting_definition, variants) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/fino/solid/adapter.rb', line 77

def read_ab_testing_conversions(setting_definition, variants)
  rows =
    Fino::Solid::Conversion
    .where(setting_key: setting_definition.key, variant_id: variants.map(&:id))
    .pluck(:variant_id, :scope, :converted_at)

  grouped = rows.group_by(&:first)

  variants.each_with_object({}) do |variant, memo|
    entries = grouped.fetch(variant.id, [])
    memo[variant] = entries.map { |_vid, scope, converted_at| [scope, (converted_at.to_f * 1000).to_i] }
  end
end

#read_multi(setting_keys) ⇒ Object 



17
18
19
20
21
 
# File 'lib/fino/solid/adapter.rb', line 17

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

#read_persisted_setting_keys ⇒ Object 



44
45
46
 
# File 'lib/fino/solid/adapter.rb', line 44

def read_persisted_setting_keys
  Fino::Solid::Setting.pluck(:key)
end

#record_ab_testing_conversion(setting_definition, variant, scope, time) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/fino/solid/adapter.rb', line 65

def record_ab_testing_conversion(setting_definition, variant, scope, time)
  Fino::Solid::Conversion.insert(
    {
      setting_key: setting_definition.key,
      variant_id: variant.id,
      scope: scope.to_s,
      converted_at: time
    },
    **unique_by_option(:idx_fino_conversions_unique)
  )
end

#write(setting_definition, value, overrides, variants) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/fino/solid/adapter.rb', line 23

def write(setting_definition, value, overrides, variants)
  serialize_value = ->(raw_value) { setting_definition.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_option(:key)
  )
end