runger_config 4.0.0 → 5.0.0

data/lib/runger/settings.rb

@@ -1,111 +1,109 @@
 # frozen_string_literal: true
 
-require "pathname"
-
-module Runger
-  # 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
+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
 
-        def settings
-          @settings ||= {}
+        define_method(name) do
+          store[name]
         end
-      end
 
-      def initialize
-        @store = {}
+        define_method(:"#{name}=") do |val|
+          store[name] = val
+        end
       end
 
-      def use(*names)
-        store.clear
-        names.each { store[_1] = self.class.settings[_1] }
+      def settings
+        @settings ||= {}
       end
+    end
 
-      setting :unwrap_known_environments, true
-
-      private
+    def initialize
+      @store = {}
+    end
 
-      attr_reader :store
+    def use(*names)
+      store.clear
+      names.each { store[_1] = self.class.settings[_1] }
     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
+    setting :unwrap_known_environments, true
 
-        val = val.to_s
+    private
 
-        @default_config_path = ->(name) { File.join(val, "#{name}.yml") }
+    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
 
-      # Enable source tracing
-      attr_accessor :tracing_enabled
+      val = val.to_s
 
-      def future
-        @future ||= Future.new
-      end
+      @default_config_path = ->(name) { File.join(val, "#{name}.yml") }
+    end
 
-      def app_root
-        Pathname.new(Dir.pwd)
-      end
+    # Enable source tracing
+    attr_accessor :tracing_enabled
 
-      def default_environmental_key?
-        !default_environmental_key.nil?
-      end
+    def future
+      @future ||= Future.new
+    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
+    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["RUNGER_ENV"]
+  # 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, 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" }
+  # 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
+  # Tracing is enabled by default
+  self.tracing_enabled = true
 end

data/lib/runger/testing/helpers.rb

@@ -1,36 +1,34 @@
 # frozen_string_literal: true
 
-module Runger
-  module Testing
-    module 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 = []
+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[key]]
-          next ENV.delete(key) if val.nil?
-          ENV[key] = val
-        end
+    data.each do |key, val|
+      was_values << [key, ENV.fetch(key, nil)]
+      next ENV.delete(key) if val.nil?
 
-        # 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
+      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?
 
-        # clear cache again
-        Runger.env.clear
-      end
+      ENV[key] = val
     end
+
+    # clear cache again
+    Runger.env.clear
   end
 end

data/lib/runger/testing.rb

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

data/lib/runger/tracing.rb

@@ -1,188 +1,195 @@
 # frozen_string_literal: true
 
-module Runger
-  # Provides method to trace values association
-  module Tracing
-    using Runger::Ext::DeepDup
-
-    using(Module.new do
-      refine Thread::Backtrace::Location do
-        def path_lineno = "#{path}:#{lineno}"
-      end
-    end)
+# Provides method to trace values association
+module Runger::Tracing
+  using Runger::Ext::DeepDup
 
-    class Trace
-      UNDEF = Object.new
+  using(Module.new do
+    refine Thread::Backtrace::Location do
+      def path_lineno = "#{path}:#{lineno}"
+    end
+  end)
 
-      attr_reader :type, :value, :source
+  class Trace
+    UNDEF = Object.new
 
-      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
+    attr_reader :type, :value, :source
 
-      def dig(...)
-        value.dig(...)
-      end
+    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, **)
-        key = path.pop
-        trace = if val.is_a?(Hash)
-          Trace.new.tap { _1.merge_values(val, **) }
+    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, **)
+          Trace.new(:value, val, **options)
         end
 
-        target_trace = path.empty? ? self : value.dig(*path)
-        target_trace.record_key(key.to_s, trace)
+      target_trace = path.empty? ? self : value.dig(*path)
+      target_trace.record_key(key.to_s, trace)
 
-        val
-      end
+      val
+    end
 
-      def merge_values(hash, **)
-        return hash unless hash
+    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, **)
-          else
-            value[key.to_s] = Trace.new(:value, val, **)
-          end
+      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
-
-        hash
       end
 
-      def record_key(key, key_trace)
-        @value = Hash.new { |h, k| h[k] = Trace.new(:trace) } unless value.is_a?(::Hash)
+      hash
+    end
 
-        value[key] = key_trace
-      end
+    def record_key(key, key_trace)
+      @value = Hash.new { |h, k| h[k] = Trace.new(:trace) } unless value.is_a?(::Hash)
 
-      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?
+      value[key] = key_trace
+    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
+    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
 
-      def keep_if(...)
-        raise ArgumentError, "You can only filter :trace type, and this is :#{type}" unless trace?
-        value.keep_if(...)
+      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 clear = value.clear
+    def keep_if(...)
+      raise(ArgumentError, "You can only filter :trace type, and this is :#{type}") unless trace?
 
-      def trace? = type == :trace
+      value.keep_if(...)
+    end
 
-      def to_h
-        if trace?
-          value.transform_values(&:to_h).tap { _1.default_proc = nil }
-        else
-          {value:, source:}
-        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
+    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
-        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
+      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
+  class << self
+    def capture
+      unless ::Runger::Settings.tracing_enabled
         yield
-        trace_stack.last
-      ensure
-        trace_stack.pop
+        return
       end
 
-      def trace_stack
-        (Thread.current[:__runger__trace_stack__] ||= [])
-      end
+      trace = Trace.new
+      trace_stack.push(trace)
+      yield
+      trace_stack.last
+    ensure
+      trace_stack.pop
+    end
 
-      def current_trace = trace_stack.last
+    def trace_stack
+      (Thread.current[:__runger__trace_stack__] ||= [])
+    end
 
-      alias_method :tracing?, :current_trace
+    def current_trace = trace_stack.last
 
-      def source_stack
-        (Thread.current[:__runger__trace_source_stack__] ||= [])
-      end
+    alias tracing? current_trace
 
-      def current_trace_source
-        source_stack.last || accessor_source(caller_locations(2, 1).first)
-      end
+    def source_stack
+      (Thread.current[:__runger__trace_source_stack__] ||= [])
+    end
 
-      def with_trace_source(src)
-        source_stack << src
-        yield
-      ensure
-        source_stack.pop
-      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
+    private
 
-      def accessor_source(location)
-        {type: :accessor, called_from: location.path_lineno}
-      end
+    def accessor_source(location)
+      { type: :accessor, called_from: location.path_lineno }
     end
+  end
 
-    module_function
+  module_function
 
-    def trace!(type, *path, **)
-      return yield unless Tracing.tracing?
-      val = yield
-      if val.is_a?(Hash)
-        Tracing.current_trace.merge_values(val, type:, **)
-      elsif !path.empty?
-        Tracing.current_trace.record_value(val, *path, type:, **)
-      end
-      val
+  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