anyway_app_config 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 617b75e0653ccf7f6cd5990ed5484810d48d08e799a1d8e6b526208499fbbe14
+  data.tar.gz: c9a057c7b0fa2f0e1ae3fa34cdfbdd0fd573113ee8002731756952815a6c2f7a
+SHA512:
+  metadata.gz: b5ed356d38908f1a8db01006504b87eb74d731b0c7dc71dc7a6df9d006ad511ca795f001daac49184272959e5dd021831a544dd86b8426eafadd6fbf265d748c
+  data.tar.gz: '058d004053ece9aeb7600162b68d5a595641b6d052c3bb3726f65451e182bd1cdedd6e36b2a88e4145d26a0f54dd5929fabadd189b1e253b5cc1f673a7b9abfd'

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"anyway_app_config" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["senid231@gmail.com"](mailto:"senid231@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Denis Talakevich
+
+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,505 @@
+# AnywayAppConfig
+
+Schema-driven application config built on top of [`anyway_config`][anyway_config].
+
+`anyway_config` does the heavy lifting of loading values from YAML and ENV.
+`anyway_app_config` adds a small DSL on top for describing app config with
+typed attributes, defaults, required fields, and **nested objects** (single
+or array). Configs can be used as plain instances or as a singleton.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "anyway_app_config"
+```
+
+Then run `bundle install`.
+
+## Defining a config
+
+Inherit from `AnywayAppConfig::Config` and describe attributes with the
+`attribute` DSL:
+
+```ruby
+require "anyway_app_config"
+
+class AppConfig < AnywayAppConfig::Config
+  config_name "app_config"
+  env_prefix  "APP"
+
+  attribute :deploy_env, type: :string, required: true
+  attribute :version,    type: :string, default: "unknown"
+  attribute :commit_sha, type: :string, default: "000000"
+
+  attribute :sentry, required: true do
+    attribute :dsn,         type: :string, default: ""
+    attribute :environment, type: :string, required: true
+    attribute :server_name, type: :string, required: true
+    attribute :tags,        type: :hash,   default: {}
+  end
+
+  attribute :prometheus, required: true do
+    attribute :enabled,        type: :boolean, default: false
+    attribute :host,           type: :string,  default: "localhost"
+    attribute :port,           type: :integer, default: 9394
+    attribute :default_labels, type: :hash,    default: {}
+  end
+end
+```
+
+`attribute` accepts:
+
+| option     | meaning                                                      |
+| ---------- | ------------------------------------------------------------ |
+| `type:`    | type id from `anyway_config`'s registry (`:string`, `:integer`, `:float`, `:boolean`, `:date`, `:datetime`, `:uri`, `:hash`, …), or any object responding to `#call(value)` |
+| `array:`   | when `true`, value is an array of `type` (or nested objects) |
+| `default:` | default value (defaults to `nil`, or `[]` when `array: true`) |
+| `required:`| validate that the attribute is present and not empty         |
+| block      | defines a nested config object (see below)                   |
+
+### Nested attributes
+
+Pass a block to define a nested config. The DSL builds a child config class
+that inherits from `AnywayAppConfig::Config`, exposes the same DSL, and is
+exposed as a constant (e.g. `AppConfig::SentryCfg`).
+
+Combine with `array: true` to get a list of nested objects:
+
+```ruby
+class AppConfig < AnywayAppConfig::Config
+  config_name "app_config"
+
+  attribute :servers, array: true do
+    attribute :host, type: :string, required: true
+    attribute :port, type: :integer, default: 80
+  end
+end
+```
+
+### The `:hash` type
+
+`AnywayAppConfig::Config` registers a `:hash` type on a per-class type
+registry. It accepts any `Hash` value as-is and raises `ArgumentError` for
+non-hash values. Anyway's global `TypeRegistry.default` is **not** mutated.
+
+## Loading config
+
+```ruby
+config = AppConfig.load!  # all sources merged, contained values frozen
+config.sentry.environment
+config.servers.first.host
+```
+
+`load!` returns a new instance every call (no caching). Sources are loaded
+through `anyway_config` (YAML + ENV by default).
+
+### Freezing
+
+On `load!` (and `deep_freeze_values!`) the config freezes all of its contained
+values — Arrays, Hashes, and scalars — so the loaded data is effectively
+immutable. The `Config` instance itself and any nested `Config` objects are
+**not** frozen, so RSpec stubs keep working:
+
+```ruby
+allow(AppConfig.sentry).to receive(:dsn).and_return("stubbed")
+```
+
+If a specific value class can't be frozen (e.g. it holds mutable state like a
+cache client or logger), add it to `skip_freeze_classes` to exclude it from
+the freeze walk (matched via `is_a?`, inherited by subclasses):
+
+```ruby
+class AppConfig < AnywayAppConfig::Config
+  self.skip_freeze_classes = [Logger, SomeCacheClient]
+  # ...
+end
+```
+
+### Explicit config path
+
+By default, `anyway_config` looks for `config/<config_name>.yml` (or whatever
+`Anyway::Settings.default_config_path` resolves to). To point at a specific
+YAML file, pass `config_path:` to `new`/`load!`:
+
+```ruby
+AppConfig.load!(config_path: "/etc/myapp/app_config.yml")
+```
+
+`config_path:` also forwards through `Singleton#load!`.
+
+For a per-class default, set `explicit_config_path` on the class (inherited
+by subclasses, overridden by a per-call `config_path:`). It accepts a `String`
+or `Pathname` directly:
+
+```ruby
+class AppConfig < AnywayAppConfig::Config
+  self.explicit_config_path = Rails.root.join('config', 'app_config.yml')
+  # ...
+end
+```
+
+Or a `Proc` for cases where the path depends on runtime state (called every
+time a new instance is built):
+
+```ruby
+class AppConfig < AnywayAppConfig::Config
+  self.explicit_config_path = -> { "/etc/myapp/#{ENV.fetch('APP_ENV')}.yml" }
+  # ...
+end
+```
+
+Anyway's other built-in mechanisms (`<CONFIG_NAME>_CONF` env var,
+`Anyway::Settings.default_config_path` lambda) still work — `config_path:` and
+`explicit_config_path` just give you a class-scoped, code-driven option.
+
+### Choosing a YAML loader
+
+By default the `:yml` loader decides whether your YAML is environment-keyed
+(`development:` / `production:` sections) or flat by inspecting the file
+content and global state. To make that explicit, the gem registers two extra
+loaders you can select via `configuration_sources`:
+
+- `:flat_yml` — always reads top-level keys, ignores environment sections.
+- `:env_yml` — always reads the section matching
+  `Anyway::Settings.current_environment`; raises if it is not set.
+
+```ruby
+class Credentials < AnywayAppConfig::Config
+  config_name 'credentials'
+  self.configuration_sources = [:flat_yml, :env]   # flat YAML + ENV overrides
+end
+
+class AppConfig < AnywayAppConfig::Config
+  config_name 'app_config'
+  self.configuration_sources = [:env_yml, :env]    # env-keyed YAML + ENV overrides
+end
+```
+
+Pick one YAML loader per class — `:yml`, `:flat_yml`, and `:env_yml` all read
+the same file, so listing more than one just loads it repeatedly. The default
+`configuration_sources` is untouched, so classes that don't opt in keep using
+`:yml`.
+
+### Singleton mode
+
+Include `AnywayAppConfig::Singleton` to get a class-level singleton with
+class-level access to all instance methods:
+
+```ruby
+class AppConfig < AnywayAppConfig::Config
+  include AnywayAppConfig::Singleton
+  # ...
+end
+
+AppConfig.load!                # values frozen, instance cached on the class
+AppConfig.deploy_env           # delegates to instance
+AppConfig.sentry.environment   # delegates to instance
+AppConfig.instance             # the cached instance
+AppConfig.loaded?              # true / false
+
+AppConfig.load!                # raises AnywayAppConfig::AlreadyLoadedError
+AppConfig.foo                  # raises AnywayAppConfig::NotLoadedError if not loaded
+```
+
+The singleton is intentionally strict — there is no `reload!`. To re-read
+config, restart the process.
+
+> Note: class-level delegation goes through `method_missing`, so attribute
+> names that clash with existing `Class` methods (`name`, `class`, `send`, …)
+> are not delegated — pick non-clashing names.
+
+### YAML and ENV
+
+Loading is provided by `anyway_config`. A typical `config/app_config.yml`:
+
+```yaml
+development: &dev
+  deploy_env: "development"
+
+  sentry:
+    dsn: ""
+    environment: "development"
+    server_name: "denis-t.localhost"
+    tags:
+      custom: "tag"
+
+  prometheus:
+    enabled: false
+    host: "localhost"
+    port: 9394
+
+test:
+  <<: *dev
+  deploy_env: "test"
+
+production:
+  <<: *dev
+```
+
+ENV vars use the prefix declared via `env_prefix`, e.g. `APP_DEPLOY_ENV`,
+`APP_SENTRY__ENVIRONMENT`. See the [anyway_config docs][anyway_config] for
+the full source list and naming rules.
+
+## Rails
+
+There is no Railtie — Rails already exposes `Rails.configuration` as the
+canonical place to hang application-wide settings, so wiring through it is
+three lines. The pattern:
+
+**1. Define the config class in `config/app_config.rb`:**
+
+```ruby
+require "anyway_app_config"
+
+class AppConfig < AnywayAppConfig::Config
+  config_name "app_config"
+  env_prefix  "APP"
+
+  attribute :deploy_env, type: :string, required: true
+  attribute :version,    type: :string, default: "unknown"
+
+  attribute :sentry, required: true do
+    attribute :dsn,         type: :string, default: ""
+    attribute :environment, type: :string, required: true
+  end
+end
+```
+
+**2. (Optional) Add `config/app_config.yml`:**
+
+```yaml
+development:
+  deploy_env: "development"
+  sentry:
+    environment: "development"
+
+production:
+  deploy_env: "production"
+  sentry:
+    environment: "production"
+```
+
+Any value can be overridden via ENV using the `env_prefix` (`APP` above).
+Examples:
+
+- `APP_DEPLOY_ENV=staging` → `AppConfig#deploy_env`
+- `APP_SENTRY__DSN=https://...` → `AppConfig#sentry.dsn` (double underscore for nesting)
+- `APP_VERSION=1.2.3` → `AppConfig#version`
+
+ENV wins over YAML. See the [anyway_config docs][anyway_config] for the full
+source list and naming rules.
+
+**3. Load and assign in `config/application.rb`:**
+
+```ruby
+require_relative "app_config"
+
+module MyApp
+  class Application < Rails::Application
+    config.app_config = AppConfig.load!
+    # ...
+  end
+end
+```
+
+**4. Use it anywhere via `Rails.configuration`:**
+
+```ruby
+Rails.configuration.app_config.deploy_env
+Rails.configuration.app_config.sentry.dsn
+```
+
+`AppConfig.load!` returns an instance with frozen values, so
+`Rails.configuration.app_config` is safe to read from any thread. If you want class-level access
+(`AppConfig.deploy_env`) instead, use [Singleton mode](#singleton-mode) and
+just call `AppConfig.load!` in `config/application.rb` without assigning it
+to `config.app_config`.
+
+### Replacing `Rails.application.credentials` (unencrypted)
+
+Rails 7.2+ encrypts `config/credentials.yml.enc` by default. If your secrets
+are already injected by your deploy pipeline (Helm, Kubernetes secrets, CI/CD
+vault, ENV) you don't need encryption-at-rest in the repo — and the encrypted
+credentials flow becomes pure overhead. `anyway_app_config` is a drop-in
+replacement: typed, required-checked, value-frozen, and ENV-overridable.
+
+**1. Define the credentials class in `config/credentials.rb`:**
+
+```ruby
+require "anyway_app_config"
+
+class Credentials < AnywayAppConfig::Config
+  config_name "credentials"
+  env_prefix  ""   # no prefix — read raw ENV like SECRET_KEY_BASE, DATABASE_PASSWORD
+  self.configuration_sources = [:yml, :env]   # see note below
+
+  attribute :secret_key_base,       type: :string, required: true
+  attribute :database_password,     type: :string, required: true
+  attribute :aws_access_key_id,     type: :string, default: ""
+  attribute :aws_secret_access_key, type: :string, default: ""
+end
+```
+
+> **Pin `configuration_sources` explicitly.** Under Rails, `anyway_config`
+> registers a `:credentials` loader that reads from
+> `Rails.application.credentials` — exactly the thing you're trying to
+> replace. If you don't override `configuration_sources`, your shiny new
+> `Credentials` class will silently merge values back in from the encrypted
+> credentials file (or fail to boot if `RAILS_MASTER_KEY` is missing).
+> Setting `self.configuration_sources = [:yml, :env]` keeps loading limited
+> to YAML + ENV and removes the dependency on the Rails credentials loader.
+
+An empty `env_prefix` matches ENV var names directly against attribute names
+(uppercased), so `SECRET_KEY_BASE` populates `:secret_key_base`. Useful for
+secrets that have well-known unprefixed names — `SECRET_KEY_BASE`,
+`DATABASE_URL`, `RAILS_MASTER_KEY`. Other ENV vars are simply ignored unless
+they match a declared attribute. **Caveat:** pick attribute names carefully
+— if you declare `attribute :path` or `:home` with empty prefix, you'll pick
+up `PATH`/`HOME` from the shell. When in doubt, keep a prefix.
+
+**2. Add `config/credentials.yml`** (gitignore it, or commit only the dev/test
+branches and inject production values via ENV):
+
+```yaml
+development:
+  secret_key_base: "dev-only-not-a-real-secret"
+  database_password: "postgres"
+
+test:
+  secret_key_base: "test-only-not-a-real-secret"
+  database_password: "postgres"
+
+production:
+  # Leave empty here and inject via ENV (SECRET_KEY_BASE=..., etc) at deploy time.
+  secret_key_base: ""
+  database_password: ""
+```
+
+**3. Wire it in `config/application.rb`:**
+
+```ruby
+require_relative "credentials"
+
+module MyApp
+  class Application < Rails::Application
+    config.load_defaults 8.1
+
+    Rails.application.credentials = Credentials.load!
+    # Rails 7.2+ generates a dynamic secret_key_base in dev/test when one
+    # is not set. Pin it from credentials so it stays stable across boots.
+    # See Rails::Application::Configuration#generate_local_secret?
+    config.secret_key_base = Rails.application.credentials.secret_key_base
+  end
+end
+```
+
+Assigning directly inside the class body works because `Rails.application` is
+already available by the time `config/application.rb` is evaluated. If you
+need the assignment deferred (e.g. credentials depend on something set up by
+an initializer or another `before_configuration` hook), wrap it in
+`config.before_configuration { ... }` instead.
+
+**4. Use it like the standard credentials object:**
+
+```ruby
+Rails.application.credentials.secret_key_base
+Rails.application.credentials.database_password
+```
+
+ENV overrides use raw names because of the empty `env_prefix`:
+`SECRET_KEY_BASE=...`, `DATABASE_PASSWORD=...`.
+
+> **Trade-off:** you lose encryption-at-rest. Only do this if `credentials.yml`
+> is gitignored or contains placeholders only, with real values injected via
+> ENV at deploy time. The win is that secrets become typed, required-checked,
+> and centrally declared — instead of an opaque `EncryptedConfiguration` blob
+> that silently returns `nil` for typos.
+
+### Inline form: `AnywayAppConfig.build`
+
+For small Rails apps where dedicated `config/app_config.rb` and
+`config/credentials.rb` files feel like overkill, declare configs inline in
+`config/application.rb` with `AnywayAppConfig.build`:
+
+```ruby
+module MyApp
+  class Application < Rails::Application
+    Rails.application.credentials = AnywayAppConfig.build(load: true) do
+      config_name "credentials"
+      env_prefix  ""   # no prefix — read raw ENV like SECRET_KEY_BASE
+
+      attribute :secret_key_base,       type: :string, required: true
+      attribute :database_password,     type: :string, required: true
+      attribute :aws_access_key_id,     type: :string, default: ""
+      attribute :aws_secret_access_key, type: :string, default: ""
+    end
+    config.secret_key_base = Rails.application.credentials.secret_key_base
+
+    config.app_config = AnywayAppConfig.build(load: true) do
+      config_name "app_config"
+      env_prefix  "APP"
+
+      attribute :deploy_env, type: :string, required: true
+      attribute :version,    type: :string, default: "unknown"
+
+      attribute :sentry, required: true do
+        attribute :dsn,         type: :string, default: ""
+        attribute :environment, type: :string, required: true
+      end
+    end
+  end
+end
+```
+
+`AnywayAppConfig.build(&block)` returns an anonymous `AnywayAppConfig::Config`
+subclass; `build(load: true, &block)` calls `load!` and returns the loaded
+instance (with frozen values). The block is `class_eval`'d on the new subclass, so `config_name`,
+`env_prefix`, and `attribute` are available exactly as in a named class.
+
+`config_name` is **mandatory** — anonymous classes have no name, so
+`anyway_config` can't infer it. Otherwise YAML loading and ENV nesting work
+identically (so `config/credentials.yml`, `config/app_config.yml`, and
+`APP_SENTRY__DSN` all behave the same as the file-based form).
+
+#### Disabling ENV loading entirely
+
+If you want a config to read **only** from YAML and ignore the environment
+(e.g. for credentials that must never leak in via stray ENV vars, or to make
+behavior deterministic in tests), restrict `configuration_sources` on the
+class to the YAML loader:
+
+```ruby
+class Credentials < AnywayAppConfig::Config
+  config_name "credentials"
+  self.configuration_sources = [:yml]   # YAML only — ignore ENV, ignore Rails secrets/credentials loaders
+
+  attribute :secret_key_base,   type: :string, required: true
+  attribute :database_password, type: :string, required: true
+end
+```
+
+`configuration_sources` is an array of loader IDs registered on
+`Anyway.loaders` (`:yml`, `:env`, `:credentials`, etc — Rails adds a few).
+Only listed loaders run for this class. With just `[:yml]`, ENV variables
+have no effect on the values, regardless of `env_prefix`.
+
+## Development
+
+```
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+<https://github.com/senid231/anyway_app_config>.
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).
+
+[anyway_config]: https://github.com/palkan/anyway_config

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/anyway_app_config/config.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'anyway_config'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
+
+module AnywayAppConfig
+  class NotLoadedError < StandardError; end
+
+  class Config < ::Anyway::Config
+    BaseNestedCfgClass = Class.new(self)
+
+    class_attribute :nested_config_class, instance_accessor: false, default: BaseNestedCfgClass
+    class_attribute :skip_freeze_classes, instance_accessor: false, default: [].freeze
+    class_attribute :explicit_config_path, instance_accessor: false
+
+    class << self
+      def attribute(name, type: nil, array: false, default: nil, required: false, &block)
+        if block
+          raise ArgumentError, "nested attribute #{name} does not support type" unless type.nil?
+          raise ArgumentError, "nested attribute #{name} does not support default" unless default.nil?
+
+          attr_nested(name, array: array, required: required, &block)
+        else
+          attr_value(name, type: type, array: array, default: default, required: required)
+        end
+      end
+
+      def attr_value(name, type:, array: false, default: nil, required: false)
+        default_val = default.nil? && array ? [] : default
+        attr_config(name => default_val)
+        coerce_types(name => { type: type, array: array })
+        self.required(name) if required
+      end
+
+      def attr_nested(name, array: false, required: false, &block)
+        nested_klass = Class.new(nested_config_class)
+        const_set("#{name.to_s.classify}Cfg", nested_klass)
+        # nested_klass.config_name represents path to config struct in main config file
+        if self < nested_config_class
+          # nested inside another nested config
+          nested_klass.config_name :"#{config_name}.#{name}"
+        else
+          # nested in main config
+          nested_klass.config_name name.to_sym
+        end
+        nested_klass.configuration_sources = []
+        nested_klass.class_eval(&block) if block
+
+        if array
+          attr_config(name => [])
+          caster = ->(v) { nested_klass.new(v) }
+          coerce_types(name => { type: caster, array: true })
+        else
+          attr_config(name => {})
+          coerce_types(name => { config: nested_klass })
+        end
+
+        self.required(name) if required
+      end
+
+      def load!(*, **)
+        new(*, **).tap(&:deep_freeze_values!)
+      end
+
+      def type_registry
+        return @type_registry if instance_variable_defined?(:@type_registry)
+
+        @type_registry =
+          if superclass < AnywayAppConfig::Config
+            superclass.type_registry.dup
+          else
+            ::Anyway::TypeRegistry.default.dup.tap do |r|
+              r.accept(:hash) do |v|
+                raise ArgumentError, "expected Hash, got #{v.class}" unless v.is_a?(::Hash)
+
+                v
+              end
+            end
+          end
+      end
+
+      def type_caster
+        @type_caster ||=
+          if coercion_mapping.empty?
+            fallback_type_caster
+          else
+            ::Anyway::TypeCaster.new(
+              coercion_mapping,
+              registry: type_registry,
+              fallback: fallback_type_caster
+            )
+          end
+      end
+    end
+
+    def initialize(overrides = nil, config_path: nil, **kwargs)
+      @explicit_config_path = calc_explicit_config_path(config_path)
+
+      if overrides.nil? && !kwargs.empty?
+        overrides = kwargs
+      elsif !kwargs.empty?
+        raise ArgumentError, "unknown keywords: #{kwargs.keys.join(', ')}"
+      end
+
+      super(overrides)
+    end
+
+    def deep_freeze_values!
+      deep_freeze_value(values)
+      self
+    end
+
+    alias deep_freeze! deep_freeze_values!
+
+    def load(overrides = nil)
+      overrides = overrides.deep_stringify_keys if overrides.is_a?(::Hash)
+      super
+    end
+
+    def resolve_config_path(name, env_prefix)
+      @explicit_config_path || super
+    end
+
+    private
+
+    def calc_explicit_config_path(config_path)
+      return config_path.to_s unless config_path.nil?
+
+      class_default = self.class.explicit_config_path
+      return if class_default.nil?
+
+      class_default = class_default.call if class_default.is_a?(Proc)
+      class_default&.to_s
+    end
+
+    def deep_freeze_value(val)
+      return val if skip_freeze?(val)
+
+      case val
+      when AnywayAppConfig::Config
+        val.deep_freeze_values!
+      when Array
+        val.each { |item| deep_freeze_value(item) }
+        val.freeze
+      when Hash
+        val.each_value { |item| deep_freeze_value(item) }
+        val.freeze
+      else
+        val.freeze if val.respond_to?(:freeze) && !val.frozen?
+      end
+      val
+    end
+
+    def skip_freeze?(val)
+      self.class.skip_freeze_classes.any? { |klass| val.is_a?(klass) }
+    end
+  end
+end

data/lib/anyway_app_config/loaders/env_yaml.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'anyway/loaders/yaml'
+
+module AnywayAppConfig
+  module Loaders
+    # YAML loader that always reads the section matching
+    # `Anyway::Settings.current_environment`, regardless of file content or
+    # global detection. Raises if the current environment is not set.
+    class EnvYAML < ::Anyway::Loaders::YAML
+      def call(**)
+        if ::Anyway::Settings.current_environment.nil?
+          raise ArgumentError,
+                'Anyway::Settings.current_environment must be set to use the :env_yml loader'
+        end
+
+        super
+      end
+
+      private
+
+      def environmental?(_parsed_yml)
+        true
+      end
+    end
+  end
+end

data/lib/anyway_app_config/loaders/flat_yaml.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'anyway/loaders/yaml'
+
+module AnywayAppConfig
+  module Loaders
+    # YAML loader that always treats the file as a flat key/value document,
+    # ignoring environment sections regardless of file content or global state.
+    class FlatYAML < ::Anyway::Loaders::YAML
+      private
+
+      def environmental?(_parsed_yml)
+        false
+      end
+    end
+  end
+end

data/lib/anyway_app_config/singleton.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AnywayAppConfig
+  class AlreadyLoadedError < StandardError; end
+
+  module Singleton
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def load!(*, **)
+        if instance_variable_defined?(:@instance) && @instance
+          raise AlreadyLoadedError, "#{name || self} is already loaded"
+        end
+
+        @instance = new(*, **).tap(&:deep_freeze_values!)
+      end
+
+      def loaded?
+        instance_variable_defined?(:@instance) && !@instance.nil?
+      end
+
+      def instance
+        return @instance if instance_variable_defined?(:@instance) && @instance
+
+        raise NotLoadedError, "#{name || self} is not loaded; call #{name || self}.load! first"
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        (loaded? && @instance.respond_to?(method_name, include_private)) || super
+      end
+
+      def method_missing(method_name, ...)
+        if instance.respond_to?(method_name)
+          instance.public_send(method_name, ...)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/anyway_app_config/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AnywayAppConfig
+  VERSION = '0.3.1'
+end

data/lib/anyway_app_config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'anyway_app_config/version'
+require_relative 'anyway_app_config/config'
+require_relative 'anyway_app_config/singleton'
+require_relative 'anyway_app_config/loaders/flat_yaml'
+require_relative 'anyway_app_config/loaders/env_yaml'
+
+Anyway.loaders.append(:flat_yml, AnywayAppConfig::Loaders::FlatYAML)
+Anyway.loaders.append(:env_yml, AnywayAppConfig::Loaders::EnvYAML)
+
+module AnywayAppConfig
+  class Error < StandardError; end
+
+  # Builds an anonymous AnywayAppConfig::Config subclass from a block,
+  # for use without a separate file. The block is class_eval'd on the new
+  # subclass, so `config_name`, `env_prefix`, and `attribute` are available.
+  #
+  # Returns the class by default; with `load: true` returns a frozen instance.
+  # Anonymous classes have no name, so `config_name` is mandatory in the block.
+  def self.build(load: false, &block)
+    raise ArgumentError, 'AnywayAppConfig.build requires a block' unless block
+
+    klass = Class.new(Config)
+    klass.class_eval(&block)
+    load ? klass.load! : klass
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: anyway_app_config
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Denis Talakevich
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  AnywayAppConfig adds a small DSL on top of anyway_config for describing
+  application configs with typed attributes, defaults, required fields and
+  nested objects (single or array). Configs can be used as plain instances
+  or as singletons, and load values from YAML and ENV via anyway_config.
+email:
+- senid231@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/anyway_app_config.rb
+- lib/anyway_app_config/config.rb
+- lib/anyway_app_config/loaders/env_yaml.rb
+- lib/anyway_app_config/loaders/flat_yaml.rb
+- lib/anyway_app_config/singleton.rb
+- lib/anyway_app_config/version.rb
+homepage: https://github.com/senid231/anyway_app_config
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/senid231/anyway_app_config
+  source_code_uri: https://github.com/senid231/anyway_app_config
+  changelog_uri: https://github.com/senid231/anyway_app_config/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Schema-driven application config built on top of anyway_config.
+test_files: []