anyway_config 2.0.6 → 2.2.2

data/lib/anyway/env.rb

@@ -49,7 +49,7 @@ module Anyway
         path = key.sub(/^#{prefix}_/, "").downcase
 
         paths = path.split("__")
-        trace!(:env, *paths, key: key) { data.bury(type_cast.call(val), *paths) }
+        trace!(:env, *paths, key:) { data.bury(type_cast.call(val), *paths) }
       end
     end
   end

data/lib/anyway/ext/deep_dup.rb

@@ -30,6 +30,18 @@ module Anyway
         end
       end
 
+      refine ::Object do
+        def deep_dup
+          dup
+        end
+      end
+
+      refine ::Module do
+        def deep_dup
+          self
+        end
+      end
+
       using self
     end
   end

data/lib/anyway/ext/hash.rb

@@ -5,18 +5,6 @@ module Anyway
     # Extend Hash through refinements
     module Hash
       refine ::Hash do
-        # From ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_merge
-        def deep_merge!(other_hash)
-          merge!(other_hash) do |key, this_value, other_value|
-            if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
-              this_value.deep_merge!(other_value)
-              this_value
-            else
-              other_value
-            end
-          end
-        end
-
         def stringify_keys!
           keys.each do |key|
             value = delete(key)

data/lib/anyway/loaders/base.rb

@@ -7,7 +7,7 @@ module Anyway
 
       class << self
         def call(local: Anyway::Settings.use_local_files, **opts)
-          new(local: local).call(**opts)
+          new(local:).call(**opts)
         end
       end
 

data/lib/anyway/loaders/env.rb

@@ -6,7 +6,9 @@ module Anyway
   module Loaders
     class Env < Base
       def call(env_prefix:, **_options)
-        Anyway.env.fetch_with_trace(env_prefix).then do |(conf, trace)|
+        env = ::Anyway::Env.new(type_cast: ::Anyway::NoCast)
+
+        env.fetch_with_trace(env_prefix).then do |(conf, trace)|
           Tracing.current_trace&.merge!(trace)
           conf
         end

data/lib/anyway/loaders/yaml.rb

@@ -17,7 +17,7 @@ module Anyway
         local_path = local_config_path(config_path)
         local_config = trace!(:yml, path: relative_config_path(local_path).to_s) { load_local_yml(local_path) }
 
-        base_config.deep_merge!(local_config)
+        Utils.deep_merge!(base_config, local_config)
       end
 
       private
@@ -25,15 +25,19 @@ module Anyway
       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.
         if defined?(ERB)
-          ::YAML.load(ERB.new(File.read(path)).result) # rubocop:disable Security/YAMLLoad
+          ::YAML.load(ERB.new(File.read(path)).result) || {} # rubocop:disable Security/YAMLLoad
         else
-          ::YAML.load_file(path)
+          ::YAML.load_file(path) || {}
         end
       end
 
-      alias load_base_yml parse_yml
-      alias load_local_yml parse_yml
+      alias_method :load_base_yml, :parse_yml
+      alias_method :load_local_yml, :parse_yml
 
       def local_config_path(path)
         path.sub(/\.yml/, ".local.yml")

data/lib/anyway/option_parser_builder.rb

@@ -8,8 +8,6 @@ module Anyway # :nodoc:
     class << self
       def call(options)
         OptionParser.new do |opts|
-          opts.accept(AutoCast) { AutoCast.call(_1) }
-
           options.each do |key, descriptor|
             opts.on(*option_parser_on_args(key, **descriptor)) do |val|
               yield [key, val]
@@ -20,7 +18,7 @@ module Anyway # :nodoc:
 
       private
 
-      def option_parser_on_args(key, flag: false, desc: nil, type: AutoCast)
+      def option_parser_on_args(key, flag: false, desc: nil, type: ::String)
         on_args = ["--#{key.to_s.tr("_", "-")}#{flag ? "" : " VALUE"}"]
         on_args << type unless flag
         on_args << desc unless desc.nil?

data/lib/anyway/optparse_config.rb

@@ -70,13 +70,11 @@ module Anyway
     end
 
     def option_parser
-      @option_parser ||= begin
-        OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
-          write_config_attr(key, val)
-        end.tap do |parser|
-          self.class.option_parser_extensions.map do |extension|
-            extension.call(parser, self)
-          end
+      @option_parser ||= OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
+                           write_config_attr(key, val)
+                         end.tap do |parser|
+        self.class.option_parser_extensions.map do |extension|
+          extension.call(parser, self)
         end
       end
     end

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

@@ -22,15 +22,15 @@ module Anyway
             :credentials,
             store: credentials_path
           ) do
-            ::Rails.application.credentials.public_send(name)
+            ::Rails.application.credentials.config[name.to_sym]
           end.then do |creds|
-            config.deep_merge!(creds) if creds
+            Utils.deep_merge!(config, creds) if creds
           end
 
           if use_local?
             trace!(:credentials, store: LOCAL_CONTENT_PATH) do
               local_credentials(name)
-            end.then { |creds| config.deep_merge!(creds) if creds }
+            end.then { |creds| Utils.deep_merge!(config, creds) if creds }
           end
 
           config
@@ -48,7 +48,7 @@ module Anyway
             key_path: ::Rails.root.join("config/credentials/local.key")
           )
 
-          creds.public_send(name)
+          creds.config[name.to_sym]
         end
 
         def credentials_path

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

@@ -15,7 +15,7 @@ module Anyway
           trace!(:secrets) do
             secrets.public_send(name)
           end.then do |secrets|
-            config.deep_merge!(secrets) if secrets
+            Utils.deep_merge!(config, secrets) if secrets
           end
 
           config
@@ -24,13 +24,11 @@ module Anyway
         private
 
         def secrets
-          @secrets ||= begin
-            ::Rails.application.secrets.tap do |_|
-              # Reset secrets state if the app hasn't been initialized
-              # See https://github.com/palkan/anyway_config/issues/14
-              next if ::Rails.application.initialized?
-              ::Rails.application.remove_instance_variable(:@secrets)
-            end
+          @secrets ||= ::Rails.application.secrets.tap do |_|
+            # Reset secrets state if the app hasn't been initialized
+            # See https://github.com/palkan/anyway_config/issues/14
+            next if ::Rails.application.initialized?
+            ::Rails.application.remove_instance_variable(:@secrets)
           end
         end
       end

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

@@ -5,11 +5,22 @@ module Anyway
     module Loaders
       class YAML < Anyway::Loaders::YAML
         def load_base_yml(*)
+          parsed_yml = super
+          return parsed_yml unless environmental?(parsed_yml)
+
           super[::Rails.env] || {}
         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
+          ::Rails.application.config.anyway_config.known_environments.any? { parsed_yml.key?(_1) }
+        end
+
         def relative_config_path(path)
           Pathname.new(path).relative_path_from(::Rails.root)
         end

data/lib/anyway/rails/settings.rb

@@ -9,8 +9,13 @@ 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
 
       if defined?(::Zeitwerk)
         def autoload_static_config_path=(val)
@@ -22,10 +27,11 @@ module Anyway
 
           @autoload_static_config_path = val
 
-          # See https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+          # See Rails 6 https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+          # and Rails 7 https://github.com/rails/rails/blob/5462fbd5de1900c1b1ce1c9dc11c1a2d8cdcd809/railties/lib/rails/autoloaders.rb#L15
           @autoloader = Zeitwerk::Loader.new.tap do |loader|
             loader.tag = "anyway.config"
-            loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+            loader.inflector = defined?(ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector) ? ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector : ::Rails::Autoloaders::Inflector
             loader.push_dir(::Rails.root.join(val))
             loader.setup
           end
@@ -56,5 +62,6 @@ module Anyway
     end
 
     self.default_config_path = ->(name) { ::Rails.root.join("config", "#{name}.yml") }
+    self.known_environments = %w[test development production]
   end
 end

data/lib/anyway/rbs.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Anyway
+  module RBSGenerator
+    TYPE_TO_CLASS = {
+      string: "String",
+      integer: "Integer",
+      float: "Float",
+      date: "Date",
+      datetime: "DateTime",
+      uri: "URI",
+      boolean: "bool"
+    }.freeze
+
+    # Generate RBS signature from a config class
+    def to_rbs
+      *namespace, class_name = name.split("::")
+
+      buf = []
+      indent = 0
+      interface_name = "_Config"
+
+      if namespace.empty?
+        interface_name = "_#{class_name}"
+      else
+        buf << "module #{namespace.join("::")}"
+        indent += 1
+      end
+
+      # Using interface emulates a module we include to provide getters and setters
+      # (thus making `super` possible)
+      buf << "#{"  " * indent}interface #{interface_name}"
+      indent += 1
+
+      # Generating setters and getters for config attributes
+      config_attributes.each do |param|
+        type = coercion_mapping[param] || defaults[param.to_s]
+
+        type =
+          case type
+          in NilClass
+            "untyped"
+          in Symbol
+            TYPE_TO_CLASS.fetch(type) { defaults[param] ? "Symbol" : "untyped" }
+          in Array
+            "Array[untyped]"
+          in array:, type:, **nil
+            "Array[#{TYPE_TO_CLASS.fetch(type, "untyped")}]"
+          in Hash
+            "Hash[string,untyped]"
+          in TrueClass | FalseClass
+            "bool"
+          else
+            type.class.to_s
+          end
+
+        getter_type = type
+        getter_type = "#{type}?" unless required_attributes.include?(param)
+
+        buf << "#{"  " * indent}def #{param}: () -> #{getter_type}"
+        buf << "#{"  " * indent}def #{param}=: (#{type}) -> void"
+
+        if type == "bool" || type == "bool?"
+          buf << "#{"  " * indent}def #{param}?: () -> #{getter_type}"
+        end
+      end
+
+      indent -= 1
+      buf << "#{"  " * indent}end"
+
+      buf << ""
+
+      buf << "#{"  " * indent}class #{class_name} < #{superclass.name}"
+      indent += 1
+
+      buf << "#{"  " * indent}include #{interface_name}"
+
+      indent -= 1
+      buf << "#{"  " * indent}end"
+
+      unless namespace.empty?
+        buf << "end"
+      end
+
+      buf << ""
+
+      buf.join("\n")
+    end
+  end
+
+  Config.extend RBSGenerator
+end

data/lib/anyway/settings.rb

@@ -5,16 +5,66 @@ module Anyway
   #
   # Settings contain the library-wide configuration.
   class Settings
+    # Future encapsulates settings that will be introduced in the upcoming version
+    # with the default values, which could break compatibility
+    class Future
+      class << self
+        def setting(name, default_value)
+          settings[name] = default_value
+
+          define_method(name) do
+            store[name]
+          end
+
+          define_method(:"#{name}=") do |val|
+            store[name] = val
+          end
+        end
+
+        def settings
+          @settings ||= {}
+        end
+      end
+
+      def initialize
+        @store = {}
+      end
+
+      def use(*names)
+        store.clear
+        names.each { store[_1] = self.class.settings[_1] }
+      end
+
+      private
+
+      attr_reader :store
+    end
+
     class << self
       # Define whether to load data from
       # *.yml.local (or credentials/local.yml.enc)
       attr_accessor :use_local_files
 
-      # Return a path to YML config file given the config name
-      attr_accessor :default_config_path
+      # A proc returning a path to YML config file given the config name
+      attr_reader :default_config_path
+
+      def default_config_path=(val)
+        if val.is_a?(Proc)
+          @default_config_path = val
+          return
+        end
+
+        val = val.to_s
+
+        @default_config_path = ->(name) { File.join(val, "#{name}.yml") }
+      end
 
       # Enable source tracing
       attr_accessor :tracing_enabled
+
+      def future
+        @future ||= Future.new
+      end
     end
 
     # By default, use local files only in development (that's the purpose if the local files)

data/lib/anyway/tracing.rb

@@ -34,11 +34,11 @@ module Anyway
 
       def record_value(val, *path, **opts)
         key = path.pop
-        if val.is_a?(Hash)
+        trace = if val.is_a?(Hash)
           Trace.new.tap { _1.merge_values(val, **opts) }
         else
           Trace.new(:value, val, **opts)
-        end => trace
+        end
 
         target_trace = path.empty? ? self : value.dig(*path)
         target_trace.value[key.to_s] = trace
@@ -86,7 +86,7 @@ module Anyway
         if trace?
           value.transform_values(&:to_h).tap { _1.default_proc = nil }
         else
-          {value: value, source: source}
+          {value, source}
         end
       end
 
@@ -141,7 +141,7 @@ module Anyway
 
       def current_trace() = trace_stack.last
 
-      alias tracing? current_trace
+      alias_method :tracing?, :current_trace
 
       def source_stack
         (Thread.current[:__anyway__trace_source_stack__] ||= [])
@@ -171,9 +171,9 @@ module Anyway
       return yield unless Tracing.tracing?
       val = yield
       if val.is_a?(Hash)
-        Tracing.current_trace.merge_values(val, type: type, **opts)
+        Tracing.current_trace.merge_values(val, type:, **opts)
       else
-        Tracing.current_trace.record_value(val, *path, type: type, **opts)
+        Tracing.current_trace.record_value(val, *path, type:, **opts)
       end
       val
     end

data/lib/anyway/type_casting.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Contains a mapping between type IDs/names and deserializers
+  class TypeRegistry
+    class << self
+      def default
+        @default ||= TypeRegistry.new
+      end
+    end
+
+    def initialize
+      @registry = {}
+    end
+
+    def accept(name_or_object, &block)
+      if !block && !name_or_object.respond_to?(:call)
+        raise ArgumentError, "Please, provide a type casting block or an object implementing #call(val) method"
+      end
+
+      registry[name_or_object] = block || name_or_object
+    end
+
+    def deserialize(raw, type_id, array: false)
+      return if raw.nil?
+
+      caster =
+        if type_id.is_a?(Symbol) || type_id.nil?
+          registry.fetch(type_id) { raise ArgumentError, "Unknown type: #{type_id}" }
+        else
+          raise ArgumentError, "Type must implement #call(val): #{type_id}" unless type_id.respond_to?(:call)
+          type_id
+        end
+
+      if array
+        raw_arr = raw.is_a?(String) ? raw.split(/\s*,\s*/) : Array(raw)
+        raw_arr.map { caster.call(_1) }
+      else
+        caster.call(raw)
+      end
+    end
+
+    def dup
+      new_obj = self.class.allocate
+      new_obj.instance_variable_set(:@registry, registry.dup)
+      new_obj
+    end
+
+    private
+
+    attr_reader :registry
+  end
+
+  TypeRegistry.default.tap do |obj|
+    obj.accept(nil, &:itself)
+    obj.accept(:string, &:to_s)
+    obj.accept(:integer, &:to_i)
+    obj.accept(:float, &:to_f)
+
+    obj.accept(:date) do
+      require "date" unless defined?(::Date)
+
+      next _1 if _1.is_a?(::Date)
+
+      next _1.to_date if _1.respond_to?(:to_date)
+
+      ::Date.parse(_1)
+    end
+
+    obj.accept(:datetime) do
+      require "date" unless defined?(::Date)
+
+      next _1 if _1.is_a?(::DateTime)
+
+      next _1.to_datetime if _1.respond_to?(:to_datetime)
+
+      ::DateTime.parse(_1)
+    end
+
+    obj.accept(:uri) do
+      require "uri" unless defined?(::URI)
+
+      next _1 if _1.is_a?(::URI)
+
+      ::URI.parse(_1)
+    end
+
+    obj.accept(:boolean) do
+      _1.to_s.match?(/\A(true|t|yes|y|1)\z/i)
+    end
+  end
+
+  # TypeCaster is an object responsible for type-casting.
+  # It uses a provided types registry and mapping, and also
+  # accepts a fallback typecaster.
+  class TypeCaster
+    using Ext::DeepDup
+    using Ext::Hash
+
+    def initialize(mapping, registry: TypeRegistry.default, fallback: ::Anyway::AutoCast)
+      @mapping = mapping.deep_dup
+      @registry = registry
+      @fallback = fallback
+    end
+
+    def coerce(key, val, config: mapping)
+      caster_config = config[key.to_sym]
+
+      return fallback.coerce(key, val) unless caster_config
+
+      case caster_config
+      in array:, type:, **nil
+        registry.deserialize(val, type, array: array)
+      in Hash
+        return val unless val.is_a?(Hash)
+
+        caster_config.each do |k, v|
+          ks = k.to_s
+          next unless val.key?(ks)
+
+          val[ks] = coerce(k, val[ks], config: caster_config)
+        end
+
+        val
+      else
+        registry.deserialize(val, caster_config)
+      end
+    end
+
+    private
+
+    attr_reader :mapping, :registry, :fallback
+  end
+end

data/lib/anyway/utils/deep_merge.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anyway
+  using Anyway::Ext::DeepDup
+
+  module Utils
+    def self.deep_merge!(source, other)
+      other.each do |key, other_value|
+        this_value = source[key]
+
+        if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
+          deep_merge!(this_value, other_value)
+        else
+          source[key] = other_value.deep_dup
+        end
+      end
+
+      source
+    end
+  end
+end

data/lib/anyway/version.rb

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

data/lib/anyway_config.rb

@@ -11,12 +11,16 @@ require "anyway/ext/deep_dup"
 require "anyway/ext/deep_freeze"
 require "anyway/ext/hash"
 
+require "anyway/utils/deep_merge"
+
 require "anyway/settings"
 require "anyway/tracing"
 require "anyway/config"
 require "anyway/auto_cast"
+require "anyway/type_casting"
 require "anyway/env"
 require "anyway/loaders"
+require "anyway/rbs"
 
 module Anyway # :nodoc:
   class << self