fino 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69285bc3c8b50977e454b0de3c9da140c18260acb43ee1f42f62f8a9288c3183
-  data.tar.gz: 714affd74ca27f673cc0b1d80a2ba66f151f9e2723c7034331d64cb5b667c7ce
+  metadata.gz: a2820a64cf64defc88202ae9e9ee7140efe02246c812e33cfe6ce07877f68b9e
+  data.tar.gz: 6b2b9c1cf4ae0ac28ad60912e0a5026cf01901b3a6006c03ecf1f5550e3f0c80
 SHA512:
-  metadata.gz: b1c18ff5d58af075601ee3df575a98d8ce56af98e0148d4d3debd5114f30ad1242786d9d8f37880e8ee4a2a40a880cf688fc807f88d227bc3ba3f40d3af5345d
-  data.tar.gz: 6f4c003666bbce10a3fee68ee17efbdd9c506c8c3654ed6e58e12f7f2fc3804412431fa3934647d806198031fbab9712b8960e874cd795847ebd1f4b6871dd1c
+  metadata.gz: 76444316536ac50999142e41abba7dbc4939832a138fb6ad3bf06bf7fb1700b3007f842b874b513789dbeec101ab3c7110818e6f862bd58bd83be06e2cca9251
+  data.tar.gz: 3120460c8c7ee45f2be9f38e00dd12150a81e93d36b8bd7a932c16f73b2061e0d0c7c431d50431244cb2e66b9ee4faa11799d96b120716a1a29f0e5b4b68e8b3

data/README.md

@@ -51,24 +51,26 @@ end
 ### Work with settings
 
 ```ruby
-Fino.value(:model, :openai) #=> "gpt-4o"
-Fino.value(:temperature, :openai) #=> 0.7
+Fino.value(:model, at: :openai) #=> "gpt-4o"
+Fino.value(:temperature, at: :openai) #=> 0.7
 
-Fino.set("gpt-5", :model, :openai)
-Fino.value(:model, :openai) #=> "gpt-5"
+Fino.values(:model, :temperature, at: :openai) #=> ["gpt-4", 0.7]
+
+Fino.set(model: "gpt-5", at: :openai)
+Fino.value(:model, at: :openai) #=> "gpt-5"
 ```
 
 ### Manage settings via UI
 
 ```ruby
-gem "fino-ui"
+gem "fino-rails"
 ```
 
-Mount Fino UI in your `config/routes.rb`:
+Mount Fino Rails engine in your `config/routes.rb`:
 
 ```ruby
 Rails.application.routes.draw do
-  mount Fino::UI::Engine, at: "/fino"
+  mount Fino::Rails::Engine, at: "/fino"
 end
 ```
 

data/lib/fino/cache/memory.rb

@@ -5,18 +5,57 @@ class Fino::Cache::Memory
 
   def initialize(expires_in:)
     @hash = {}
-    @expirator = Fino::Expirator.new(ttl: expires_in)
+    @expirator = Fino::Expirator.new(ttl: expires_in) if expires_in
   end
 
-  def fetch(key, &)
-    @hash.fetch(key, &)
+  def exist?(key)
+    hash.key?(key)
   ensure
-    @expirator.when_ready do
-      @hash.clear
-    end
+    expire_if_needed
+  end
+
+  def read(key)
+    hash[key]
+  ensure
+    expire_if_needed
   end
 
   def write(key, value)
-    @hash[key] = value
+    hash[key] = value
+  end
+
+  def fetch(key, &block)
+    hash.fetch(key) do
+      write(key, block.call)
+    end
+  ensure
+    expire_if_needed
+  end
+
+  def fetch_multi(keys, &block)
+    missing_keys = keys - hash.keys
+
+    if missing_keys.any?
+      results = block.call(missing_keys)
+
+      results.each do |key, value|
+        write(key, value)
+      end
+    end
+
+    hash.values_at(*keys)
+  ensure
+    expire_if_needed
+  end
+
+  private
+
+  attr_reader :hash, :expirator
+
+  def expire_if_needed
+    expirator&.when_ready do
+      Fino.logger.debug { "Expiring all cache entries" }
+      hash.clear
+    end
   end
 end

data/lib/fino/configuration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Fino::Configuration
-  attr_reader :registry, :adapter_builder_block, :cache_builder_block
+  attr_reader :registry, :adapter_builder_block, :cache_builder_block, :pipeline_builder_block
 
   def initialize(registry)
     @registry = registry
@@ -15,6 +15,10 @@ class Fino::Configuration
     @cache_builder_block = block
   end
 
+  def pipeline(&block)
+    @pipeline_builder_block = block
+  end
+
   def settings(&)
     Fino::Registry::DSL.new(registry).instance_eval(&)
   end

data/lib/fino/definition/section.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Fino::Definition::Section
+  attr_reader :name, :options
+
+  def initialize(name:, **options)
+    @name = name
+    @options = options
+  end
+
+  def label
+    options.fetch(:label, name.to_s.capitalize)
+  end
+end

data/lib/fino/definition/setting.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Fino::Definition::Setting
+  attr_reader :setting_name, :section_definition, :type, :options
+
+  def initialize(type:, setting_name:, section_definition: nil, **options)
+    @setting_name = setting_name
+    @section_definition = section_definition
+    @type = type
+    @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
+  end
+
+  def default
+    return @default if defined?(@default)
+
+    @default = options[:default]
+  end
+
+  def description
+    options[:description]
+  end
+
+  def path
+    @path ||= [setting_name, section_definition&.name].compact
+  end
+
+  def key
+    @key ||= path.reverse.join("/")
+  end
+end

data/lib/fino/library.rb

@@ -7,49 +7,76 @@ class Fino::Library
     @configuration = configuration
   end
 
-  def value(*setting_path)
-    setting(*setting_path).value
+  def value(setting_name, at: nil)
+    setting(setting_name, at: at).value
   end
 
-  def setting(*setting_path)
-    pipeline.read(build_setting_definition(*setting_path))
+  def values(*setting_names, at: nil)
+    settings(*setting_names, at: at).map(&:value)
   end
 
-  def all
-    pipeline.read_multi(configuration.registry.setting_definitions)
+  def setting(setting_name, at: nil)
+    pipeline.read(build_setting_definition(setting_name, at: at))
   end
 
-  def set(value, *setting_path)
-    setting_definition = build_setting_definition(*setting_path)
+  def settings(*setting_names, at: Fino::EMPTINESS)
+    setting_definitions =
+      if setting_names.empty? && at.equal?(Fino::EMPTINESS)
+        configuration.registry.setting_definitions
+      elsif at.equal?(Fino::EMPTINESS)
+        setting_names.map { |name| build_setting_definition(name) }
+      elsif setting_names.empty?
+        configuration.registry.setting_definitions(at: at)
+      else
+        setting_names.map { |name| build_setting_definition(name, at: at) }
+      end
 
-    pipeline.write(
-      setting_definition.type_class.deserialize(value),
-      setting_definition
-    )
+    pipeline.read_multi(setting_definitions)
+  end
+
+  def set(**setting_names_to_values)
+    at = setting_names_to_values.delete(:at)
+
+    setting_names_to_values.each do |setting_name, value|
+      setting_definition = build_setting_definition(setting_name, at: at)
+
+      pipeline.write(
+        setting_definition,
+        setting_definition.type_class.deserialize(value)
+      )
+    end
+  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)
+      end
+    end
+
+    pipeline.read_multi(setting_definitions)
   end
 
   private
 
   attr_reader :configuration
 
-  def build_setting_definition(*setting_path)
-    configuration.registry.fetch(*setting_path)
+  def build_setting_definition(setting_name, at: nil)
+    configuration.registry.setting_definition(setting_name.to_s, at&.to_s)
   end
 
   def pipeline
-    @pipeline ||= Fino::Pipeline.new.tap do |p|
-      p.use Fino::Pipeline::Cache.new(cache) if cache
-      p.use Fino::Pipeline::Adapter.new(adapter)
+    @pipeline ||= Fino::Pipeline.new(storage).tap do |p|
+      p.use Fino::Pipe::Cache, cache if cache
+      p.instance_exec(&configuration.pipeline_builder_block) if configuration.pipeline_builder_block
     end
   end
 
-  def cache
-    return @cache if defined?(@cache)
-
-    @cache = configuration.cache_builder_block&.call
+  def storage
+    Fino::Pipe::Storage.new(configuration.adapter_builder_block.call)
   end
 
-  def adapter
-    @adapter ||= configuration.adapter_builder_block.call
+  def cache
+    defined?(@cache) ? @cache : @cache = configuration.cache_builder_block&.call
   end
 end

data/lib/fino/metadata.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "./version"
+
+module Fino
+  module_function
+
+  def metadata(spec)
+    spec.metadata["source_code_uri"]       = spec.homepage
+    spec.metadata["bug_tracker_uri"]       = "#{spec.homepage}/issues"
+    spec.metadata["rubygems_mfa_required"] = "true"
+  end
+end

data/lib/fino/pipe/cache.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Fino::Pipe::Cache
+  include Fino::Pipe
+
+  def initialize(pipe, cache)
+    super(pipe)
+    @cache = cache
+  end
+
+  def read(setting_definition)
+    cache.fetch(setting_definition.key) do
+      pipe.read(setting_definition)
+    end
+  end
+
+  def read_multi(setting_definitions)
+    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)
+    pipe.write(setting_definition, value)
+
+    cache.write(
+      setting_definition.key,
+      setting_definition.type_class.build(setting_definition, value)
+    )
+  end
+
+  private
+
+  attr_reader :cache
+end

data/lib/fino/{pipeline/adapter.rb → pipe/storage.rb}

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-class Fino::Pipeline::Adapter
+class Fino::Pipe::Storage
+  include Fino::Pipe
+
   def initialize(adapter)
     @adapter = adapter
   end

data/lib/fino/pipe.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fino::Pipe
+  def initialize(pipe)
+    @pipe = pipe
+  end
+
+  def read(setting_definition)
+    raise NotImplementedError
+  end
+
+  def read_multi(setting_definitions)
+    raise NotImplementedError
+  end
+
+  def write(setting_definition, value)
+    raise NotImplementedError
+  end
+
+  private
+
+  attr_reader :pipe
+end

data/lib/fino/pipeline.rb

@@ -1,38 +1,33 @@
 # frozen_string_literal: true
 
 class Fino::Pipeline
-  def initialize(pipes = [])
-    @pipes = pipes
-  end
+  extend Forwardable
 
-  def use(pipe)
-    @pipes << pipe
-  end
+  def_delegators :pipeline, *Fino::Pipe.public_instance_methods
 
-  def read(setting_definition)
-    read_pipeline(setting_definition)
+  def initialize(storage, pipes = [])
+    @storage = storage
+    @pipes = pipes
+    @pipe_wrapper = ->(pipe) { pipe }
   end
 
-  def read_multi(setting_definitions)
-    @pipes.each do |pipe|
-      settings = pipe.read_multi(setting_definitions)
-      return settings if settings
-    end
+  def use(pipe_class, *args, **kwargs, &block)
+    pipes << ->(pipe) { pipe_class.new(pipe, *args, **kwargs, &block) }
+    @pipeline = nil
   end
 
-  def write(value, setting_definition)
-    @pipes.each do |pipe|
-      pipe.write(setting_definition, value)
-    end
-
-    value
+  def wrap(&block)
+    @pipe_wrapper = block
+    @pipeline = nil
   end
 
   private
 
-  def read_pipeline(setting_definition, pipe_index = 0)
-    @pipes[pipe_index]&.read(setting_definition) do
-      read_pipeline(setting_definition, pipe_index + 1)
+  attr_reader :storage, :pipes, :pipe_wrapper
+
+  def pipeline
+    @pipeline ||= pipes.inject(pipe_wrapper.call(storage)) do |pipe, builder|
+      pipe_wrapper.call(builder.call(pipe))
     end
   end
 end

data/lib/fino/registry.rb

@@ -3,17 +3,17 @@
 class Fino::Registry
   class DSL
     class SectionDSL
-      def initialize(section_name, _options, registry)
-        @section_name = section_name
+      def initialize(section_definition, registry)
+        @section_definition = section_definition
         @registry = registry
       end
 
       def setting(setting_name, type, **)
         @registry.register(
-          Fino::SettingDefinition.new(
+          Fino::Definition::Setting.new(
             type: type,
             setting_name: setting_name,
-            section_name: @section_name,
+            section_definition: @section_definition,
             **
           )
         )
@@ -26,7 +26,7 @@ class Fino::Registry
 
     def setting(setting_name, type, **)
       @registry.register(
-        Fino::SettingDefinition.new(
+        Fino::Definition::Setting.new(
           type: type,
           setting_name: setting_name,
           **
@@ -35,7 +35,14 @@ class Fino::Registry
     end
 
     def section(section_name, options = {}, &)
-      SectionDSL.new(section_name, options, @registry).instance_eval(&)
+      section_definition = Fino::Definition::Section.new(
+        name: section_name,
+        **options
+      )
+
+      @registry.register_section(section_definition)
+
+      SectionDSL.new(section_definition, @registry).instance_eval(&)
     end
   end
 
@@ -43,22 +50,45 @@ class Fino::Registry
 
   using Fino::Ext::Hash
 
-  attr_reader :setting_definitions_by_path, :setting_definitions
+  attr_reader :setting_definitions, :section_definitions
 
   def initialize
-    @setting_definitions_by_path = {}
     @setting_definitions = []
+    @setting_definitions_by_path = {}
+
+    @section_definitions = []
+    @section_definitions_by_name = {}
   end
 
-  def fetch(*path)
-    @setting_definitions_by_path.dig(*path.reverse).tap do |definition|
+  def setting_definition(*path)
+    @setting_definitions_by_path.dig(*path.compact.reverse).tap do |definition|
       raise UnknownSetting, "Unknown setting: #{path.compact.join('.')}" unless definition
     end
   end
 
+  def setting_definitions(at: Fino::EMPTINESS)
+    case at
+    when Fino::EMPTINESS
+      @setting_definitions
+    when nil
+      @setting_definitions.select { |d| d.section_definition.nil? }
+    else
+      @setting_definitions_by_path[at&.to_s]&.values || []
+    end
+  end
+
+  def section_definition(section_name)
+    @section_definitions_by_name[section_name.to_s]
+  end
+
   def register(setting_definition)
     @setting_definitions << setting_definition
 
-    @setting_definitions_by_path.deep_set(setting_definition, *setting_definition.path)
+    @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)
   end
 end

data/lib/fino/setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module Fino::Setting
-  UNSET_VALUE = Object.new.freeze
-
   def self.included(base)
     base.extend(ClassMethods)
   end
@@ -19,7 +17,7 @@ module Fino::Setting
     def build(setting_definition, raw_value, *options)
       new(
         setting_definition,
-        raw_value.equal?(UNSET_VALUE) ? setting_definition.options[:default] : deserialize(raw_value),
+        raw_value.equal?(Fino::EMPTINESS) ? setting_definition.options[:default] : deserialize(raw_value),
         *options
       )
     end
@@ -38,11 +36,42 @@ module Fino::Setting
     definition.setting_name
   end
 
+  def key
+    definition.key
+  end
+
+  def type
+    definition.type
+  end
+
+  def type_class
+    definition.type_class
+  end
+
+  def section_definition
+    definition.section_definition
+  end
+
   def section_name
-    definition.section_name
+    definition.section_definition&.name
   end
 
   def default
     definition.default
   end
+
+  def description
+    definition.description
+  end
+
+  def inspect
+    attributes = [
+      "key=#{key.inspect}",
+      "type=#{type_class.inspect}",
+      "value=#{value.inspect}",
+      "default=#{default.inspect}"
+    ]
+
+    "#<#{self.class.name} #{attributes.join(', ')}>"
+  end
 end

data/lib/fino/settings/boolean.rb

@@ -9,7 +9,10 @@ class Fino::Settings::Boolean
     end
 
     def deserialize(raw_value)
-      raw_value == "1"
+      case raw_value
+      when "1", 1, true, "true", "t", "yes", "y" then true
+      else false
+      end
     end
   end
 end

data/lib/fino/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Fino
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
+  REQUIRED_RUBY_VERSION = ">= 3.0.0"
 end

data/lib/fino.rb

@@ -5,8 +5,8 @@ require "zeitwerk"
 
 module Fino
   module Configurable
-    def configure(&)
-      configuration.instance_eval(&)
+    def configure(&block)
+      configuration.instance_eval(&block)
     end
 
     private
@@ -21,8 +21,10 @@ module Fino
 
     def_delegators :library,
                    :value,
+                   :values,
                    :setting,
-                   :all,
+                   :settings,
+                   :slice,
                    :set
 
     module_function
@@ -35,6 +37,8 @@ module Fino
   extend Configurable
   extend SettingsAccessible
 
+  EMPTINESS = Object.new.freeze
+
   module_function
 
   def library
@@ -45,6 +49,20 @@ module Fino
     @registry ||= Fino::Registry.new
   end
 
+  def logger
+    @logger ||= begin
+      require "logger"
+
+      Logger.new($stdout).tap do |l|
+        l.progname = name
+        l.level = ENV.fetch("FINO_LOG_LEVEL", "info")
+        l.formatter = proc do |severity, datetime, progname, msg|
+          "[#{progname}] #{severity}: #{msg}\n"
+        end
+      end
+    end
+  end
+
   def root
     File.expand_path("..", __dir__)
   end
@@ -55,17 +73,19 @@ Zeitwerk::Loader.for_gem.tap do |l|
 
   l.ignore(
     [
-      root_relative_path.call("lib/fino-ui.rb"),
-      root_relative_path.call("lib/fino/ui.rb"),
-      root_relative_path.call("lib/fino/ui/"),
+      # Fino Rails
+      root_relative_path.call("lib/fino-rails.rb"),
+      root_relative_path.call("lib/fino/rails.rb"),
+      root_relative_path.call("lib/fino/rails/"),
 
+      # Fino Redis
       root_relative_path.call("lib/fino-redis.rb"),
       root_relative_path.call("lib/fino/redis.rb"),
       root_relative_path.call("lib/fino/redis/"),
 
-      root_relative_path.call("lib/fino/engine.rb")
+      # Other
+      root_relative_path.call("lib/fino/metadata.rb"),
+      root_relative_path.call("lib/fino/railtie.rb")
     ]
   )
 end.setup
-
-require "fino/engine" if defined?(Rails)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fino
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Egor Iskrenkov
@@ -30,44 +30,36 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- lib/fino-redis.rb
-- lib/fino-ui.rb
 - lib/fino.rb
 - lib/fino/adapter.rb
 - lib/fino/cache.rb
 - lib/fino/cache/memory.rb
-- lib/fino/cache/null.rb
 - lib/fino/configuration.rb
-- lib/fino/engine.rb
+- lib/fino/definition/section.rb
+- lib/fino/definition/setting.rb
 - lib/fino/error.rb
 - lib/fino/expirator.rb
 - lib/fino/ext/hash.rb
 - lib/fino/library.rb
+- lib/fino/metadata.rb
+- lib/fino/pipe.rb
+- lib/fino/pipe/cache.rb
+- lib/fino/pipe/storage.rb
 - lib/fino/pipeline.rb
-- lib/fino/pipeline/adapter.rb
-- lib/fino/pipeline/cache.rb
-- lib/fino/redis.rb
-- lib/fino/redis/adapter.rb
 - lib/fino/registry.rb
 - lib/fino/setting.rb
-- lib/fino/setting_definition.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/ui.rb
-- lib/fino/ui/app/controllers/fino/ui/application_controller.rb
-- lib/fino/ui/app/controllers/fino/ui/settings_controller.rb
-- lib/fino/ui/config/initializers/inflections.rb
-- lib/fino/ui/config/routes.rb
-- lib/fino/ui/engine.rb
 - lib/fino/version.rb
 homepage: https://github.com/eiskrenkov/fino
-licenses: []
+licenses:
+- MIT
 metadata:
-  homepage_uri: https://github.com/eiskrenkov/fino
   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:

data/lib/fino/cache/null.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::Cache::Null
-  include Fino::Cache
-
-  def fetch(_key)
-    yield
-  end
-end

data/lib/fino/engine.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::Engine < Rails::Engine
-  isolate_namespace Fino
-end

data/lib/fino/pipeline/cache.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::Pipeline::Cache
-  def initialize(cache)
-    @cache = cache
-  end
-
-  def read(setting_definition, &)
-    cache.fetch(setting_definition.key, &)
-  end
-
-  def read_multi(setting_definitions, &); end
-
-  def write(setting_definition, value)
-    cache.write(setting_definition.key, setting_definition.type_class.build(setting_definition, value))
-  end
-
-  private
-
-  attr_reader :cache
-end

data/lib/fino/redis/adapter.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::Redis::Adapter
-  include Fino::Adapter
-
-  DEFAULT_REDIS_NAMESPACE = "fino"
-  VALUE_KEY = "v"
-
-  def initialize(redis, namespace: DEFAULT_REDIS_NAMESPACE)
-    @redis = redis
-    @redis_namespace = namespace
-  end
-
-  def read(setting_definition)
-    redis.hgetall(redis_key_for(setting_definition))
-  end
-
-  def write(setting_definition, value)
-    redis.hset(redis_key_for(setting_definition), VALUE_KEY, setting_definition.type_class.serialize(value))
-  end
-
-  def read_multi(setting_definitions)
-    keys = setting_definitions.map { |definition| redis_key_for(definition) }
-
-    redis.pipelined do |pipeline|
-      keys.each { |key| pipeline.hgetall(key) }
-    end
-  end
-
-  def fetch_value_from(raw_adapter_data)
-    raw_adapter_data.key?(VALUE_KEY) ? raw_adapter_data.delete(VALUE_KEY) : Fino::Setting::UNSET_VALUE
-  end
-
-  private
-
-  attr_reader :redis, :redis_namespace
-
-  def redis_key_for(setting_definition)
-    "#{redis_namespace}:#{setting_definition.path.join(':')}"
-  end
-end

data/lib/fino/redis.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "fino"
-require "redis"
-
-module Fino::Redis
-end
-
-require "fino/redis/adapter"

data/lib/fino/setting_definition.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::SettingDefinition
-  attr_reader :setting_name, :section_name, :type, :options
-
-  def initialize(type:, setting_name:, section_name: nil, **options)
-    @setting_name = setting_name
-    @section_name = section_name
-    @type = type
-    @options = options
-  end
-
-  def 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
-  end
-
-  def default
-    options[:default]
-  end
-
-  def path
-    @path ||= [setting_name, section_name].compact
-  end
-
-  def key
-    path.join("_")
-  end
-end

data/lib/fino/ui/app/controllers/fino/ui/application_controller.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::UI::ApplicationController < ActionController::Base
-end

data/lib/fino/ui/app/controllers/fino/ui/settings_controller.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class Fino::UI::SettingsController < Fino::UI::ApplicationController
-  def index
-    @settings = Fino.library.all
-  end
-
-  def edit
-    setting_path = parse_setting_path(params[:key])
-
-    @setting = Fino.setting(*setting_path)
-  end
-
-  def update
-    begin
-      # Parse the key to create the setting path
-      setting_path = parse_setting_path(params[:key])
-
-      # Update the setting using the correct API
-      Fino.set(params[:value], *setting_path)
-
-      redirect_to root_path, notice: "Setting updated successfully"
-    rescue Fino::Registry::UnknownSetting
-      redirect_to root_path, alert: "Setting not found"
-    end
-  end
-
-  private
-
-  def parse_setting_path(key)
-    key.split('.').map(&:to_sym).reverse
-  end
-end

data/lib/fino/ui/config/initializers/inflections.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-ActiveSupport::Inflector.inflections(:en) do |inflect|
-  inflect.acronym "UI"
-end

data/lib/fino/ui/config/routes.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-Fino::UI::Engine.routes.draw do
-  root to: "settings#index"
-
-  resources :settings, only: [:index, :edit, :update], param: :key, constraints: { key: /[^\/]+/ }
-end

data/lib/fino/ui/engine.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "fino-ui"
-
-class Fino::UI::Engine < Rails::Engine
-  isolate_namespace Fino::UI
-
-  paths["app"] << root.join("lib", "fino", "ui", "app")
-  paths["config/initializers"] << root.join("lib", "fino", "ui", "config", "initializers")
-
-  initializer "fino.ui.append_view_paths" do |_app|
-    ActiveSupport.on_load :action_controller do
-      prepend_view_path Fino::UI::Engine.root.join("lib", "fino", "ui", "app", "views")
-    end
-  end
-
-  initializer "fino.ui.load_routes", before: :add_routing_paths do |app|
-    custom_routes = root.join("lib", "fino", "ui", "config", "routes.rb")
-    app.routes_reloader.paths << custom_routes.to_s
-  end
-end

data/lib/fino/ui.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "fino"
-
-module Fino::UI
-end
-
-require "fino/ui/engine"

data/lib/fino-redis.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "fino/redis"

data/lib/fino-ui.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "fino/ui"