config_reader 3.0.3 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5f34ccb03e315e9301ebedd211dca7e5fde4842e14e15a4f809ee6c0e5f16cd
-  data.tar.gz: 45f064ce87458166d7ccec76e18d8f3ceeaee36ac91665d6c0db6037f8e84d9b
+  metadata.gz: d8ed2bf310952ce4e846d92391a28d703d4d33beccb4801e98525909a38c4e16
+  data.tar.gz: 8ec8728939e738129bc359458165ff904d754a97b5efe6331a08a02d341c4cdc
 SHA512:
-  metadata.gz: 297c24bc4211132943f69e3a5b85f7d2686389f481c4b3b51fc10d530abebd638bb2705b274ac4546be65f9738331f573b39f10ea5b8d2d088270653c41058d5
-  data.tar.gz: 171d64da65475f7188967b1152715ec63730a4322b814372b66c4f5da1f8601b9619ff82c437907efc3acaf3e9ecff06bbcb7cd068584a0adb44e613cfb5c024
+  metadata.gz: 67a2478345db255b9ae177058bd347f7b3d665995d77f797c25907de185c60af866824bf6001d68e6ec8dbab90badff0f8e3c0ae72db7a81d0810581ad666104
+  data.tar.gz: b730fa2dac028ab694207c13b1fde1019b205258e572c59e2c2c58cd3487a817c6d9636f0e33980f2ef8b7eedbeb320663c3ea3c7ba94e47dca34bed029286f1

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 3.1.0 2026-04-18
+
+Add `parse_path` and `dig_path` for dotted user input.
+Fix config loading edge cases for false values, arrays, and missing config state.
+Update the README and load Sekrets lazily unless it is configured.
+
+## 3.0.4 2024-06-10
+
+Make reload actually reload, useful in development.
+
 ## 3.0.3 2025-01-06
 
 Fix a bug in deep merge where values weren't getting set properly.

data/README.md

@@ -1,59 +1,179 @@
 # ConfigReader
 
-[![Maintainability](https://codeclimate.com/github/UnderpantsGnome/config_reader-gem.png)](https://codeclimate.com/github/UnderpantsGnome/config_reader-gem)
 ![Specs](https://github.com/UnderpantsGnome/config_reader-gem/actions/workflows/ruby.yml/badge.svg)
 ![Ruby 3.0+](https://img.shields.io/badge/Ruby-%3E%3D%203.0-success)
 
-Provides a way to manage environment specific configuration settings. It will
-use the defaults for any environment and override any values you specify for
-an environment.
+`ConfigReader` loads environment-specific settings from YAML, merges each
+environment with `defaults`, and exposes the result through method access,
+hash access, and `dig`.
 
-Example config file:
+## Installation
 
-    defaults:
-      site_url: http://localhost:3000
-      host_name: example.com
-      mail_from: noreply@example.com
-      site_name: example
-      admin_email: admin@example.com
+Add the gem to your application's Gemfile:
 
-    production:
-      site_url: http://example.com
+```ruby
+gem "config_reader"
+```
 
-## Sekrets
+If you use encrypted config files with `sekrets_file`, add `sekrets` too:
+
+```ruby
+gem "sekrets", "~> 1.14"
+```
+
+## Config Format
 
-Includes Sekrets integration. See <https://github.com/ahoward/sekrets> for more
-information.
+`defaults` is required. `config.environment` must match one of the top-level
+environment keys in the file.
 
-The format of the sekrets file is the same as the regular file.
+```yaml
+defaults:
+  site_url: http://localhost:3000
+  host_name: example.com
+  mail_from: noreply@example.com
+  features:
+    search: true
+
+production:
+  site_url: http://example.com
+
+test:
+  features:
+    search: false
+```
 
 ## Setup
 
-    class MyConfig < ConfigReader
-      configure do |config|
-        config.environment = Rails.env # (set this however you access the env in your app)
-        config.config_file = "config/my_config.yml"
-        config.sekrets_file = "config/my_config.yml.enc" # (default nil)
-        config.ignore_missing_keys = true # (default false, raises KeyError)
-      end
-    end
+```ruby
+class MyConfig < ConfigReader
+  configure do |config|
+    config.environment = Rails.env
+    config.config_file = "config/my_config.yml"
+    config.sekrets_file = "config/my_config.yml.enc" # optional
+    config.ignore_missing_keys = false # default
+    config.permitted_classes = [] # optional
+  end
+end
+```
+
+`config_file` may be an exact path. If that path does not exist, ConfigReader
+also checks the current directory and `config/`.
 
 ## Usage
 
-    MyConfig.mail_from    #=> noreply@example.com
-    MyConfig[:mail_from]  #=> noreply@example.com
-    MyConfig["mail_from"] #=> noreply@example.com
+Top-level and nested values are available through methods, `[]`, and `dig`:
+
+```ruby
+MyConfig.mail_from
+MyConfig[:mail_from]
+MyConfig["mail_from"]
+
+MyConfig.features.search
+MyConfig[:features][:search]
+MyConfig.dig(:features, :search)
+```
+
+Arrays work with `dig` too:
+
+```ruby
+MyConfig.dig(:servers, 0, :host)
+```
+
+If you want to read a dotted path from user input, use `dig_path`:
+
+```ruby
+#!/usr/bin/env ruby
 
-## Note on Patches/Pull Requests
+require "bundler/setup"
+require_relative "../app/lib/config"
+
+print Config.dig_path(ARGV.fetch(0))
+```
+
+`parse_path` is also public if you need the normalized path segments:
+
+```ruby
+MyConfig.parse_path("servers.0.host")
+# => [:servers, 0, :host]
+```
+
+String paths treat numeric segments as array indexes. If you need a literal key
+that contains `.` or looks numeric, pass an array instead:
+
+```ruby
+MyConfig.dig_path([:numeric_keys, "0"])
+MyConfig.dig_path(["smtp.example.com"])
+```
+
+You can inspect the resolved config for all environments and reload it at
+runtime:
+
+```ruby
+MyConfig.envs["production"]
+MyConfig.reload
+```
+
+By default, missing keys raise `KeyError`. To return `nil` instead:
+
+```ruby
+class LenientConfig < ConfigReader
+  configure do |config|
+    config.environment = Rails.env
+    config.config_file = "config/my_config.yml"
+    config.ignore_missing_keys = true
+  end
+end
+```
+
+## Sekrets
 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don"t break it in a future
-    version unintentionally.
-* Commit, do not mess with rakefile, version, or history. (if you want to
-    have your own version, that is fine but bump version in a commit by itself
-    I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+ConfigReader supports Sekrets integration, but only loads the `sekrets` gem
+when `sekrets_file` is configured.
+
+The sekrets file uses the same structure as the main config file. Sekrets
+values are merged after the normal defaults plus environment merge, so matching
+sekrets values override plain YAML values.
+
+```ruby
+class SecureConfig < ConfigReader
+  configure do |config|
+    config.environment = Rails.env
+    config.config_file = "config/my_config.yml"
+    config.sekrets_file = "config/my_config.yml.enc"
+  end
+end
+```
+
+See <https://github.com/ahoward/sekrets> for more information.
+
+## Advanced YAML
+
+ERB is evaluated before the YAML is parsed:
+
+```yaml
+defaults:
+  cache_url: <%= ENV.fetch("CACHE_URL", "redis://localhost:6379/0") %>
+```
+
+YAML is loaded with `Psych.safe_load`. `Symbol` is always permitted, and you
+can allow additional classes through `permitted_classes`:
+
+```ruby
+class TypedConfig < ConfigReader
+  configure do |config|
+    config.environment = Rails.env
+    config.config_file = "config/my_config.yml"
+    config.permitted_classes = [Date, Time]
+  end
+end
+```
+
+## Contributing
+
+- Fork the project.
+- Make your change.
+- Add or update tests.
+- Open a pull request.
 
 ## Copyright
 

data/lib/config_reader/config_hash.rb

@@ -7,18 +7,26 @@ class ConfigReader
       config_hash.ignore_missing_keys = ignore_missing_keys
 
       hash.each_pair do |key, value|
-        config_hash[key.to_sym] = if value.is_a?(Hash)
-          convert_hash(value, ignore_missing_keys)
-        else
-          value
-        end
+        config_hash[key.to_sym] = convert_value(value, ignore_missing_keys)
       end
 
       config_hash
     end
 
+    def self.convert_value(value, ignore_missing_keys = false)
+      if value.is_a?(Hash)
+        convert_hash(value, ignore_missing_keys)
+      elsif value.is_a?(Array)
+        value.map { |item| convert_value(item, ignore_missing_keys) }
+      else
+        value
+      end
+    end
+
     def [](key)
-      fetch(key.to_sym)
+      key = key.to_sym if key.respond_to?(:to_sym)
+
+      fetch(key)
     rescue KeyError => e
       raise e unless ignore_missing_keys
     end

data/lib/config_reader/version.rb

@@ -1,3 +1,3 @@
 class ConfigReader
-  VERSION = "3.0.3"
+  VERSION = "3.1.0"
 end

data/lib/config_reader.rb

@@ -2,11 +2,6 @@ require "config_reader/version"
 require "config_reader/config_hash"
 require "psych"
 
-begin
-  require "sekrets"
-rescue LoadError
-end
-
 begin
   require "erb"
 rescue LoadError
@@ -36,7 +31,7 @@ class ConfigReader
     end
 
     def deep_merge(hash, other_hash)
-      hash.merge(other_hash) do |key, this_val, other_val|
+      hash.merge(other_hash) do |_key, this_val, other_val|
         if this_val.is_a?(Hash) && other_val.is_a?(Hash)
           deep_merge(this_val, other_val)
         else
@@ -45,13 +40,36 @@ class ConfigReader
       end
     end
 
+    def dig_path(path, separator: ".")
+      dig(*parse_path(path, separator: separator))
+    end
+
     def dig(*args)
-      args.map!(&:to_sym) if args.respond_to?(:map!)
+      if args.respond_to?(:map!)
+        args.map! do |arg|
+          (arg.respond_to?(:to_sym) && !arg.is_a?(Integer)) ? arg.to_sym : arg
+        end
+      end
 
       config.dig(*args)
     end
 
+    def parse_path(path, separator: ".")
+      case path
+      when String
+        raise ArgumentError, "Path must not be blank" if path.strip.empty?
+
+        path.split(separator).map { |segment| normalize_string_path_segment(segment) }
+      when Array
+        path.map { |segment| normalize_array_path_segment(segment) }
+      else
+        raise ArgumentError, "Path must be a String or Array"
+      end
+    end
+
     def find_config
+      return nil unless configuration.config_file
+
       return configuration.config_file if File.exist?(configuration.config_file)
 
       %w[. config].each do |dir|
@@ -78,16 +96,25 @@ class ConfigReader
 
     def load_sekrets
       if configuration.sekrets_file
-        if !defined?(::Sekrets)
-          raise ArgumentError,
-                "You specified a sekrets_file, but the sekrets gem isn't available."
-        else
+        if sekrets_available?
           ::Sekrets.settings_for(configuration.sekrets_file) ||
             raise("No sekrets found")
+        else
+          raise ArgumentError,
+                "You specified a sekrets_file, but the sekrets gem isn't available."
         end
       end
     end
 
+    def sekrets_available?
+      return true if defined?(::Sekrets)
+
+      require "sekrets"
+      true
+    rescue LoadError
+      false
+    end
+
     def load_yaml
       permitted_classes = configuration.permitted_classes.to_a + [Symbol]
 
@@ -99,7 +126,7 @@ class ConfigReader
         )
       else
         Psych.safe_load_file(
-          File.read(find_config),
+          find_config,
           aliases: true,
           permitted_classes: permitted_classes
         )
@@ -122,6 +149,7 @@ class ConfigReader
 
     def merge_configs(conf, sekrets)
       defaults = conf["defaults"]
+      raise "No defaults config found" unless defaults
 
       if sekrets&.[]("defaults")
         defaults = deep_merge(defaults, sekrets["defaults"])
@@ -129,7 +157,8 @@ class ConfigReader
 
       merge_all_configs(conf, defaults, sekrets)
 
-      @envs[configuration.environment]
+      @envs[configuration.environment] ||
+        raise("No config found for environment \"#{configuration.environment}\"")
     end
 
     def method_missing(key, *_args, &_block)
@@ -137,15 +166,33 @@ class ConfigReader
         raise ArgumentError.new("ConfigReader is immutable")
       end
 
-      config[key] || nil
+      config[key]
     end
 
     def reload
-      merge_configs(load_config, load_sekrets)
+      @config = merge_configs(load_config, load_sekrets)
     end
 
-    def respond_to_missing?(m, *)
-      config.key?(m)
+    def respond_to_missing?(m, include_private = false)
+      super || config.key?(m)
+    end
+
+    def normalize_array_path_segment(segment)
+      if segment.is_a?(String) || segment.is_a?(Symbol)
+        segment.to_sym
+      elsif segment.is_a?(Integer)
+        segment
+      else
+        raise ArgumentError, "Path segments must be Strings, Symbols, or Integers"
+      end
+    end
+
+    def normalize_string_path_segment(segment)
+      if segment.is_a?(String) && segment.match?(/\A\d+\z/)
+        segment.to_i
+      else
+        normalize_array_path_segment(segment)
+      end
     end
   end
 

data/spec/config_reader_spec.rb

@@ -53,6 +53,70 @@ describe "ConfigReader" do
     end
   end
 
+  describe ".parse_path" do
+    it "parses dotted paths into dig segments" do
+      expect(TestConfig.parse_path("nested_key.value")).to eq(%i[nested_key value])
+    end
+
+    it "parses array indexes from dotted paths" do
+      expect(TestConfig.parse_path("items.0.name")).to eq([:items, 0, :name])
+    end
+
+    it "normalizes array input" do
+      expect(TestConfig.parse_path(["nested_key", :value, 0])).to eq(
+        [:nested_key, :value, 0]
+      )
+    end
+
+    it "rejects blank strings" do
+      expect { TestConfig.parse_path("") }.to raise_error(
+        ArgumentError,
+        "Path must not be blank"
+      )
+    end
+
+    it "rejects unsupported types" do
+      expect { TestConfig.parse_path(Object.new) }.to raise_error(
+        ArgumentError,
+        "Path must be a String or Array"
+      )
+    end
+  end
+
+  describe ".dig_path" do
+    it "digs through dotted paths" do
+      expect(TestConfig.dig_path("nested_key.value")).to eq("test")
+    end
+
+    it "digs through arrays" do
+      config_class = Class.new(ConfigReader) do
+        class << self
+          def reload
+            ConfigReader::ConfigHash.convert_hash(
+              "items" => [{ "name" => "first" }]
+            )
+          end
+        end
+      end
+
+      expect(config_class.dig_path("items.0.name")).to eq("first")
+    end
+
+    it "allows array input for numeric-looking keys" do
+      config_class = Class.new(ConfigReader) do
+        class << self
+          def reload
+            ConfigReader::ConfigHash.convert_hash(
+              "numeric_keys" => { "0" => "zero" }
+            )
+          end
+        end
+      end
+
+      expect(config_class.dig_path([:numeric_keys, "0"])).to eq("zero")
+    end
+  end
+
   describe "ignoring KeyNotFound" do
     it "should not raise on missing key with [] accessor" do
       expect { NoKeyNoErrorConfig[:no_key] }.to_not raise_error
@@ -145,21 +209,144 @@ describe "ConfigReader" do
         expect(SekretsConfig["nested_key"]["value"]).to eq("test_sekret")
       end
 
-      it "should find sekrets only nested values using method_missing" do
-        expect(SekretsConfig.nested_key.value).to eq("test_sekret")
+      it "should find values that only exist in sekrets" do
+        config_class = Class.new(ConfigReader) do
+          class << self
+            def load_config
+              {
+                "defaults" => { "app_name" => "default_app" },
+                "test" => { "app_name" => "test_app" }
+              }
+            end
+
+            def load_sekrets
+              {
+                "test" => {
+                  "sekrets_only" => { "value" => "test_sekret_only" }
+                }
+              }
+            end
+          end
+
+          configure do |config|
+            config.environment = "test"
+          end
+        end
+
+        expect(config_class.sekrets_only.value).to eq("test_sekret_only")
+        expect(config_class[:sekrets_only][:value]).to eq("test_sekret_only")
+        expect(config_class["sekrets_only"]["value"]).to eq("test_sekret_only")
       end
 
-      it "should find sekrets only nested values using [] and a symbol" do
-        expect(SekretsConfig[:nested_key][:value]).to eq("test_sekret")
+      it "shouldn't need to have all keys duplicated in the environment section" do
+        expect(SekretsConfig.nested_key.only_in_test_env).to be true
       end
+    end
+  end
 
-      it "should find sekrets only nested values using [] and a string" do
-        expect(SekretsConfig["nested_key"]["value"]).to eq("test_sekret")
+  describe "regressions" do
+    it "does not load sekrets on a plain require" do
+      ruby_code = <<~RUBY
+        require "config_reader"
+        abort("sekrets loaded") if defined?(::Sekrets)
+      RUBY
+
+      stdout, stderr, status = Open3.capture3(
+        "bundle",
+        "exec",
+        "ruby",
+        "-Ilib",
+        "-e",
+        ruby_code,
+        chdir: File.expand_path("..", __dir__)
+      )
+
+      expect(status.success?).to be(true), stderr
+      expect(stdout).to eq("")
+    end
+
+    it "returns false for existing false values via method access" do
+      config_class = Class.new(ConfigReader) do
+        class << self
+          def reload
+            ConfigReader::ConfigHash.convert_hash("feature_enabled" => false)
+          end
+        end
       end
 
-      it "shouldn't need to have all keys duplicated in the environment section" do
-        expect(SekretsConfig.nested_key.only_in_test_env).to be true
+      expect(config_class.feature_enabled).to be(false)
+    end
+
+    it "raises a clear error when config_file is not set" do
+      config_class = Class.new(ConfigReader) do
+        configure do |config|
+          config.environment = "test"
+        end
       end
+
+      expect { config_class.load_config }.to raise_error("No config file set")
+    end
+
+    it "raises a clear error when the configured environment is missing" do
+      config_class = Class.new(ConfigReader) do
+        configure do |config|
+          config.environment = "missing"
+          config.config_file = "spec/test_config.yml"
+        end
+      end
+
+      expect { config_class.reload }.to raise_error(
+        'No config found for environment "missing"'
+      )
+    end
+
+    it "loads YAML without ERB support" do
+      config_class = Class.new(ConfigReader) do
+        configure do |config|
+          config.environment = "test"
+          config.config_file = "spec/test_config.yml"
+        end
+      end
+
+      hide_const("ERB")
+
+      expect(config_class.load_yaml.dig("test", "app_name")).to eq("test_app")
+    end
+
+    it "supports arrays when digging through config values" do
+      config_class = Class.new(ConfigReader) do
+        class << self
+          def reload
+            ConfigReader::ConfigHash.convert_hash(
+              "items" => [{ "name" => "first", "enabled" => false }]
+            )
+          end
+        end
+      end
+
+      expect(config_class[:items][0][:name]).to eq("first")
+      expect(config_class.dig(:items, 0, :name)).to eq("first")
+      expect(config_class.dig("items", 0, "enabled")).to be(false)
+    end
+
+    it "raises a clear error when defaults are missing" do
+      config_class = Class.new(ConfigReader) do
+        class << self
+          def load_config
+            { "test" => { "app_name" => "test_app" } }
+          end
+
+          def load_sekrets
+            nil
+          end
+        end
+
+        configure do |config|
+          config.environment = "test"
+        end
+      end
+
+      expect { config_class.reload }.to raise_error("No defaults config found")
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
+require "open3"
 require "config_reader"
 require "test_config"
 require "sekrets_config"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: config_reader
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.1.0
 platform: ruby
 authors:
 - Michael Moen
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abbrev
@@ -144,8 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Provides a way to manage environment specific configuration settings.
 test_files: []