configx 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51b3ba99940f73078c374d7fb7804e231e58657903d6592ad9b594f42925d3b2
+  data.tar.gz: f51ed4cd4c47db8f05eb512d83d2d38bc0277e6acaed4aef54bd964e1bf87812
+SHA512:
+  metadata.gz: 0d07f1c7ab54071b42411736e107635a6c75a2a867dc22e32c685e7964eaa9ab1c4204a988c797a6280b0dc71a8470d760b16fb8092e04142a138c9d3c8bc9fd
+  data.tar.gz: 5bf94989849a17a47c833a6599ca029123fdf1b96cb704baab1d028fcfd9ce6efb09b1ed7b50285bc41fce5c05a78e70ceeab36367f53e14631a77c892162559

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Tëma Bolshakov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,178 @@
+# ⚙️ConfigX
+
+ConfigX is a simple configuration library that you can use with your application or libraries.
+
+ConfigX is NOT that kind of library that allows you configuring any Ruby object, instead
+it takes a different approach. It reads configuration from YAML files and environment variables
+and load it into a ruby object. It's highly influenced by the [config] gem, but it does
+not define a global objects and allows you having multiple independent configurations.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add configx
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install configx
+
+## Usage
+
+Start using the library as simple as loading configuration from default locations:
+
+```ruby
+config = ConfigX.load
+```
+
+It loads configuration from the following locations in the specified order:
+
+1. `config/settings.yml`
+2. `config/settings/production.yml`
+3. `config/settings.local.yml`
+4. `config/settings/production.local.yml`
+5. Environment variables
+
+All the configuration source are merged an intuitive way. For instance, 
+
+* **config/settings.yml**
+
+```yaml
+---
+api: 
+  enabled: false 
+  endpoint: https://example.com 
+  access_token: 
+```
+
+* **config/settings/production.yml**
+
+```yaml
+---
+api: 
+  enabled: true
+```
+
+* Environment Variables
+
+``` 
+export SETTINGS__API__ACCESS_TOKEN=foobar
+```
+
+The resulting configuration will be:
+
+```ruby
+config = ConfigX.load
+config.api.enabled # => true
+config.api.endpoint # => "https://example.com"
+config.api.pretty_print # => "foobar"
+```
+
+### Customizing Configuration
+
+You can customize the configuration by passing optional arguments to the `load` method:
+
+```ruby
+ConfigX.load(
+  "development",
+  dir_name: 'settings',
+  file_name: 'settings',
+  config_root: 'config',
+  env_prefix: 'SETTINGS',
+  env_separator: '__'
+)
+```
+
+The first four options, `env` (positional), `dir_name`, `file_name`, and `config_root` are used to specify 
+the configuration files to read:
+
+1. `{config_root}/{file_name}.yml`
+2. `{config_root}/{file_name}/{env}.yml`
+3. `{config_root}/{file_name}.local.yml`
+4. `{config_root}/{file_name}/{env}.local.yml`
+
+
+The `env_prefix` and `env_separator` options are used to specify how the environment variables should be constructed. In
+the above example, they start from `SETTINGS` and use `__` as a separator. 
+
+For instance, the following environment variable: 
+
+```
+export SETTINGS__API__ACCESS_TOKEN=foobar
+```
+
+corresponds to the following configuration:
+
+```yaml
+---
+api:
+  access_token: foobar
+```
+
+You can also pass boolean value to environment variables using convenient YAML syntax:
+
+```sh
+export SETTINGS__API__ENABLED=true
+export SETTINGS__API__ENABLED=false
+export SETTINGS__API__ENABLED=on
+export SETTINGS__API__ENABLED=off
+```
+
+Environment variables have the highest priority and override the values from the configuration files. 
+
+### Builder Interface
+
+When you don't need to load configuration from the predefined default locations, you can use the builder interface
+which enables you to load configuration from any source:
+
+1. Plain ruby Hash
+
+```ruby 
+config = ConfigX.builder
+  .add_source({api: {enabled: true}})
+  .load
+
+config.api.enabled # => true
+```
+
+2. YAML file
+
+```ruby
+config = ConfigX.builder
+  .add_source('config/settings.yml')
+  .load
+```
+
+3. Environment variables
+
+```ruby
+config = ConfigX.builder
+  .add_source(ENV, prefix: "SETTINGS", separator: "__")
+  .load
+```
+
+You can also use the builder interface to load configuration from multiple sources:
+
+```ruby
+config = ConfigX.builder
+  .add_source({api: {enabled: true}})
+  .add_source('config/settings.yml')
+  .add_source(ENV, prefix: "SETTINGS", separator: "__")
+  .load
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bolshakov/configx.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+[config]: https://rubygems.org/gems/config

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/Steepfile

@@ -0,0 +1,31 @@
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+
+  check "lib" # Directory name
+  #   check "Gemfile"                   # File name
+  #   check "app/models/**/*.rb"        # Glob
+  #   # ignore "lib/templates/*.rb"
+  #
+  library "yaml"
+  library "pathname"
+
+  # library "strong_json"           # Gems
+  #
+  #   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  #   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  #   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  #   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  #   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   #   hash[D::Ruby::NoMethod] = :information
+  #   # end
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname"              # Standard libraries
+# end

data/lib/config_x/builder.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "deep_merge/core"
+
+module ConfigX
+  class Builder
+    class << self
+      def source(source, **args)
+        case source
+        in Source then source
+        in Hash then HashSource.new(source)
+        in String then FileSource.new(source)
+        in Pathname then FileSource.new(source)
+        in ENV then EnvSource.new(ENV, **args)
+        end
+      end
+
+      # @see #initialize
+      def load(...)
+        new(...).load
+      end
+    end
+
+    # @example
+    #   ConfigX.new("production").load
+    #   ConfigX.new.load
+    #
+    def initialize
+      @sources = []
+    end
+
+    attr_reader :sources
+
+    def add_source(source, **args)
+      sources << self.class.source(source, **args)
+      self
+    end
+
+    # Loads config in the following order:
+    #   1. Reads default config
+    #   2. Reads all the config files provided in the order
+    #   3. Reads environment variables
+    def load
+      Config.new(read_from_sources)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.sources == sources
+    end
+
+    private def read_from_sources
+      sources.each_with_object({}) do |source, config|
+        DeepMerge.deep_merge!(source.load, config, overwrite_arrays: true)
+      end
+    end
+  end
+end

data/lib/config_x/config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "deep_merge/core"
+
+module ConfigX
+  class Config < OpenStruct
+    def initialize(members)
+      super()
+
+      members.each do |key, value|
+        raise ArgumentError, "option keys should be strings" unless key.respond_to?(:to_s)
+
+        key = key.to_s
+
+        if value.is_a?(Hash)
+          value = self.class.new(value)
+        elsif value.is_a?(Array)
+          value = value.map do |element|
+            element.is_a?(Hash) ? self.class.new(element) : element
+          end
+        end
+
+        self[key] = value.freeze
+      end
+
+      freeze
+    end
+
+    def with_fallback(fallback)
+      DeepMerge.deep_merge!(
+        to_h,
+        fallback.to_h,
+        overwrite_arrays: true
+      ).then { Config.new(_1) }
+    end
+
+    def to_h
+      each_pair.each_with_object({}) do |(key, value), hash|
+        hash[key] = value.is_a?(Config) ? value.to_h : value
+      end
+    end
+  end
+end

data/lib/config_x/config_factory.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ConfigX
+  # This class is responsible for loading configuration settings for an application.
+  # It follows a specific order in loading these settings:
+  #   1. Reads default config
+  #   2. Reads all the config files provided in the order
+  #   3. Reads environment variables
+  class ConfigFactory
+    class << self
+      # Default environment variable prefix
+      def default_env_prefix = "SETTINGS"
+
+      # Default environment variable separator
+      def default_env_separator = "__"
+
+      # Default directory name for environment-specific settings
+      def default_dir_name = "settings"
+
+      # Default environment name
+      def default_env = "production"
+
+      # Default config file name
+      def default_file_name = "settings"
+
+      # Default root directory for configuration
+      def default_config_root = "config"
+
+      # Load method to initialize and load the configuration
+      def load(...) = new(...).load
+    end
+
+    # Initializes a new instance of the ConfigFactory class.
+    # @param env [String] the environment name.
+    # @param env_prefix [String] the prefix for environment variables.
+    # @param env_separator [String] the separator for environment variables.
+    # @param dir_name [String] the directory name for settings.
+    # @param file_name [String] the file name for settings.
+    # @param config_root [String] the root directory for configuration.
+    def initialize(
+      env = self.class.default_env,
+      env_prefix: self.class.default_env_prefix,
+      env_separator: self.class.default_env_separator,
+      dir_name: self.class.default_dir_name,
+      file_name: self.class.default_file_name,
+      config_root: self.class.default_config_root
+    )
+      @env = env
+      @env_prefix = env_prefix
+      @env_separator = env_separator
+      @dir_name = dir_name
+      @file_name = file_name
+      @config_root = config_root
+    end
+
+    # Loads the configuration from the sources and additional sources.
+    # @param additional_sources [Array] additional sources to load configuration from.
+    # @return [Config] the loaded configuration.
+    def load(*additional_sources)
+      (sources + additional_sources)
+        .reduce(Builder.new) { |builder, source| builder.add_source(source) }
+        .load
+    end
+
+    private
+
+    # Returns the sources from which to load the configuration.
+    # @return [Array] the sources.
+    def sources
+      [
+        *setting_files,
+        Builder.source(ENV, prefix: env_prefix, separator: env_separator)
+      ]
+    end
+
+    # Returns the setting files.
+    # @return [Array] the setting files.
+    def setting_files
+      [
+        File.join(config_root, "#{file_name}.yml"),
+        File.join(config_root, dir_name, "#{env}.yml"),
+        *local_setting_files
+      ].freeze
+    end
+
+    # Returns the local setting files.
+    # @return [Array] the local setting files.
+    def local_setting_files
+      [
+        (File.join(config_root, "#{file_name}.local.yml") if env != "test"),
+        File.join(config_root, dir_name, "#{env}.local.yml")
+      ].compact
+    end
+
+    # The root directory for configuration.
+    attr_reader :config_root
+
+    # The directory name for environment-specific settings.
+    attr_reader :dir_name
+
+    # The environment name.
+    attr_reader :env
+
+    # The prefix for environment variables.
+    attr_reader :env_prefix
+
+    # The separator for environment variables.
+    attr_reader :env_separator
+
+    # The file name for settings.
+    attr_reader :file_name
+  end
+end

data/lib/config_x/env_source.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "deep_merge/core"
+require "yaml"
+
+module ConfigX
+  class EnvSource < HashSource
+    def initialize(env, prefix:, separator:)
+      @env = env
+      @prefix = prefix
+      @separator = separator
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        source == other.source &&
+        prefix == other.prefix &&
+        separator == other.separator
+    end
+
+    protected
+
+    def source
+      env.each_with_object({}) do |(key, value), config|
+        next unless key.start_with?(prefix + separator)
+
+        Array(key.split(separator)[1..])
+          .reverse_each
+          .reduce(YAML.load(value)) { |acc, k| {k.downcase => acc} }
+          .tap { DeepMerge.deep_merge!(_1, config) }
+      end
+    end
+
+    attr_reader :env, :prefix, :separator
+  end
+end

data/lib/config_x/file_source.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module ConfigX
+  class FileSource < Source
+    def initialize(path)
+      @path = path
+    end
+
+    def load
+      if path && File.exist?(path)
+        YamlSource.new(File.read(path.to_s)).load
+      else
+        {}
+      end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.path == path
+    end
+
+    protected
+
+    attr_reader :path
+  end
+end

data/lib/config_x/hash_source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module ConfigX
+  class HashSource < Source
+    attr_reader :source
+    protected :source
+
+    def initialize(source)
+      @source = source
+    end
+
+    def load = source
+
+    def ==(other)
+      other.is_a?(self.class) && source == other.source
+    end
+  end
+end

data/lib/config_x/source.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ConfigX
+  class Source
+    def load = raise NotImplementedError
+  end
+end

data/lib/config_x/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ConfigX
+  VERSION = "0.1.0"
+end

data/lib/config_x/yaml_source.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module ConfigX
+  class YamlSource < Source
+    def initialize(source)
+      @source = source
+    end
+
+    def load
+      YAML.load(source) || {}
+    end
+
+    private
+
+    attr_reader :source
+  end
+end

data/lib/config_x.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require_relative "config_x/version"
+
+module ConfigX
+  class << self
+    # @api private
+    def loader
+      @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+        loader.ignore("#{__dir__}/configx.rb")
+      end
+    end
+
+    def load(...) = ConfigFactory.load(...)
+
+    def builder = Builder.new
+
+    # Loads config from the given source
+    # @example
+    #   config = ConfigX.from({api: {endpoint: "http://example.com", enabled: true}})
+    #   config.api.endpoint # => "http://example.com"
+    #   config.api.enabled # => true
+    #
+    def from(source, **args) = builder.add_source(source, **args).load
+  end
+end
+
+ConfigX.loader.setup

data/lib/configx.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "config_x"

data/sig/config_x/builder.rbs

@@ -0,0 +1,21 @@
+module ConfigX
+  class Builder
+    type source = Source | Hash[untyped, untyped] | String | Pathname | Object
+
+    def self.load: -> Config
+    def self.source: [T < Source] (source, **untyped) -> T
+
+    def initialize: -> void
+
+    attr_reader sources: Array[Source]
+
+
+    def add_source: (source, **untyped) -> self
+
+    def load: -> Config
+
+    private
+
+    def read_from_sources: -> Hash[untyped, untyped]
+  end
+end

data/sig/config_x/config.rbs

@@ -0,0 +1,13 @@
+module ConfigX
+  class Config
+    def initialize: (Hash[untyped, untyped]) -> void
+
+    def to_h: -> Hash[untyped, untyped]
+
+    def with_fallback: (Config) -> Config
+
+    def each_pair: -> Enumerable[[untyped, untyped]]
+
+    def []=: (untyped, untyped) -> untyped
+  end
+end

data/sig/config_x/config_factory.rbs

@@ -0,0 +1,55 @@
+module ConfigX
+  class ConfigFactory
+    def self.default_config_root: -> String
+
+    def self.default_dir_name: -> String
+
+    def self.default_env_prefix: -> String
+
+    def self.default_env_separator: -> String
+
+    def self.default_env: -> String
+
+    def self.default_file_name: -> String
+
+    def self.load: (
+        String env,
+        env_prefix: String,
+        env_separator: String,
+        dir_name: String,
+        file_name: String,
+        config_root: String
+      ) -> Config
+
+    def initialize: (
+        String env,
+        env_prefix: String,
+        env_separator: String,
+        dir_name: String,
+        file_name: String,
+        config_root: String
+      ) -> void
+
+    def load: -> Config
+
+    private
+
+    def local_setting_files: -> Array[String]
+
+    def setting_files: -> Array[String]
+
+    attr_reader config_root: String
+
+    attr_reader dir_name: String
+
+    attr_reader env_prefix: String
+
+    attr_reader env_separator: String
+
+    attr_reader env: String
+
+    attr_reader file_name: String
+
+    def sources: -> Array[Builder::source]
+  end
+end

data/sig/config_x/env_source.rbs

@@ -0,0 +1,11 @@
+module ConfigX
+  class EnvSource < HashSource
+    type env = Hash[String, String]
+
+    def initialize: (env, prefix: String, separator: String) -> void
+
+    attr_reader env: env
+    attr_reader prefix: String
+    attr_reader separator: String
+  end
+end

data/sig/config_x/file_source.rbs

@@ -0,0 +1,7 @@
+module ConfigX
+  class FileSource < Source
+    def initialize: (String | Pathname) -> void
+
+    attr_reader path: String | Pathname
+  end
+end

data/sig/config_x/hash_source.rbs

@@ -0,0 +1,8 @@
+
+module ConfigX
+  class HashSource < Source
+    def initialize: (Source::config_hash) -> void
+
+    attr_reader source: Source::config_hash
+  end
+end

data/sig/config_x/source.rbs

@@ -0,0 +1,8 @@
+
+module ConfigX
+  class Source
+    type config_hash = Hash[untyped, untyped]
+
+    def load: -> config_hash
+  end
+end

data/sig/config_x/yaml_source.rbs

@@ -0,0 +1,10 @@
+
+module ConfigX
+  class YamlSource < Source
+    def initialize: (String) -> void
+
+    private
+
+    attr_reader source: String
+  end
+end

data/sig/config_x.rbs

@@ -0,0 +1,18 @@
+module ConfigX
+  VERSION: String
+
+  def self.builder: -> Builder
+  def self.from: (Builder::source, **untyped) -> Config
+
+  def self.load: (
+      String env,
+      env_prefix: String,
+      env_separator: String,
+      dir_name: String,
+      file_name: String,
+      config_root: String
+    ) -> Config
+
+
+  def self.loader: -> Zeitwerk::Loader
+end

data/sig/shims/deep_merge.rbs

@@ -0,0 +1,7 @@
+module DeepMerge
+  def self.deep_merge!: [K1, V1, K2, V2] (
+      Hash[K1, V1] source,
+      Hash[K2, V2] destination,
+      ?overwrite_arrays: bool
+    ) -> Hash[K1 | K2, V1 | V2]
+end

data/sig/shims/env.rbs

@@ -0,0 +1,17 @@
+# module ENV
+#   extend Enumerable[[String, String]]
+#
+#   # def self.[]: (::String) -> (::String | nil)
+#   # def self.[]=: (::String, ::String) -> ::String
+#   # def self.fetch: [A] (key: ::String, default: A) -> (A | ::String)
+#   # def self.fetch: (key: ::String) ?{ ::String -> A } -> (::String | A)
+#   # def self.delete: (::String) -> (::String | nil)
+#   # def self.key?: (::String) -> bool
+#   # def self.clear: () -> void
+#   # def self.to_h: () -> Hash[::String, ::String]
+#   # def self.each: () { (::String, ::String) -> void } -> void
+#   # def self.each_key: () { (::String) -> void } -> void
+#   # def self.each_value: () { (::String) -> void } -> void
+#   # def self.keys: () -> Array[::String]
+#   # def self.values: () -> Array[::String]
+# end

data/sig/shims/zeitwerk/loader.rbs

@@ -0,0 +1,8 @@
+module Zeitwerk
+  class Loader
+    def self.for_gem: -> instance
+
+    def ignore: (String) -> void
+    def setup: -> void
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: configx
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tëma Bolshakov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  ConfigX is a Ruby library for configuration management. It provides battle-tested defaults
+  and an intuitive interface for managing settings from YAML files and environment variables.
+  It also offers flexibility for developers to build their own configurations.
+email:
+- tema@bolshakov.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- lib/config_x.rb
+- lib/config_x/builder.rb
+- lib/config_x/config.rb
+- lib/config_x/config_factory.rb
+- lib/config_x/env_source.rb
+- lib/config_x/file_source.rb
+- lib/config_x/hash_source.rb
+- lib/config_x/source.rb
+- lib/config_x/version.rb
+- lib/config_x/yaml_source.rb
+- lib/configx.rb
+- sig/config_x.rbs
+- sig/config_x/builder.rbs
+- sig/config_x/config.rbs
+- sig/config_x/config_factory.rbs
+- sig/config_x/env_source.rbs
+- sig/config_x/file_source.rbs
+- sig/config_x/hash_source.rbs
+- sig/config_x/source.rbs
+- sig/config_x/yaml_source.rbs
+- sig/shims/deep_merge.rbs
+- sig/shims/env.rbs
+- sig/shims/zeitwerk/loader.rbs
+homepage: https://github.com/bolshakov/configx
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bolshakov/configx
+  source_code_uri: https://github.com/bolshakov/configx
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.10
+signing_key:
+specification_version: 4
+summary: Configuration simplified
+test_files: []