anyway_config 2.1.0 → 2.2.0

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+using RubyNext;
+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)
+      caster =
+        if type_id.is_a?(Symbol)
+          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?(Array) ? raw : raw.split(/\s*,\s*/)
+        raw_arr.map { |_1| 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(:string, &:to_s)
+    obj.accept(:integer, &:to_i)
+    obj.accept(:float, &:to_f)
+
+    obj.accept(:date) do |_1|
+      require "date" unless defined?(::Date)
+
+      Date.parse(_1)
+    end
+
+    obj.accept(:datetime) do |_1|
+      require "date" unless defined?(::Date)
+
+      DateTime.parse(_1)
+    end
+
+    obj.accept(:uri) do |_1|
+      require "uri" unless defined?(::URI)
+
+      URI.parse(_1)
+    end
+
+    obj.accept(:boolean) do |_1|
+      _1.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; when ((__m__ = caster_config)) && false 
+      when ((__m__.respond_to?(:deconstruct_keys) && (((__m_hash__src__ = __m__.deconstruct_keys(nil)) || true) && (Hash === __m_hash__src__ || Kernel.raise(TypeError, "#deconstruct_keys must return Hash"))) && (__m_hash__ = __m_hash__src__.dup)) && ((__m_hash__.key?(:array) && __m_hash__.key?(:type)) && (((array = __m_hash__.delete(:array)) || true) && (((type = __m_hash__.delete(:type)) || true) && __m_hash__.empty?))))
+        registry.deserialize(val, type, array: array)
+      when (Hash === __m__)
+
+
+
+
+
+
+
+
+
+        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/.rbnext/3.0/anyway/auto_cast.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Anyway
+  module AutoCast
+    # Regexp to detect array values
+    # Array value is a values that contains at least one comma
+    # and doesn't start/end with quote
+    ARRAY_RXP = /\A[^'"].*\s*,\s*.*[^'"]\z/
+
+    class << self
+      def call(val)
+        return val unless val.is_a?(::Hash) || val.is_a?(::String)
+
+        case val
+        when Hash
+          val.transform_values { call(_1) }
+        when ARRAY_RXP
+          val.split(/\s*,\s*/).map { call(_1) }
+        when /\A(true|t|yes|y)\z/i
+          true
+        when /\A(false|f|no|n)\z/i
+          false
+        when /\A(nil|null)\z/i
+          nil
+        when /\A\d+\z/
+          val.to_i
+        when /\A\d*\.\d+\z/
+          val.to_f
+        when /\A['"].*['"]\z/
+          val.gsub(/(\A['"]|['"]\z)/, "")
+        else
+          val
+        end
+      end
+
+      def cast_hash(obj)
+        obj.transform_values do |val|
+          val.is_a?(::Hash) ? cast_hash(val) : call(val)
+        end
+      end
+
+      def coerce(_key, val)
+        call(val)
+      end
+    end
+  end
+
+  module NoCast
+    def self.call(val) ;  val; end
+
+    def self.coerce(_key, val) ;  val; end
+  end
+end

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

@@ -44,6 +44,7 @@ module Anyway # :nodoc:
       to_h
       to_source_trace
       write_config_attr
+      __type_caster__
     ].freeze
 
     class Error < StandardError; end
@@ -196,6 +197,47 @@ module Anyway # :nodoc:
 
       def new_empty_config() ;  {}; end
 
+      def coerce_types(mapping)
+        coercion_mapping.deep_merge!(mapping)
+      end
+
+      def coercion_mapping
+        return @coercion_mapping if instance_variable_defined?(:@coercion_mapping)
+
+        @coercion_mapping = if superclass < Anyway::Config
+          superclass.coercion_mapping.deep_dup
+        else
+          {}
+        end
+      end
+
+      def type_caster(val = nil)
+        return @type_caster unless val.nil?
+
+        @type_caster ||=
+          if coercion_mapping.empty?
+            fallback_type_caster
+          else
+            ::Anyway::TypeCaster.new(coercion_mapping, fallback: fallback_type_caster)
+          end
+      end
+
+      def fallback_type_caster(val = nil)
+        return (@fallback_type_caster = val) unless val.nil?
+
+        return @fallback_type_caster if instance_variable_defined?(:@fallback_type_caster)
+
+        @fallback_type_caster = if superclass < Anyway::Config
+          superclass.fallback_type_caster.deep_dup
+        else
+          ::Anyway::AutoCast
+        end
+      end
+
+      def disable_auto_cast!
+        @fallback_type_caster = ::Anyway::NoCast
+      end
+
       private
 
       def define_config_accessor(*names)
@@ -373,7 +415,7 @@ module Anyway # :nodoc:
         values[name].nil? || (values[name].is_a?(String) && values[name].empty?)
       end.then do |missing|
         next if missing.empty?
-        raise_validation_error "The following config parameters are missing or empty: #{missing.join(", ")}"
+        raise_validation_error "The following config parameters for `#{self.class.name}(config_name: #{self.class.config_name})` are missing or empty: #{missing.join(", ")}"
       end
     end
 
@@ -381,11 +423,16 @@ module Anyway # :nodoc:
       key = key.to_sym
       return unless self.class.config_attributes.include?(key)
 
+      val = __type_caster__.coerce(key, val)
       public_send(:"#{key}=", val)
     end
 
     def raise_validation_error(msg)
       raise ValidationError, msg
     end
+
+    def __type_caster__
+      self.class.type_caster
+    end
   end
 end

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

@@ -34,13 +34,11 @@ module Anyway
 
       def record_value(val, *path, **opts)
         key = path.pop
-        (__m__ = if val.is_a?(Hash)
-  Trace.new.tap {
-    _1.merge_values(val, **opts)
-  }
-else
-  Trace.new(:value, val, **opts)
-end) && (((trace = __m__) || true) || Kernel.raise(NoMatchingPatternError, __m__.inspect))
+        trace = if val.is_a?(Hash)
+          Trace.new.tap { _1.merge_values(val, **opts) }
+        else
+          Trace.new(:value, val, **opts)
+        end
 
         target_trace = path.empty? ? self : value.dig(*path)
         target_trace.value[key.to_s] = trace

data/lib/anyway/auto_cast.rb

@@ -7,27 +7,47 @@ module Anyway
     # and doesn't start/end with quote
     ARRAY_RXP = /\A[^'"].*\s*,\s*.*[^'"]\z/
 
-    def self.call(val)
-      return val unless String === val
+    class << self
+      def call(val)
+        return val unless val.is_a?(::Hash) || val.is_a?(::String)
 
-      case val
-      when ARRAY_RXP
-        val.split(/\s*,\s*/).map { call(_1) }
-      when /\A(true|t|yes|y)\z/i
-        true
-      when /\A(false|f|no|n)\z/i
-        false
-      when /\A(nil|null)\z/i
-        nil
-      when /\A\d+\z/
-        val.to_i
-      when /\A\d*\.\d+\z/
-        val.to_f
-      when /\A['"].*['"]\z/
-        val.gsub(/(\A['"]|['"]\z)/, "")
-      else
-        val
+        case val
+        when Hash
+          val.transform_values { call(_1) }
+        when ARRAY_RXP
+          val.split(/\s*,\s*/).map { call(_1) }
+        when /\A(true|t|yes|y)\z/i
+          true
+        when /\A(false|f|no|n)\z/i
+          false
+        when /\A(nil|null)\z/i
+          nil
+        when /\A\d+\z/
+          val.to_i
+        when /\A\d*\.\d+\z/
+          val.to_f
+        when /\A['"].*['"]\z/
+          val.gsub(/(\A['"]|['"]\z)/, "")
+        else
+          val
+        end
+      end
+
+      def cast_hash(obj)
+        obj.transform_values do |val|
+          val.is_a?(::Hash) ? cast_hash(val) : call(val)
+        end
+      end
+
+      def coerce(_key, val)
+        call(val)
       end
     end
   end
+
+  module NoCast
+    def self.call(val) = val
+
+    def self.coerce(_key, val) = val
+  end
 end

data/lib/anyway/config.rb

@@ -44,6 +44,7 @@ module Anyway # :nodoc:
       to_h
       to_source_trace
       write_config_attr
+      __type_caster__
     ].freeze
 
     class Error < StandardError; end
@@ -196,6 +197,47 @@ module Anyway # :nodoc:
 
       def new_empty_config() = {}
 
+      def coerce_types(mapping)
+        coercion_mapping.deep_merge!(mapping)
+      end
+
+      def coercion_mapping
+        return @coercion_mapping if instance_variable_defined?(:@coercion_mapping)
+
+        @coercion_mapping = if superclass < Anyway::Config
+          superclass.coercion_mapping.deep_dup
+        else
+          {}
+        end
+      end
+
+      def type_caster(val = nil)
+        return @type_caster unless val.nil?
+
+        @type_caster ||=
+          if coercion_mapping.empty?
+            fallback_type_caster
+          else
+            ::Anyway::TypeCaster.new(coercion_mapping, fallback: fallback_type_caster)
+          end
+      end
+
+      def fallback_type_caster(val = nil)
+        return (@fallback_type_caster = val) unless val.nil?
+
+        return @fallback_type_caster if instance_variable_defined?(:@fallback_type_caster)
+
+        @fallback_type_caster = if superclass < Anyway::Config
+          superclass.fallback_type_caster.deep_dup
+        else
+          ::Anyway::AutoCast
+        end
+      end
+
+      def disable_auto_cast!
+        @fallback_type_caster = ::Anyway::NoCast
+      end
+
       private
 
       def define_config_accessor(*names)
@@ -373,7 +415,7 @@ module Anyway # :nodoc:
         values[name].nil? || (values[name].is_a?(String) && values[name].empty?)
       end.then do |missing|
         next if missing.empty?
-        raise_validation_error "The following config parameters are missing or empty: #{missing.join(", ")}"
+        raise_validation_error "The following config parameters for `#{self.class.name}(config_name: #{self.class.config_name})` are missing or empty: #{missing.join(", ")}"
       end
     end
 
@@ -381,11 +423,16 @@ module Anyway # :nodoc:
       key = key.to_sym
       return unless self.class.config_attributes.include?(key)
 
+      val = __type_caster__.coerce(key, val)
       public_send(:"#{key}=", val)
     end
 
     def raise_validation_error(msg)
       raise ValidationError, msg
     end
+
+    def __type_caster__
+      self.class.type_caster
+    end
   end
 end

data/lib/anyway/dynamic_config.rb

@@ -12,11 +12,15 @@ module Anyway
       #   my_config = Anyway::Config.for(:my_app)
       #   # will load data from config/my_app.yml, secrets.my_app, ENV["MY_APP_*"]
       #
-      def for(name, **options)
+      def for(name, auto_cast: true, **options)
         config = allocate
         options[:env_prefix] ||= name.to_s.upcase
         options[:config_path] ||= config.resolve_config_path(name, options[:env_prefix])
-        config.load_from_sources(new_empty_config, name:, **options)
+
+        raw_config = config.load_from_sources(new_empty_config, name:, **options)
+        return raw_config unless auto_cast
+
+        AutoCast.call(raw_config)
       end
     end
 

data/lib/anyway/ext/deep_dup.rb

@@ -36,6 +36,12 @@ module Anyway
         end
       end
 
+      refine ::Module do
+        def deep_dup
+          self
+        end
+      end
+
       using self
     end
   end

data/lib/anyway/ext/hash.rb

@@ -26,6 +26,16 @@ module Anyway
           end
           hash[last_key] = val
         end
+
+        def deep_merge!(other)
+          other.each do |k, v|
+            if key?(k) && self[k].is_a?(::Hash) && v.is_a?(::Hash)
+              self[k].deep_merge!(v)
+            else
+              self[k] = v
+            end
+          end
+        end
       end
 
       using self

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

@@ -25,10 +25,14 @@ 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
 

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,7 +22,7 @@ module Anyway
             :credentials,
             store: credentials_path
           ) do
-            ::Rails.application.credentials.public_send(name)
+            ::Rails.application.credentials.config[name.to_sym]
           end.then do |creds|
             Utils.deep_merge!(config, creds) if creds
           end
@@ -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

@@ -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/settings.rb

@@ -27,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