fino 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 923a928e308816fef20053f1f35fff93f8fbc43e48dcc80e7ef83eab6a69a3bd
+  data.tar.gz: ff5af3d11e4184cb45fa06039514722596b2237be3c42e00be1b87fee3c401d1
+SHA512:
+  metadata.gz: 02ebcf4c01d917a775909b9d9bfcca9f7840aa0941a9339f885b491fa91337e9367f3692de7cc0f6ba75a27ce9cfebed221014aa50fd1079eb1cdbe97508353d
+  data.tar.gz: 308a664811806d793796208a7d0dfe736c1d20f8e4ba3bda8d2bebb65e420872669127cd05c214e877026df855cba6c0d9d7189b317f70b3b9599d7996054cc8

data/README.md

@@ -0,0 +1,11 @@
+# Fino
+
+```ruby
+Fino.value(:retries_amount)
+Fino.value(:http_read_timeout, :service_a)
+```
+
+## TODO
+
+- Basic validations (presence, range, numericality)
+- Enum setting type

data/lib/fino/adapter/memory.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Fino::Adapters::Memory
+  include Fino::Adapter
+end

data/lib/fino/adapter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Fino::Adapter
+  def read(setting_definition)
+    raise NotImplementedError
+  end
+
+  def read_multi(setting_definitions)
+    raise NotImplementedError
+  end
+
+  def write(setting_definition, value)
+    raise NotImplementedError
+  end
+end

data/lib/fino/cache/memory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Fino::Cache::Memory
+  include Fino::Cache
+
+  def initialize(expires_in:)
+    @hash = {}
+    @expirator = Fino::Expirator.new(ttl: expires_in)
+  end
+
+  def fetch(key, &)
+    @hash.fetch(key, &)
+  ensure
+    @expirator.when_ready do
+      @hash.clear
+    end
+  end
+
+  def write(key, value)
+    @hash[key] = value
+  end
+end

data/lib/fino/cache/null.rb

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

data/lib/fino/cache.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fino::Cache
+  def fetch(key, &)
+    raise NotImplementedError
+  end
+
+  def write(key, value)
+    raise NotImplementedError
+  end
+end

data/lib/fino/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Fino::Configuration
+  attr_reader :registry, :adapter_builder_block, :cache_builder_block
+
+  def initialize(registry)
+    @registry = registry
+  end
+
+  def adapter(&block)
+    @adapter_builder_block = block
+  end
+
+  def cache(&block)
+    @cache_builder_block = block
+  end
+
+  def settings(&)
+    Fino::Registry::DSL.new(registry).instance_eval(&)
+  end
+end

data/lib/fino/engine.rb

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

data/lib/fino/error.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Fino::Error = Class.new(StandardError)

data/lib/fino/expirator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Fino::Expirator
+  def initialize(ttl:)
+    @ttl = ttl
+    reset_timestamp
+  end
+
+  def when_ready
+    return if current_timestamp - stored_timestamp < ttl
+
+    yield
+
+    reset_timestamp
+  end
+
+  private
+
+  attr_reader :stored_timestamp, :ttl
+
+  def reset_timestamp
+    @stored_timestamp = current_timestamp
+  end
+
+  def current_timestamp
+    Time.now.to_i
+  end
+end

data/lib/fino/ext/hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Fino::Ext::Hash
+  refine Hash do
+    def deep_set(value, *path)
+      item = path.pop
+
+      if path.empty?
+        self[item] = value
+      else
+        (self[item] ||= {}).deep_set(value, *path)
+      end
+    end
+  end
+end

data/lib/fino/library.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+class Fino::Library
+  def initialize(configuration)
+    @configuration = configuration
+  end
+
+  def value(*setting_path)
+    setting(*setting_path).value
+  end
+
+  def setting(*setting_path)
+    pipeline.read(build_setting_definition(*setting_path))
+  end
+
+  def all
+    pipeline.read_multi(configuration.registry.setting_definitions)
+  end
+
+  def set(value, *setting_path)
+    pipeline.write(value, build_setting_definition(*setting_path))
+  end
+
+  private
+
+  attr_reader :configuration
+
+  def build_setting_definition(*setting_path)
+    configuration.registry.fetch(*setting_path)
+  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)
+    end
+  end
+
+  def cache
+    return @cache if defined?(@cache)
+
+    @cache = configuration.cache_builder_block&.call
+  end
+
+  def adapter
+    @adapter ||= configuration.adapter_builder_block.call
+  end
+end

data/lib/fino/pipeline/adapter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Fino::Pipeline::Adapter
+  def initialize(adapter)
+    @adapter = adapter
+  end
+
+  def read(setting_definition)
+    to_setting(setting_definition, adapter.read(setting_definition))
+  end
+
+  def read_multi(setting_definitions)
+    setting_definitions.zip(adapter.read_multi(setting_definitions)).map do |definition, raw_data|
+      to_setting(definition, raw_data)
+    end
+  end
+
+  def write(setting_definition, value)
+    adapter.write(setting_definition, value)
+  end
+
+  private
+
+  attr_reader :adapter
+
+  def to_setting(setting_definition, raw_adapter_data)
+    raw_value = adapter.fetch_value_from(raw_adapter_data)
+
+    setting_definition.type_class.build(
+      setting_definition,
+      raw_value,
+      **raw_adapter_data
+    )
+  end
+end

data/lib/fino/pipeline/cache.rb

@@ -0,0 +1,21 @@
+# 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/pipeline.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Fino::Pipeline
+  def initialize(pipes = [])
+    @pipes = pipes
+  end
+
+  def use(pipe)
+    @pipes << pipe
+  end
+
+  def read(setting_definition)
+    read_pipeline(setting_definition)
+  end
+
+  def read_multi(setting_definitions)
+    @pipes.each do |pipe|
+      settings = pipe.read_multi(setting_definitions)
+      return settings if settings
+    end
+  end
+
+  def write(value, setting_definition)
+    @pipes.each do |pipe|
+      pipe.write(setting_definition, value)
+    end
+  end
+
+  private
+
+  def read_pipeline(setting_definition, pipe_index = 0)
+    @pipes[pipe_index]&.read(setting_definition) do
+      read_pipeline(setting_definition, pipe_index + 1)
+    end
+  end
+end

data/lib/fino/redis/adapter.rb

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

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

data/lib/fino/registry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Fino::Registry
+  class DSL
+    class SectionDSL
+      def initialize(section_name, _options, registry)
+        @section_name = section_name
+        @registry = registry
+      end
+
+      def setting(setting_name, type, **)
+        @registry.register(
+          Fino::SettingDefinition.new(
+            type: type,
+            setting_name: setting_name,
+            section_name: @section_name,
+            **
+          )
+        )
+      end
+    end
+
+    def initialize(registry)
+      @registry = registry
+    end
+
+    def setting(setting_name, type, **)
+      @registry.register(
+        Fino::SettingDefinition.new(
+          type: type,
+          setting_name: setting_name,
+          **
+        )
+      )
+    end
+
+    def section(section_name, options = {}, &)
+      SectionDSL.new(section_name, options, @registry).instance_eval(&)
+    end
+  end
+
+  UnknownSetting = Class.new(Fino::Error)
+
+  using Fino::Ext::Hash
+
+  attr_reader :setting_definitions_by_path, :setting_definitions
+
+  def initialize
+    @setting_definitions_by_path = {}
+    @setting_definitions = []
+  end
+
+  def fetch(*path)
+    @setting_definitions_by_path.dig(*path.reverse).tap do |definition|
+      raise UnknownSetting, "Unknown setting: #{path.compact.join('.')}" unless definition
+    end
+  end
+
+  def register(setting_definition)
+    @setting_definitions << setting_definition
+
+    @setting_definitions_by_path.deep_set(setting_definition, *setting_definition.path)
+  end
+end

data/lib/fino/setting.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Fino::Setting
+  UNSET_VALUE = Object.new.freeze
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def serialize(value)
+      raise NotImplementedError
+    end
+
+    def deserialize(raw_value)
+      raise NotImplementedError
+    end
+
+    def build(setting_definition, raw_value, *options)
+      new(
+        setting_definition,
+        raw_value.equal?(UNSET_VALUE) ? setting_definition.options[:default] : deserialize(raw_value),
+        *options
+      )
+    end
+  end
+
+  attr_reader :definition, :value
+
+  def initialize(definition, value, **options)
+    @definition = definition
+    @value = value
+
+    @options = options
+  end
+
+  def name
+    definition.setting_name
+  end
+
+  def section_name
+    definition.section_name
+  end
+
+  def default
+    definition.default
+  end
+end

data/lib/fino/setting_definition.rb

@@ -0,0 +1,39 @@
+# 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/settings/boolean.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Fino::Settings::Boolean
+  include Fino::Setting
+
+  class << self
+    def serialize(value)
+      value ? "1" : "0"
+    end
+
+    def deserialize(raw_value)
+      raw_value == "1"
+    end
+  end
+end

data/lib/fino/settings/float.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Fino::Settings::Float
+  include Fino::Setting
+
+  class << self
+    def serialize(value)
+      value.to_s
+    end
+
+    def deserialize(raw_value)
+      raw_value.to_f
+    end
+  end
+end

data/lib/fino/settings/integer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Fino::Settings::Integer
+  include Fino::Setting
+
+  class << self
+    def serialize(value)
+      value.to_s
+    end
+
+    def deserialize(raw_value)
+      raw_value.to_i
+    end
+  end
+end

data/lib/fino/settings/section.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Fino::Settings::Section
+  attr_reader :name, :label, :settings
+
+  def initialize(name = nil, label: nil)
+    @name = name
+    @label = label
+
+    @settings = {}
+  end
+end

data/lib/fino/settings/string.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Fino::Settings::String
+  include Fino::Setting
+
+  class << self
+    def serialize(value)
+      value
+    end
+
+    def deserialize(raw_value)
+      raw_value
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

data/lib/fino/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Fino
+  VERSION = "1.0.0"
+end

data/lib/fino-redis.rb

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

data/lib/fino-ui.rb

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

data/lib/fino.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "zeitwerk"
+
+module Fino
+  module Configurable
+    def configure(&)
+      configuration.instance_eval(&)
+    end
+
+    private
+
+    def configuration
+      @configuration ||= Fino::Configuration.new(registry)
+    end
+  end
+
+  module SettingsAccessible
+    extend Forwardable
+
+    def_delegators :library,
+                   :value,
+                   :setting,
+                   :all,
+                   :set
+
+    module_function
+
+    def library
+      raise NotImplementedError
+    end
+  end
+
+  extend Configurable
+  extend SettingsAccessible
+
+  module_function
+
+  def library
+    Thread.current[:fino_library] ||= Fino::Library.new(configuration)
+  end
+
+  def registry
+    @registry ||= Fino::Registry.new
+  end
+
+  def root
+    File.expand_path("..", __dir__)
+  end
+end
+
+Zeitwerk::Loader.for_gem.tap do |l|
+  root_relative_path = ->(path) { File.join(Fino.root, path) }
+
+  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/"),
+
+      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")
+    ]
+  )
+end.setup
+
+require "fino/engine" if defined?(Rails)

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: fino
+version: !ruby/object:Gem::Version
+  version: 1.0.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: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+email:
+- egor@iskrenkov.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/fino-redis.rb
+- lib/fino-ui.rb
+- lib/fino.rb
+- lib/fino/adapter.rb
+- lib/fino/adapter/memory.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/error.rb
+- lib/fino/expirator.rb
+- lib/fino/ext/hash.rb
+- lib/fino/library.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: []
+metadata:
+  homepage_uri: https://github.com/eiskrenkov/fino
+  source_code_uri: https://github.com/eiskrenkov/fino
+  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: Elegant & performant settings engine for Ruby and Rails
+test_files: []