anyway_config 2.0.5 → 2.2.1

data/lib/.rbnext/1995.next/anyway/tracing.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Provides method to trace values association
+  module Tracing
+    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)
+
+    class Trace
+      UNDEF = Object.new
+
+      attr_reader :type, :value, :source
+
+      def initialize(type = :trace, value = UNDEF, **source)
+        @type = type
+        @source = source
+        @value = value == UNDEF ? Hash.new { |h, k| h[k] = Trace.new(:trace) } : value
+      end
+
+      def dig(...)
+        value.dig(...)
+      end
+
+      def record_value(val, *path, **opts)
+        key = path.pop
+        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
+
+        val
+      end
+
+      def merge_values(hash, **opts)
+        return hash unless hash
+
+        hash.each do |key, val|
+          if val.is_a?(Hash)
+            value[key.to_s].merge_values(val, **opts)
+          else
+            value[key.to_s] = Trace.new(:value, val, **opts)
+          end
+        end
+
+        hash
+      end
+
+      def merge!(another_trace)
+        raise ArgumentError, "You can only merge into a :trace type, and this is :#{type}" unless trace?
+        raise ArgumentError, "You can only merge a :trace type, but trying :#{type}" unless another_trace.trace?
+
+        another_trace.value.each do |key, sub_trace|
+          if sub_trace.trace?
+            value[key].merge! sub_trace
+          else
+            value[key] = sub_trace
+          end
+        end
+      end
+
+      def keep_if(...)
+        raise ArgumentError, "You can only filter :trace type, and this is :#{type}" unless trace?
+        value.keep_if(...)
+      end
+
+      def clear() = value.clear
+
+      def trace?() = type == :trace
+
+      def to_h
+        if trace?
+          value.transform_values(&:to_h).tap { _1.default_proc = nil }
+        else
+          {value: value, source: source}
+        end
+      end
+
+      def dup() = self.class.new(type, value.dup, **source)
+
+      def pretty_print(q)
+        if trace?
+          q.nest(2) do
+            q.breakable ""
+            q.seplist(value, nil, :each) do |k, v|
+              q.group do
+                q.text k
+                q.text " =>"
+                q.breakable " " unless v.trace?
+                q.pp v
+              end
+            end
+          end
+        else
+          q.pp value
+          q.group(0, " (", ")") do
+            q.seplist(source, lambda { q.breakable " " }, :each) do |k, v|
+              q.group do
+                q.text k.to_s
+                q.text "="
+                q.text v.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class << self
+      def capture
+        unless Settings.tracing_enabled
+          yield
+          return
+        end
+
+        trace = Trace.new
+        trace_stack.push trace
+        yield
+        trace_stack.last
+      ensure
+        trace_stack.pop
+      end
+
+      def trace_stack
+        (Thread.current[:__anyway__trace_stack__] ||= [])
+      end
+
+      def current_trace() = trace_stack.last
+
+      alias_method :tracing?, :current_trace
+
+      def source_stack
+        (Thread.current[:__anyway__trace_source_stack__] ||= [])
+      end
+
+      def current_trace_source
+        source_stack.last || accessor_source(caller_locations(2, 1).first)
+      end
+
+      def with_trace_source(src)
+        source_stack << src
+        yield
+      ensure
+        source_stack.pop
+      end
+
+      private
+
+      def accessor_source(location)
+        {type: :accessor, called_from: location.path_lineno}
+      end
+    end
+
+    module_function
+
+    def trace!(type, *path, **opts)
+      return yield unless Tracing.tracing?
+      val = yield
+      if val.is_a?(Hash)
+        Tracing.current_trace.merge_values(val, type: type, **opts)
+      else
+        Tracing.current_trace.record_value(val, *path, type: type, **opts)
+      end
+      val
+    end
+  end
+end

data/lib/.rbnext/2.7/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 { |_1| 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 { |_1| call(_1) }
+        when ARRAY_RXP
+          val.split(/\s*,\s*/).map { |_1| 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.7/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 { |_1| 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.7/anyway/rails/loaders/yaml.rb

@@ -0,0 +1,30 @@
+# 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)
+
+          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? { |_1| parsed_yml.key?(_1) }
+        end
+
+        def relative_config_path(path)
+          Pathname.new(path).relative_path_from(::Rails.root)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+using RubyNext;
+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; when ((__m__ = type)) && false 
+          when (NilClass === __m__)
+            "untyped"
+          when (Symbol === __m__)
+            TYPE_TO_CLASS.fetch(type) { defaults[param] ? "Symbol" : "untyped" }
+          when (Array === __m__)
+            "Array[untyped]"
+          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?))))
+            "Array[#{TYPE_TO_CLASS.fetch(type, "untyped")}]"
+          when (Hash === __m__)
+            "Hash[string,untyped]"
+          when ((TrueClass === __m__) || (FalseClass === __m__))
+            "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/.rbnext/2.7/anyway/settings.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Use Settings name to not confuse with Config.
+  #
+  # 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 { |_1| 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
+
+      # 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)
+    self.use_local_files = (ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development")
+
+    # By default, consider configs are stored in the ./config folder
+    self.default_config_path = ->(name) { "./config/#{name}.yml" }
+
+    # Tracing is enabled by default
+    self.tracing_enabled = true
+  end
+end

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

@@ -32,7 +32,8 @@ module Anyway
         value.dig(*__rest__, &__block__)
       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| _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