Coditsu Diffing Tool

Files changed (40) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +8 -0
data/README.md +457 -137
data/lib/qonfig.rb +1 -0
data/lib/qonfig/command_set.rb +7 -1
data/lib/qonfig/commands/add_nested_option.rb +3 -1
data/lib/qonfig/commands/add_option.rb +2 -1
data/lib/qonfig/commands/base.rb +2 -1
data/lib/qonfig/commands/compose.rb +16 -10
data/lib/qonfig/commands/expose_yaml.rb +2 -1
data/lib/qonfig/commands/load_from_env.rb +2 -1
data/lib/qonfig/commands/load_from_json.rb +2 -1
data/lib/qonfig/commands/load_from_self.rb +2 -1
data/lib/qonfig/commands/load_from_yaml.rb +2 -1
data/lib/qonfig/data_set.rb +92 -23
data/lib/qonfig/data_set/lock.rb +46 -0
data/lib/qonfig/data_set/validator.rb +0 -7
data/lib/qonfig/errors.rb +8 -0
data/lib/qonfig/plugins/toml/commands/expose_toml.rb +2 -1
data/lib/qonfig/plugins/toml/commands/load_from_toml.rb +2 -1
data/lib/qonfig/settings.rb +144 -33
data/lib/qonfig/settings/builder.rb +20 -4
data/lib/qonfig/settings/callbacks.rb +43 -0
data/lib/qonfig/settings/key_matcher.rb +175 -0
data/lib/qonfig/settings/lock.rb +3 -3
data/lib/qonfig/validator.rb +58 -0
data/lib/qonfig/validator/basic.rb +53 -0
data/lib/qonfig/validator/builder.rb +169 -0
data/lib/qonfig/validator/builder/attribute_consistency.rb +181 -0
data/lib/qonfig/validator/collection.rb +73 -0
data/lib/qonfig/validator/dsl.rb +51 -0
data/lib/qonfig/validator/method_based.rb +49 -0
data/lib/qonfig/validator/predefined.rb +41 -0
data/lib/qonfig/validator/predefined/common.rb +53 -0
data/lib/qonfig/validator/predefined/registry.rb +83 -0
data/lib/qonfig/validator/predefined/registry_control_mixin.rb +43 -0
data/lib/qonfig/validator/proc_based.rb +53 -0
data/lib/qonfig/version.rb +1 -1
data/qonfig.gemspec +1 -1
metadata +19 -5

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62b74a92c4c74b79f222e029726296a63b51ba3a57886a00911a34ffbcbced25
-  data.tar.gz: 33fa91631b6554dec3547c9c31faddf805bc4a56becbe7042e1942c19c493f16
+  metadata.gz: c7f383ceef309126a60c17c1383cdfd3de9445aa5978ccb80374226dfd17e83c
+  data.tar.gz: 6f2f868550a9822b4feb8daff758a2a91d486903f9e57726c1045725fc658e55
 SHA512:
-  metadata.gz: 152acb89e834fccaaed1b4bfae379f8263d795b2e4e7b7913f6a2b98fd1bfebf984dec1c82a3568ddc08a3e16fdec2be7783f1f583ef09a3dc6b1386f9afb18f
-  data.tar.gz: c468d5a5c289dc8b4b7b337e62314dbbf9d388b5dd6df1248a14e957a97be9937d7f24c47aa8634ffe415dbd092ed4f3c5b447036770b171fb6d87454eceb4e8
+  metadata.gz: bf030ed32f26241ebe6a8717e02e3b705d5f31e666c1096f19776c14e2db92f251e08ee12e668831a69bea51ce2fb40288791dbc4d8dfd19bc9fdd10c0505db8
+  data.tar.gz: 67e3f1712357a8de30e651271b8ca2dd2590af18cedd42ee57d48b86a755bfe15a0ea7ae59fea448212ae5fa798b19a12364acaa2fde588fc5778c33ef4d25c1

data/CHANGELOG.md CHANGED

@@ -1,6 +1,14 @@
 # Changelog
 All notable changes to this project will be documented in this file.
+## [0.13.0] - 2019-08-13
+### Added
+- Iteration over setting keys (`#each_setting { |key, value| }`, `#deep_each_setting { |key, value| }`);
+- Brand new `Validation API`;
+            +
+### Changed
+- Actualized development dependencies;
+            +
 ## [0.12.0] - 2019-07-19
 ### Added
 - Support for **TOML** (`.toml`) format

data/README.md CHANGED

@@ -1,7 +1,8 @@
 # Qonfig &middot; [![Gem Version](https://badge.fury.io/rb/qonfig.svg)](https://badge.fury.io/rb/qonfig) [![Build Status](https://travis-ci.org/0exp/qonfig.svg?branch=master)](https://travis-ci.org/0exp/qonfig) [![Coverage Status](https://coveralls.io/repos/github/0exp/qonfig/badge.svg?branch=master)](https://coveralls.io/github/0exp/qonfig?branch=master)
 Config. Defined as a class. Used as an instance. Support for inheritance and composition.
-Lazy instantiation. Thread-safe. Command-style DSL. Extremely simple to define. Extremely simple to use. That's all.
+Lazy instantiation. Thread-safe. Command-style DSL. Validation layer. Support for **YAML**, **TOML**, **JSON**, **\_\_END\_\_**, **ENV**.
+Extremely simple to define. Extremely simple to use. That's all? **NOT** :)
 ## Installation
@@ -21,27 +22,38 @@ require 'qonfig'
 ## Usage
-- [Definition and Settings Access](#definition-and-access)
-- [Configuration](#configuration)
-- [Inheritance](#inheritance)
-- [Composition](#composition)
-- [Hash representation](#hash-representation)
-- [Config reloading](#config-reloading) (reload config definitions and option values)
-- [Clear options](#clear-options) (set to nil)
-- [State freeze](#state-freeze)
-- [Settings as Predicates](#settings-as-predicates)
-- [Load from YAML file](#load-from-yaml-file)
-- [Expose YAML](#expose-yaml) (`Rails`-like environment-based YAML configs)
-- [Load from JSON file](#load-from-json-file)
-- [Load from ENV](#load-from-env)
-- [Load from \_\_END\_\_](#load-from-__end__) (aka `load_from_self`)
-- [Save to JSON file](#save-to-json-file) (`save_to_json`)
-- [Save to YAML file](#save-to-yaml-file) (`save_to_yaml`)
-- [Smart Mixin](#smart-mixin) (`Qonfig::Configurable`)
+- [Definition](#definition)
+  - [Definition and Settings Access](#definition-and-access)
+  - [Configuration](#configuration)
+  - [Inheritance](#inheritance)
+  - [Composition](#composition)
+  - [Hash representation](#hash-representation)
+  - [Smart Mixin](#smart-mixin) (`Qonfig::Configurable`)
+- [Interaction](#interaction)
+  - [Iteration over setting keys](#iteration-over-setting-keys) (`#each_setting`, `#deep_each_setting`)
+  - [Config reloading](#config-reloading) (reload config definitions and option values)
+  - [Clear options](#clear-options) (set to nil)
+  - [State freeze](#state-freeze)
+  - [Settings as Predicates](#settings-as-predicates)
+- [Validation](#validation)
+  - [Key search pattern](#key-search-pattern)
+  - [Proc-based validation](#proc-based-validation)
+  - [Method-based validation](#method-based-validation)
+  - [Predefined validations](#predefined-validations)
+- [Work with files](#work-with-files)
+  - [Load from YAML file](#load-from-yaml-file)
+  - [Expose YAML](#expose-yaml) (`Rails`-like environment-based YAML configs)
+  - [Load from JSON file](#load-from-json-file)
+  - [Load from ENV](#load-from-env)
+  - [Load from \_\_END\_\_](#load-from-__end__) (aka `load_from_self`)
+  - [Save to JSON file](#save-to-json-file) (`save_to_json`)
+  - [Save to YAML file](#save-to-yaml-file) (`save_to_yaml`)
 - [Plugins](#plugins)
-  - [toml](#plugin-toml) (provides `load_from_toml`, `save_to_toml`, `expose_toml`)
+  - [toml](#plugins-toml) (provides `load_from_toml`, `save_to_toml`, `expose_toml`)
 ---
+## Definition
+            +
 ### Definition and Access
 ```ruby
@@ -274,6 +286,164 @@ Config.new.to_h
 ---
+### Smart Mixin
+            +
+- class-level:
+  - `.configuration` - settings definitions;
+  - `.configure` - configuration;
+  - `.config` - config object;
+  - settings definitions are inheritable;
+- instance-level:
+  - `#configure` - configuration;
+  - `#config` - config object;
+  - `#shared_config` - class-level config object;
+            +
+```ruby
+# --- usage ---
+            +
+class Application
+  # make configurable
+  include Qonfig::Configurable
+            +
+  configuration do
+    setting :user
+    setting :password
+  end
+end
+            +
+app = Application.new
+            +
+# class-level config
+Application.config.settings.user # => nil
+Application.config.settings.password # => nil
+            +
+# instance-level config
+app.config.settings.user # => nil
+app.config.settings.password # => nil
+            +
+# access to the class level config from an instance
+app.shared_config.settings.user # => nil
+app.shared_config.settings.password # => nil
+            +
+# class-level configuration
+Application.configure do |conf|
+  conf.user = '0exp'
+  conf.password = 'test123'
+end
+            +
+# instance-level configuration
+app.configure do |conf|
+  conf.user = 'admin'
+  conf.password = '123test'
+end
+            +
+# class has own config object
+Application.config.settings.user # => '0exp'
+Application.config.settings.password # => 'test123'
+            +
+# instance has own config object
+app.config.settings.user # => 'admin'
+app.config.settings.password # => '123test'
+            +
+# access to the class level config from an instance
+app.shared_config.settings.user # => '0exp'
+app.shared_config.settings.password # => 'test123'
+            +
+# and etc... (all Qonfig-related features)
+```
+            +
+```ruby
+# --- inheritance ---
+            +
+class BasicApplication
+  # make configurable
+  include Qonfig::Configurable
+            +
+  configuration do
+    setting :user
+    setting :pswd
+  end
+            +
+  configure do |conf|
+    conf.user = 'admin'
+    conf.pswd = 'admin'
+  end
+end
+            +
+class GeneralApplication < BasicApplication
+  # extend inherited definitions
+  configuration do
+    setting :db do
+      setting :adapter
+    end
+  end
+            +
+  configure do |conf|
+    conf.user = '0exp' # .user inherited from BasicApplication
+    conf.pswd = '123test' # .pswd inherited from BasicApplication
+    conf.db.adapter = 'pg'
+  end
+end
+            +
+BasicApplication.config.to_h
+{ 'user' => 'admin', 'pswd' => 'admin' }
+            +
+GeneralApplication.config.to_h
+{ 'user' => '0exp', 'pswd' => '123test', 'db' => { 'adapter' => 'pg' } }
+            +
+# and etc... (all Qonfig-related features)
+```
+            +
+---
+            +
+            +
+## Interaction
+            +
+---
+            +
+### Iteration over setting keys
+            +
+- `#each_setting { |key, value| }`
+  - iterates over the root setting keys;
+- `#deep_each_setting { |key, value| }`
+  - iterates over all setting keys (deep inside);
+  - key object is represented as a string of `.`-joined keys;
+            +
+```ruby
+class Config < Qonfig::DataSet
+  setting :db do
+    setting :creds do
+      setting :user, 'D@iVeR'
+      setting :password, 'test123',
+      setting :data, test: false
+    end
+  end
+            +
+  setting :telegraf_url, 'udp://localhost:8094'
+  setting :telegraf_prefix, 'test'
+end
+            +
+config = Config.new
+            +
+# 1. #each_setting
+config.each_setting { |key, value| { key => value } }
+# result of each step:
+{ 'db' => <Qonfig::Settings:0x00007ff8> }
+{ 'telegraf_url' => 'udp://localhost:8094' }
+{ 'telegraf_prefix' => 'test' }
+            +
+# 2. #deep_each_setting
+config.deep_each_setting { |key, value| { key => value } }
+# result of each step:
+{ 'db.creds.user' => 'D@iveR' }
+{ 'db.creds.password' => 'test123' }
+{ 'db.creds.data' => { test: false } }
+{ 'telegraf_url' => 'udp://localhost:8094' }
+{ 'telegraf_prefix' => 'test' }
+```
+            +
+---
+            +
 ### Config reloading
 ```ruby
@@ -423,6 +593,264 @@ config.settings.database.engine.driver? # => true (true => true)
 ---
+## Validation
+            +
+Qonfig provides a lightweight DSL for defining validations and works in all cases when setting values are initialized or mutated.
+Settings are validated as keys (matched with a [specific string pattern](#key-search-patern)).
+You can validate both a set of keys and each key separately.
+If you want to check the config object completely you can define a custom validation.
+            +
+**Features**:
+            +
+- is invoked on any mutation of any setting key
+  - during dataset instantiation;
+  - when assigning new values;
+  - when calling `#reload!`;
+  - when calling `#clear!`;
+            +
+- provides special [key search pattern](#key-search-pattern) for matching setting key names;
+- uses the [key search pattern](#key-search-pattern) for definging what the setting key should be validated;
+- you can define your own custom validation logic and validate dataset instance completely;
+- validation logic should return **truthy** or **falsy** value;
+            +
+- supprots two validation techniques (**proc-based** and **dataset-method-based**)
+  - **proc-based** (`setting validation`)
+    ```ruby
+      validate 'db.user' do |value|
+        value.is_a?(String)
+      end
+    ```
+  - **proc-based** (`dataset validation`)
+    ```ruby
+      validate do
+        settings.user == User[1]
+      end
+    ```
+  - **dataset-method-based** (`setting validation`)
+    ```ruby
+      validate 'db.user', by: :check_user
+            +
+      def check_user(value)
+        value.is_a?(String)
+      end
+    ```
+  - **dataset-method-based** (`dataset validation`)
+    ```ruby
+      validate by: :check_config
+            +
+      def check_config
+        settings.user == User[1]
+      end
+    ```
+            +
+- provides a set of standard validations:
+  - `integer`
+  - `float`
+  - `numeric`
+  - `big_decimal`
+  - `boolean`
+  - `string`
+  - `symbol`
+  - `text` (string or symbol)
+  - `array`
+  - `hash`
+  - `proc`
+  - `class`
+  - `module`
+  - `not_nil`
+            +
+---
+            +
+### Key search pattern
+            +
+**Key search pattern** works according to the following rules:
+            +
+- works in `RabbitMQ`-like key pattern ruleses;
+- has a string format;
+- nested configs are defined by a set of keys separated by `.`-symbol;
+- if the setting key name at the current nesting level does not matter - use `*`;
+- if both the setting key name and nesting level does not matter - use `#`
+- examples:
+  - `db.settings.user` - matches to `db.settings.user` setting;
+  - `db.settings.*` - matches to all setting keys inside `db.settings` group of settings;
+  - `db.*.user` - matches to all `user` setting keys at the first level of `db` group of settings;
+  - `#.user` - matches to all `user` setting keys;
+  - `service.#.password` - matches to all `password` setting keys at all levels of `service` group of settings;
+  - `#` - matches to ALL setting keys;
+  - `*` - matches to all setting keys at the root level;
+  - and etc;
+            +
+---
+            +
+### Proc-based validation
+            +
+- your proc should return truthy value or falsy value;
+- how to validate setting keys:
+  - define proc with attribute: `validate 'your.setting.path' do |value|; end`
+  - proc will receive setting value;
+- how to validate dataset instance:
+  - define proc without setting key pattern: `validate do; end`
+            +
+```ruby
+class Config < Qonfig::DataSet
+  setting :db do
+    setting :user, 'D@iVeR'
+    setting :password, 'test123'
+  end
+            +
+  setting :service do
+    setting :address, 'google.ru'
+    setting :protocol, 'https'
+            +
+    setting :creds do
+      seting :admin, 'D@iVeR'
+    end
+  end
+            +
+  setting :enabled, false
+            +
+  # validates:
+  #   - db.password
+  validate 'db.password' do |value|
+    value.is_a?(String)
+  end
+            +
+  # validates:
+  #   - service.address
+  #   - service.protocol
+  #   - service.creds.user
+  validate 'service.#' do |value|
+    value.is_a?(String)
+  end
+            +
+  # validates:
+  #   - dataset instance
+  validate do # NOTE: no setting key pattern
+    settings.enabled == false
+  end
+end
+            +
+config = Config.new
+config.settings.db.password = 123 # => Qonfig::ValidationError (should be a string)
+config.settings.service.address = 123 # => Qonfig::ValidationError (should be a string)
+config.settings.service.protocol = :http # => Qonfig::ValidationError (should be a string)
+config.settings.service.creds.admin = :billikota # => Qonfig::ValidationError (should be a string)
+config.settings.enabled = true # => Qonfig::ValidationError (isnt `true`)
+```
+            +
+---
+            +
+### Method-based validation
+            +
+- method should return truthy value or falsy value;
+- how to validate setting keys:
+  - define validation: `validate 'db.*.user', by: :your_custom_method`;
+  - define your method with attribute: `def your_custom_method(setting_value); end`
+- how to validate config instance
+  - define validation: `validate by: :your_custom_method`
+  - define your method without attributes: `def your_custom_method; end`
+            +
+```ruby
+class Config < Qonfig::DataSet
+  setting :services do
+    setting :counts do
+      setting :google, 2
+      setting :rambler, 3
+    end
+            +
+    setting :minimals do
+      setting :google, 1
+      setting :rambler, 0
+    end
+  end
+            +
+  setting :enabled, true
+            +
+  # validates:
+  #   - services.counts.google
+  #   - services.counts.rambler
+  #   - services.minimals.google
+  #   - services.minimals.rambler
+  validate 'services.#', by: :check_presence
+            +
+  # validates:
+  #   - dataset instance
+  validate by: :check_state # NOTE: no setting key pattern
+            +
+  def check_presence(value)
+    value.is_a?(Numeric) && value > 0
+  end
+            +
+  def check_state
+    settings.enabled.is_a?(TrueClass) || settings.enabled.is_a?(FalseClass)
+  end
+end
+            +
+config = Config.new
+            +
+config.settings.counts.google = 0 # => Qonfig::ValidationError (< 0)
+config.settings.counts.rambler = nil # => Qonfig::ValidationError (should be a numeric)
+config.settings.minimals.google = -1 # => Qonfig::ValidationError (< 0)
+config.settings.minimals.rambler = 'no' # => Qonfig::ValidationError (should be a numeric)
+config.settings.enabled = nil # => Qonfig::ValidationError (should be a boolean)
+```
+            +
+---
+            +
+### Predefined validations
+            +
+- DSL: `validate 'key.pattern', :predefned_validator`
+- predefined validators:
+  - `:not_nil`
+  - `:integer`
+  - `:float`
+  - `:numeric`
+  - `:big_decimal`
+  - `:array`
+  - `:hash`
+  - `:string`
+  - `:symbol`
+  - `:text` (`string` or `symbol`)
+  - `:boolean`
+  - `:class`
+  - `:module`
+  - `:proc`
+            +
+```ruby
+class Config < Qonfig::DataSet
+  setting :user
+  setting :password
+            +
+  setting :service do
+    setting :provider
+    setting :protocol
+    setting :on_fail, -> { puts 'atata!' }
+  end
+            +
+  setting :ignorance, false
+            +
+  validate 'user', :string
+  validate 'password', :string
+  validate 'service.provider', :text
+  validate 'service.protocol', :text
+  validate 'service.on_fail', :proc
+  validate 'ignorance', :not_nil
+end
+            +
+config = Config.new do |conf|
+  conf.user = 'D@iVeR'
+  conf.password = 'test123'
+  conf.service.provider = :google
+  conf.service.protocol = :https
+end # NOTE: all right :)
+            +
+config.settings.ignorance = nil # => Qonfig::ValidationError (cant be nil)
+```
+            +
+---
+            +
+## Work with files
+            +
 ### Load from YAML file
 - supports `ERB`;
@@ -922,116 +1350,6 @@ dynamic: 10
 ---
-### Smart Mixin
-            -
-- class-level:
-  - `.configuration` - settings definitions;
-  - `.configure` - configuration;
-  - `.config` - config object;
-  - settings definitions are inheritable;
-- instance-level:
-  - `#configure` - configuration;
-  - `#config` - config object;
-  - `#shared_config` - class-level config object;
-            -
-```ruby
-# --- usage ---
-            -
-class Application
-  # make configurable
-  include Qonfig::Configurable
-            -
-  configuration do
-    setting :user
-    setting :password
-  end
-end
-            -
-app = Application.new
-            -
-# class-level config
-Application.config.settings.user # => nil
-Application.config.settings.password # => nil
-            -
-# instance-level config
-app.config.settings.user # => nil
-app.config.settings.password # => nil
-            -
-# access to the class level config from an instance
-app.shared_config.settings.user # => nil
-app.shared_config.settings.password # => nil
-            -
-# class-level configuration
-Application.configure do |conf|
-  conf.user = '0exp'
-  conf.password = 'test123'
-end
-            -
-# instance-level configuration
-app.configure do |conf|
-  conf.user = 'admin'
-  conf.password = '123test'
-end
-            -
-# class has own config object
-Application.config.settings.user # => '0exp'
-Application.config.settings.password # => 'test123'
-            -
-# instance has own config object
-app.config.settings.user # => 'admin'
-app.config.settings.password # => '123test'
-            -
-# access to the class level config from an instance
-app.shared_config.settings.user # => '0exp'
-app.shared_config.settings.password # => 'test123'
-            -
-# and etc... (all Qonfig-related features)
-```
-            -
-```ruby
-# --- inheritance ---
-            -
-class BasicApplication
-  # make configurable
-  include Qonfig::Configurable
-            -
-  configuration do
-    setting :user
-    setting :pswd
-  end
-            -
-  configure do |conf|
-    conf.user = 'admin'
-    conf.pswd = 'admin'
-  end
-end
-            -
-class GeneralApplication < BasicApplication
-  # extend inherited definitions
-  configuration do
-    setting :db do
-      setting :adapter
-    end
-  end
-            -
-  configure do |conf|
-    conf.user = '0exp' # .user inherited from BasicApplication
-    conf.pswd = '123test' # .pswd inherited from BasicApplication
-    conf.db.adapter = 'pg'
-  end
-end
-            -
-BasicApplication.config.to_h
-{ 'user' => 'admin', 'pswd' => 'admin' }
-            -
-GeneralApplication.config.to_h
-{ 'user' => '0exp', 'pswd' => '123test', 'db' => { 'adapter' => 'pg' } }
-            -
-# and etc... (all Qonfig-related features)
-```
-            -
----
-            -
 ### Plugins
 ```ruby
@@ -1047,23 +1365,25 @@ Qonfig.plugin(:plugin_name) # or Qonfig.plugin('plugin_name')
 ### Plugins: toml
 - adds support for `toml` format ([specification](https://github.com/toml-lang/toml));
-- depends on `toml-rb` gem;
-- provides `load_from_toml` (works in `load_from_yaml` manner [doc](#load-from-yaml-file));
-- provides `save_to_toml` (works in `save_to_yaml` manner [doc](#save-to-yaml-file)) (`toml-rb` has no native options);
-- provides `expose_toml` (works in `expose_yaml` manner [doc](#expose-yaml));
+- depends on `toml-rb` gem ([link](https://github.com/emancu/toml-rb));
+- supports TOML `0.4.0` format (dependency lock);
+- provides `load_from_toml` (works in `load_from_yaml` manner ([doc](#load-from-yaml-file)));
+- provides `save_to_toml` (works in `save_to_yaml` manner ([doc](#save-to-yaml-file))) (`toml-rb` has no native options);
+- provides `expose_toml` (works in `expose_yaml` manner ([doc](#expose-yaml)));
 ```ruby
+# 1) require external dependency
 require 'toml-rb'
+            +
+# 2) enable plugin
 Qonfig.plugin(:toml)
-# and use :)
+            +
+# 3) use :)
 ```
 ---
 ## Roadmap
-- support for TOML format;
-- explicit "settings" object;
-- validation layer;
 - distributed configuration server;
 - support for Rails-like secrets;

data/lib/qonfig.rb CHANGED

@@ -10,6 +10,7 @@ module Qonfig
   require_relative 'qonfig/uploaders'
   require_relative 'qonfig/commands'
   require_relative 'qonfig/command_set'
+  require_relative 'qonfig/validator'
   require_relative 'qonfig/settings'
   require_relative 'qonfig/dsl'
   require_relative 'qonfig/data_set'

data/lib/qonfig/command_set.rb CHANGED

@@ -3,12 +3,18 @@
 # @api private
 # @since 0.1.0
 class Qonfig::CommandSet
+  # @api private
+  # @since 0.13.0
+  include Enumerable
+            +
   # @return [Array<Qonfig::Commands::Base>]
   #
   # @api private
   # @since 0.1.0
   attr_reader :commands
+  # @return [void]
+  #
   # @api private
   # @since 0.1.0
   def initialize
@@ -57,7 +63,7 @@ class Qonfig::CommandSet
   private
   # @param block [Proc]
-  # @return [Object]
+  # @return [Any]
   #
   # @api private
   # @since 0.2.0

data/lib/qonfig/commands/add_nested_option.rb CHANGED

@@ -32,14 +32,16 @@ class Qonfig::Commands::AddNestedOption < Qonfig::Commands::Base
     end
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.1.0
-  def call(settings)
+  def call(data_set, settings)
     nested_settings = nested_data_set_klass.new.settings
+    nested_settings.__mutation_callbacks__.add(settings.__mutation_callbacks__)
     settings.__define_setting__(key, nested_settings)
   end
 end

data/lib/qonfig/commands/add_option.rb CHANGED

@@ -30,12 +30,13 @@ class Qonfig::Commands::AddOption < Qonfig::Commands::Base
     @value = value
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.1.0
-  def call(settings)
+  def call(data_set, settings)
     settings.__define_setting__(key, value)
   end
 end

data/lib/qonfig/commands/base.rb CHANGED

@@ -3,10 +3,11 @@
 # @api private
 # @since 0.1.0
 class Qonfig::Commands::Base
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.1.0
-  def call(settings); end
+  def call(data_set, settings); end
 end

data/lib/qonfig/commands/compose.rb CHANGED

@@ -7,31 +7,37 @@ class Qonfig::Commands::Compose < Qonfig::Commands::Base
   #
   # @api private
   # @since 0.1.0
-  attr_reader :data_set_klass
+  attr_reader :composable_data_set_klass
-  # @param data_set_klass [Qonfig::DataSet]
+  # @param composable_data_set_klass [Qonfig::DataSet]
   #
   # @raise [Qonfig::ArgumentError]
   #
   # @api private
   # @since 0.1.0
-  def initialize(data_set_klass)
-    raise(
-      Qonfig::ArgumentError,
-      'Composed config class should be a subtype of Qonfig::DataSet'
-    ) unless data_set_klass.is_a?(Class) && data_set_klass < Qonfig::DataSet
+  def initialize(composable_data_set_klass)
+    unless composable_data_set_klass.is_a?(Class) && composable_data_set_klass < Qonfig::DataSet
+      raise(
+        Qonfig::ArgumentError,
+        'Composed config class should be a subtype of Qonfig::DataSet'
+      )
+    end
-    @data_set_klass = data_set_klass
+    @composable_data_set_klass = composable_data_set_klass
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.1.0
-  def call(settings)
-    composite_settings = data_set_klass.new.settings
+  def call(data_set, settings)
+    # NOTE: append new validators
+    data_set.class.validators.concat(composable_data_set_klass.validators.dup)
+    # NOTE: append new settings
+    composite_settings = composable_data_set_klass.new.settings
     settings.__append_settings__(composite_settings)
   end
 end

data/lib/qonfig/commands/expose_yaml.rb CHANGED

@@ -60,12 +60,13 @@ class Qonfig::Commands::ExposeYAML < Qonfig::Commands::Base
     @env       = env
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.7.0
-  def call(settings)
+  def call(data_set, settings)
     case via
     when EXPOSERS[:file_name]
       expose_file_name!(settings)

data/lib/qonfig/commands/load_from_env.rb CHANGED

@@ -55,12 +55,13 @@ class Qonfig::Commands::LoadFromENV < Qonfig::Commands::Base
     @trim_pattern   = prefix.is_a?(Regexp) ? prefix : /\A(#{Regexp.escape(prefix.to_s)})/m
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.2.0
-  def call(settings)
+  def call(data_set, settings)
     env_data = extract_env_data
     env_based_settings = build_data_set_class(env_data).new.settings

data/lib/qonfig/commands/load_from_json.rb CHANGED

@@ -25,12 +25,13 @@ class Qonfig::Commands::LoadFromJSON < Qonfig::Commands::Base
     @strict = strict
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.5.0
-  def call(settings)
+  def call(data_set, settings)
     json_data = Qonfig::Loaders::JSON.load_file(file_path, fail_on_unexist: strict)
     raise(

data/lib/qonfig/commands/load_from_self.rb CHANGED

@@ -17,12 +17,13 @@ class Qonfig::Commands::LoadFromSelf < Qonfig::Commands::Base
     @caller_location = caller_location
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.2.0
-  def call(settings)
+  def call(data_set, settings)
     yaml_data = load_self_placed_yaml_data
     yaml_based_settings = build_data_set_klass(yaml_data).new.settings

data/lib/qonfig/commands/load_from_yaml.rb CHANGED

@@ -25,6 +25,7 @@ class Qonfig::Commands::LoadFromYAML < Qonfig::Commands::Base
     @strict = strict
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
@@ -32,7 +33,7 @@ class Qonfig::Commands::LoadFromYAML < Qonfig::Commands::Base
   #
   # @api private
   # @since 0.2.0
-  def call(settings)
+  def call(data_set, settings)
     yaml_data = Qonfig::Loaders::YAML.load_file(file_path, fail_on_unexist: strict)
     raise(

data/lib/qonfig/data_set.rb CHANGED

@@ -2,29 +2,30 @@
 # @api public
 # @since 0.1.0
-class Qonfig::DataSet
+class Qonfig::DataSet # rubocop:disable Metrics/ClassLength
   require_relative 'data_set/class_builder'
-  require_relative 'data_set/validator'
+  require_relative 'data_set/lock'
   # @since 0.1.0
   extend Qonfig::DSL
+  # @since 0.13.0
+  extend Qonfig::Validator::DSL
+            +
   # @return [Qonfig::Settings]
   #
   # @api private
   # @since 0.1.0
   attr_reader :settings
-  # @param options_map [Hash]
+  # @param settings_map [Hash]
   # @param configurations [Proc]
   #
   # @api public
   # @since 0.1.0
-  def initialize(options_map = {}, &configurations)
-    @__access_lock__ = Mutex.new
-    @__definition_lock__ = Mutex.new
+  def initialize(settings_map = {}, &configurations)
+    @__lock__ = Qonfig::DataSet::Lock.new
+    thread_safe_definition { load!(settings_map, &configurations) }
-            -
-    thread_safe_definition { load!(options_map, &configurations) }
   end
   # @return [void]
@@ -43,7 +44,7 @@ class Qonfig::DataSet
     thread_safe_access { settings.__is_frozen__ }
   end
-  # @param options_map [Hash]
+  # @param settings_map [Hash]
   # @param configurations [Proc]
   # @return [void]
   #
@@ -51,22 +52,21 @@ class Qonfig::DataSet
   #
   # @api public
   # @since 0.2.0
-  def reload!(options_map = {}, &configurations)
+  def reload!(settings_map = {}, &configurations)
     thread_safe_definition do
       raise Qonfig::FrozenSettingsError, 'Frozen config can not be reloaded' if frozen?
-      load!(options_map, &configurations)
+      load!(settings_map, &configurations)
     end
   end
-  # @param options_map [Hash]
+  # @param settings_map [Hash]
   # @return [void]
   #
   # @api public
   # @since 0.1.0
-  def configure(options_map = {})
+  def configure(settings_map = {}, &configurations)
     thread_safe_access do
-      settings.__apply_values__(options_map)
+      apply_settings(settings_map, &configurations)
-      yield(settings) if block_given?
     end
   end
@@ -172,25 +172,94 @@ class Qonfig::DataSet
     thread_safe_access { settings.__clear__ }
   end
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @yield [setting_key, setting_value]
+  # @yieldparam setting_key [String]
+  # @yieldparam setting_value [Object]
+  #
+  # @api public
+  # @since 0.13.0
+  def each_setting(&block)
+    thread_safe_access { settings.__each_setting__(&block) }
+  end
+            +
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @yield [setting_key, setting_value]
+  # @yieldparam setting_key [String]
+  # @yieldparam setting_value [Object]
+  #
+  # @api public
+  # @since 0.13.0
+  def deep_each_setting(&block)
+    thread_safe_access { settings.__deep_each_setting__(&block) }
+  end
+            +
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.13.0
+  def valid?
+    thread_safe_access { validator.valid? }
+  end
+            +
+  # @return [void]
+  #
+  # @api public
+  # @since 0.13.0
+  def validate!
+    thread_safe_access { validator.validate! }
+  end
+            +
   private
-  # @return [Qonfig::Settings]
+  # @return [Qonfig::Validator]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validator
+            +
+  # @return [void]
   #
   # @api private
   # @since 0.2.0
   def build_settings
-    Qonfig::Settings::Builder.build(self.class.commands.dup)
+    @settings = Qonfig::Settings::Builder.build(self)
+    validator.validate!
+  end
+            +
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_validator
+    @validator = Qonfig::Validator.new(self)
+  end
+            +
+  # @param settings_map [Hash]
+  # @param configurations [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def apply_settings(settings_map = {}, &configurations)
+    settings.__apply_values__(settings_map)
+    yield(settings) if block_given?
   end
-  # @param options_map [Hash]
+  # @param settings_map [Hash]
   # @param configurations [Proc]
   # @return [void]
   #
   # @api private
   # @since 0.2.0
-  def load!(options_map = {}, &configurations)
-    @settings = build_settings
-    configure(options_map, &configurations)
+  def load!(settings_map = {}, &configurations)
+    build_validator
+    build_settings
+    apply_settings(settings_map, &configurations)
   end
   # @param instructions [Proc]
@@ -199,7 +268,7 @@ class Qonfig::DataSet
   # @api private
   # @since 0.2.0
   def thread_safe_access(&instructions)
-    @__access_lock__.synchronize(&instructions)
+    @__lock__.thread_safe_access(&instructions)
   end
   # @param instructions [Proc]
@@ -208,6 +277,6 @@ class Qonfig::DataSet
   # @api private
   # @since 0.2.0
   def thread_safe_definition(&instructions)
-    @__definition_lock__.synchronize(&instructions)
+    @__lock__.thread_safe_definition(&instructions)
   end
 end

data/lib/qonfig/data_set/lock.rb ADDED

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::DataSet::Lock
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize
+    @access_lock = Mutex.new
+    @definition_lock = Mutex.new
+  end
+            +
+  # @param instructions [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def thread_safe_access(&instructions)
+    access_lock.owned? ? yield : access_lock.synchronize(&instructions)
+  end
+            +
+  # @param instructions [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def thread_safe_definition(&instructions)
+    definition_lock.owned? ? yield : definition_lock.synchronize(&instructions)
+  end
+            +
+  private
+            +
+  # @return [Mutex]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :access_lock
+            +
+  # @return [Mutex]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :definition_lock
+end

data/lib/qonfig/data_set/validator.rb DELETED

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-            -
-# @api public
-# @since 0.?.0
-class Qonfig::DataSet::Validator
-  # TODO: think about validation layer
-end

data/lib/qonfig/errors.rb CHANGED

@@ -10,6 +10,14 @@ module Qonfig
   ArgumentError = Class.new(ArgumentError)
   # @api public
+  # @since 0.13.0
+  ValidatorArgumentError = Class.new(ArgumentError)
+            +
+  # @api public
+  # @since 0.13.0
+  ValidationError = Class.new(Error)
+            +
+  # @api public
   # @since 0.12.0
   PluginError = Class.new(Error)

data/lib/qonfig/plugins/toml/commands/expose_toml.rb CHANGED

@@ -60,12 +60,13 @@ class Qonfig::Commands::ExposeTOML < Qonfig::Commands::Base
     @env       = env
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.12.0
-  def call(settings)
+  def call(data_set, settings)
     case via
     when EXPOSERS[:file_name]
       expose_file_name!(settings)

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

@@ -25,12 +25,13 @@ class Qonfig::Commands::LoadFromTOML < Qonfig::Commands::Base
     @strict = strict
   end
+  # @param data_set [Qonfig::DataSet]
   # @param settings [Qonfig::Settings]
   # @return [void]
   #
   # @api private
   # @since 0.12.0
-  def call(settings)
+  def call(data_set, 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)

data/lib/qonfig/settings.rb CHANGED

@@ -2,11 +2,13 @@
 # @api private
 # @since 0.1.0
-# rubocop:disable Metrics/ClassLength
-class Qonfig::Settings
+# rubocop:disable Metrics/ClassLength, Layout/ClassStructure
+class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_METHODS constant
+  require_relative 'settings/callbacks'
   require_relative 'settings/lock'
   require_relative 'settings/builder'
   require_relative 'settings/key_guard'
+  require_relative 'settings/key_matcher'
   # @return [Proc]
   #
@@ -26,11 +28,49 @@ class Qonfig::Settings
   # @since 0.1.0
   attr_reader :__options__
+  # @return [Qonfig::Settings::Callbacks]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :__mutation_callbacks__
+            +
   # @api private
   # @since 0.1.0
-  def initialize
+  def initialize(__mutation_callbacks__)
     @__options__ = {}
     @__lock__ = Lock.new
+    @__mutation_callbacks__ = __mutation_callbacks__
+  end
+            +
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @yield [key, value]
+  # @yieldparam key [String]
+  # @yieldparam value [Object]
+  #
+  # @api private
+  # @since 0.13.0
+  def __each_setting__(&block)
+    __lock__.thread_safe_access do
+      __each_key_value_pair__(&block)
+    end
+  end
+            +
+  # @param initial_setting_key [String, NilClass]
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @yield [key, value]
+  # @yieldparam key [String]
+  # @yieldparam value [Object]
+  #
+  # @api private
+  # @since 0.13.0
+  def __deep_each_setting__(initial_setting_key = nil, &block)
+    __lock__.thread_safe_access do
+      __deep_each_key_value_pair__(initial_setting_key, &block)
+    end
   end
   # @param key [Symbol, String]
@@ -39,7 +79,7 @@ class Qonfig::Settings
   #
   # @api private
   # @since 0.1.0
-  def __define_setting__(key, value)
+  def __define_setting__(key, value) # rubocop:disable Metrics/AbcSize
     __lock__.thread_safe_definition do
       key = __indifferently_accessable_option_key__(key)
@@ -48,13 +88,15 @@ class Qonfig::Settings
       case
       when !__options__.key?(key)
         __options__[key] = value
-      when __options__[key].is_a?(Qonfig::Settings) && value.is_a?(Qonfig::Settings)
+      when __is_a_setting__(__options__[key]) && __is_a_setting__(value)
         __options__[key].__append_settings__(value)
       else
         __options__[key] = value
       end
-      __define_accessor__(key)
+      __define_option_reader__(key)
+      __define_option_writer__(key)
+      __define_option_predicate__(key)
     end
   end
@@ -71,6 +113,14 @@ class Qonfig::Settings
     end
   end
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def __invoke_mutation_callbacks__
+    __mutation_callbacks__.call
+  end
+            +
   # @param key [Symbol, String]
   # @return [Object]
   #
@@ -90,13 +140,13 @@ class Qonfig::Settings
     __lock__.thread_safe_access { __set_value__(key, value) }
   end
-  # @param options_map [Hash]
+  # @param settings_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) }
+  def __apply_values__(settings_map)
+    __lock__.thread_safe_access { __set_values_from_map__(settings_map) }
   end
   # @param keys [Array<String, Symbol>]
@@ -191,7 +241,7 @@ class Qonfig::Settings
       __options__.freeze
       __options__.each_value do |value|
-        value.__freeze__ if value.is_a?(Qonfig::Settings)
+        value.__freeze__ if __is_a_setting__(value)
       end
     end
   end
@@ -204,6 +254,15 @@ class Qonfig::Settings
     __lock__.thread_safe_access { __options__.frozen? }
   end
+  # @param value [Any]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def __is_a_setting__(value)
+    value.is_a?(Qonfig::Settings)
+  end
+            +
   private
   # @return [Qonfig::Settings::Lock]
@@ -212,7 +271,47 @@ class Qonfig::Settings
   # @since 0.2.0
   attr_reader :__lock__
-  # @param options_map [Hash]
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @yield [setting_key, setting_value]
+  # @yieldparam key [String]
+  # @yieldparam value [Object]
+  #
+  # @api private
+  # @since 0.13.0
+  def __each_key_value_pair__(&block)
+    __options__.each_pair(&block)
+  end
+            +
+  # @param initial_setting_key [String, NilClass]
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @yield [setting_key, setting_value]
+  # @yieldparam setting_key [String]
+  # @yieldparam setting_value [Object]
+  #
+  # @api private
+  # @since 0.13.0
+  def __deep_each_key_value_pair__(initial_setting_key = nil, &block)
+    enumerator = Enumerator.new do |yielder|
+      __each_key_value_pair__ do |setting_key, setting_value|
+        final_setting_key =
+          initial_setting_key ? "#{initial_setting_key}.#{setting_key}" : setting_key
+            +
+        if __is_a_setting__(setting_value)
+          setting_value.__deep_each_setting__(final_setting_key, &block)
+        else
+          yielder.yield(final_setting_key, setting_value)
+        end
+      end
+    end
+            +
+    block_given? ? enumerator.each(&block) : enumerator
+  end
+            +
+  # @param settings_map [Hash]
   # @return [void]
   #
   # @raise [Qonfig::ArgumentError]
@@ -220,21 +319,21 @@ class Qonfig::Settings
   #
   # @api private
   # @since 0.3.0
-  def __set_values_from_map__(options_map)
+  def __set_values_from_map__(settings_map)
     ::Kernel.raise(
       Qonfig::ArgumentError, 'Options map should be represented as a hash'
-    ) unless options_map.is_a?(Hash)
+    ) unless settings_map.is_a?(Hash)
-    options_map.each_pair do |key, value|
+    settings_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)
+      when !__is_a_setting__(current_value)
         __set_value__(key, value)
-      when current_value.is_a?(Qonfig::Settings) && value.is_a?(Hash)
+      when __is_a_setting__(current_value) && value.is_a?(Hash)
         current_value.__apply_values__(value)
-      when current_value.is_a?(Qonfig::Settings) && !value.is_a?(Hash)
+      when __is_a_setting__(current_value) && !value.is_a?(Hash)
         ::Kernel.raise(
           Qonfig::AmbiguousSettingValueError,
           "Can not redefine option <#{key}> that contains nested options"
@@ -255,12 +354,10 @@ class Qonfig::Settings
     ) if __options__.frozen?
     __options__.each_pair do |key, value|
-      if value.is_a?(Qonfig::Settings)
+      __is_a_setting__(value) ? value.__clear__ : __options__[key] = nil
-        value.__clear__
-      else
-        __options__[key] = nil
-      end
     end
+            +
+    __invoke_mutation_callbacks__
   end
   # @param key [String, Symbol]
@@ -301,14 +398,16 @@ class Qonfig::Settings
       ::Kernel.raise(Qonfig::FrozenSettingsError, 'Can not modify frozen settings')
     end
-    if __options__[key].is_a?(Qonfig::Settings)
+    if __is_a_setting__(__options__[key])
       ::Kernel.raise(
         Qonfig::AmbiguousSettingValueError,
         "Can not redefine option <#{key}> that contains nested options"
       )
     end
-    __options__[key] = value
+    (__options__[key] = value)
+            +
+    __invoke_mutation_callbacks__
   end
   # @param keys [Array<Symbol, String>]
@@ -328,12 +427,12 @@ class Qonfig::Settings
     case
     when rest_keys.empty?
       result
-    when !result.is_a?(Qonfig::Settings)
+    when !__is_a_setting__(result)
       ::Kernel.raise(
         Qonfig::UnknownSettingError,
         'Setting with required digging sequence does not exist!'
       )
-    when result.is_a?(Qonfig::Settings)
+    when __is_a_setting__(result)
       result.__dig__(*rest_keys)
     end
   end
@@ -350,7 +449,7 @@ class Qonfig::Settings
     {}.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
+        result[required_key] = __is_a_setting__(setting) ? setting.__to_h__ : setting
       end
     end
   end
@@ -386,7 +485,7 @@ class Qonfig::Settings
           transform_key: transform_key,
           transform_value: transform_value
         )
-      when value.is_a?(Qonfig::Settings)
+      when __is_a_setting__(value)
         hash[final_key] = value.__to_hash__(
           transform_key: transform_key,
           transform_value: transform_value
@@ -402,16 +501,30 @@ class Qonfig::Settings
   # @return [void]
   #
   # @api private
-  # @since 0.1.0
-  def __define_accessor__(key)
+  # @since 0.13.0
+  def __define_option_reader__(key)
     define_singleton_method(key) do
       self.[](key)
     end
+  end
+  # @param key [Symbol, String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def __define_option_writer__(key)
     define_singleton_method("#{key}=") do |value|
       self.[]=(key, value)
     end
+  end
+  # @param key [Symbol, String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def __define_option_predicate__(key)
     define_singleton_method("#{key}?") do
       !!self.[](key)
     end
@@ -442,7 +555,6 @@ class Qonfig::Settings
     KeyGuard.new(key).prevent_core_method_intersection!
   end
-  # rubocop:disable Layout/ClassStructure
   # @return [Array<String>]
   #
   # @api private
@@ -452,6 +564,5 @@ class Qonfig::Settings
     private_instance_methods(false) |
     %i[super define_singleton_method self]
   ).map(&:to_s).freeze
-  # rubocop:enable Layout/ClassStructure
 end
-# rubocop:enable Metrics/ClassLength
+# rubocop:enable Metrics/ClassLength, Layout/ClassStructure

data/lib/qonfig/settings/builder.rb CHANGED

@@ -4,14 +4,30 @@
 # @since 0.2.0
 module Qonfig::Settings::Builder
   class << self
-    # @param commands [Qonfig::CommandSet]
+    # @param data_set [Qonfig::DataSet]
     # @return [Qonfig::Settings]
     #
     # @api private
     # @since 0.2.0
-    def build(commands)
-      Qonfig::Settings.new.tap do |settings|
-        commands.each { |command| command.call(settings) }
+    def build(data_set)
+      Qonfig::Settings.new(build_mutation_callbacks(data_set)).tap do |settings|
+        data_set.class.commands.dup.each do |command|
+          command.call(data_set, settings)
+        end
+      end
+    end
+            +
+    private
+            +
+    # @param data_set [Qonfig::DataSet]
+    # @return [Qonfig::Settings::Callbacks]
+    #
+    # @api private
+    # @since 0.13.0
+    def build_mutation_callbacks(data_set)
+      Qonfig::Settings::Callbacks.new.tap do |callbacks|
+        # NOTE: validation callbacks
+        callbacks.add(proc { data_set.validate! })
       end
     end
   end

data/lib/qonfig/settings/callbacks.rb ADDED

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Settings::Callbacks
+  # @api private
+  # @since 0.13.0
+  include Enumerable
+            +
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize
+    @callbacks = []
+  end
+            +
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def call
+    callbacks.each(&:call)
+  end
+            +
+  # @param callback [Proc, Qonfig::Settings::Callbacks, #call]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def add(callback)
+    callbacks << callback
+  end
+  attr_reader :callback
+            +
+  private
+            +
+  # @return [Array<Proc>]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :callbacks
+end

data/lib/qonfig/settings/key_matcher.rb ADDED

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Settings::KeyMatcher
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  SCOPE_SPLITTER = '.'
+            +
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  MATCHER_SCOPE_SPLITTER = '\.'
+            +
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  GENERIC_PART_PATTERN = '*'
+            +
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  GENERIC_REGEXP_PATTERN = '[^\.]+\.'
+            +
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  INFINITE_PART_PATTERN = '#'
+            +
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  INFINITE_REGEXP_PATTERN = '\.*.*'
+            +
+  # @param scope_pattern [String]
+  # @return [void]
+  #
+  # @raise [Qonfig::ArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(scope_pattern)
+    raise Qonfig::ArgumentError unless scope_pattern.is_a?(String)
+            +
+    @scope_pattern      = scope_pattern
+    @scope_pattern_size = count_scope_pattern_size(scope_pattern)
+    @pattern_matcher    = build_pattern_matcher(scope_pattern)
+  end
+            +
+  # @param setting_key_pattern [String]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def match?(setting_key_pattern)
+    return false unless comparable_event_scopes?(setting_key_pattern)
+    !!pattern_matcher.match(setting_key_pattern)
+  end
+            +
+  private
+            +
+  # @return [Regexp]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :pattern_matcher
+            +
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :scope_pattern
+            +
+  # @return [Integer, Float::INFINITY]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :scope_pattern_size
+            +
+  # @param scope_pattern [String]
+  # @return [Integer, Float::INFINITY]
+  #
+  # @api private
+  # @since 0.13.0
+  def count_scope_pattern_size(scope_pattern)
+    return Float::INFINITY if scope_pattern == INFINITE_PART_PATTERN
+    return Float::INFINITY if scope_pattern.include?('.#')
+    return Float::INFINITY if scope_pattern.include?('#.')
+    return Float::INFINITY if scope_pattern.include?('.#.')
+            +
+    scope_pattern.split(SCOPE_SPLITTER).size
+  end
+            +
+  # @param setting_key_pattern [String]
+  # @return [Integer]
+  #
+  # @api private
+  # @since 0.13.0
+  def count_setting_key_pattern_size(setting_key_pattern)
+    setting_key_pattern.split(SCOPE_SPLITTER).size
+  end
+            +
+  # @param setting_key_pattern [String]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def comparable_event_scopes?(setting_key_pattern)
+    # NOTE: Integer#finite?, Integer#infinite?, Float#finite?, Float#nfinite?
+    #   Cant be used (backward compatability with old ruby versions)
+    return true if scope_pattern_size == Float::INFINITY
+    scope_pattern_size == count_setting_key_pattern_size(setting_key_pattern)
+  end
+            +
+  # @param pattern [String, NilClass]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def non_generic_pattern?(pattern = nil)
+    return false unless pattern
+    pattern != GENERIC_REGEXP_PATTERN && pattern != INFINITE_REGEXP_PATTERN
+  end
+            +
+  # "\.test\.created\.today\." => "test\.created\.today"
+  #
+  # @param regexp_string [String]
+  # @option left [Boolean]
+  # @option right [Boolean]
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  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
+            +
+  # @param scope_pattern [String]
+  # @return [Regexp]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_pattern_matcher(scope_pattern)
+    routing_parts = scope_pattern.split(SCOPE_SPLITTER)
+            +
+    regexp_string = routing_parts.each_with_object([]) do |routing_part, regexp_parts|
+      case routing_part
+      when GENERIC_PART_PATTERN
+        regexp_parts << GENERIC_REGEXP_PATTERN
+      when INFINITE_PART_PATTERN
+        if non_generic_pattern?(regexp_parts.last)
+          regexp_parts[-1] = strip_regexp_string(regexp_parts.last, right: true)
+        end
+            +
+        regexp_parts << INFINITE_REGEXP_PATTERN
+      else
+        regexp_parts << (Regexp.escape(routing_part) + MATCHER_SCOPE_SPLITTER)
+      end
+    end.join
+            +
+    regexp_string = strip_regexp_string(regexp_string, left: true, right: true)
+            +
+    Regexp.new('\A' + regexp_string + '\z')
+  end
+end

data/lib/qonfig/settings/lock.rb CHANGED

@@ -17,7 +17,7 @@ class Qonfig::Settings::Lock
   # @api private
   # @since 0.2.0
   def thread_safe_definition(&instructions)
-    definition_lock.synchronize(&instructions)
+    definition_lock.owned? ? yield : definition_lock.synchronize(&instructions)
   end
   # @param instructions [Proc]
@@ -26,7 +26,7 @@ class Qonfig::Settings::Lock
   # @api private
   # @since 0.2.0
   def thread_safe_access(&instructions)
-    access_lock.synchronize(&instructions)
+    access_lock.owned? ? yield : access_lock.synchronize(&instructions)
   end
   # @param instructions [Proc]
@@ -35,7 +35,7 @@ class Qonfig::Settings::Lock
   # @api private
   # @since 0.2.0
   def thread_safe_merge(&instructions)
-    merge_lock.synchronize(&instructions)
+    merge_lock.owned? ? yield : merge_lock.synchronize(&instructions)
   end
   private

data/lib/qonfig/validator.rb ADDED

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator
+  require_relative 'validator/basic'
+  require_relative 'validator/method_based'
+  require_relative 'validator/proc_based'
+  require_relative 'validator/builder'
+  require_relative 'validator/collection'
+  require_relative 'validator/predefined'
+  require_relative 'validator/dsl'
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(data_set)
+    @data_set = data_set
+    @validators = data_set.class.validators.dup
+  end
+            +
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate!
+    validators.each do |validator|
+      validator.validate(data_set)
+    end
+  end
+            +
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def valid?
+    validate!
+    true
+  rescue Qonfig::ValidationError
+    false
+  end
+            +
+  private
+            +
+  # @return [Qonfig::DataSet]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :data_set
+            +
+  # @return [Qonfig::Validator::Collection]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validators
+end

data/lib/qonfig/validator/basic.rb ADDED

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::Basic
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :setting_key_matcher
+            +
+  # @param setting_key_matcher [Qonfig::Settings::KeyMatcher, NilClass]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(setting_key_matcher)
+    @setting_key_matcher = setting_key_matcher
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate(data_set)
+    setting_key_provided? ? validate_concrete(data_set) : validate_full(data_set)
+  end
+            +
+  private
+            +
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def setting_key_provided?
+    !setting_key_matcher.nil?
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_full(data_set); end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_concrete(data_set); end
+end

data/lib/qonfig/validator/builder.rb ADDED

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::Builder
+  require_relative 'builder/attribute_consistency'
+            +
+  # @return [NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  EMPTY_SETTING_KEY_PATTERN = nil
+            +
+  # @return [NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  NO_RUNTIME_VALIDATION_METHOD = nil
+            +
+  # @return [NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  NO_VALIDATION_LOGIC = nil
+            +
+  # @return [NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  NO_PREDEFINED_VALIDATOR = nil
+            +
+  class << self
+    # @option setting_key_pattern [String, Symbol, NilClass]
+    # @option predefined_validator [String, Symbol, NilClass]
+    # @option runtime_validation_method [String, Symbol, NilClass]
+    # @option validation_logic [Proc, NilClass]
+    # @return [Qonfig::Validator::MethodBased, Qonfig::Validator::ProcBased]
+    #
+    # @api private
+    # @since 0.13.0
+    def build(
+      setting_key_pattern: EMPTY_SETTING_KEY_PATTERN,
+      runtime_validation_method: NO_RUNTIME_VALIDATION_METHOD,
+      validation_logic: NO_VALIDATION_LOGIC,
+      predefined_validator: NO_PREDEFINED_VALIDATOR
+    )
+      new(
+        setting_key_pattern,
+        predefined_validator,
+        runtime_validation_method,
+        validation_logic
+      ).build
+    end
+  end
+            +
+  # @param setting_key_pattern [String, Symbol, NilClass]
+  # @param predefined_validator [String, Symbol, NilClass]
+  # @param runtime_validation_method [String, Symbol, NilClass]
+  # @param validation_logic [Proc, NilClass]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(
+    setting_key_pattern,
+    predefined_validator,
+    runtime_validation_method,
+    validation_logic
+  )
+    @setting_key_pattern = setting_key_pattern
+    @predefined_validator = predefined_validator
+    @runtime_validation_method = runtime_validation_method
+    @validation_logic = validation_logic
+  end
+            +
+  # @return [Qonfig::Validator::MethodBased, Qonfig::Validator::ProcBased]
+  #
+  # @api private
+  # @since 0.13.0
+  def build
+    validate_attributes!
+    build_validator
+  end
+            +
+  private
+            +
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :setting_key_pattern
+            +
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :predefined_validator
+            +
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :runtime_validation_method
+            +
+  # @return [Proc, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validation_logic
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_attributes!
+    AttributeConsistency.check!(
+      setting_key_pattern,
+      predefined_validator,
+      runtime_validation_method,
+      validation_logic
+    )
+  end
+            +
+  # @return [Qonfig::Validator::MethodBased, Qonfig::Validator::PorcBased]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_validator
+    case
+    when predefined_validator      then build_predefined
+    when runtime_validation_method then build_method_based
+    when validation_logic          then build_proc_based
+    end
+  end
+            +
+  # @return [Qonfig::Settings::KeyMatcher, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_setting_key_matcher
+    Qonfig::Settings::KeyMatcher.new(setting_key_pattern.to_s) if setting_key_pattern
+  end
+            +
+  # @return [Qonfig::Validator::MethodBased]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_method_based
+    Qonfig::Validator::MethodBased.new(build_setting_key_matcher, runtime_validation_method)
+  end
+            +
+  # @return [Qonfig::Validator::ProcBased]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_proc_based
+    Qonfig::Validator::ProcBased.new(build_setting_key_matcher, validation_logic)
+  end
+            +
+  # @return [Qonfig::Settings::Predefined]
+  #
+  # @api private
+  # @since 0.13.0
+  def build_predefined
+    Qonfig::Validator::Predefined.build(predefined_validator, build_setting_key_matcher)
+  end
+end

data/lib/qonfig/validator/builder/attribute_consistency.rb ADDED

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::Builder::AttributeConsistency
+  class << self
+    # @param setting_key_pattern [String, Symbol, NilClass]
+    # @param predefined_validator [String, Symbol, NilClass]
+    # @param runtime_validation_method [String, Symbol, NilClass]
+    # @param validation_logic [Proc, NilClass]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.13.0
+    def check!(
+      setting_key_pattern,
+      predefined_validator,
+      runtime_validation_method,
+      validation_logic
+    )
+      new(
+        setting_key_pattern,
+        predefined_validator,
+        runtime_validation_method,
+        validation_logic
+      ).check!
+    end
+  end
+            +
+  # @param setting_key_pattern [String, Symbol, NilClass]
+  # @param predefined_validator [String, Symbol, NilClass]
+  # @param runtime_validation_method [String, Symbol, NilClass]
+  # @param validation_logic [Proc, NilClass]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(
+    setting_key_pattern,
+    predefined_validator,
+    runtime_validation_method,
+    validation_logic
+  )
+    @setting_key_pattern = setting_key_pattern
+    @predefined_validator = predefined_validator
+    @runtime_validation_method = runtime_validation_method
+    @validation_logic = validation_logic
+  end
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def check!
+    consistent_method_choice!
+    consistent_predefined_validator!
+    cosnistent_runtime_validation_method!
+    consistent_validation_logic!
+    consistent_setting_key_pattern!
+  end
+            +
+  private
+            +
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :setting_key_pattern
+            +
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :predefined_validator
+            +
+  # @return [String, Symbol, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :runtime_validation_method
+            +
+  # @return [Proc, NilClass]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validation_logic
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def consistent_method_choice!
+    unless runtime_validation_method || validation_logic || predefined_validator
+      raise(
+        Qonfig::ValidatorArgumentError,
+        'Empty validation (you should provide: dataset method OR proc OR predefined validator)'
+      )
+    end
+            +
+    if ((runtime_validation_method && validation_logic) ||
+       (predefined_validator && (runtime_validation_method || validation_logic)))
+      raise(
+        Qonfig::ValidatorArgumentError,
+        'Incosistent validation (you should use: dataset method OR proc OR predefined validator)'
+      )
+    end
+  end
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def consistent_predefined_validator!
+    return if predefined_validator.nil?
+    return if predefined_validator.is_a?(Symbol)
+    return if predefined_validator.is_a?(String)
+            +
+    raise(
+      Qonfig::ValidatorArgumentError,
+      'Incorrect name of predefined validator (should be a symbol or a string)'
+    )
+  end
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def cosnistent_runtime_validation_method!
+    return if runtime_validation_method.nil?
+    return if runtime_validation_method.is_a?(Symbol)
+    return if runtime_validation_method.is_a?(String)
+            +
+    raise(
+      Qonfig::ValidatorArgumentError,
+      'Incompatible validation method name (should be a symbol or a string)'
+    )
+  end
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def consistent_validation_logic!
+    return if validation_logic.nil?
+    return if validation_logic.is_a?(Proc)
+            +
+    # :nocov:
+    raise(
+      Qonfig::ValidatorArgumentError,
+      'Incompatible validation object (should be a proc)'
+    )
+    # :nocov:
+  end
+            +
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def consistent_setting_key_pattern!
+    return if setting_key_pattern.nil?
+    return if setting_key_pattern.is_a?(Symbol)
+    return if setting_key_pattern.is_a?(String)
+            +
+    raise(
+      Qonfig::ValidatorArgumentError,
+      'Incompatible setting key pattern (should be a string or a symbol)'
+    )
+  end
+end

data/lib/qonfig/validator/collection.rb ADDED

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::Collection
+  # @api private
+  # @since 0.13.0
+  include Enumerable
+            +
+  # @return [Array<Qonfig::Validator::MethodBased,Qonfig::Validator::ProcBased>]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validators
+            +
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize
+    @validators = []
+    @access_lock = Mutex.new
+  end
+            +
+  # @param validator [Qonfig::Validator::MethodBased, Qonfig::Validator::ProcBased]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def add_validator(validator)
+    thread_safe { validators << validator }
+  end
+  alias_method :<<, :add_validator
+            +
+  # @param block [Proc]
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.13.0
+  def each(&block)
+    thread_safe { block_given? ? validators.each(&block) : validators.each }
+  end
+            +
+  # @param collection [Qonfig::Validator::Collection]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def concat(collection)
+    thread_safe { validators.concat(collection.validators) }
+  end
+            +
+  # @return [Qonfig::Validator::Collection]
+  #
+  # @api private
+  # @since 0.13.0
+  def dup
+    thread_safe do
+      self.class.new.tap { |duplicate| duplicate.concat(self) }
+    end
+  end
+            +
+  private
+            +
+  # @param block [Proc]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.13.0
+  def thread_safe(&block)
+    @access_lock.synchronize(&block)
+  end
+end

data/lib/qonfig/validator/dsl.rb ADDED

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+module Qonfig::Validator::DSL
+  class << self
+    # @param child_klass [Qonfig::DataSet]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.13.0
+    def extended(child_klass)
+      child_klass.instance_variable_set(:@validators, Qonfig::Validator::Collection.new)
+            +
+      child_klass.singleton_class.prepend(Module.new do
+        def inherited(child_klass)
+          child_klass.instance_variable_set(:@validators, Qonfig::Validator::Collection.new)
+          child_klass.validators.concat(validators)
+          super
+        end
+      end)
+    end
+  end
+            +
+  # @return [Qonfig::Validator::Collection]
+  #
+  # @api private
+  # @since 0.13.0
+  def validators
+    @validators
+  end
+            +
+  # @param setting_key_pattern [String, Symbol, NilClass]
+  # @param predefined [String, Symbol]
+  # @option by [String, Symbol, NilClass]
+  # @param custom_validation [Proc]
+  # @return [void]
+  #
+  # @see Qonfig::Validator::Builder
+  #
+  # @api private
+  # @since 0.13.0
+  def validate(setting_key_pattern = nil, predefined = nil, by: nil, &custom_validation)
+    validators << Qonfig::Validator::Builder.build(
+      setting_key_pattern: setting_key_pattern,
+      predefined_validator: predefined,
+      runtime_validation_method: by,
+      validation_logic: custom_validation
+    )
+  end
+end

data/lib/qonfig/validator/method_based.rb ADDED

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::MethodBased < Qonfig::Validator::Basic
+  # @return [Symbol, String]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :runtime_validation_method
+            +
+  # @param setting_key_matcher [Qonfig::Settings::KeyMatcher, NilClass]
+  # @param runtime_validation_method [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(setting_key_matcher, runtime_validation_method)
+    super(setting_key_matcher)
+    @runtime_validation_method = runtime_validation_method
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_concrete(data_set)
+    data_set.settings.__deep_each_setting__ do |setting_key, setting_value|
+      next unless setting_key_matcher.match?(setting_key)
+            +
+      raise(
+        Qonfig::ValidationError,
+        "Invalid value of setting <#{setting_key}> (#{setting_value})"
+      ) unless data_set.__send__(runtime_validation_method, setting_value)
+    end
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_full(data_set)
+    unless data_set.__send__(runtime_validation_method)
+      raise(Qonfig::ValidationError, 'Invalid config object')
+    end
+  end
+end

data/lib/qonfig/validator/predefined.rb ADDED

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+module Qonfig::Validator::Predefined
+  require_relative 'predefined/common'
+  require_relative 'predefined/registry'
+  require_relative 'predefined/registry_control_mixin'
+            +
+  # @since 0.13.0
+  extend Qonfig::Validator::Predefined::RegistryControlMixin
+            +
+  # @since 0.13.0
+  predefine(:integer) { |value| value.is_a?(Integer) }
+  # @since 0.13.0
+  predefine(:float) { |value| value.is_a?(Float) }
+  # @since 0.13.0
+  predefine(:numeric) { |value| value.is_a?(Numeric) }
+  # @since 0.13.0
+  predefine(:string) { |value| value.is_a?(String) }
+  # @since 0.13.0
+  predefine(:symbol) { |value| value.is_a?(Symbol) }
+  # @since 0.13.0
+  predefine(:text) { |value| value.is_a?(Symbol) || value.is_a?(String) }
+  # @since 0.13.0
+  predefine(:array) { |value| value.is_a?(Array) }
+  # @since 0.13.0
+  predefine(:hash) { |value| value.is_a?(Hash) }
+  # @since 0.13.0
+  predefine(:big_decimal) { |value| value.is_a?(BigDecimal) }
+  # @since 0.13.0
+  predefine(:boolean) { |value| value.is_a?(TrueClass) || value.is_a?(FalseClass) }
+  # @since 0.13.0
+  predefine(:proc) { |value| value.is_a?(Proc) }
+  # @since 0.13.0
+  predefine(:class) { |value| value.is_a?(Class) }
+  # @since 0.13.0
+  predefine(:module) { |value| value.is_a?(Module) }
+  # @since 0.13.0
+  predefine(:not_nil) { |value| !value.nil? }
+end

data/lib/qonfig/validator/predefined/common.rb ADDED

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::Predefined::Common < Qonfig::Validator::Basic
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validation
+            +
+  # @param setting_key_matcher [Qonfig::Settings::KeyMatcher]
+  # @param validation [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(setting_key_matcher, validation)
+    super(setting_key_matcher)
+    @validation = validation
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidationError]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_concrete(data_set)
+    data_set.settings.__deep_each_setting__ do |setting_key, setting_value|
+      next unless setting_key_matcher.match?(setting_key)
+            +
+      raise(
+        Qonfig::ValidationError,
+        "Invalid value of setting <#{setting_key}> (#{setting_value})"
+      ) unless validation.call(setting_value)
+    end
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidationError]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_full(data_set)
+    # :nocov:
+    raise Qonfig::Error, 'Predefined validator should be used only with a setting key'
+    # :nocov:
+  end
+end

data/lib/qonfig/validator/predefined/registry.rb ADDED

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::Predefined::Registry
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize
+    @validators = {}
+    @lock = Mutex.new
+  end
+            +
+  # @param name [String, Symbol]
+  # @param validation [Proc]
+  # @return [void]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def register(name, &validation)
+    thread_safe do
+      name = indifferently_accessable_name(name)
+            +
+      raise(
+        Qonfig::ValidatorArgumentError,
+        "Predefined validator with name '#{name}' already exists."
+      ) if validators.key?(name)
+            +
+      validators[name] = validation
+    end
+  end
+            +
+  # @param name [String, Symbol]
+  # @return [Qonfig::Validator::ProcBased, Qonfig::Validator::MethodBased]
+  #
+  # @raise [Qonfig::ValidatorArgumentError]
+  #
+  # @api private
+  # @since 0.13.0
+  def resolve(name)
+    thread_safe do
+      # rubocop:disable Style/RedundantBegin
+      begin
+        validators.fetch(indifferently_accessable_name(name))
+      rescue KeyError
+        raise(
+          Qonfig::ValidatorArgumentError,
+          "Predefined validator with name '#{name}' does not exist."
+        )
+      end
+      # rubocop:enable Style/RedundantBegin
+    end
+  end
+            +
+  private
+            +
+  # @return [Hash<String,Proc>]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validators
+            +
+  # @param name [String, Symbol]
+  # @return [String]
+  #
+  # @api private
+  # @since 0.13.0
+  def indifferently_accessable_name(name)
+    name.to_s
+  end
+            +
+  # @param block [Proc]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.13.0
+  def thread_safe(&block)
+    @lock.synchronize(&block)
+  end
+end

data/lib/qonfig/validator/predefined/registry_control_mixin.rb ADDED

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+module Qonfig::Validator::Predefined::RegistryControlMixin
+  class << self
+    # @param basic_klass [Class, Module]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.13.0
+    def extended(basic_klass)
+      basic_klass.instance_variable_set(:@registry, Qonfig::Validator::Predefined::Registry.new)
+    end
+  end
+            +
+  # @return [Qonfig::Validator::Predefined::Registry]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :registry
+            +
+  # @param name [String, Symbol]
+  # @param validation [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def predefine(name, &validation)
+    registry.register(name, &validation)
+  end
+            +
+  # @param name [String, Symbol]
+  # @param setting_key_matcher [Qonfig::Setting::KeyMatcher]
+  # @return [Qonfig::Validator::Predefined::Common]
+  #
+  # @api private
+  # @since 0.13.0
+  def build(name, setting_key_matcher)
+    validation = registry.resolve(name)
+    Qonfig::Validator::Predefined::Common.new(setting_key_matcher, validation)
+  end
+end

data/lib/qonfig/validator/proc_based.rb ADDED

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+            +
+# @api private
+# @since 0.13.0
+class Qonfig::Validator::ProcBased < Qonfig::Validator::Basic
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.13.0
+  attr_reader :validation
+            +
+  # @param setting_key_matcher [Qonfig::Settings::KeyMatcher, NilClass]
+  # @param vaidation [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.13.0
+  def initialize(setting_key_matcher, validation)
+    super(setting_key_matcher)
+    @validation = validation
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Boolean]
+  #
+  # @raise [Qonfig::ValidationError]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_concrete(data_set)
+    data_set.settings.__deep_each_setting__ do |setting_key, setting_value|
+      next unless setting_key_matcher.match?(setting_key)
+            +
+      raise(
+        Qonfig::ValidationError,
+        "Invalid value of setting <#{setting_key}> (#{setting_value})"
+      ) unless data_set.instance_exec(setting_value, &validation)
+    end
+  end
+            +
+  # @param data_set [Qonfig::DataSet]
+  # @return [Boolean]
+  #
+  # @raise [Qonfig::ValidationError]
+  #
+  # @api private
+  # @since 0.13.0
+  def validate_full(data_set)
+    unless data_set.instance_eval(&validation)
+      raise(Qonfig::ValidationError, 'Invalid config object')
+    end
+  end
+end

data/lib/qonfig/version.rb CHANGED

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

data/qonfig.gemspec CHANGED

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   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.73'
+  spec.add_development_dependency 'armitage-rubocop', '~> 0.74'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qonfig
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
+date: 2019-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.73'
+        version: '0.74'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.73'
+        version: '0.74'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -149,7 +149,7 @@ files:
 - lib/qonfig/configurable.rb
 - lib/qonfig/data_set.rb
 - lib/qonfig/data_set/class_builder.rb
-- lib/qonfig/data_set/validator.rb
+- lib/qonfig/data_set/lock.rb
 - lib/qonfig/dsl.rb
 - lib/qonfig/errors.rb
 - lib/qonfig/loaders.rb
@@ -170,13 +170,27 @@ files:
 - lib/qonfig/plugins/toml/uploaders/toml.rb
 - lib/qonfig/settings.rb
 - lib/qonfig/settings/builder.rb
+- lib/qonfig/settings/callbacks.rb
 - lib/qonfig/settings/key_guard.rb
+- lib/qonfig/settings/key_matcher.rb
 - lib/qonfig/settings/lock.rb
 - lib/qonfig/uploaders.rb
 - lib/qonfig/uploaders/base.rb
 - lib/qonfig/uploaders/file.rb
 - lib/qonfig/uploaders/json.rb
 - lib/qonfig/uploaders/yaml.rb
+- lib/qonfig/validator.rb

qonfig 0.12.0 0.13.0