runger_config 3.0.1 → 5.0.0

data/lib/runger/rails/loaders/secrets.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Runger::Rails::Loaders::Secrets < Runger::Loaders::Base
+  def call(name:, **_options)
+    return {} unless ::Rails.application.respond_to?(:secrets)
+
+    # Create a new hash cause secrets are mutable!
+    config = {}
+
+    trace!(:secrets) do
+      secrets.public_send(name)
+    end.then do |secrets|
+      ::Runger::Utils.deep_merge!(config, secrets) if secrets
+    end
+
+    config
+  end
+
+  private
+
+  def secrets
+    @secrets ||=
+      ::Rails.application.secrets.tap do |_|
+        # Reset secrets state if the app hasn't been initialized
+        # See https://github.com/palkan/runger_config/issues/14
+        next if ::Rails.application.initialized?
+
+        ::Rails.application.remove_instance_variable(:@secrets)
+      end
+  end
+end

data/lib/runger/rails/loaders/yaml.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Runger::Rails::Loaders::YAML < Runger::Loaders::YAML
+end

data/lib/runger/rails/loaders.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'runger/rails/loaders/credentials'
+require 'runger/rails/loaders/secrets'
+require 'runger/rails/loaders/yaml'

data/lib/runger/rails/settings.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Try to require zeitwerk
+begin
+  require 'active_support/dependencies/zeitwerk_integration'
+  require 'zeitwerk'
+rescue LoadError
+end
+
+class Runger::Settings
+  class << self
+    attr_reader :autoload_static_config_path, :autoloader
+    attr_writer :autoload_via_zeitwerk
+
+    def autoload_static_config_path=(val)
+      if autoload_via_zeitwerk
+        raise('Cannot setup autoloader after application has been initialized') if ::Rails.application.initialized?
+
+        return unless ::Rails.root.join(val).exist?
+
+        return if val == autoload_static_config_path
+
+        autoloader&.unload
+
+        @autoload_static_config_path = val
+
+        # See Rails 6 https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+        # and Rails 7 https://github.com/rails/rails/blob/5462fbd5de1900c1b1ce1c9dc11c1a2d8cdcd809/railties/lib/rails/autoloaders.rb#L15
+        @autoloader =
+          Zeitwerk::Loader.new.tap do |loader|
+            loader.tag = 'runger.config'
+
+            if defined?(ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector)
+              loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+            elsif defined?(::Rails::Autoloaders::Inflector)
+              loader.inflector = ::Rails::Autoloaders::Inflector
+            end
+            loader.push_dir(::Rails.root.join(val))
+            loader.setup
+          end
+      else
+        if autoload_static_config_path
+          old_path = ::Rails.root.join(autoload_static_config_path).to_s
+          ActiveSupport::Dependencies.autoload_paths.delete(old_path)
+          ::Rails.application.config.eager_load_paths.delete(old_path)
+        end
+
+        @autoload_static_config_path = val
+        new_path = ::Rails.root.join(val).to_s
+        ActiveSupport::Dependencies.autoload_paths << new_path
+        ::Rails.application.config.eager_load_paths << new_path
+      end
+    end
+
+    def cleanup_autoload_paths
+      return unless autoload_via_zeitwerk
+
+      return unless autoload_static_config_path
+
+      ActiveSupport::Dependencies.autoload_paths.delete(::Rails.root.join(autoload_static_config_path).to_s)
+    end
+
+    def autoload_via_zeitwerk
+      return @autoload_via_zeitwerk if instance_variable_defined?(:@autoload_via_zeitwerk)
+
+      @autoload_via_zeitwerk = defined?(::Zeitwerk)
+    end
+
+    def current_environment
+      @current_environment || ::Rails.env.to_s
+    end
+
+    def app_root
+      ::Rails.root
+    end
+  end
+
+  self.default_config_path = ->(name) { ::Rails.root.join('config', "#{name}.yml") }
+  self.known_environments = %w[test development production]
+  self.use_local_files ||= ::Rails.env.development?
+  # Don't try read defaults when no key defined
+  self.default_environmental_key = nil
+end

data/lib/runger/rails.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Runger::Rails
+end
+
+require 'runger/rails/config'
+require 'runger/rails/loaders'
+require 'runger/rails/settings'
+
+# Configure Rails loaders
+Runger.loaders.override(:yml, Runger::Rails::Loaders::YAML)
+
+if Rails::VERSION::MAJOR >= 7 && Rails::VERSION::MINOR >= 1
+  Runger.loaders.insert_after(:yml, :credentials, Runger::Rails::Loaders::Credentials)
+else
+  Runger.loaders.insert_after(:yml, :secrets, Runger::Rails::Loaders::Secrets)
+  Runger.loaders.insert_after(:secrets, :credentials, Runger::Rails::Loaders::Credentials)
+end
+
+# Load Railties after configuring loaders.
+# The application could be already initialized, and that would make `Runger.loaders` frozen
+require 'runger/railtie'

data/lib/{anyway → runger}/railtie.rb

@@ -1,28 +1,29 @@
 # frozen_string_literal: true
 
-module Anyway # :nodoc:
-  DEFAULT_CONFIGS_PATH = "config/configs"
+module Runger # :nodoc:
+  DEFAULT_CONFIGS_PATH = 'config/configs'
 
   class Railtie < ::Rails::Railtie # :nodoc:
     # Add settings to Rails config
-    config.anyway_config = Anyway::Settings
+    config.runger_config = Runger::Settings
 
     config.before_configuration do
       next if ::Rails.application.initialized?
-      config.anyway_config.autoload_static_config_path = DEFAULT_CONFIGS_PATH
+
+      config.runger_config.autoload_static_config_path = DEFAULT_CONFIGS_PATH
     end
 
     config.before_eager_load do
-      Anyway::Settings.autoloader&.eager_load
+      Runger::Settings.autoloader&.eager_load
     end
 
     # Remove `autoload_static_config_path` from Rails `autoload_paths`
     # since we use our own autoloading mechanism
-    initializer "anyway_config.cleanup_autoload" do
-      Anyway::Settings.cleanup_autoload_paths
+    initializer 'runger_config.cleanup_autoload' do
+      Runger::Settings.cleanup_autoload_paths
     end
 
     # Make sure loaders are not changed in runtime
-    config.after_initialize { Anyway.loaders.freeze }
+    config.after_initialize { Runger.loaders.freeze }
   end
 end

data/lib/{anyway → runger}/rbs.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-module Anyway
+module Runger
   module RBSGenerator
     TYPE_TO_CLASS = {
-      string: "String",
-      integer: "Integer",
-      float: "Float",
-      date: "Date",
-      datetime: "DateTime",
-      uri: "URI",
-      boolean: "bool"
+      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("::")
+      *namespace, class_name = name.split('::')
 
       buf = []
       indent = 0
-      interface_name = "_Config"
+      interface_name = '_Config'
 
       if namespace.empty?
         interface_name = "_#{class_name}"
       else
-        buf << "module #{namespace.join("::")}"
+        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}"
+      buf << "#{'  ' * indent}interface #{interface_name}"
       indent += 1
 
       # Generating setters and getters for config attributes
@@ -39,17 +39,17 @@ module Anyway
         type =
           case type
           in NilClass
-            "untyped"
+            'untyped'
           in Symbol
-            TYPE_TO_CLASS.fetch(type) { defaults[param] ? "Symbol" : "untyped" }
+            TYPE_TO_CLASS.fetch(type) { defaults[param] ? 'Symbol' : 'untyped' }
           in Array
-            "Array[untyped]"
+            'Array[untyped]'
           in array: _, type:, **nil
-            "Array[#{TYPE_TO_CLASS.fetch(type, "untyped")}]"
+            "Array[#{TYPE_TO_CLASS.fetch(type, 'untyped')}]"
           in Hash
-            "Hash[string,untyped]"
+            'Hash[string,untyped]'
           in TrueClass | FalseClass
-            "bool"
+            'bool'
           else
             type.class.to_s
           end
@@ -57,36 +57,36 @@ module Anyway
         getter_type = type
         getter_type = "#{type}?" unless required_attributes.include?(param)
 
-        buf << "#{"  " * indent}def #{param}: () -> #{getter_type}"
-        buf << "#{"  " * indent}def #{param}=: (#{type}) -> void"
+        buf << "#{'  ' * indent}def #{param}: () -> #{getter_type}"
+        buf << "#{'  ' * indent}def #{param}=: (#{type}) -> void"
 
-        if type == "bool" || type == "bool?"
-          buf << "#{"  " * indent}def #{param}?: () -> #{getter_type}"
+        if ['bool', 'bool?'].include?(type)
+          buf << "#{'  ' * indent}def #{param}?: () -> #{getter_type}"
         end
       end
 
       indent -= 1
-      buf << "#{"  " * indent}end"
+      buf << "#{'  ' * indent}end"
 
-      buf << ""
+      buf << ''
 
-      buf << "#{"  " * indent}class #{class_name} < #{superclass.name}"
+      buf << "#{'  ' * indent}class #{class_name} < #{superclass.name}"
       indent += 1
 
-      buf << "#{"  " * indent}include #{interface_name}"
+      buf << "#{'  ' * indent}include #{interface_name}"
 
       indent -= 1
-      buf << "#{"  " * indent}end"
+      buf << "#{'  ' * indent}end"
 
       unless namespace.empty?
-        buf << "end"
+        buf << 'end'
       end
 
-      buf << ""
+      buf << ''
 
       buf.join("\n")
     end
   end
 
-  Config.extend RBSGenerator
+  Config.extend(RBSGenerator)
 end

data/lib/runger/settings.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+# Use Settings name to not confuse with Config.
+#
+# Settings contain the library-wide configuration.
+class Runger::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 { store[_1] = self.class.settings[_1] }
+    end
+
+    setting :unwrap_known_environments, true
+
+    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,
+      :current_environment,
+      :default_environmental_key,
+      :known_environments
+
+    # 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
+
+    def app_root
+      Pathname.new(Dir.pwd)
+    end
+
+    def default_environmental_key?
+      !default_environmental_key.nil?
+    end
+
+    def matching_env?(env)
+      return true if env.nil? || env.to_s == current_environment
+
+      if env.is_a?(::Hash)
+        envs = env[:except]
+        excluded_envs = [envs].flat_map(&:to_s)
+        excluded_envs.none?(current_environment)
+      elsif env.is_a?(::Array)
+        env.flat_map(&:to_s).include?(current_environment)
+      else
+        false
+      end
+    end
+  end
+
+  # By default, use RUNGER_ENV
+  self.current_environment = ENV.fetch('RUNGER_ENV', nil)
+
+  # By default, use local files only in development (that's the purpose if the local files)
+  self.use_local_files = (ENV['RUNGER_ENV'] == 'development' || ENV['RACK_ENV'] == 'development' || ENV['RAILS_ENV'] == 'development' || (defined?(Rails) && 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

data/lib/runger/testing/helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Runger::Testing::Helpers
+  # Sets the ENV variables to the provided
+  # values and restore outside the block
+  #
+  # Also resets Runger.env before and after calling the block
+  # to make sure that the values are not cached.
+  #
+  # NOTE: to remove the env value, pass `nil` as the value
+  def with_env(data)
+    was_values = []
+
+    data.each do |key, val|
+      was_values << [key, ENV.fetch(key, nil)]
+      next ENV.delete(key) if val.nil?
+
+      ENV[key] = val
+    end
+
+    # clear cached env values
+    Runger.env.clear
+    yield
+  ensure
+    was_values.each do |(key, val)|
+      next ENV.delete(key) if val.nil?
+
+      ENV[key] = val
+    end
+
+    # clear cache again
+    Runger.env.clear
+  end
+end

data/lib/{anyway → runger}/testing.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require "anyway/testing/helpers"
+require 'runger/testing/helpers'
 
 if defined?(RSpec::Core) && RSpec.respond_to?(:configure)
   RSpec.configure do |config|
     config.include(
-      Anyway::Testing::Helpers,
+      Runger::Testing::Helpers,
       type: :config,
-      file_path: %r{spec/configs}
+      file_path: %r{spec/configs},
     )
   end
 end

data/lib/runger/tracing.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+# Provides method to trace values association
+module Runger::Tracing
+  using Runger::Ext::DeepDup
+
+  using(Module.new do
+    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, **options)
+      key = path.pop
+      trace =
+        if val.is_a?(Hash)
+          Trace.new.tap { _1.merge_values(val, **options) }
+        else
+          Trace.new(:value, val, **options)
+        end
+
+      target_trace = path.empty? ? self : value.dig(*path)
+      target_trace.record_key(key.to_s, trace)
+
+      val
+    end
+
+    def merge_values(hash, **options)
+      return hash unless hash
+
+      hash.each do |key, val|
+        if val.is_a?(Hash)
+          value[key.to_s].merge_values(val, **options)
+        else
+          value[key.to_s] = Trace.new(:value, val, **options)
+        end
+      end
+
+      hash
+    end
+
+    def record_key(key, key_trace)
+      @value = Hash.new { |h, k| h[k] = Trace.new(:trace) } unless value.is_a?(::Hash)
+
+      value[key] = key_trace
+    end
+
+    def merge!(another_trace)
+      unless trace?
+        raise(ArgumentError,
+          "You can only merge into a :trace type, and this is :#{type}")
+      end
+      unless another_trace.trace?
+        raise(ArgumentError,
+          "You can only merge a :trace type, but trying :#{type}")
+      end
+
+      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:, 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 ' =>'
+              if v.trace?
+                q.text ' { '
+                q.pp(v)
+                q.breakable(' ')
+                q.text '}'
+              else
+                q.breakable(' ')
+                q.pp(v)
+              end
+            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 ::Runger::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[:__runger__trace_stack__] ||= [])
+    end
+
+    def current_trace = trace_stack.last
+
+    alias tracing? current_trace
+
+    def source_stack
+      (Thread.current[:__runger__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, **options)
+    return yield unless ::Runger::Tracing.tracing?
+
+    val = yield
+    if val.is_a?(Hash)
+      ::Runger::Tracing.current_trace.merge_values(val, type:, **options)
+    elsif !path.empty?
+      ::Runger::Tracing.current_trace.record_value(val, *path, type:, **options)
+    end
+    val
+  end
+end