anyway_config 2.0.5 → 2.2.1

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

@@ -0,0 +1,143 @@
+# 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)
+      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 { |_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(nil, &:itself)
+    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)
+
+      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 |_1|
+      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 |_1|
+      require "uri" unless defined?(::URI)
+
+      next _1 if _1.is_a?(::URI)
+
+      ::URI.parse(_1)
+    end
+
+    obj.accept(:boolean) do |_1|
+      _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; 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/{2.8 → 3.0}/anyway/config.rb

@@ -19,7 +19,7 @@ module Anyway # :nodoc:
   # Provides `attr_config` method to describe
   # configuration parameters and set defaults
   class Config
-    PARAM_NAME = /^[a-z_]([\w]+)?$/
+    PARAM_NAME = /^[a-z_](\w+)?$/
 
     # List of names that couldn't be used as config names
     # (the class instance methods we use)
@@ -40,12 +40,15 @@ module Anyway # :nodoc:
       raise_validation_error
       reload
       resolve_config_path
+      tap
       to_h
       to_source_trace
       write_config_attr
+      __type_caster__
     ].freeze
 
     class Error < StandardError; end
+
     class ValidationError < Error; end
 
     include OptparseConfig
@@ -142,9 +145,9 @@ module Anyway # :nodoc:
       end
 
       def on_load(*names, &block)
-        raise ArgumentError, "Either methods or block should be specified, not both" if block_given? && !names.empty?
+        raise ArgumentError, "Either methods or block should be specified, not both" if block && !names.empty?
 
-        if block_given?
+        if block
           load_callbacks << BlockCallback.new(block)
         else
           load_callbacks.push(*names.map { NamedCallback.new(_1) })
@@ -194,15 +197,55 @@ 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)
         names.each do |name|
           accessors_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{name}=(val)
-              __trace__&.record_value(val, \"#{name}\", Tracing.current_trace_source)
-              # DEPRECATED: instance variable set will be removed in 2.1
-              @#{name} = values[:#{name}] = val
+              __trace__&.record_value(val, \"#{name}\", **Tracing.current_trace_source)
+              values[:#{name}] = val
             end
 
             def #{name}
@@ -229,7 +272,7 @@ module Anyway # :nodoc:
         # handle two cases:
         # - SomeModule::Config => "some_module"
         # - SomeConfig => "some"
-        unless name =~ /^(\w+)(\:\:)?Config$/
+        unless name =~ /^(\w+)(::)?Config$/
           raise "Couldn't infer config name, please, specify it explicitly" \
             "via `config_name :my_config`"
         end
@@ -288,17 +331,14 @@ module Anyway # :nodoc:
       trace = Tracing.capture do
         Tracing.trace!(:defaults) { base_config }
 
-        load_from_sources(
-          base_config,
-          name: config_name,
-          env_prefix: env_prefix,
-          config_path: resolve_config_path(config_name, env_prefix)
-        )
+        config_path = resolve_config_path(config_name, env_prefix)
+
+        load_from_sources(base_config, name: config_name, env_prefix: env_prefix, config_path: config_path)
 
         if overrides
           Tracing.trace!(:load) { overrides }
 
-          base_config.deep_merge!(overrides)
+          Utils.deep_merge!(base_config, overrides)
         end
       end
 
@@ -321,7 +361,7 @@ module Anyway # :nodoc:
 
     def load_from_sources(base_config, **options)
       Anyway.loaders.each do |(_id, loader)|
-        base_config.deep_merge!(loader.call(**options))
+        Utils.deep_merge!(base_config, loader.call(**options))
       end
       base_config
     end
@@ -375,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
 
@@ -383,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/{2.8 → 3.0}/anyway/tracing.rb

@@ -32,7 +32,8 @@ module Anyway
         value.dig(...)
       end
 
-      def record_value(val, *path, key, **opts)
+      def record_value(val, *path, **opts)
+        key = path.pop
         trace = if val.is_a?(Hash)
           Trace.new.tap { _1.merge_values(val, **opts) }
         else
@@ -89,7 +90,7 @@ module Anyway
         end
       end
 
-      def dup() ;  self.class.new(type, value.dup, source); end
+      def dup() ;  self.class.new(type, value.dup, **source); end
 
       def pretty_print(q)
         if trace?
@@ -140,7 +141,7 @@ module Anyway
 
       def current_trace() ;  trace_stack.last; end
 
-      alias tracing? current_trace
+      alias_method :tracing?, :current_trace
 
       def source_stack
         (Thread.current[:__anyway__trace_source_stack__] ||= [])
@@ -168,12 +169,11 @@ module Anyway
 
     def trace!(type, *path, **opts)
       return yield unless Tracing.tracing?
-      source = {type: type}.merge(opts)
       val = yield
       if val.is_a?(Hash)
-        Tracing.current_trace.merge_values(val, **source)
+        Tracing.current_trace.merge_values(val, type: type, **opts)
       else
-        Tracing.current_trace.record_value(val, *path, **source)
+        Tracing.current_trace.record_value(val, *path, type: type, **opts)
       end
       val
     end

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