anyway_config 2.0.1 → 2.0.6

data/lib/.rbnext/2.8/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/2.8/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/2.8/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
+    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; 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 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)
 
@@ -72,9 +70,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 +106,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
+        if superclass < Anyway::Config
+          superclass.defaults.deep_dup
+        else
+          new_empty_config
+        end => @defaults
       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
+        if superclass < Anyway::Config
+          superclass.config_attributes.dup
+        else
+          []
+        end => @config_attributes
       end
 
       def required(*names)
@@ -140,12 +134,11 @@ 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
+        if superclass < Anyway::Config
+          superclass.required_attributes.dup
+        else
+          []
+        end => @required_attributes
       end
 
       def on_load(*names, &block)
@@ -161,12 +154,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
+        if superclass <= Anyway::Config
+          superclass.load_callbacks.dup
+        else
+          []
+        end => @load_callbacks
       end
 
       def config_name(val = nil)
@@ -186,26 +178,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
+        if superclass < Anyway::Config && superclass.explicit_config_name?
+          superclass.env_prefix
+        else
+          config_name.upcase
+        end => @env_prefix
       end
 
-      def new_empty_config
-        {}
-      end
+      def new_empty_config() = {}
 
       private
 
@@ -213,7 +200,7 @@ 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)
+              __trace__&.record_value(val, \"#{name}\", **Tracing.current_trace_source)
               # DEPRECATED: instance variable set will be removed in 2.1
               @#{name} = values[:#{name}] = val
             end
@@ -228,9 +215,9 @@ module Anyway # :nodoc:
       def accessors_module
         return @accessors_module if instance_variable_defined?(:@accessors_module)
 
-        @accessors_module = Module.new.tap do |mod|
+        Module.new.tap do |mod|
           include mod
-        end
+        end => @accessors_module
       end
 
       def build_config_name
@@ -298,7 +285,7 @@ module Anyway # :nodoc:
     def load(overrides = nil)
       base_config = self.class.defaults.deep_dup
 
-      trace = Tracing.capture do
+      Tracing.capture do
         Tracing.trace!(:defaults) { base_config }
 
         load_from_sources(
@@ -313,7 +300,7 @@ module Anyway # :nodoc:
 
           base_config.deep_merge!(overrides)
         end
-      end
+      end => trace
 
       base_config.each do |key, val|
         write_config_attr(key.to_sym, val)
@@ -339,13 +326,9 @@ module Anyway # :nodoc:
       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 +343,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}\" " \