anyway_config 2.0.2 → 2.1.0

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Adds ability to generate anonymous (class-less) config dynamicly
+  # (like Rails.application.config_for but using more data sources).
+  module DynamicConfig
+    module ClassMethods
+      # Load config as Hash by any name
+      #
+      # Example:
+      #
+      #   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)
+        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: name, **options)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Parses environment variables and provides
+  # method-like access
+  class Env
+    using RubyNext
+    using Anyway::Ext::DeepDup
+    using Anyway::Ext::Hash
+
+    include Tracing
+
+    attr_reader :data, :traces, :type_cast
+
+    def initialize(type_cast: AutoCast)
+      @type_cast = type_cast
+      @data = {}
+      @traces = {}
+    end
+
+    def clear
+      data.clear
+      traces.clear
+    end
+
+    def fetch(prefix)
+      return data[prefix].deep_dup if data.key?(prefix)
+
+      Tracing.capture do
+        data[prefix] = parse_env(prefix)
+      end.then do |trace|
+        traces[prefix] = trace
+      end
+
+      data[prefix].deep_dup
+    end
+
+    def fetch_with_trace(prefix)
+      [fetch(prefix), traces[prefix]]
+    end
+
+    private
+
+    def parse_env(prefix)
+      match_prefix = "#{prefix}_"
+      ENV.each_pair.with_object({}) do |(key, val), data|
+        next unless key.start_with?(match_prefix)
+
+        path = key.sub(/^#{prefix}_/, "").downcase
+
+        paths = path.split("__")
+        trace!(:env, *paths, key: key) { data.bury(type_cast.call(val), *paths) }
+      end
+    end
+  end
+end

data/lib/.rbnext/1995.next/anyway/loaders/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Loaders
+    class Base
+      include Tracing
+
+      class << self
+        def call(local: Anyway::Settings.use_local_files, **opts)
+          new(local: local).call(**opts)
+        end
+      end
+
+      def initialize(local:)
+        @local = local
+      end
+
+      def use_local?() = @local == true
+    end
+  end
+end

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
+        if val.is_a?(Hash)
+          Trace.new.tap { _1.merge_values(val, **opts) }
+        else
+          Trace.new(:value, val, **opts)
+        end => trace
+
+        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/config.rb

@@ -11,9 +11,7 @@ module Anyway # :nodoc:
 
   using(Module.new do
     refine Object do
-      def vm_object_id
-        (object_id << 1).to_s(16)
-      end
+      def vm_object_id() ;  (object_id << 1).to_s(16); end
     end
   end)
 
@@ -21,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)
@@ -42,12 +40,14 @@ module Anyway # :nodoc:
       raise_validation_error
       reload
       resolve_config_path
+      tap
       to_h
       to_source_trace
       write_config_attr
     ].freeze
 
     class Error < StandardError; end
+
     class ValidationError < Error; end
 
     include OptparseConfig
@@ -72,9 +72,7 @@ module Anyway # :nodoc:
         @name = name
       end
 
-      def apply_to(config)
-        config.send(name)
-      end
+      def apply_to(config) ;  config.send(name); end
     end
 
     class << self
@@ -110,23 +108,21 @@ module Anyway # :nodoc:
       def defaults
         return @defaults if instance_variable_defined?(:@defaults)
 
-        @defaults =
-          if superclass < Anyway::Config
-            superclass.defaults.deep_dup
-          else
-            new_empty_config
-          end
+        @defaults = if superclass < Anyway::Config
+          superclass.defaults.deep_dup
+        else
+          new_empty_config
+        end
       end
 
       def config_attributes
         return @config_attributes if instance_variable_defined?(:@config_attributes)
 
-        @config_attributes =
-          if superclass < Anyway::Config
-            superclass.config_attributes.dup
-          else
-            []
-          end
+        @config_attributes = if superclass < Anyway::Config
+          superclass.config_attributes.dup
+        else
+          []
+        end
       end
 
       def required(*names)
@@ -140,18 +136,17 @@ module Anyway # :nodoc:
       def required_attributes
         return @required_attributes if instance_variable_defined?(:@required_attributes)
 
-        @required_attributes =
-          if superclass < Anyway::Config
-            superclass.required_attributes.dup
-          else
-            []
-          end
+        @required_attributes = if superclass < Anyway::Config
+          superclass.required_attributes.dup
+        else
+          []
+        end
       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) })
@@ -161,12 +156,11 @@ module Anyway # :nodoc:
       def load_callbacks
         return @load_callbacks if instance_variable_defined?(:@load_callbacks)
 
-        @load_callbacks =
-          if superclass <= Anyway::Config
-            superclass.load_callbacks.dup
-          else
-            []
-          end
+        @load_callbacks = if superclass <= Anyway::Config
+          superclass.load_callbacks.dup
+        else
+          []
+        end
       end
 
       def config_name(val = nil)
@@ -186,26 +180,21 @@ module Anyway # :nodoc:
           end
       end
 
-      def explicit_config_name?
-        !explicit_config_name.nil?
-      end
+      def explicit_config_name?() ;  !explicit_config_name.nil?; end
 
       def env_prefix(val = nil)
         return (@env_prefix = val.to_s.upcase) unless val.nil?
 
         return @env_prefix if instance_variable_defined?(:@env_prefix)
 
-        @env_prefix =
-          if superclass < Anyway::Config && superclass.explicit_config_name?
-            superclass.env_prefix
-          else
-            config_name.upcase
-          end
+        @env_prefix = if superclass < Anyway::Config && superclass.explicit_config_name?
+          superclass.env_prefix
+        else
+          config_name.upcase
+        end
       end
 
-      def new_empty_config
-        {}
-      end
+      def new_empty_config() ;  {}; end
 
       private
 
@@ -213,9 +202,8 @@ module Anyway # :nodoc:
         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}
@@ -242,7 +230,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
@@ -301,17 +289,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
 
@@ -334,18 +319,14 @@ 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
 
-    def dig(*keys)
-      values.dig(*keys)
-    end
+    def dig(*keys) ;  values.dig(*keys); end
 
-    def to_h
-      values.deep_dup.deep_freeze
-    end
+    def to_h() ;  values.deep_dup.deep_freeze; end
 
     def dup
       self.class.allocate.tap do |new_config|
@@ -360,13 +341,9 @@ module Anyway # :nodoc:
       Anyway.env.fetch(env_prefix).delete("conf") || Settings.default_config_path.call(name)
     end
 
-    def deconstruct_keys(keys)
-      values.deconstruct_keys(keys)
-    end
+    def deconstruct_keys(keys) ;  values.deconstruct_keys(keys); end
 
-    def to_source_trace
-      __trace__&.to_h
-    end
+    def to_source_trace() ;  __trace__&.to_h; end
 
     def inspect
       "#<#{self.class}:0x#{vm_object_id.rjust(16, "0")} config_name=\"#{config_name}\" env_prefix=\"#{env_prefix}\" " \