anyway_config 2.0.2 → 2.1.0

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Anyway
+  using RubyNext
+
+  module Loaders
+    class Registry
+      attr_reader :registry
+
+      def initialize
+        @registry = []
+      end
+
+      def prepend(id, handler = nil, &block)
+        handler ||= block
+        insert_at(0, id, handler)
+      end
+
+      def append(id, handler = nil, &block)
+        handler ||= block
+        insert_at(registry.size, id, handler)
+      end
+
+      def insert_before(another_id, id, handler = nil, &block)
+        ind = registry.find_index { |(hid, _)| hid == another_id }
+        raise ArgumentError, "Loader with ID #{another_id} hasn't been registered" if ind.nil?
+
+        handler ||= block
+        insert_at(ind, id, handler)
+      end
+
+      def insert_after(another_id, id, handler = nil, &block)
+        ind = registry.find_index { |(hid, _)| hid == another_id }
+        raise ArgumentError, "Loader with ID #{another_id} hasn't been registered" if ind.nil?
+
+        handler ||= block
+        insert_at(ind + 1, id, handler)
+      end
+
+      def override(id, handler)
+        find(id).then do |id_to_handler|
+          raise ArgumentError, "Loader with ID #{id} hasn't been registered" if id_to_handler.nil?
+          id_to_handler[1] = handler
+        end
+      end
+
+      def delete(id)
+        find(id).then do |id_to_handler|
+          raise ArgumentError, "Loader with ID #{id} hasn't been registered" if id_to_handler.nil?
+          registry.delete id_to_handler
+        end
+      end
+
+      def each(&block)
+        registry.each(&block)
+      end
+
+      def freeze() ;  registry.freeze; end
+
+      private
+
+      def insert_at(index, id, handler)
+        raise ArgumentError, "Loader with ID #{id} has been already registered" unless find(id).nil?
+
+        registry.insert(index, [id, handler])
+      end
+
+      def find(id)
+        registry.find { |(hid, _)| hid == id }
+      end
+    end
+  end
+end
+
+require "anyway/loaders/base"
+require "anyway/loaders/yaml"
+require "anyway/loaders/env"

data/lib/.rbnext/3.0/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
+end

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

@@ -0,0 +1,183 @@
+# 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
+    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
+        (__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))
+
+        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; end
+
+      def trace?() ;  type == :trace; end
+
+      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); end
+
+      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; end
+
+      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/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)
 
@@ -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
 
     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 { 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?
 
       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() = {}
 
       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:, 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)
 
-    def to_h
-      values.deep_dup.deep_freeze
-    end
+    def to_h() = values.deep_dup.deep_freeze
 
     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)
 
-    def to_source_trace
-      __trace__&.to_h
-    end
+    def to_source_trace() = __trace__&.to_h
 
     def inspect
       "#<#{self.class}:0x#{vm_object_id.rjust(16, "0")} config_name=\"#{config_name}\" env_prefix=\"#{env_prefix}\" " \