qonfig 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bff64afc18729b2319a870162938579b2442a21ffcf808371c49d0449f8ad56e
-  data.tar.gz: f65cbd7f5fa80e35f42f03f7f14886dddebf7e4e6572dd18eda38c6c79e88b6f
+  metadata.gz: 7a51d2be5daa99fe68c0a7b3db5a802409a8b02e3ca2fe62abca61c0d1f7f0cf
+  data.tar.gz: a54a12a2fa42abd3b7025b1427e1939582063a5ccc0f4d3648fe8a336361ce52
 SHA512:
-  metadata.gz: dd25b7a25be0f1a5c481d8a2c8672e10fc50fcdb8013924be149d3815fb28709919f414bf2ee1fb8360b75680b3f6dbfab4cf19eb5315615ca1b4ed76f69e32b
-  data.tar.gz: 790284b0e80c1131fce3d0e4b1d353b147cae0209204c674c2e1042ded3048608d563fedc2ecd32e53240a3a067f02b64037e755e88a803fd879a5f66e9ba98a
+  metadata.gz: 915fb311e7af429433f218b04b7162c4691d7208329ae6d104990952a417c59ce6cdc55721f3393b435aa2e07642000c4afdd7902f3f20a018c287661f4462c5
+  data.tar.gz: 73f06741831e901ea385c1712d6a56f42e7a780809d5fa8dca848a6025f95fa24ddd84c3a4e80bb2a03934f2c55c65e43827537114801d16d1780b4e7c34572e

data/.github/workflows/build.yml

@@ -36,6 +36,8 @@ jobs:
         include:
           - ruby: head
             experimental: true
+          - ruby: truffleruby
+            experimental: true
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1

data/CHANGELOG.md

@@ -1,15 +1,27 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+### Added
+- Support for `truffleruby`;
+
+## [0.31.0] - 2026-06-24
+### Changed
+- Performance: nested / dot-notated reads (`config['a.b.c.d.e.f']`, `config.dig(...)`)
+  are now memoized inside each config instance instead of re-splitting and re-digging
+  the key on every access. The cache is dropped on any mutation and the invalidation
+  cascades up through all parent config instances ("matryoshka" cache invalidation),
+  so nested configs (which are separate instances) never serve stale values.
+
 ## [0.30.0] - 2024-12-14
 ### Changed
 - Updated development dependencies;
 - Updated code style;
-- Dropped EOL rubies support. Now Qonfig supports ruby with version `>= 3.1`;
+- Dropped EOL rubies support. Now Qonfig supports rubies started from `>= 3.1`;
 - CI: returned separated plugin-related specs (`bin/rspec -w` + `bin/rspec -n` (with- and without- plugins respectively));
 - CI: dropped coveralls (temporary);
 - CI: droppet java-based rubies support (temporary);
-- Simplified CI;
+- Simplified CI (temporary);
 
 ## [0.29.0] - 2024-05-06
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qonfig (0.29.1)
+    qonfig (0.31.0)
       base64 (>= 0.2)
 
 GEM

data/README.md

@@ -3329,9 +3329,9 @@ Qonfig.plugin(:vault)
 
 ## Roadmap
 
-- **General**:
-  - documentation rework;
 - **Major**:
+  - `on_change`-hooks (in order to proviade the possibility to change something like "re-initialize redis connection pool on each redis config changement" and so on);
+  - Runtime Configuration (with in-memory cache);
   - support for Rails-like secrets;
   - support for persistent data storages (we want to store configs in multiple databases and files);
   - rails plugin;
@@ -3347,6 +3347,7 @@ Qonfig.plugin(:vault)
   - File geneartors (.rb-files with a pre-filled code (and (maybe) with a pre-generated yaml/json/etc files));
   - Setting value changement subscriptions and callbacks;
   - CI rework (new configs, new steps, no strange dependencies);
+  - CI: thread-safety specs for `thruffleruby`;
 
 ## Build
 

data/gemfiles/with_external_deps.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    qonfig (0.29.1)
+    qonfig (0.31.0)
       base64 (>= 0.2)
 
 GEM

data/gemfiles/without_external_deps.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    qonfig (0.29.1)
+    qonfig (0.31.0)
       base64 (>= 0.2)
 
 GEM

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

@@ -41,10 +41,14 @@ class Qonfig::Commands::Definition::AddNestedOption < Qonfig::Commands::Base
   #
   # @api private
   # @since 0.1.0
+  # @version 0.31.0
   def call(data_set, settings)
     nested_settings = nested_data_set_klass.new.settings
 
-    nested_settings.__mutation_callbacks__.add(settings.__mutation_callbacks__)
+    # NOTE:
+    #   The nested instance is wired into the host's mutation-callback chain by
+    #   Qonfig::Settings#__define_setting__ itself (see __store_setting_value__),
+    #   so every nested-settings entry point shares one wiring path.
     settings.__define_setting__(key, nested_settings)
   end
 end

data/lib/qonfig/commands/definition/re_define_option.rb

@@ -48,10 +48,14 @@ class Qonfig::Commands::Definition::ReDefineOption < Qonfig::Commands::Base
   #
   # @api private
   # @since 0.20.0
+  # @version 0.31.0
   def call(data_set, settings)
     if nested_data_set_klass
       nested_settings = nested_data_set_klass.new.settings
-      nested_settings.__mutation_callbacks__.add(settings.__mutation_callbacks__)
+      # NOTE:
+      #   The nested instance is wired into the host's mutation-callback chain by
+      #   Qonfig::Settings#__define_setting__ itself (see __store_setting_value__),
+      #   so every nested-settings entry point shares one wiring path.
       settings.__define_setting__(key, nested_settings, with_redefinition: true)
     else
       settings.__define_setting__(key, value, with_redefinition: true)

data/lib/qonfig/settings/callbacks.rb

@@ -35,6 +35,15 @@ class Qonfig::Settings::Callbacks
     thread_safe { callbacks << callback }
   end
 
+  # @param callback [Proc, Qonfig::Settings::Callbacks, #call]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.31.0
+  def prepend(callback)
+    thread_safe { callbacks.unshift(callback) }
+  end
+
   private
 
   # @return [Array<Proc>]

data/lib/qonfig/settings.rb

@@ -48,10 +48,24 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
 
   # @api private
   # @since 0.1.0
+  # @version 0.31.0
   def initialize(__mutation_callbacks__)
     @__options__ = {}
     @__lock__ = Lock.new
     @__mutation_callbacks__ = __mutation_callbacks__
+    @__deep_access_cache__ = {}
+
+    # NOTE:
+    #   Register a cache invalidator inside our own mutation callbacks.
+    #   Nested settings add their parent's callbacks object to their own callbacks
+    #   (see #__store_setting_value__), so a mutation of any nested config propagates
+    #   upwards through the chain and drops the cached digging results on EACH config
+    #   instance along the way ("matryoshka" cache invalidation).
+    #
+    #   It is prepended so that it runs BEFORE the validation callback — full
+    #   data-set validators read setting values back through #__dig__, so the
+    #   cache must already be dropped by the time they run.
+    @__mutation_callbacks__.prepend(proc { __invalidate_deep_access_cache__ })
   end
 
   # @param block [Proc]
@@ -93,7 +107,7 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   #
   # @api private
   # @since 0.1.0
-  # @version 0.20.0
+  # @version 0.31.0
   def __define_setting__(key, value, with_redefinition: false) # rubocop:disable Metrics/AbcSize
     __lock__.thread_safe_definition do
       key = __indifferently_accessable_option_key__(key)
@@ -102,11 +116,11 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
 
       case
       when with_redefinition || !__options__.key?(key)
-        __options__[key] = value
+        __store_setting_value__(key, value)
       when __is_a_setting__(__options__[key]) && __is_a_setting__(value)
         __options__[key].__append_settings__(value)
       else
-        __options__[key] = value
+        __store_setting_value__(key, value)
       end
 
       __define_option_reader__(key)
@@ -175,16 +189,21 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
   #
   # @api private
   # @since 0.2.0
+  # @version 0.31.0
   def __dig__(*keys)
     __lock__.thread_safe_access do
-      begin
-        __deep_access__(*keys)
-      rescue Qonfig::UnknownSettingError
-        if keys.size == 1
-          __deep_access__(*__parse_dot_notated_key__(keys.first))
-        else
-          raise
-        end
+      # NOTE:
+      #   Resolving a dot-notated/nested key (config['a.b.c.d']) is expensive:
+      #   it splits and re-joins string fragments and digs through every nested
+      #   config instance on each access. We memoize the resolved value per key
+      #   set; the cache is dropped on any mutation (see __invalidate...).
+      cache = @__deep_access_cache__
+      cache_key = __deep_access_cache_key__(keys)
+
+      if cache.key?(cache_key)
+        cache[cache_key]
+      else
+        __resolve_deep_access__(*keys).tap { |value| cache[cache_key] = value }
       end
     end
   end
@@ -575,6 +594,75 @@ class Qonfig::Settings # NOTE: Layout/ClassStructure is disabled only for CORE_M
     __invoke_mutation_callbacks__
   end
 
+  # @param key [String]
+  # @param value [Object]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.31.0
+  def __store_setting_value__(key, value)
+    __options__[key] = value
+
+    # NOTE:
+    #   A nested settings instance can arrive here "foreign" — built under another
+    #   data set and merged into us by reference (compose / load_from_* / expose_* /
+    #   option re-definition). Its mutation callbacks would then still point only at
+    #   the discarded foreign parent, so a mutation of the nested config would never
+    #   invalidate OUR deep-access cache (=> stale reads). Wire the nested instance
+    #   into our callback chain on assignment so invalidation always cascades upwards
+    #   ("matryoshka"), regardless of how the nested settings instance got here.
+    value.__mutation_callbacks__.add(__mutation_callbacks__) if __is_a_setting__(value)
+  end
+
+  # @param keys [Array<String, Symbol>]
+  # @return [Object]
+  #
+  # @raise [Qonfig::UnknownSettingError]
+  #
+  # @api private
+  # @since 0.31.0
+  def __resolve_deep_access__(*keys)
+    __deep_access__(*keys)
+  rescue Qonfig::UnknownSettingError
+    if keys.size == 1
+      __deep_access__(*__parse_dot_notated_key__(keys.first))
+    else
+      raise
+    end
+  end
+
+  # @param keys [Array<String, Symbol>]
+  # @return [String, Array<String>]
+  #
+  # @api private
+  # @since 0.31.0
+  def __deep_access_cache_key__(keys)
+    # NOTE:
+    #   Stringify keys so that symbol/string variants share a single cache slot
+    #   (indifferent access), while preserving key boundaries — ['a.b', 'c'] and
+    #   ['a', 'b', 'c'] resolve differently and must not collide. The single-key
+    #   case (the dominant config['a.b.c'] form) avoids an extra array allocation.
+    (keys.size == 1) ? keys.first.to_s : keys.map(&:to_s)
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.31.0
+  def __invalidate_deep_access_cache__
+    # NOTE:
+    #   Reassign (instead of #clear) so concurrent readers never observe a
+    #   half-cleared hash — invalidation can propagate upwards from a nested
+    #   mutation WITHOUT holding our access lock.
+    #
+    #   The reassignment must be UNCONDITIONAL. A `unless empty?` guard would skip
+    #   the swap during the window where a concurrent reader has already resolved a
+    #   now-stale value but has not yet written it into the (still-empty) cache —
+    #   the stale write would then survive and be served forever. Rebinding the ivar
+    #   to a fresh hash makes such a late write land in an orphaned hash instead.
+    @__deep_access_cache__ = {}
+  end
+
   # @param keys [Array<Symbol, String>]
   # @return [Object]
   #

data/lib/qonfig/version.rb

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

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/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,22 +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
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: qonfig
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Rustam Ibragimov
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -154,7 +153,6 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/build.yml"
 - ".gitignore"
-- ".jrubyrc"
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -319,6 +317,7 @@ files:
 - spec/features/load_setting_values_from_file/load_from_yaml_spec.rb
 - spec/features/load_setting_values_from_file/shared_behavior_spec.rb
 - spec/features/mixin_spec.rb
+- spec/features/nested_access_caching_spec.rb
 - spec/features/non_redefineable_core_methods_spec.rb
 - spec/features/plugins/pretty_print_spec.rb
 - spec/features/plugins/toml/expose_self/format_option_toml_spec.rb
@@ -399,7 +398,6 @@ homepage: https://github.com/0exp/qonfig
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -414,8 +412,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Config object
 test_files: []

data/.jrubyrc

@@ -1 +0,0 @@
-debug.fullTrace=true