qonfig 0.29.0 → 0.31.0

data/qonfig.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'qonfig/version'
 
 Gem::Specification.new do |spec|
-  spec.required_ruby_version = '>= 2.6.0'
+  spec.required_ruby_version = '>= 3.1'
 
   spec.name        = 'qonfig'
   spec.version     = Qonfig::VERSION
@@ -27,14 +27,14 @@ Gem::Specification.new do |spec|
 
   spec.files = `git ls-files -z`.split("\x0")
 
-  spec.add_development_dependency 'simplecov',        '~> 0.21'
-  spec.add_development_dependency 'rspec',            '~> 3.11'
-  spec.add_development_dependency 'armitage-rubocop', '~> 1.30'
-  spec.add_development_dependency 'steep',            '~> 1.0'
+  spec.add_dependency 'base64', '>= 0.2'
+
+  spec.add_development_dependency 'simplecov',        '~> 0.22'
+  spec.add_development_dependency 'rspec',            '~> 3.2'
+  spec.add_development_dependency 'armitage-rubocop', '~> 1.59'
+  spec.add_development_dependency 'activesupport',    '~> 6', '< 8'
   spec.add_development_dependency 'bundler',          '>= 1'
-  spec.add_development_dependency 'bundler-audit',    '~> 0.9'
-  spec.add_development_dependency 'ci-helper',        '~> 0.5'
-  spec.add_development_dependency 'pry',              '~> 0.14'
+  spec.add_development_dependency 'pry',              '~> 0.15'
   spec.add_development_dependency 'rake',             '>= 13'
   spec.add_development_dependency 'simplecov-lcov',   '~> 0.8'
 end

data/spec/features/config_definition_and_representation_spec.rb

@@ -76,7 +76,7 @@ describe 'Config definition and representation' do
     )
 
     # hash representation (with key transformation)
-    expect(config.to_h(key_transformer: proc { |value| value.to_sym })).to match(
+    expect(config.to_h(key_transformer: proc(&:to_sym))).to match(
       serializers: {
         json: :native,
         xml: :native
@@ -94,7 +94,7 @@ describe 'Config definition and representation' do
     )
 
     # hash representation (with value transformation)
-    expect(config.to_h(value_transformer: proc { |value| value.to_s })).to match(
+    expect(config.to_h(value_transformer: proc(&:to_s))).to match(
       'serializers' => {
         'json' => 'native',
         'xml' => 'native'
@@ -114,8 +114,8 @@ describe 'Config definition and representation' do
     # hash representation (with key and value transformations)
     expect(
       config.to_h(
-        key_transformer: proc { |value| value.to_sym },
-        value_transformer: proc { |value| value.to_s }
+        key_transformer: proc(&:to_sym),
+        value_transformer: proc(&:to_s)
       )
     ).to match(
       serializers: {
@@ -381,7 +381,7 @@ describe 'Config definition and representation' do
     end.to raise_error(Qonfig::AmbiguousSettingValueError)
 
     # attempt to use non-hash object
-    [1, 1.0, Object.new, true, false, Class.new, Module.new, (proc {}), (-> {})].each do |non_hash|
+    [1, 1.0, Object.new, true, false, Class.new, Module.new, proc {}, -> {}].each do |non_hash|
       expect do
         # without proc
         HashConfigurableConfig.new(non_hash)
@@ -435,7 +435,7 @@ describe 'Config definition and representation' do
   end
 
   specify 'only string and symbol keys are supported' do
-    [1, 1.0, Object.new, true, false, Class.new, Module.new, (proc {}), (-> {})].each do |key|
+    [1, 1.0, Object.new, true, false, Class.new, Module.new, proc {}, -> {}].each do |key|
       expect do
         Class.new(Qonfig::DataSet) { setting(key) }
       end.to raise_error(Qonfig::ArgumentError)
@@ -477,7 +477,7 @@ describe 'Config definition and representation' do
   end
 
   specify 'fails when tries to use a non-string/non-symbol value as a setting key' do
-    incorrect_key_values = [123, Object.new, 15.1, (proc {}), Class.new, true, false]
+    incorrect_key_values = [123, Object.new, 15.1, proc {}, Class.new, true, false]
     correct_key_values   = ['test', :test]
 
     incorrect_key_values.each do |incorrect_key|

data/spec/features/freeze_state_spec.rb

@@ -36,13 +36,13 @@ describe 'Freeze state' do
         expect { conf.additionals = true }.to       raise_error(Qonfig::FrozenSettingsError)
 
         if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-          expect { conf.api_mode_enabled = false }.to raise_error(::FrozenError)
-          expect { conf.api.format = :xml }.to        raise_error(::FrozenError)
-          expect { conf.additionals = true }.to       raise_error(::FrozenError)
+          expect { conf.api_mode_enabled = false }.to raise_error(FrozenError)
+          expect { conf.api.format = :xml }.to        raise_error(FrozenError)
+          expect { conf.additionals = true }.to       raise_error(FrozenError)
         else
-          expect { conf.api_mode_enabled = false }.to raise_error(::RuntimeError)
-          expect { conf.api.format = :xml }.to        raise_error(::RuntimeError)
-          expect { conf.additionals = true }.to       raise_error(::RuntimeError)
+          expect { conf.api_mode_enabled = false }.to raise_error(RuntimeError)
+          expect { conf.api.format = :xml }.to        raise_error(RuntimeError)
+          expect { conf.additionals = true }.to       raise_error(RuntimeError)
         end
       end
 
@@ -55,11 +55,11 @@ describe 'Freeze state' do
       expect { frozen_config.clear! }.to raise_error(Qonfig::FrozenSettingsError)
 
       if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-        expect { frozen_config.reload! }.to raise_error(::FrozenError)
-        expect { frozen_config.clear! }.to raise_error(::FrozenError)
+        expect { frozen_config.reload! }.to raise_error(FrozenError)
+        expect { frozen_config.clear! }.to raise_error(FrozenError)
       else
-        expect { frozen_config.reload! }.to raise_error(::RuntimeError)
-        expect { frozen_config.clear! }.to raise_error(::RuntimeError)
+        expect { frozen_config.reload! }.to raise_error(RuntimeError)
+        expect { frozen_config.clear! }.to raise_error(RuntimeError)
       end
 
       expect(frozen_config.to_h).to match(

data/spec/features/nested_access_caching_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+describe 'Nested access caching (with matryoshka cache invalidation)' do
+  let(:config) do
+    Qonfig::DataSet.build do
+      setting :a do
+        setting :b do
+          setting :c do
+            setting :d, 1
+          end
+        end
+      end
+
+      setting :flat, 'value'
+    end
+  end
+
+  specify 'repeated dot-notated / nested reads return the same (memoized) result' do
+    expect(config['a.b.c.d']).to eq(1)
+    expect(config['a.b.c.d']).to eq(1)
+
+    nested = config['a.b.c']
+    expect(nested).to be_a(Qonfig::Settings)
+    # the very same nested settings instance is returned from the cache
+    expect(config['a.b.c']).to equal(nested)
+    expect(config.dig(:a, :b, :c)).to equal(nested)
+  end
+
+  specify 'symbol and string key variants share the cache (indifferent access)' do
+    expect(config[:a][:b][:c][:d]).to eq(1)
+    expect(config['a.b.c.d']).to eq(1)
+    expect(config.dig('a', :b, 'c', :d)).to eq(1)
+  end
+
+  specify 'assigning a value invalidates the cache' do
+    expect(config['a.b.c.d']).to eq(1)
+
+    config['a.b.c.d'] = 2
+    expect(config['a.b.c.d']).to eq(2)
+  end
+
+  specify 'mutating a nested config instance invalidates every parent cache (matryoshka)' do
+    # warm up caches on every level
+    expect(config['a.b.c.d']).to eq(1)
+    expect(config['a.b.c']['d']).to eq(1)
+
+    # mutate through a directly-grabbed nested instance
+    nested = config['a.b.c']
+    nested['d'] = 99
+
+    # the mutation must be visible from the root through the (now stale) cache
+    expect(config['a.b.c.d']).to eq(99)
+    expect(config['a.b']['c.d']).to eq(99)
+    expect(nested['d']).to eq(99)
+  end
+
+  specify 'a flat value mutation invalidates the cache' do
+    expect(config['flat']).to eq('value')
+    config['flat'] = 'changed'
+    expect(config['flat']).to eq('changed')
+  end
+
+  specify '#clear! invalidates the cache' do
+    expect(config['a.b.c.d']).to eq(1)
+    config.clear!
+    expect(config['a.b.c.d']).to be_nil
+  end
+
+  specify 'full data-set validators observe fresh values after mutation (no stale cache)' do
+    validated_config = Class.new(Qonfig::DataSet) do
+      setting :nested do
+        setting :flag, :yes
+      end
+
+      validate { settings.nested.flag.is_a?(Symbol) }
+    end
+
+    instance = validated_config.new
+    # warm the cache through the validator-read path
+    expect(instance.settings.nested.flag).to eq(:yes)
+
+    expect { instance.settings.nested.flag = 123 }.to raise_error(Qonfig::ValidationError)
+  end
+
+  specify 'composed nested settings invalidate the host cache on mutation' do
+    shared = Class.new(Qonfig::DataSet) do
+      setting :s do
+        setting :v, 1
+      end
+    end
+
+    host = Qonfig::DataSet.build { compose shared }
+
+    expect(host['s.v']).to eq(1) # warm up the cache through the host
+    host['s.v'] = 88
+    # the nested instance was merged in "by reference"; mutating it must still
+    # cascade invalidation up to the host (otherwise the host serves a stale 1)
+    expect(host['s.v']).to eq(88)
+  end
+
+  specify 're-defined nested settings invalidate the cache on mutation' do
+    redefined_config = Class.new(Qonfig::DataSet) do
+      setting :s do
+        setting :v, 1
+      end
+
+      re_setting :s do
+        setting :v, 10
+      end
+    end
+
+    instance = redefined_config.new
+
+    expect(instance['s.v']).to eq(10) # warm up the cache
+    instance['s.v'] = 77
+    expect(instance['s.v']).to eq(77)
+  end
+
+  specify 'cache invalidation always swaps in a fresh hash, even when already empty' do
+    # Guards the lock-free invalidation contract: invalidation may propagate up
+    # from a nested mutation without holding our access lock, so the swap must be
+    # unconditional. A `unless empty?` guard would let a concurrent reader that has
+    # resolved a stale value (but not yet written it) persist that value forever.
+    settings = config.settings
+    empty_cache = settings.instance_variable_get(:@__deep_access_cache__)
+    expect(empty_cache).to be_empty
+
+    settings.send(:__invalidate_deep_access_cache__)
+
+    swapped_cache = settings.instance_variable_get(:@__deep_access_cache__)
+    expect(swapped_cache).to be_empty
+    expect(swapped_cache).not_to equal(empty_cache)
+  end
+end

data/spec/features/plugins/pretty_print_spec.rb

@@ -35,13 +35,13 @@ describe 'Plugins(:pretty_print): Pretty print :)', plugin: :pretty_print do
         )
 
         expect(pretty_printer_output.string).to include(
-          " api.domain: \"google\",\n" \
-          " api.creds.token: \"a0sdj10k@\",\n" \
-          " api.creds.login: \"D2\",\n" \
-          " database.adapter: \"pg\",\n" \
-          " database.logging.queries: nil,\n" \
-          " logging: false,\n" \
-          " author: nil>\n"
+          " api.domain: \"google\",\n " \
+          "api.creds.token: \"a0sdj10k@\",\n " \
+          "api.creds.login: \"D2\",\n " \
+          "database.adapter: \"pg\",\n " \
+          "database.logging.queries: nil,\n " \
+          "logging: false,\n " \
+          "author: nil>\n"
         )
       end
     else
@@ -50,14 +50,14 @@ describe 'Plugins(:pretty_print): Pretty print :)', plugin: :pretty_print do
         value_space = SpecSupport.from_object_id_space_to_value_space(config)
 
         expect(pretty_printer_output.string).to eq(
-          "#<#{expected_config_klass_name}:0x#{value_space}\n" \
-          " api.domain: \"google\",\n" \
-          " api.creds.token: \"a0sdj10k@\",\n" \
-          " api.creds.login: \"D2\",\n" \
-          " database.adapter: \"pg\",\n" \
-          " database.logging.queries: nil,\n" \
-          " logging: false,\n" \
-          " author: nil>\n"
+          "#<#{expected_config_klass_name}:0x#{value_space}\n " \
+          "api.domain: \"google\",\n " \
+          "api.creds.token: \"a0sdj10k@\",\n " \
+          "api.creds.login: \"D2\",\n " \
+          "database.adapter: \"pg\",\n " \
+          "database.logging.queries: nil,\n " \
+          "logging: false,\n " \
+          "author: nil>\n"
         )
       end
     end

data/spec/features/plugins/toml/save_to_toml_spec.rb

@@ -142,7 +142,7 @@ describe 'Plugins(toml): Save to .toml (TOML)', plugin: :toml do
       end
 
       specify 'fails with parser error' do
-        expect { config.save_to_toml(path: config_file_path) }.to raise_error(::TomlRB::ParseError)
+        expect { config.save_to_toml(path: config_file_path) }.to raise_error(TomlRB::ParseError)
       end
     end
   end

data/spec/features/plugins/vault/expose_vault_spec.rb

@@ -104,7 +104,7 @@ describe 'Plugins(vault): expose vault', plugin: :vault do
       end
     end
 
-    let(:secret_data) { Hash[] }
+    let(:secret_data) { {} }
 
     specify "doesn't fail and uses empty config" do
       expect(Vault.logical).to receive(:read).with('kv/data/env_key').and_return(returned_data)

data/spec/features/run_code_with_temporary_settings_spec.rb

@@ -22,83 +22,85 @@ describe 'Run code with temporary settings' do
     expect(config.settings.api.login).to eq('D@iVeR')
   end
 
-  specify 'thread-safety' do
-    config = Qonfig::DataSet.build do
-      setting :api do
-        setting :token, 'test123'
-        setting :login, 'D@iVeR'
-      end
+  unless RUBY_ENGINE.include?('truffleruby')
+    specify 'thread-safety' do
+      config = Qonfig::DataSet.build do
+        setting :api do
+          setting :token, 'test123'
+          setting :login, 'D@iVeR'
+        end
 
-      setting :credentials do
-        setting :user, 'admin'
-        setting :password, '1234asdf'
+        setting :credentials do
+          setting :user, 'admin'
+          setting :password, '1234asdf'
+        end
       end
-    end
 
-    ThreadGroup.new.tap do |thread_group|
-      10.times do
-        thread_group.add(Thread.new do
-          # NOTE: change settings temporary
-          config.with(api: { token: '777555' }, credentials: { password: 'test123' }) do
-            config.settings.credentials.user = 'nimda'
-          end
-        end)
+      ThreadGroup.new.tap do |thread_group|
+        10.times do
+          thread_group.add(Thread.new do
+            # NOTE: change settings temporary
+            config.with(api: { token: '777555' }, credentials: { password: 'test123' }) do
+              config.settings.credentials.user = 'nimda'
+            end
+          end)
 
-        thread_group.add(Thread.new do
-          # NOTE: settings are not changed :)
-          expect(config.settings.credentials.user).to eq('admin')
-          expect(config.settings.credentials.password).to eq('1234asdf')
-          expect(config.settings.api.token).to eq('test123')
-          expect(config.settings.api.login).to eq('D@iVeR')
-        end)
+          thread_group.add(Thread.new do
+            # NOTE: settings are not changed :)
+            expect(config.settings.credentials.user).to eq('admin')
+            expect(config.settings.credentials.password).to eq('1234asdf')
+            expect(config.settings.api.token).to eq('test123')
+            expect(config.settings.api.login).to eq('D@iVeR')
+          end)
 
-        thread_group.add(Thread.new do
-          # NOTE: change settings temporary
-          config.with do
-            config.settings.api.login = 'provider'
-            config.settings.api.token = 'super_puper_123'
-          end
-        end)
+          thread_group.add(Thread.new do
+            # NOTE: change settings temporary
+            config.with do
+              config.settings.api.login = 'provider'
+              config.settings.api.token = 'super_puper_123'
+            end
+          end)
 
-        thread_group.add(Thread.new do
-          # NOTE: settings are not changed :)
-          expect(config.settings.credentials.user).to eq('admin')
-          expect(config.settings.credentials.password).to eq('1234asdf')
-          expect(config.settings.api.token).to eq('test123')
-          expect(config.settings.api.login).to eq('D@iVeR')
-        end)
+          thread_group.add(Thread.new do
+            # NOTE: settings are not changed :)
+            expect(config.settings.credentials.user).to eq('admin')
+            expect(config.settings.credentials.password).to eq('1234asdf')
+            expect(config.settings.api.token).to eq('test123')
+            expect(config.settings.api.login).to eq('D@iVeR')
+          end)
 
-        thread_group.add(Thread.new do
-          config.with(api: { login: '0exp' }, credentials: { user: 'D@iVeR' }) do
-            config.settings.api.token = 'kekpek123'
-            config.settings.credentials.password = 'admin'
-          end
-        end)
+          thread_group.add(Thread.new do
+            config.with(api: { login: '0exp' }, credentials: { user: 'D@iVeR' }) do
+              config.settings.api.token = 'kekpek123'
+              config.settings.credentials.password = 'admin'
+            end
+          end)
 
-        thread_group.add(Thread.new do
-          # NOTE: settings are not changed :)
-          expect(config.settings.credentials.user).to eq('admin')
-          expect(config.settings.credentials.password).to eq('1234asdf')
-          expect(config.settings.api.token).to eq('test123')
-          expect(config.settings.api.login).to eq('D@iVeR')
-        end)
+          thread_group.add(Thread.new do
+            # NOTE: settings are not changed :)
+            expect(config.settings.credentials.user).to eq('admin')
+            expect(config.settings.credentials.password).to eq('1234asdf')
+            expect(config.settings.api.token).to eq('test123')
+            expect(config.settings.api.login).to eq('D@iVeR')
+          end)
 
-        thread_group.add(Thread.new do
-          # NOTE: change settings temporary
-          config.with(api: { login: 'mobile_legends' }, credentials: { user: 'dota2' }) do
-            config.settings.api.token = 'league_of_legends'
-            config.settings.credentials.password = 'overwatch'
-          end
-        end)
+          thread_group.add(Thread.new do
+            # NOTE: change settings temporary
+            config.with(api: { login: 'mobile_legends' }, credentials: { user: 'dota2' }) do
+              config.settings.api.token = 'league_of_legends'
+              config.settings.credentials.password = 'overwatch'
+            end
+          end)
 
-        thread_group.add(Thread.new do
-          # NOTE: settings are not changed :)
-          expect(config.settings.credentials.user).to eq('admin')
-          expect(config.settings.credentials.password).to eq('1234asdf')
-          expect(config.settings.api.token).to eq('test123')
-          expect(config.settings.api.login).to eq('D@iVeR')
-        end)
-      end
-    end.list.map(&:join)
+          thread_group.add(Thread.new do
+            # NOTE: settings are not changed :)
+            expect(config.settings.credentials.user).to eq('admin')
+            expect(config.settings.credentials.password).to eq('1234asdf')
+            expect(config.settings.api.token).to eq('test123')
+            expect(config.settings.api.login).to eq('D@iVeR')
+          end)
+        end
+      end.list.map(&:join)
+    end
   end
 end

data/spec/features/save_to_file/save_to_json_spec.rb

@@ -108,24 +108,44 @@ describe 'Save to .json (JSON)' do
       # NOTE: step 2) read saved file
       file_data = File.read(config_file_path)
 
-      expect(file_data).to eq(<<~JSON.strip)
-        {
-         "true_bollean": true,
-         "false_boolean": false,
-         "empty_object": {
-         },
-         "filled_object": {
-          "a": 1,
-          "b": null,
-          "c": true,
-          "d": "1",
-          "e": false
-         },
-         "null_data": null,
-         "collection": [  "1",  2,  true,  false,  null,  [],  {
-          }]
-        }
-      JSON
+      expected_json =
+        if RUBY_ENGINE.include?('truffleruby')
+          <<~JSON.strip
+            {
+             "true_bollean": true,
+             "false_boolean": false,
+             "empty_object": {},
+             "filled_object": {
+              "a": 1,
+              "b": null,
+              "c": true,
+              "d": "1",
+              "e": false
+             },
+             "null_data": null,
+             "collection": ["1",2,true,false,null,[],{}]
+            }
+          JSON
+        else
+          <<~JSON.strip
+            {
+             "true_bollean": true,
+             "false_boolean": false,
+             "empty_object": {},
+             "filled_object": {
+              "a": 1,
+              "b": null,
+              "c": true,
+              "d": "1",
+              "e": false
+             },
+             "null_data": null,
+             "collection": [  "1",  2,  true,  false,  null,  [],  {}]
+            }
+          JSON
+        end
+
+      expect(file_data).to eq(expected_json)
     end
   end