qonfig 0.25.0 → 0.26.0

data/lib/qonfig/commands/definition/load_from_env/value_converter.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 0.2.0
+# rubocop:disable Style/RedundantFreeze, Performance/MethodObjectAsBlock
 module Qonfig::Commands::Definition::LoadFromENV::ValueConverter
   # @return [Regexp]
   #
@@ -80,3 +81,4 @@ module Qonfig::Commands::Definition::LoadFromENV::ValueConverter
     end
   end
 end
+# rubocop:enable Style/RedundantFreeze, Performance/MethodObjectAsBlock

data/lib/qonfig/imports/direct_key.rb

@@ -34,7 +34,10 @@ class Qonfig::Imports::DirectKey < Qonfig::Imports::Abstract
   # @api private
   # @since 0.18.0
   # @version 0.21.0
-  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/BlockLength
+  # rubocop:disable Metrics/PerceivedComplexity
   def import!(settings_interface = Module.new)
     key_matchers.each do |key_matcher|
       raise(
@@ -80,7 +83,10 @@ class Qonfig::Imports::DirectKey < Qonfig::Imports::Abstract
       end
     end
   end
-  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/BlockLength
+  # rubocop:enable Metrics/PerceivedComplexity
 
   private
 

data/lib/qonfig/imports/mappings.rb

@@ -40,7 +40,10 @@ class Qonfig::Imports::Mappings < Qonfig::Imports::Abstract
   # @api private
   # @since 0.18.0
   # @version 0.21.0
-  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/BlockLength
+  # rubocop:disable Metrics/PerceivedComplexity
   def import!(settings_interface = Module.new) # rubocop:disable Metrics/AbcSize
     key_matchers.each_pair do |(mapped_method_name, key_matcher)|
       raise(
@@ -85,7 +88,10 @@ class Qonfig::Imports::Mappings < Qonfig::Imports::Abstract
       end
     end
   end
-  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/BlockLength
+  # rubocop:enable Metrics/PerceivedComplexity
 
   private
 

data/lib/qonfig/loaders/basic.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 0.2.0
+# rubocop:disable Style/StaticClass
 class Qonfig::Loaders::Basic
   class << self
     # @param data [String]
@@ -36,3 +37,4 @@ class Qonfig::Loaders::Basic
     end
   end
 end
+# rubocop:enable Style/StaticClass

data/lib/qonfig/loaders/json.rb

@@ -11,8 +11,9 @@ class Qonfig::Loaders::JSON < Qonfig::Loaders::Basic
     #
     # @api private
     # @since 0.5.0
+    # @version 0.26.0
     def load(data)
-      ::JSON.parse(data, max_nesting: false, allow_nan: true)
+      ::JSON.parse(ERB.new(data).result, max_nesting: false, allow_nan: true)
     rescue ::JSON::ParserError => error
       raise(Qonfig::JSONLoaderParseError.new(error.message).tap do |exception|
         exception.set_backtrace(error.backtrace)

data/lib/qonfig/settings.rb

@@ -100,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
@@ -108,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)
@@ -622,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
@@ -642,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]
@@ -685,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,

data/lib/qonfig/settings/key_matcher.rb

@@ -181,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/yaml.rb

@@ -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.25.0'
+  VERSION = '0.26.0'
 end

data/qonfig.gemspec

@@ -25,13 +25,11 @@ 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 'simplecov',        '~> 0.19'
-  spec.add_development_dependency 'rspec',            '~> 3.9'
-  spec.add_development_dependency 'armitage-rubocop', '~> 0.89'
+  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', '>= 13'

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