anyway_config 2.2.3 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4b1e98155e34f0220746d9230e433072143638e838f8975023c79cf75a9fe1
-  data.tar.gz: e5d8b4f78fe7f32fc2dd3068f90897a28f57a292596346f5bb368a36094cea36
+  metadata.gz: fe4f769be22bc9cb820fd1159b88a565b2fb71e13ad617d90aaafbcb1673f995
+  data.tar.gz: 175e468716722b43b6c7d163a97b6523801f6658118d1c56bb5a4a0255807ef9
 SHA512:
-  metadata.gz: 849c9c7fb4bc1101444dfec952a84ac3b1f605f3415d65d31ea727f176d9281cddc90e8b56ff73a3b25431126d61640931cfbc2621dc607493014e9a97d4ee3a
-  data.tar.gz: 840073b4420e4c1a792db2571b29eb7605cbc7066833bc4afe91defd94ba08153a4f32036a6cd09c6cf8f1da718f7f11d41bb46c8b9ea1ab0a0bfd2a81ab0a20
+  metadata.gz: 7c323f89197ca35405ca77ee1e58a8b3fbbf4b0d6b57e7ccce380311a13994d18121966428a2681cb55a5892c2eff52ec347a6e3568072ea8f85d1cf7f75aa80
+  data.tar.gz: 25ee0b877318a2335c2019a414684d5b15e3755ceff90e51de3a0b821ee48f86a119f9753eaddac5dfb4724e38876ec5f18b68b065db7aa4b23d20b837666929

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## master
 
+## 2.3.0 (2022-03-11)
+
+- Add ability to load configurations under specific environments in pure Ruby apps. ([@fargelus][]).
+
+Before loading environment configurations you need to specify variable `Anyway::Settings.current_environment`. In Rails apps this variable is same as `Rails.env` value.
+After adding yaml loader will try to load params under this environment.
+
+Also required env option was added to `Anyway::Config`.
+
 ## 2.2.3 (2022-01-21)
 
 - Fix Ruby 3.1 compatibility. ([@palkan][])
@@ -449,3 +458,4 @@ No we're dependency-free!
 [@envek]: https://github.com/Envek
 [@progapandist]: https://github.com/progapandist
 [@skryukov]: https://github.com/skryukov
+[@fargelus]: https://github.com/fargelus

data/README.md

@@ -297,6 +297,24 @@ end
 MyConfig.new(api_secret: "") #=> raises Anyway::Config::ValidationError
 ```
 
+`Required` method supports additional `env` parameter which indicates necessity to run validations under specified
+environments. `Env` parameter could be present in symbol, string, array or hash formats:
+
+```ruby
+class EnvConfig < Anyway::Config
+  required :password, env: "production"
+  required :maps_api_key, env: :production
+  required :smtp_host, env: %i[production staging]
+  required :aws_bucket, env: %w[production staging]
+  required :anycable_rpc_host, env: {except: :development}
+  required :anycable_redis_url, env: {except: %i[development test]}
+  required :anycable_broadcast_adapter, env: {except: %w[development test]}
+end
+```
+
+If your current `Anyway::Settings.current_environment` is mismatch keys that specified
+`Anyway::Config::ValidationError` error will be raised.
+
 If you need more complex validation or need to manipulate with config state right after it has been loaded, you can use _on load callbacks_ and `#raise_validation_error` method:
 
 ```ruby
@@ -529,7 +547,22 @@ The default data loading mechanism for non-Rails applications is the following (
 
 1) **YAML configuration files**: `./config/<config-name>.yml`.
 
-In pure Ruby apps, we do not know about _environments_ (`test`, `development`, `production`, etc.); thus, we assume that the YAML contains values for a single environment:
+In pure Ruby apps, we also can load data under specific _environments_ (`test`, `development`, `production`, etc.).
+If you want to enable this feature you must specify `Anyway::Settings.current_environment` variable for load config under specific environment.
+
+```ruby
+Anyway::Settings.current_environment = "development"
+```
+
+YAML files should be in this format:
+
+```yml
+development:
+  host: localhost
+  port: 3000
+```
+
+If `Anyway::Settings.current_environment` is missed we assume that the YAML contains values for a single environment:
 
 ```yml
 host: localhost

data/lib/.rbnext/2.7/anyway/config.rb

@@ -47,6 +47,8 @@ module Anyway # :nodoc:
       __type_caster__
     ].freeze
 
+    ENV_OPTION_EXCLUDE_KEY = :except
+
     class Error < StandardError; end
 
     class ValidationError < Error; end
@@ -126,14 +128,36 @@ module Anyway # :nodoc:
         end
       end
 
-      def required(*names)
-        unless (unknown_names = (names - config_attributes)).empty?
-          raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}"
-        end
+      def required(*names, env: nil)
+        unknown_names = names - config_attributes
+        raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}" if unknown_names.any?
 
+        names = filter_by_env(names, env)
         required_attributes.push(*names)
       end
 
+      def filter_by_env(names, env)
+        return names if env.nil? || env.to_s == current_env
+
+        filtered_names = if env.is_a?(Hash)
+          names_with_exclude_env_option(names, env)
+        elsif env.is_a?(Array)
+          names if env.flat_map(&:to_s).include?(current_env)
+        end
+
+        filtered_names || []
+      end
+
+      def current_env
+        Settings.current_environment.to_s
+      end
+
+      def names_with_exclude_env_option(names, env)
+        envs = env[ENV_OPTION_EXCLUDE_KEY]
+        excluded_envs = [envs].flat_map(&:to_s)
+        names if excluded_envs.none?(current_env)
+      end
+
       def required_attributes
         return @required_attributes if instance_variable_defined?(:@required_attributes)
 

data/lib/.rbnext/2.7/anyway/loaders/yaml.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "anyway/ext/hash"
+
+using RubyNext
+using Anyway::Ext::Hash
+
+module Anyway
+  module Loaders
+    class YAML < Base
+      def call(config_path:, **_options)
+        rel_config_path = relative_config_path(config_path).to_s
+        base_config = trace!(:yml, path: rel_config_path) do
+          config = load_base_yml(config_path)
+          environmental?(config) ? config_with_env(config) : config
+        end
+
+        return base_config unless use_local?
+
+        local_path = local_config_path(config_path)
+        local_config = trace!(:yml, path: relative_config_path(local_path).to_s) { load_local_yml(local_path) }
+        Utils.deep_merge!(base_config, local_config)
+      end
+
+      private
+
+      def environmental?(parsed_yml)
+        # strange, but still possible
+        return true if Settings.default_environmental_key? && parsed_yml.key?(Settings.default_environmental_key)
+        # possible
+        return true if !Settings.future.unwrap_known_environments && Settings.current_environment
+        # for other environments
+        return true if Settings.known_environments&.any? { |_1| parsed_yml.key?(_1) }
+        # preferred
+        parsed_yml.key?(Settings.current_environment)
+      end
+
+      def config_with_env(config)
+        env_config = config[Settings.current_environment] || {}
+        return env_config unless Settings.default_environmental_key?
+
+        default_config = config[Settings.default_environmental_key] || {}
+        Utils.deep_merge!(default_config, env_config)
+      end
+
+      def parse_yml(path)
+        return {} unless File.file?(path)
+        require "yaml" unless defined?(::YAML)
+
+        # By default, YAML load will return `false` when the yaml document is
+        # empty. When this occurs, we return an empty hash instead, to match
+        # the interface when no config file is present.
+        begin
+          if defined?(ERB)
+            ::YAML.load(ERB.new(File.read(path)).result, aliases: true) || {} # rubocop:disable Security/YAMLLoad
+          else
+            ::YAML.load_file(path, aliases: true) || {}
+          end
+        rescue ArgumentError
+          if defined?(ERB)
+            ::YAML.load(ERB.new(File.read(path)).result) || {} # rubocop:disable Security/YAMLLoad
+          else
+            ::YAML.load_file(path) || {}
+          end
+        end
+      end
+
+      alias_method :load_base_yml, :parse_yml
+      alias_method :load_local_yml, :parse_yml
+
+      def local_config_path(path)
+        path.sub(/\.yml/, ".local.yml")
+      end
+
+      def relative_config_path(path)
+        Pathname.new(path).then do |path|
+          return path if path.relative?
+          path.relative_path_from(Settings.app_root)
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/2.7/anyway/settings.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 module Anyway
   # Use Settings name to not confuse with Config.
   #
@@ -35,6 +37,8 @@ module Anyway
         names.each { |_1| store[_1] = self.class.settings[_1] }
       end
 
+      setting :unwrap_known_environments, true
+
       private
 
       attr_reader :store
@@ -43,7 +47,10 @@ module Anyway
     class << self
       # Define whether to load data from
       # *.yml.local (or credentials/local.yml.enc)
-      attr_accessor :use_local_files
+      attr_accessor :use_local_files,
+        :current_environment,
+        :default_environmental_key,
+        :known_environments
 
       # A proc returning a path to YML config file given the config name
       attr_reader :default_config_path
@@ -65,6 +72,14 @@ module Anyway
       def future
         @future ||= Future.new
       end
+
+      def app_root
+        Pathname.new(Dir.pwd)
+      end
+
+      def default_environmental_key?
+        !default_environmental_key.nil?
+      end
     end
 
     # By default, use local files only in development (that's the purpose if the local files)

data/lib/.rbnext/2.7/anyway/tracing.rb

@@ -6,12 +6,6 @@ module Anyway
     using Anyway::Ext::DeepDup
 
     using(Module.new do
-      refine Hash do
-        def inspect
-          "{#{map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}}"
-        end
-      end
-
       refine Thread::Backtrace::Location do
         def path_lineno() ;  "#{path}:#{lineno}"; end
       end
@@ -100,8 +94,15 @@ module Anyway
               q.group do
                 q.text k
                 q.text " =>"
-                q.breakable " " unless v.trace?
-                q.pp v
+                if v.trace?
+                  q.text " { "
+                  q.pp v
+                  q.breakable " "
+                  q.text "}"
+                else
+                  q.breakable " "
+                  q.pp v
+                end
               end
             end
           end

data/lib/.rbnext/3.0/anyway/config.rb

@@ -47,6 +47,8 @@ module Anyway # :nodoc:
       __type_caster__
     ].freeze
 
+    ENV_OPTION_EXCLUDE_KEY = :except
+
     class Error < StandardError; end
 
     class ValidationError < Error; end
@@ -126,14 +128,36 @@ module Anyway # :nodoc:
         end
       end
 
-      def required(*names)
-        unless (unknown_names = (names - config_attributes)).empty?
-          raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}"
-        end
+      def required(*names, env: nil)
+        unknown_names = names - config_attributes
+        raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}" if unknown_names.any?
 
+        names = filter_by_env(names, env)
         required_attributes.push(*names)
       end
 
+      def filter_by_env(names, env)
+        return names if env.nil? || env.to_s == current_env
+
+        filtered_names = if env.is_a?(Hash)
+          names_with_exclude_env_option(names, env)
+        elsif env.is_a?(Array)
+          names if env.flat_map(&:to_s).include?(current_env)
+        end
+
+        filtered_names || []
+      end
+
+      def current_env
+        Settings.current_environment.to_s
+      end
+
+      def names_with_exclude_env_option(names, env)
+        envs = env[ENV_OPTION_EXCLUDE_KEY]
+        excluded_envs = [envs].flat_map(&:to_s)
+        names if excluded_envs.none?(current_env)
+      end
+
       def required_attributes
         return @required_attributes if instance_variable_defined?(:@required_attributes)
 

data/lib/.rbnext/3.0/anyway/tracing.rb

@@ -6,12 +6,6 @@ module Anyway
     using Anyway::Ext::DeepDup
 
     using(Module.new do
-      refine Hash do
-        def inspect
-          "{#{map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}}"
-        end
-      end
-
       refine Thread::Backtrace::Location do
         def path_lineno() ;  "#{path}:#{lineno}"; end
       end
@@ -100,8 +94,15 @@ module Anyway
               q.group do
                 q.text k
                 q.text " =>"
-                q.breakable " " unless v.trace?
-                q.pp v
+                if v.trace?
+                  q.text " { "
+                  q.pp v
+                  q.breakable " "
+                  q.text "}"
+                else
+                  q.breakable " "
+                  q.pp v
+                end
               end
             end
           end

data/lib/.rbnext/3.1/anyway/config.rb

@@ -47,6 +47,8 @@ module Anyway # :nodoc:
       __type_caster__
     ].freeze
 
+    ENV_OPTION_EXCLUDE_KEY = :except
+
     class Error < StandardError; end
 
     class ValidationError < Error; end
@@ -126,14 +128,36 @@ module Anyway # :nodoc:
         end
       end
 
-      def required(*names)
-        unless (unknown_names = (names - config_attributes)).empty?
-          raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}"
-        end
+      def required(*names, env: nil)
+        unknown_names = names - config_attributes
+        raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}" if unknown_names.any?
 
+        names = filter_by_env(names, env)
         required_attributes.push(*names)
       end
 
+      def filter_by_env(names, env)
+        return names if env.nil? || env.to_s == current_env
+
+        filtered_names = if env.is_a?(Hash)
+          names_with_exclude_env_option(names, env)
+        elsif env.is_a?(Array)
+          names if env.flat_map(&:to_s).include?(current_env)
+        end
+
+        filtered_names || []
+      end
+
+      def current_env
+        Settings.current_environment.to_s
+      end
+
+      def names_with_exclude_env_option(names, env)
+        envs = env[ENV_OPTION_EXCLUDE_KEY]
+        excluded_envs = [envs].flat_map(&:to_s)
+        names if excluded_envs.none?(current_env)
+      end
+
       def required_attributes
         return @required_attributes if instance_variable_defined?(:@required_attributes)
 

data/lib/.rbnext/3.1/anyway/tracing.rb

@@ -6,12 +6,6 @@ module Anyway
     using Anyway::Ext::DeepDup
 
     using(Module.new do
-      refine Hash do
-        def inspect
-          "{#{map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}}"
-        end
-      end
-
       refine Thread::Backtrace::Location do
         def path_lineno() = "#{path}:#{lineno}"
       end
@@ -100,8 +94,15 @@ module Anyway
               q.group do
                 q.text k
                 q.text " =>"
-                q.breakable " " unless v.trace?
-                q.pp v
+                if v.trace?
+                  q.text " { "
+                  q.pp v
+                  q.breakable " "
+                  q.text "}"
+                else
+                  q.breakable " "
+                  q.pp v
+                end
               end
             end
           end

data/lib/anyway/config.rb

@@ -47,6 +47,8 @@ module Anyway # :nodoc:
       __type_caster__
     ].freeze
 
+    ENV_OPTION_EXCLUDE_KEY = :except
+
     class Error < StandardError; end
 
     class ValidationError < Error; end
@@ -126,14 +128,36 @@ module Anyway # :nodoc:
         end
       end
 
-      def required(*names)
-        unless (unknown_names = (names - config_attributes)).empty?
-          raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}"
-        end
+      def required(*names, env: nil)
+        unknown_names = names - config_attributes
+        raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}" if unknown_names.any?
 
+        names = filter_by_env(names, env)
         required_attributes.push(*names)
       end
 
+      def filter_by_env(names, env)
+        return names if env.nil? || env.to_s == current_env
+
+        filtered_names = if env.is_a?(Hash)
+          names_with_exclude_env_option(names, env)
+        elsif env.is_a?(Array)
+          names if env.flat_map(&:to_s).include?(current_env)
+        end
+
+        filtered_names || []
+      end
+
+      def current_env
+        Settings.current_environment.to_s
+      end
+
+      def names_with_exclude_env_option(names, env)
+        envs = env[ENV_OPTION_EXCLUDE_KEY]
+        excluded_envs = [envs].flat_map(&:to_s)
+        names if excluded_envs.none?(current_env)
+      end
+
       def required_attributes
         return @required_attributes if instance_variable_defined?(:@required_attributes)
 

data/lib/anyway/loaders/yaml.rb

@@ -10,18 +10,40 @@ module Anyway
   module Loaders
     class YAML < Base
       def call(config_path:, **_options)
-        base_config = trace!(:yml, path: relative_config_path(config_path).to_s) { load_base_yml(config_path) }
+        rel_config_path = relative_config_path(config_path).to_s
+        base_config = trace!(:yml, path: rel_config_path) do
+          config = load_base_yml(config_path)
+          environmental?(config) ? config_with_env(config) : config
+        end
 
         return base_config unless use_local?
 
         local_path = local_config_path(config_path)
         local_config = trace!(:yml, path: relative_config_path(local_path).to_s) { load_local_yml(local_path) }
-
         Utils.deep_merge!(base_config, local_config)
       end
 
       private
 
+      def environmental?(parsed_yml)
+        # strange, but still possible
+        return true if Settings.default_environmental_key? && parsed_yml.key?(Settings.default_environmental_key)
+        # possible
+        return true if !Settings.future.unwrap_known_environments && Settings.current_environment
+        # for other environments
+        return true if Settings.known_environments&.any? { parsed_yml.key?(_1) }
+        # preferred
+        parsed_yml.key?(Settings.current_environment)
+      end
+
+      def config_with_env(config)
+        env_config = config[Settings.current_environment] || {}
+        return env_config unless Settings.default_environmental_key?
+
+        default_config = config[Settings.default_environmental_key] || {}
+        Utils.deep_merge!(default_config, env_config)
+      end
+
       def parse_yml(path)
         return {} unless File.file?(path)
         require "yaml" unless defined?(::YAML)
@@ -54,7 +76,7 @@ module Anyway
       def relative_config_path(path)
         Pathname.new(path).then do |path|
           return path if path.relative?
-          path.relative_path_from(Pathname.new(Dir.pwd))
+          path.relative_path_from(Settings.app_root)
         end
       end
     end

data/lib/anyway/rails/loaders/yaml.rb

@@ -3,34 +3,7 @@
 module Anyway
   module Rails
     module Loaders
-      class YAML < Anyway::Loaders::YAML
-        def load_base_yml(*)
-          parsed_yml = super
-          return parsed_yml unless environmental?(parsed_yml)
-
-          env_config = parsed_yml[::Rails.env] || {}
-          return env_config if Anyway::Settings.default_environmental_key.blank?
-
-          default_config = parsed_yml[Anyway::Settings.default_environmental_key] || {}
-          Utils.deep_merge!(default_config, env_config)
-        end
-
-        private
-
-        def environmental?(parsed_yml)
-          return true unless Settings.future.unwrap_known_environments
-          # likely
-          return true if parsed_yml.key?(::Rails.env)
-          # less likely
-          return true if ::Rails.application.config.anyway_config.known_environments.any? { parsed_yml.key?(_1) }
-          # strange, but still possible
-          Anyway::Settings.default_environmental_key.present? && parsed_yml.key?(Anyway::Settings.default_environmental_key)
-        end
-
-        def relative_config_path(path)
-          Pathname.new(path).relative_path_from(::Rails.root)
-        end
-      end
+      class YAML < Anyway::Loaders::YAML; end
     end
   end
 end

data/lib/anyway/rails/settings.rb

@@ -9,16 +9,8 @@ end
 
 module Anyway
   class Settings
-    class Future
-      setting :unwrap_known_environments, true
-    end
-
     class << self
       attr_reader :autoload_static_config_path, :autoloader
-      attr_accessor :known_environments
-
-      # Define a key for environmental yaml files to read default values from
-      attr_accessor :default_environmental_key
 
       if defined?(::Zeitwerk)
         def autoload_static_config_path=(val)
@@ -62,6 +54,14 @@ module Anyway
           :no_op
         end
       end
+
+      def current_environment
+        ::Rails.env.to_s
+      end
+
+      def app_root
+        ::Rails.root
+      end
     end
 
     self.default_config_path = ->(name) { ::Rails.root.join("config", "#{name}.yml") }

data/lib/anyway/settings.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 module Anyway
   # Use Settings name to not confuse with Config.
   #
@@ -35,6 +37,8 @@ module Anyway
         names.each { store[_1] = self.class.settings[_1] }
       end
 
+      setting :unwrap_known_environments, true
+
       private
 
       attr_reader :store
@@ -43,7 +47,10 @@ module Anyway
     class << self
       # Define whether to load data from
       # *.yml.local (or credentials/local.yml.enc)
-      attr_accessor :use_local_files
+      attr_accessor :use_local_files,
+        :current_environment,
+        :default_environmental_key,
+        :known_environments
 
       # A proc returning a path to YML config file given the config name
       attr_reader :default_config_path
@@ -65,6 +72,14 @@ module Anyway
       def future
         @future ||= Future.new
       end
+
+      def app_root
+        Pathname.new(Dir.pwd)
+      end
+
+      def default_environmental_key?
+        !default_environmental_key.nil?
+      end
     end
 
     # By default, use local files only in development (that's the purpose if the local files)

data/lib/anyway/tracing.rb

@@ -6,12 +6,6 @@ module Anyway
     using Anyway::Ext::DeepDup
 
     using(Module.new do
-      refine Hash do
-        def inspect
-          "{#{map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}}"
-        end
-      end
-
       refine Thread::Backtrace::Location do
         def path_lineno() = "#{path}:#{lineno}"
       end
@@ -100,8 +94,15 @@ module Anyway
               q.group do
                 q.text k
                 q.text " =>"
-                q.breakable " " unless v.trace?
-                q.pp v
+                if v.trace?
+                  q.text " { "
+                  q.pp v
+                  q.breakable " "
+                  q.text "}"
+                else
+                  q.breakable " "
+                  q.pp v
+                end
               end
             end
           end

data/lib/anyway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Anyway # :nodoc:
-  VERSION = "2.2.3"
+  VERSION = "2.3.0"
 end

data/sig/anyway_config.rbs

@@ -3,8 +3,11 @@ module Anyway
   def self.loaders: -> Loaders::Registry
 
   class Settings
-    def self.default_config_path=: (^(untyped) -> String val) -> ^(untyped) -> String?
+    def self.default_config_path=: (String | Pathname | ^(untyped) -> String val) -> void
     def self.future: -> Future
+    def self.current_environment: -> String?
+    def self.default_environmental_key: -> String?
+    def self.known_environments: -> Array[String]?
 
     class Future
       def self.setting: (untyped name, untyped default_value) -> untyped
@@ -19,14 +22,14 @@ module Anyway
     end
 
     def inspect: -> String
-    def self.capture: ?{ -> Hash[untyped, untyped] } -> nil
+    def self.capture: ?{ -> Hash[untyped, untyped]? } -> Trace
     def self.trace_stack: -> Array[untyped]
     def self.current_trace: -> Trace?
     def self.source_stack: -> Array[untyped]
-    def self.current_trace_source: -> {type: :accessor, called_from: untyped}
-    def self.with_trace_source: (untyped src) -> untyped
-    def trace!: (Symbol, *Array[String] paths, **untyped) ?{ -> Hash[untyped, untyped]} -> Hash[untyped, untyped]
-    def self.trace!: (Symbol, *Array[String] paths, **untyped) ?{ -> Hash[untyped, untyped]} -> Hash[untyped, untyped]
+    def self.current_trace_source: -> ({type: Symbol} & Hash[Symbol, untyped])
+    def self.with_trace_source: (untyped src) { -> void } -> untyped
+    def trace!: [V] (Symbol, *String paths, **untyped) ?{ -> V} -> V
+    def self.trace!: [V] (Symbol, *String paths, **untyped) ?{ -> V} -> V
   end
 
   module RBSGenerator
@@ -56,6 +59,7 @@ module Anyway
   type hashType = Hash[Symbol, valueType | arrayType | hashType]
 
   type mappingType = valueType | arrayType | hashType
+  type envType = String | Symbol | Array[String | Symbol] | {except: String | Symbol | Array[String | Symbol]}
 
   class Config
     extend RBSGenerator
@@ -67,7 +71,7 @@ module Anyway
     def self.attr_config: (*Symbol args, **untyped) -> void
     def self.defaults: -> Hash[String, untyped]
     def self.config_attributes: -> Array[Symbol]?
-    def self.required: (*Symbol names) -> void
+    def self.required: (*Symbol names, ?env: envType) -> void
     def self.required_attributes: -> Array[Symbol]
     def self.on_load: (*Symbol callbacks) ?{ () -> void } -> void
     def self.config_name: (?(Symbol | String) val) -> String?
@@ -80,9 +84,11 @@ module Anyway
     attr_reader env_prefix: String
 
     def initialize: (?Hash[Symbol | String, untyped] overrides) -> void
+                  | (NilClass) -> void
     def reload: (?Hash[Symbol | String, untyped] overrides) -> Config
     def clear: -> void
     def load: (Hash[Symbol | String, untyped] overrides) -> Config
+            | (NilClass) -> Config
     def dig: (*(Symbol | String) keys) -> untyped
     def to_h: -> Hash[untyped, untyped]
     def dup: -> Config
@@ -117,12 +123,21 @@ module Anyway
       def use_local?: -> bool
     end
 
+    interface _Loader
+      def call: (**untyped) -> Hash[untyped, untyped]
+    end
+
     class Registry
-      def prepend: (Symbol id, Base loader) -> void
-      def append: (Symbol id, Base loader) -> void
-      def insert_before: (Symbol another_id, Symbol id, Base loader) -> void
-      def insert_after: (Symbol another_id, Symbol id, Base loader) -> void
-      def override: (Symbol id, Base loader) -> void
+      def prepend: (Symbol id, _Loader loader) -> void
+                 | (Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def append: (Symbol id, _Loader loader) -> void
+                | (Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def insert_before: (Symbol another_id, Symbol id, _Loader loader) -> void
+                       | (Symbol another_id, Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def insert_after: (Symbol another_id, Symbol id, _Loader loader) -> void
+                      | (Symbol another_id, Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def override: (Symbol id, _Loader loader) -> void
+                  | (Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
       def delete: (Symbol id) -> void
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anyway_config
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.3.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next-core
@@ -108,7 +108,7 @@ files:
 - README.md
 - lib/.rbnext/2.7/anyway/auto_cast.rb
 - lib/.rbnext/2.7/anyway/config.rb
-- lib/.rbnext/2.7/anyway/rails/loaders/yaml.rb
+- lib/.rbnext/2.7/anyway/loaders/yaml.rb
 - lib/.rbnext/2.7/anyway/rbs.rb
 - lib/.rbnext/2.7/anyway/settings.rb
 - lib/.rbnext/2.7/anyway/tracing.rb

data/lib/.rbnext/2.7/anyway/rails/loaders/yaml.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Rails
-    module Loaders
-      class YAML < Anyway::Loaders::YAML
-        def load_base_yml(*)
-          parsed_yml = super
-          return parsed_yml unless environmental?(parsed_yml)
-
-          env_config = parsed_yml[::Rails.env] || {}
-          return env_config if Anyway::Settings.default_environmental_key.blank?
-
-          default_config = parsed_yml[Anyway::Settings.default_environmental_key] || {}
-          Utils.deep_merge!(default_config, env_config)
-        end
-
-        private
-
-        def environmental?(parsed_yml)
-          return true unless Settings.future.unwrap_known_environments
-          # likely
-          return true if parsed_yml.key?(::Rails.env)
-          # less likely
-          return true if ::Rails.application.config.anyway_config.known_environments.any? { |_1| parsed_yml.key?(_1) }
-          # strange, but still possible
-          Anyway::Settings.default_environmental_key.present? && parsed_yml.key?(Anyway::Settings.default_environmental_key)
-        end
-
-        def relative_config_path(path)
-          Pathname.new(path).relative_path_from(::Rails.root)
-        end
-      end
-    end
-  end
-end