qonfig 0.0.0 → 0.12.0

data/lib/qonfig/plugins/toml/commands/load_from_toml.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.12.0
+class Qonfig::Commands::LoadFromTOML < Qonfig::Commands::Base
+  # @return [String]
+  #
+  # @api private
+  # @since 0.12.0
+  attr_reader :file_path
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.12.0
+  attr_reader :strict
+
+  # @param file_path [String]
+  # @option strict [Boolean]
+  #
+  # @api private
+  # @since 0.12.0
+  def initialize(file_path, strict: true)
+    @file_path = file_path
+    @strict = strict
+  end
+
+  # @param settings [Qonfig::Settings]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.12.0
+  def call(settings)
+    toml_data = Qonfig::Loaders::TOML.load_file(file_path, fail_on_unexist: strict)
+    toml_based_settings = build_data_set_class(toml_data).new.settings
+    settings.__append_settings__(toml_based_settings)
+  end
+
+  private
+
+  # @param toml_data [Hash]
+  # @return [Class<Qonfig::DataSet>]
+  #
+  # @api private
+  # @since 0.12.0
+  def build_data_set_class(toml_data)
+    Qonfig::DataSet::ClassBuilder.build_from_hash(toml_data)
+  end
+end

data/lib/qonfig/plugins/toml/data_set.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.12.0
+class Qonfig::DataSet
+  # @option path [String]
+  # @option options [Hash<Symbol,Any>] Nothing, just for compatability and consistency
+  # @param value_processor [Block]
+  # @return [void]
+  #
+  # @api public
+  # @since 0.12.0
+  def save_to_toml(path:, options: Qonfig::Uploaders::TOML::DEFAULT_OPTIONS, &value_processor)
+    thread_safe_access do
+      Qonfig::Uploaders::TOML.upload(settings, path: path, options: options, &value_processor)
+    end
+  end
+  alias_method :dump_to_toml, :save_to_toml
+end

data/lib/qonfig/plugins/toml/dsl.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.12.0
+module Qonfig::DSL
+  # @param file_path [String]
+  # @option strict [Boolean]
+  # @return [void]
+  #
+  # @api public
+  # @since 0.12.0
+  def load_from_toml(file_path, strict: true)
+    commands << Qonfig::Commands::LoadFromTOML.new(file_path, strict: strict)
+  end
+
+  # @param file_path [String]
+  # @option strict [Boolean]
+  # @option via [Symbol]
+  # @option env [Symbol, String]
+  # @return [void]
+  #
+  # @api public
+  # @since 0.12.0
+  def expose_toml(file_path, strict: true, via:, env:)
+    commands << Qonfig::Commands::ExposeTOML.new(file_path, strict: strict, via: via, env: env)
+  end
+end

data/lib/qonfig/plugins/toml/loaders/toml.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.12.0
+class Qonfig::Loaders::TOML < Qonfig::Loaders::Basic
+  class << self
+    # @param data [String]
+    # @return [Object]
+    #
+    # @api private
+    # @since 0.12.0
+    def load(data)
+      ::TomlRB.parse(ERB.new(data).result)
+    end
+
+    # @return [Object]
+    #
+    # @api private
+    # @since 0.12.0
+    def load_empty_data
+      ::TomlRB.parse('')
+    end
+  end
+end

data/lib/qonfig/plugins/toml/tomlrb_fixes.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# NOTE:
+#   - dumper sorts settins keys as a collection of string or symbols only
+#   - settings values like { a: 1, 'b' => 2 } will fail on comparison errors (Symbol with String)
+#   - problem is located in TomlRB::Dumper#sort_pairs(hash) method
+#   - problem code: `hash.keys.sort.map` (failed on `.sort` part)
+#   - we can patch this code by explicit `.map(&:to_s)` before `.sort`
+#
+# @api private
+# @since 0.12.0
+module TomlRB::Dumper::SortFixPatch
+  private
+
+  # NOTE: target method for our fix
+  def sort_pairs(hash)
+    nested_pairs = []
+    simple_pairs = []
+    table_array_pairs = []
+
+    # NOTE: our fix (original code: `hash.keys.sort`) (for details see notes above)
+    fixed_keys_sort(hash).each do |key|
+      val = hash[key]
+      element = [key, val]
+
+      if val.is_a? Hash
+        nested_pairs << element
+      elsif val.is_a?(Array) && val.first.is_a?(Hash)
+        table_array_pairs << element
+      else
+        simple_pairs << element
+      end
+    end
+
+    [simple_pairs, nested_pairs, table_array_pairs]
+  end
+
+  # NOTE: our fix (for detales see notes above)
+  def fixed_keys_sort(hash)
+    hash.keys.sort_by(&:to_s)
+  end
+end
+
+# NOTE:
+#   - dumper uses ultra primitive way to conver objects to toml format
+#   - dumper represents nil values as a simple strings without quots,
+#     but should not represent them at all
+#   - dumper can not validate invalid structures
+#     (for example: [1, [2,3], nil] (invalid, cuz arrays should contain values of one type))
+#
+# @api private
+# @since 0.12.0
+module TomlRB::Dumper::ObjectConverterFix
+  private
+
+  # NOTE: target method for our fix
+  def dump_simple_pairs(simple_pairs)
+    simple_pairs.each do |key, val|
+      key = quote_key(key) unless bare_key? key
+      # NOTE: our fix (original code: `@toml_str << "#{key} = #{to_toml(val)}\n"`)
+      fixed_toml_value_append(key, val)
+    end
+  end
+
+  # NOTE: our fix
+  def fixed_toml_value_append(key, val)
+    @toml_str << "#{key} = #{fixed_to_toml(val)}\n" unless val.nil?
+  end
+
+  # NOTE our fix
+  def fixed_to_toml(object)
+    # NOTE: original code of #toml(obj):
+    #  if object.is_a? Time
+    #    object.strftime('%Y-%m-%dT%H:%M:%SZ')
+    #  else
+    #    object.inspect
+    #  end
+
+    case object
+    when Time, DateTime, Date
+      object.strftime('%Y-%m-%dT%H:%M:%SZ')
+    else
+      # NOTE: validate result value via value parsing before dump
+      object.inspect.tap { |value| ::TomlRB.parse("sample = #{value}") }
+    end
+  end
+end
+
+# @since 0.12.0
+TomlRB::Dumper.prepend(TomlRB::Dumper::SortFixPatch)
+# @since 0.12.0
+TomlRB::Dumper.prepend(TomlRB::Dumper::ObjectConverterFix)

data/lib/qonfig/plugins/toml/uploaders/toml.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.12.0
+class Qonfig::Uploaders::TOML < Qonfig::Uploaders::File
+  class << self
+    # @param settings [Qonfig::Settings]
+    # @param options [Hash<Symbol,Any>]
+    # @param value_processor [Block]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.12.0
+    def represent_settings(settings, options, &value_processor)
+      settings_hash =
+        if block_given?
+          settings.__to_hash__(transform_value: value_processor)
+        else
+          settings.__to_hash__
+        end
+
+      ::TomlRB.dump(settings_hash)
+    end
+  end
+end

data/lib/qonfig/settings.rb

@@ -0,0 +1,457 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+# rubocop:disable Metrics/ClassLength
+class Qonfig::Settings
+  require_relative 'settings/lock'
+  require_relative 'settings/builder'
+  require_relative 'settings/key_guard'
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.11.0
+  BASIC_SETTING_KEY_TRANSFORMER = (proc { |value| value }).freeze
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.11.0
+  BASIC_SETTING_VALUE_TRANSFORMER = (proc { |value| value }).freeze
+
+  # @return [Hash]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :__options__
+
+  # @api private
+  # @since 0.1.0
+  def initialize
+    @__options__ = {}
+    @__lock__ = Lock.new
+  end
+
+  # @param key [Symbol, String]
+  # @param value [Object]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def __define_setting__(key, value)
+    __lock__.thread_safe_definition do
+      key = __indifferently_accessable_option_key__(key)
+
+      __prevent_core_method_intersection__(key)
+
+      case
+      when !__options__.key?(key)
+        __options__[key] = value
+      when __options__[key].is_a?(Qonfig::Settings) && value.is_a?(Qonfig::Settings)
+        __options__[key].__append_settings__(value)
+      else
+        __options__[key] = value
+      end
+
+      __define_accessor__(key)
+    end
+  end
+
+  # @param settings [Qonfig::Settings]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def __append_settings__(settings)
+    __lock__.thread_safe_merge do
+      settings.__options__.each_pair do |key, value|
+        __define_setting__(key, value)
+      end
+    end
+  end
+
+  # @param key [Symbol, String]
+  # @return [Object]
+  #
+  # @api public
+  # @since 0.1.0
+  def [](key)
+    __lock__.thread_safe_access { __get_value__(key) }
+  end
+
+  # @param key [String, Symbol]
+  # @param value [Object]
+  # @return [void]
+  #
+  # @api public
+  # @since 0.1.0
+  def []=(key, value)
+    __lock__.thread_safe_access { __set_value__(key, value) }
+  end
+
+  # @param options_map [Hash]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.3.0
+  def __apply_values__(options_map)
+    __lock__.thread_safe_access { __set_values_from_map__(options_map) }
+  end
+
+  # @param keys [Array<String, Symbol>]
+  # @return [Object]
+  #
+  # @api private
+  # @since 0.2.0
+  def __dig__(*keys)
+    __lock__.thread_safe_access { __deep_access__(*keys) }
+  end
+
+  # @param keys [Array<String, Symbol>]
+  # @return [Hash]
+  #
+  # @api private
+  # @since 0.9.0
+  def __slice__(*keys)
+    __lock__.thread_safe_access { __deep_slice__(*keys) }
+  end
+
+  # @param keys [Array<String, Symbol>]
+  # @return [Hash, Any]
+  #
+  # @api private
+  # @since 0.10.0
+  def __slice_value__(*keys)
+    __lock__.thread_safe_access { __deep_slice_value__(*keys) }
+  end
+
+  # @option transform_key [Proc]
+  # @option transform_value [Proc]
+  # @return [Hash]
+  #
+  # @api private
+  # @since 0.1.0
+  # rubocop:disable Metrics/LineLength
+  def __to_hash__(transform_key: BASIC_SETTING_KEY_TRANSFORMER, transform_value: BASIC_SETTING_VALUE_TRANSFORMER)
+    unless transform_key.is_a?(Proc)
+      ::Kernel.raise(Qonfig::IncorrectKeyTransformerError, 'Key transformer should be a proc')
+    end
+
+    unless transform_value.is_a?(Proc)
+      ::Kernel.raise(Qonfig::IncorrectValueTransformerError, 'Value transformer should be a proc')
+    end
+
+    __lock__.thread_safe_access do
+      __build_hash_representation__(transform_key: transform_key, transform_value: transform_value)
+    end
+  end
+  # rubocop:enable Metrics/LineLength
+  alias_method :__to_h__, :__to_hash__
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.2.0
+  def __clear__
+    __lock__.thread_safe_access { __clear_option_values__ }
+  end
+
+  # @param method_name [String, Symbol]
+  # @param arguments [Array<Object>]
+  # @param block [Proc]
+  # @return [void]
+  #
+  # @raise [Qonfig::UnknownSettingError]
+  #
+  # @api private
+  # @since 0.1.0
+  def method_missing(method_name, *arguments, &block)
+    super
+  rescue NoMethodError
+    ::Kernel.raise(Qonfig::UnknownSettingError, "Setting with <#{method_name}> key doesnt exist!")
+  end
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def respond_to_missing?(method_name, include_private = false)
+    # :nocov:
+    __options__.key?(method_name.to_s) || __options__.key?(method_name.to_sym) || super
+    # :nocov:
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def __freeze__
+    __lock__.thread_safe_access do
+      __options__.freeze
+
+      __options__.each_value do |value|
+        value.__freeze__ if value.is_a?(Qonfig::Settings)
+      end
+    end
+  end
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.2.0
+  def __is_frozen__
+    __lock__.thread_safe_access { __options__.frozen? }
+  end
+
+  private
+
+  # @return [Qonfig::Settings::Lock]
+  #
+  # @api private
+  # @since 0.2.0
+  attr_reader :__lock__
+
+  # @param options_map [Hash]
+  # @return [void]
+  #
+  # @raise [Qonfig::ArgumentError]
+  # @raise [Qonfig::AmbiguousSettingValueError]
+  #
+  # @api private
+  # @since 0.3.0
+  def __set_values_from_map__(options_map)
+    ::Kernel.raise(
+      Qonfig::ArgumentError, 'Options map should be represented as a hash'
+    ) unless options_map.is_a?(Hash)
+
+    options_map.each_pair do |key, value|
+      current_value = __get_value__(key)
+
+      # NOTE: some duplications here was made only for the better code readability
+      case
+      when !current_value.is_a?(Qonfig::Settings)
+        __set_value__(key, value)
+      when current_value.is_a?(Qonfig::Settings) && value.is_a?(Hash)
+        current_value.__apply_values__(value)
+      when current_value.is_a?(Qonfig::Settings) && !value.is_a?(Hash)
+        ::Kernel.raise(
+          Qonfig::AmbiguousSettingValueError,
+          "Can not redefine option <#{key}> that contains nested options"
+        )
+      end
+    end
+  end
+
+  # @return [void]
+  #
+  # @raise [Qonfig::FrozenSettingsError]
+  #
+  # @api private
+  # @since 0.2.0
+  def __clear_option_values__
+    ::Kernel.raise(
+      Qonfig::FrozenSettingsError, 'Can not modify frozen settings'
+    ) if __options__.frozen?
+
+    __options__.each_pair do |key, value|
+      if value.is_a?(Qonfig::Settings)
+        value.__clear__
+      else
+        __options__[key] = nil
+      end
+    end
+  end
+
+  # @param key [String, Symbol]
+  # @return [Object]
+  #
+  # @raise [Qonfig::UnknownSettingError]
+  #
+  # @api private
+  # @since 0.2.0
+  def __get_value__(key)
+    key = __indifferently_accessable_option_key__(key)
+
+    unless __options__.key?(key)
+      ::Kernel.raise(Qonfig::UnknownSettingError, "Setting with <#{key}> key does not exist!")
+    end
+
+    __options__[key]
+  end
+
+  # @param key [String, Symbol]
+  # @param value [Object]
+  # @return [void]
+  #
+  # @raise [Qonfig::UnknownSettingError]
+  # @raise [Qonfig::FrozenSettingsError]
+  # @raise [Qonfig::AmbiguousSettingValueError]
+  #
+  # @api private
+  # @since 0.2.0
+  def __set_value__(key, value)
+    key = __indifferently_accessable_option_key__(key)
+
+    unless __options__.key?(key)
+      ::Kernel.raise(Qonfig::UnknownSettingError, "Setting with <#{key}> key does not exist!")
+    end
+
+    if __options__.frozen?
+      ::Kernel.raise(Qonfig::FrozenSettingsError, 'Can not modify frozen settings')
+    end
+
+    if __options__[key].is_a?(Qonfig::Settings)
+      ::Kernel.raise(
+        Qonfig::AmbiguousSettingValueError,
+        "Can not redefine option <#{key}> that contains nested options"
+      )
+    end
+
+    __options__[key] = value
+  end
+
+  # @param keys [Array<Symbol, String>]
+  # @return [Object]
+  #
+  # @raise [Qonfig::ArgumentError]
+  # @raise [Qonfig::UnknownSettingError]
+  #
+  # @api private
+  # @since 0.2.0
+  def __deep_access__(*keys)
+    ::Kernel.raise(Qonfig::ArgumentError, 'Key list can not be empty') if keys.empty?
+
+    result = __get_value__(keys.first)
+    rest_keys = Array(keys[1..-1])
+
+    case
+    when rest_keys.empty?
+      result
+    when !result.is_a?(Qonfig::Settings)
+      ::Kernel.raise(
+        Qonfig::UnknownSettingError,
+        'Setting with required digging sequence does not exist!'
+      )
+    when result.is_a?(Qonfig::Settings)
+      result.__dig__(*rest_keys)
+    end
+  end
+
+  # @param keys [Array<Symbol, String>]
+  # @return [Hash]
+  #
+  # @raise [Qonfig::ArgumentError]
+  # @raise [Qonfig::UnknownSettingError]
+  #
+  # @api private
+  # @since 0.9.0
+  def __deep_slice__(*keys)
+    {}.tap do |result|
+      __deep_access__(*keys).tap do |setting|
+        required_key = __indifferently_accessable_option_key__(keys.last)
+        result[required_key] = setting.is_a?(Qonfig::Settings) ? setting.__to_h__ : setting
+      end
+    end
+  end
+
+  # @param keys [Array<Symbol, String>]
+  # @return [Hash]
+  #
+  # @raise [Qonfig::ArgumentError]
+  # @raise [Qonfig::UnknownSettingError]
+  #
+  # @api private
+  # @since 0.1.0
+  def __deep_slice_value__(*keys)
+    required_key = __indifferently_accessable_option_key__(keys.last)
+    __deep_slice__(*keys)[required_key]
+  end
+
+  # @param options_part [Hash]
+  # @option transform_key [Proc]
+  # @option transform_value [Proc]
+  # @return [Hash]
+  #
+  # @api private
+  # @since 0.2.0
+  def __build_hash_representation__(options_part = __options__, transform_key:, transform_value:)
+    options_part.each_with_object({}) do |(key, value), hash|
+      final_key = transform_key.call(key)
+
+      case
+      when value.is_a?(Hash)
+        hash[final_key] = __build_hash_representation__(
+          value,
+          transform_key: transform_key,
+          transform_value: transform_value
+        )
+      when value.is_a?(Qonfig::Settings)
+        hash[final_key] = value.__to_hash__(
+          transform_key: transform_key,
+          transform_value: transform_value
+        )
+      else
+        final_value = transform_value.call(value)
+        hash[final_key] = final_value
+      end
+    end
+  end
+
+  # @param key [Symbol, String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def __define_accessor__(key)
+    define_singleton_method(key) do
+      self.[](key)
+    end
+
+    define_singleton_method("#{key}=") do |value|
+      self.[]=(key, value)
+    end
+
+    define_singleton_method("#{key}?") do
+      !!self.[](key)
+    end
+  end
+
+  # @param key [Symbol, String]
+  # @return [String]
+  #
+  # @raise [Qonfig::ArgumentError]
+  # @see Qonfig::Settings::KeyGuard
+  #
+  # @api private
+  # @since 0.2.0
+  def __indifferently_accessable_option_key__(key)
+    KeyGuard.new(key).prevent_incompatible_key_type!
+    key.to_s
+  end
+
+  # @param key [Symbol, String]
+  # @return [void]
+  #
+  # @raise [Qonfig::CoreMethodIntersectionError]
+  # @see Qonfig::Settings::KeyGuard
+  #
+  # @api private
+  # @since 0.2.0
+  def __prevent_core_method_intersection__(key)
+    KeyGuard.new(key).prevent_core_method_intersection!
+  end
+
+  # rubocop:disable Layout/ClassStructure
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.2.0
+  CORE_METHODS = Array(
+    instance_methods(false) |
+    private_instance_methods(false) |
+    %i[super define_singleton_method self]
+  ).map(&:to_s).freeze
+  # rubocop:enable Layout/ClassStructure
+end
+# rubocop:enable Metrics/ClassLength