qonfig 0.22.0 → 0.26.0

data/lib/qonfig/settings.rb

@@ -22,6 +22,12 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   # @since 0.11.0
   BASIC_SETTING_VALUE_TRANSFORMER = (proc { |value| value }).freeze
 
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.25.0
+  REPRESENT_HASH_IN_DOT_STYLE = false
+
   # @return [String]
   #
   # @api private
@@ -94,6 +100,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
 
       __prevent_core_method_intersection__(key)
 
+      # rubocop:disable Lint/DuplicateBranch
       case
       when with_redefinition || !__options__.key?(key)
         __options__[key] = value
@@ -102,6 +109,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
       else
         __options__[key] = value
       end
+      # rubocop:enable Lint/DuplicateBranch
 
       __define_option_reader__(key)
       __define_option_writer__(key)
@@ -133,16 +141,13 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   # @param key [Symbol, String]
   # @return [Object]
   #
+  # @raise [Qonfig::ArgumentError]
+  #
   # @api public
   # @since 0.1.0
-  def [](key)
-    __lock__.thread_safe_access do
-      begin
-        __get_value__(key)
-      rescue Qonfig::UnknownSettingError
-        __deep_access__(*__parse_dot_notated_key__(key))
-      end
-    end
+  # @version 0.25.0
+  def [](*keys)
+    __dig__(*keys)
   end
 
   # @param key [String, Symbol]
@@ -211,27 +216,47 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
     __lock__.thread_safe_access { __deep_subset__(*keys) }
   end
 
+  # @option dot_notation [Boolean]
   # @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)
+  # @version 0.25.0
+  def __to_hash__(
+    dot_notation: REPRESENT_HASH_IN_DOT_STYLE,
+    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 type of proc')
+      ::Kernel.raise(
+        Qonfig::IncorrectKeyTransformerError,
+        'Key transformer should be a type of proc'
+      )
     end
 
     unless transform_value.is_a?(Proc)
-      ::Kernel.raise(Qonfig::IncorrectValueTransformerError, 'Value transformer should be a type of proc')
+      ::Kernel.raise(
+        Qonfig::IncorrectValueTransformerError,
+        'Value transformer should be a type of proc'
+      )
     end
 
     __lock__.thread_safe_access do
-      __build_hash_representation__(transform_key: transform_key, transform_value: transform_value)
+      if dot_notation
+        __build_dot_notated_hash_representation__(
+          transform_key: transform_key,
+          transform_value: transform_value
+        )
+      else
+        __build_basic_hash_representation__(
+          transform_key: transform_key,
+          transform_value: transform_value
+        )
+      end
     end
   end
-  # rubocop:enable Metrics/LineLength
   alias_method :__to_h__, :__to_hash__
 
   # @option all_variants [Boolean]
@@ -496,7 +521,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   #
   # @api private
   # @since 0.21.0
-  # rubocop:disable Naming/RescuedExceptionsVariableName
+  # rubocop:disable Naming/RescuedExceptionsVariableName, Style/SlicingWithRange
   def __assign_value__(key, value)
     key = __indifferently_accessable_option_key__(key)
     __set_value__(key, value)
@@ -507,6 +532,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
     raise(initial_error) if key_set.size == 1
 
     begin
+      # TODO: rewrite with __deep_access__-like key resolving functionality
       setting_value = __get_value__(key_set.first)
       required_key = key_set[1..-1].join(DOT_NOTATION_SEPARATOR)
       setting_value[required_key] = value # NOTE: pseudo-recoursive assignment
@@ -514,7 +540,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
       raise(initial_error)
     end
   end
-  # rubocop:enable Naming/RescuedExceptionsVariableName
+  # rubocop:enable Naming/RescuedExceptionsVariableName, Style/SlicingWithRange
 
   # @param key [String, Symbol]
   # @param value [Object]
@@ -557,11 +583,24 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   #
   # @api private
   # @since 0.2.0
+  # rubocop:disable Metrics/AbcSize, Style/SlicingWithRange
   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])
+    result = nil
+    rest_keys = nil
+    key_parts_boundary = keys.size - 1
+
+    0.upto(key_parts_boundary) do |key_parts_slice_boundary|
+      begin
+        setting_key = keys[0..key_parts_slice_boundary].join(DOT_NOTATION_SEPARATOR)
+        result = __get_value__(setting_key)
+        rest_keys = Array(keys[(key_parts_slice_boundary + 1)..-1])
+        break
+      rescue Qonfig::UnknownSettingError => error
+        key_parts_boundary == key_parts_slice_boundary ? raise(error) : next
+      end
+    end
 
     case
     when rest_keys.empty?
@@ -575,6 +614,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
       result.__dig__(*rest_keys)
     end
   end
+  # rubocop:enable Metrics/AbcSize, Style/SlicingWithRange
 
   # @param keys [Array<Symbol, String>]
   # @return [Hash]
@@ -584,6 +624,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   #
   # @api private
   # @since 0.9.0
+  # rubocop:disable Metrics/AbcSize
   def __deep_slice__(*keys)
     {}.tap do |result|
       begin
@@ -604,6 +645,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
       end
     end
   end
+  # rubocop:enable Metrics/AbcSize
 
   # @param keys [Array<Symbol, String>]
   # @return [Hash]
@@ -647,7 +689,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
             # TODO: support for patterns
             __indifferently_accessable_option_key__(key_set)
           when Array
-            key_set.map(&method(:__indifferently_accessable_option_key__))
+            key_set.map { |key| __indifferently_accessable_option_key__(key) }
           else
             raise(
               Qonfig::ArgumentError,
@@ -667,14 +709,15 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   # @return [Hash]
   #
   # @api private
-  # @since 0.2.0
-  def __build_hash_representation__(options_part = __options__, transform_key:, transform_value:)
+  # @since 0.25.0
+  # rubocop:disable Layout/LineLength
+  def __build_basic_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__(
+        hash[final_key] = __build_basic_hash_representation__(
           value,
           transform_key: transform_key,
           transform_value: transform_value
@@ -690,6 +733,24 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
       end
     end
   end
+  # rubocop:enable Layout/LineLength
+
+  # @option transform_key [Proc]
+  # @option transform_value [Proc]
+  # @return [Hash]
+  #
+  # @api private
+  # @since 0.25.0
+  def __build_dot_notated_hash_representation__(transform_key:, transform_value:)
+    {}.tap do |hash|
+      __deep_each_key_value_pair__ do |setting_key, setting_value|
+        final_key = transform_key.call(setting_key)
+        final_value = transform_value.call(setting_value)
+
+        hash[final_key] = final_value
+      end
+    end
+  end
 
   # @param key [Symbol, String]
   # @return [void]

data/lib/qonfig/settings/key_matcher.rb

@@ -147,12 +147,14 @@ class Qonfig::Settings::KeyMatcher
   #
   # @api private
   # @since 0.13.0
+  # rubocop:disable Style/SlicingWithRange
   def strip_regexp_string(regexp_string, left: false, right: false)
     pattern = regexp_string
     pattern = pattern[2..-1] if left && pattern[0..1] == MATCHER_SCOPE_SPLITTER
     pattern = pattern[0..-3] if right && pattern[-2..-1] == MATCHER_SCOPE_SPLITTER
     pattern
   end
+  # rubocop:enable Style/SlicingWithRange
 
   # @param scope_pattern [String]
   # @return [Regexp]
@@ -179,6 +181,6 @@ class Qonfig::Settings::KeyMatcher
 
     regexp_string = strip_regexp_string(regexp_string, left: true, right: true)
 
-    Regexp.new('\A' + regexp_string + '\z')
+    Regexp.new("\\A#{regexp_string}\\z")
   end
 end

data/lib/qonfig/uploaders/base.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 0.11.0
+# rubocop:disable Style/StaticClass
 class Qonfig::Uploaders::Base
   class << self
     # @param settings [Qonfig::Settings]
@@ -16,3 +17,4 @@ class Qonfig::Uploaders::Base
     end
   end
 end
+# rubocop:enable Style/StaticClass

data/lib/qonfig/uploaders/file.rb

@@ -23,9 +23,9 @@ class Qonfig::Uploaders::File < Qonfig::Uploaders::Base
 
   class << self
     # @param settings [Qonfig::Settings]
-    # @param options [Hash<Symbol|String,Any>]
     # @param value_processor [Block]
-    # @option path [String]
+    # @option path [String, Pathname]
+    # @option options [Hash<Symbol|String,Any>]
     # @return [void]
     #
     # @api private

data/lib/qonfig/uploaders/yaml.rb

@@ -47,7 +47,7 @@ class Qonfig::Uploaders::YAML < Qonfig::Uploaders::File
     # @since 0.11.0
     def represent_settings(settings, options, &value_processor)
       settings_hash_opts = hash_representation_options(options, &value_processor)
-      settings_hash = settings.__to_hash__(settings_hash_opts)
+      settings_hash = settings.__to_hash__(**settings_hash_opts)
       to_yaml_string(settings_hash, options)
     end
 
@@ -60,6 +60,7 @@ class Qonfig::Uploaders::YAML < Qonfig::Uploaders::File
     def hash_representation_options(options, &value_processor)
       {}.tap do |representation_opts|
         # NOTE: this case/when with the same logic is only used for better code readbility
+        # rubocop:disable Lint/DuplicateBranch
         case
         # NOTE: options has :symbolize_keys key
         when options.key?(:symbolize_keys) && !!options[:symbolize_keys]
@@ -70,6 +71,7 @@ class Qonfig::Uploaders::YAML < Qonfig::Uploaders::File
           representation_opts[:transform_key] = KEY_SYMBOLIZER
           # :nocov:
         end
+        # rubocop:enable Lint/DuplicateBranch
 
         # NOTE: provide value transformer
         if block_given?

data/lib/qonfig/version.rb

@@ -5,5 +5,5 @@ module Qonfig
   #
   # @api public
   # @since 0.1.0
-  VERSION = '0.22.0'
+  VERSION = '0.26.0'
 end

data/qonfig.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'qonfig/version'
 
 Gem::Specification.new do |spec|
-  spec.required_ruby_version = '>= 2.4.9'
+  spec.required_ruby_version = '>= 2.4.10'
 
   spec.name        = 'qonfig'
   spec.version     = Qonfig::VERSION
@@ -25,16 +25,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
+  spec.files = `git ls-files -z`.split("\x0")
 
-  spec.add_development_dependency 'coveralls',        '~> 0.8'
-  spec.add_development_dependency 'simplecov',        '~> 0.16'
-  spec.add_development_dependency 'rspec',            '~> 3.8'
-  spec.add_development_dependency 'armitage-rubocop', '~> 0.77'
+  spec.add_development_dependency 'simplecov',        '~> 0.20'
+  spec.add_development_dependency 'rspec',            '~> 3.10'
+  spec.add_development_dependency 'armitage-rubocop', '~> 1.7'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake', '>= 13'
   spec.add_development_dependency 'pry'
 end

data/spec/features/clear_options_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+describe 'Clear options' do
+  specify '#clear - sets all options to nil' do
+    ENV['QONFIG_CLEAR_GENERIC_OPTION'] = 'true'
+    ENV['QONFIG_CLEAR_MEGA_SECRET_VALUE'] = '100500'
+
+    class SimplifiedConfig < Qonfig::DataSet
+      setting :a do
+        setting :b do
+          setting :c, 55
+        end
+      end
+
+      load_from_env prefix: 'QONFIG_CLEAR'
+    end
+
+    class CleansedConfig < Qonfig::DataSet
+      setting :database do
+        setting :user, '0exp'
+        setting :password, 'test123'
+      end
+
+      setting :travis do
+        load_from_yaml SpecSupport.fixture_path('travis_settings.yml')
+      end
+
+      setting :self_data do
+        load_from_self
+      end
+
+      setting :env_data do
+        load_from_env convert_values: true, prefix: /\AQONFIG_CLEAR.*\z/i
+      end
+
+      setting :composed do
+        compose SimplifiedConfig
+      end
+    end
+
+    config = CleansedConfig.new
+
+    config.clear!
+
+    expect(config[:database][:user]).to eq(nil)
+    expect(config[:database][:password]).to eq(nil)
+    expect(config[:travis][:sudo]).to eq(nil)
+    expect(config[:travis][:language]).to eq(nil)
+    expect(config[:travis][:rvm]).to eq(nil)
+    expect(config[:self_data][:secret_key]).to eq(nil)
+    expect(config[:self_data][:api_host]).to eq(nil)
+    expect(config[:self_data][:connection_timeout][:seconds]).to eq(nil)
+    expect(config[:self_data][:connection_timeout][:enabled]).to eq(nil)
+    expect(config[:env_data][:QONFIG_CLEAR_GENERIC_OPTION]).to eq(nil)
+    expect(config[:env_data][:QONFIG_CLEAR_MEGA_SECRET_VALUE]).to eq(nil)
+    expect(config[:composed][:a][:b][:c]).to eq(nil)
+
+    expect(config.to_h).to match(
+      'database' => { 'user' => nil, 'password' => nil },
+      'travis' => {
+        'sudo' => nil,
+        'language' => nil,
+        'rvm' => nil
+      },
+      'self_data' => {
+        'secret_key' => nil,
+        'api_host' => nil,
+        'connection_timeout' => {
+          'seconds' => nil,
+          'enabled' => nil
+        }
+      },
+      'env_data' => {
+        'QONFIG_CLEAR_GENERIC_OPTION' => nil,
+        'QONFIG_CLEAR_MEGA_SECRET_VALUE' => nil
+      },
+      'composed' => {
+        'a' => { 'b' => { 'c' => nil } },
+        'QONFIG_CLEAR_GENERIC_OPTION' => nil,
+        'QONFIG_CLEAR_MEGA_SECRET_VALUE' => nil
+      }
+    )
+  end
+end
+
+__END__
+
+secret_key: top-mega-secret
+api_host: super.puper-google.com
+:connection_timeout:
+   seconds: 10
+   enabled: false

data/spec/features/compacted_config_spec.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+describe 'Compacted config' do
+  describe 'definition and settings access' do
+    specify 'constructor without dataset builds compacted config from config\'s class commands' do
+      class CompactedCommandsCheck < Qonfig::Compacted
+        setting :test, true
+        setting :db do
+          setting :creds do
+            setting :user, '0exp'
+            setting :password, 'test123'
+          end
+        end
+
+        validate :test, :boolean
+        validate 'db.creds.*', :string
+      end
+
+      compacted_config = CompactedCommandsCheck.new
+
+      # NOTE: check readers
+      expect(compacted_config.test).to eq(true)
+      expect(compacted_config.db.creds.user).to eq('0exp')
+      expect(compacted_config.db.creds.password).to eq('test123')
+      # and dot-notation:
+      expect(compacted_config[:test]).to eq(true)
+      expect(compacted_config['db.creds.user']).to eq('0exp')
+      expect(compacted_config['db.creds.password']).to eq('test123')
+
+      # NOTE: check writers
+      compacted_config.test = false
+      compacted_config.db.creds.user = 'D@iVeR'
+      # and dot-notation:
+      compacted_config['db.creds.password'] = 'atata123'
+
+      # NOTE: check new values
+      expect(compacted_config.test).to eq(false)
+      expect(compacted_config.db.creds.user).to eq('D@iVeR')
+      expect(compacted_config.db.creds.password).to eq('atata123')
+
+      # NOTE: check validators
+      expect { compacted_config.test = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { compacted_config.db.creds.user = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { compacted_config['db.creds.password'] = 123 }.to raise_error(Qonfig::ValidationError)
+    end
+
+    specify 'support for predicates' do
+      class PredicateCheckForCompactedConfig < Qonfig::Compacted
+        setting :enabled, true
+        setting :queue do
+          setting :engine, nil
+          setting :workers_count, 10
+        end
+      end
+
+      config = PredicateCheckForCompactedConfig.new
+
+      expect(config.enabled?).to eq(true)
+      expect(config.queue?).to eq(true)
+      expect(config.queue.engine?).to eq(false)
+      expect(config.queue.workers_count?).to eq(true)
+
+      config.enabled = nil
+      config.queue.engine = :sidekiq
+
+      expect(config.enabled?).to eq(false)
+      expect(config.queue.engine?).to eq(true)
+
+      config.enabled = false
+      expect(config.enabled?).to eq(false)
+    end
+
+    specify 'constructor with passed dataset builds compacted config from passed dataset' do
+      data_set_based_config = Class.new(Qonfig::DataSet).build do
+        setting :test, true
+        setting :db do
+          setting :creds do
+            setting :user, '0exp'
+            setting :password, 'test123'
+          end
+        end
+
+        validate :test, :boolean
+        validate 'db.creds.*', :string
+      end
+
+      compacted_config = Qonfig::Compacted.build_from(data_set_based_config)
+
+      # NOTE: check readers
+      expect(compacted_config.test).to eq(true)
+      expect(compacted_config.db.creds.user).to eq('0exp')
+      expect(compacted_config.db.creds.password).to eq('test123')
+      # and dot-notation:
+      expect(compacted_config[:test]).to eq(true)
+      expect(compacted_config['db.creds.user']).to eq('0exp')
+      expect(compacted_config['db.creds.password']).to eq('test123')
+
+      # NOTE: check writers
+      compacted_config.test = false
+      compacted_config.db.creds.user = 'D@iVeR'
+      # and dot-notation:
+      compacted_config['db.creds.password'] = 'atata123'
+
+      # NOTE: check new values
+      expect(compacted_config.test).to eq(false)
+      expect(compacted_config.db.creds.user).to eq('D@iVeR')
+      expect(compacted_config.db.creds.password).to eq('atata123')
+
+      # NOTE: check validators
+      expect { compacted_config.test = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { compacted_config.db.creds.user = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { compacted_config['db.creds.password'] = 123 }.to raise_error(Qonfig::ValidationError)
+    end
+
+    specify 'fails on incorrect datasets passed to constructor' do
+      expect { Qonfig::Compacted.build_from(Object.new) }.to raise_error(Qonfig::ArgumentError)
+    end
+
+    specify 'inheritance works as expected' do
+      class BaseCompactedConfig < Qonfig::Compacted
+        setting :test, true
+        setting :db do
+          setting :creds do
+            setting :user, '0exp'
+            setting :password, 'test123'
+          end
+        end
+
+        validate :test, :boolean
+        validate 'db.creds.*', :string
+      end
+
+      class ChildCompactedConfig < BaseCompactedConfig
+        setting :db do
+          setting :creds do
+            setting :token, 'kekpek'
+          end
+        end
+      end
+
+      child_compacted_config = ChildCompactedConfig.new
+
+      # NOTE: check readers
+      expect(child_compacted_config.test).to eq(true)
+      expect(child_compacted_config.db.creds.user).to eq('0exp')
+      expect(child_compacted_config.db.creds.password).to eq('test123')
+      expect(child_compacted_config.db.creds.token).to eq('kekpek')
+      # and dot-notation:
+      expect(child_compacted_config[:test]).to eq(true)
+      expect(child_compacted_config['db.creds.user']).to eq('0exp')
+      expect(child_compacted_config['db.creds.password']).to eq('test123')
+      expect(child_compacted_config['db.creds.token']).to eq('kekpek')
+
+      # NOTE: check writers
+      child_compacted_config.test = false
+      child_compacted_config.db.creds.user = 'D@iVeR'
+      child_compacted_config.db.creds.password = 'atata123'
+      child_compacted_config.db.creds.token = 'trututu'
+
+      # NOTE: check new values
+      expect(child_compacted_config.test).to eq(false)
+      expect(child_compacted_config.db.creds.user).to eq('D@iVeR')
+      expect(child_compacted_config.db.creds.password).to eq('atata123')
+      expect(child_compacted_config.db.creds.token).to eq('trututu')
+
+      # NOTE: check validators
+      # rubocop:disable Layout/LineLength
+      expect { child_compacted_config.test = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { child_compacted_config.db.creds.user = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { child_compacted_config['db.creds.password'] = 123 }.to raise_error(Qonfig::ValidationError)
+      expect { child_compacted_config.db.creds.token = 123 }.to raise_error(Qonfig::ValidationError)
+      # rubocop:enable Layout/LineLength
+    end
+
+    describe 'instantiation without definition' do
+      specify 'creates new Qonfig::Compacted instance' do
+        config = Qonfig::Compacted.build do
+          setting :api, 'api.overwatch.com'
+          setting(:tokens) { setting :internal, 'test123' }
+        end
+
+        expect((class << config; self; end).superclass.superclass).to eq(Qonfig::Compacted)
+        expect(config.api).to eq('api.overwatch.com')
+        expect(config.tokens.internal).to eq('test123')
+      end
+
+      specify 'can inherit existing Qonfig::Compacted class' do
+        base_config_klass = Class.new(Qonfig::Compacted) do
+          setting(:creds) { setting :login, 'test123' }
+          setting :enabled, true
+        end
+
+        config = Qonfig::Compacted.build(base_config_klass) do
+          setting :api, 'api.overwatch.com'
+          setting :enabled, false
+          setting(:creds) { setting :password, 'kekpek' }
+        end
+
+        expect(config.creds.login).to eq('test123') # NOTE: inherited definition
+        expect(config.enabled).to eq(false) # NOTE: redefined setting
+        expect(config.creds.password).to eq('kekpek') # NOTE: extended setting "creds"
+        expect(config.api).to eq('api.overwatch.com') # NOTE: own setting
+      end
+    end
+
+    specify 'Qonfig::DataSet#compacted build compacted config from itself' do
+      class CompactCheckConfig < Qonfig::DataSet
+        setting :db do
+          setting :creds do
+            setting :user, 'D@iVeR'
+            setting :password, 'test123'
+            setting :data, test: false
+          end
+        end
+        setting :logger, nil
+        setting :graphql_endpoint, 'https://localhost:1234/graphql'
+      end
+
+      compacted_config = CompactCheckConfig.new.compacted
+
+      # NOTE: check readers
+      expect(compacted_config.db.creds.user).to eq('D@iVeR')
+      expect(compacted_config.db.creds.password).to eq('test123')
+      expect(compacted_config.db.creds.data).to eq(test: false)
+      expect(compacted_config.logger).to eq(nil)
+      expect(compacted_config.graphql_endpoint).to eq('https://localhost:1234/graphql')
+
+      # NOTE: check writers
+      # ambigous write is impossible
+      expect do
+        compacted_config.db = :test
+      end.to raise_error(Qonfig::AmbiguousSettingValueError)
+      expect do
+        compacted_config.db.creds = :test
+      end.to raise_error(Qonfig::AmbiguousSettingValueError)
+      # regular write is possible :)
+      compacted_config.db.creds.user = '0exp'
+      compacted_config.db.creds.password = '123test'
+      compacted_config.db.creds.data = { no: :errors }
+      compacted_config.logger = :logger
+      compacted_config.graphql_endpoint = 'https://localhost:4321/graphql'
+      # corresponding values was correctly assigned
+      expect(compacted_config.db.creds.user).to eq('0exp')
+      expect(compacted_config.db.creds.password).to eq('123test')
+      expect(compacted_config.db.creds.data).to eq(no: :errors)
+      expect(compacted_config.logger).to eq(:logger)
+      expect(compacted_config.graphql_endpoint).to eq('https://localhost:4321/graphql')
+    end
+
+    specify 'Qonfig::DataSet.build_compacted - builds compacted config object' do
+      compacted_config = Qonfig::DataSet.build_compacted do
+        setting(:db) { setting(:creds) { setting :user, '0exp' } }
+        setting :logger, :no_logger
+        setting :graphql_endpoint, '/graph_dracula'
+      end
+
+      # NOTE: check readers
+      expect(compacted_config.db.creds.user).to eq('0exp')
+      expect(compacted_config.logger).to eq(:no_logger)
+      expect(compacted_config.graphql_endpoint).to eq('/graph_dracula')
+
+      # NOTE: check writers
+      # ambigous write is impossible
+      expect do
+        compacted_config.db = :test
+      end.to raise_error(Qonfig::AmbiguousSettingValueError)
+      expect do
+        compacted_config.db.creds = :test
+      end.to raise_error(Qonfig::AmbiguousSettingValueError)
+      # regular write is possible :)
+      compacted_config.db.creds.user = 'D@iVeR'
+      compacted_config.logger = :logger
+      compacted_config.graphql_endpoint = 'https://localhost:4321/graphql'
+      # corresponding values was correctly assigned
+      expect(compacted_config.db.creds.user).to eq('D@iVeR')
+      expect(compacted_config.logger).to eq(:logger)
+      expect(compacted_config.graphql_endpoint).to eq('https://localhost:4321/graphql')
+    end
+  end
+
+  describe '(.valid_with?) class-level pre-validation checking' do
+    specify 'support for do-config notation :)' do
+      config_klass = Class.new(Qonfig::Compacted) do
+        setting :enabled, false
+        setting(:db) { setting :user, 'D@iVeR' }
+        validate :enabled, :boolean, strict: true
+        validate 'db.#', :text, strict: true
+      end
+
+      # class-level checker
+      expect(
+        (config_klass.valid_with?(enabled: true) do |conf|
+          conf.db.user = '0exp'
+        end)
+      ).to eq(true)
+      expect(
+        (config_klass.valid_with?(enabled: false) do |conf|
+          conf.db.user = 123
+        end)
+      ).to eq(false)
+      expect(
+        (config_klass.valid_with?(enabled: nil) do |conf|
+          conf.db.user = 'test'
+        end)
+      ).to eq(false)
+    end
+  end
+end