runger_config 4.0.0 → 5.0.0

data/lib/runger/dynamic_config.rb

@@ -1,31 +1,29 @@
 # frozen_string_literal: true
 
-module Runger
-  # 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 = Runger::Config.for(:my_app)
-      #   # will load data from config/my_app.yml, secrets.my_app, ENV["MY_APP_*"]
-      #
-      def for(name, auto_cast: true, **options)
-        config = allocate
-        options[:env_prefix] ||= name.to_s.upcase
-        options[:config_path] ||= config.resolve_config_path(name, options[:env_prefix])
+# Adds ability to generate anonymous (class-less) config dynamicly
+# (like Rails.application.config_for but using more data sources).
+module Runger::DynamicConfig
+  module ClassMethods
+    # Load config as Hash by any name
+    #
+    # Example:
+    #
+    #   my_config = Runger::Config.for(:my_app)
+    #   # will load data from config/my_app.yml, secrets.my_app, ENV["MY_APP_*"]
+    #
+    def for(name, auto_cast: true, **options)
+      config = allocate
+      options[:env_prefix] ||= name.to_s.upcase
+      options[:config_path] ||= config.resolve_config_path(name, options[:env_prefix])
 
-        raw_config = config.load_from_sources(new_empty_config, name:, **options)
-        return raw_config unless auto_cast
+      raw_config = config.load_from_sources(new_empty_config, name:, **options)
+      return raw_config unless auto_cast
 
-        AutoCast.call(raw_config)
-      end
+      ::Runger::AutoCast.call(raw_config)
     end
+  end
 
-    def self.included(base)
-      base.extend ClassMethods
-    end
+  def self.included(base)
+    base.extend(ClassMethods)
   end
 end

data/lib/runger/ejson_parser.rb

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
-require "open3"
-require "runger/ext/hash"
+require 'open3'
+require 'runger/ext/hash'
 
 using Runger::Ext::Hash
 
-module Runger
-  class EJSONParser
-    attr_reader :bin_path
+class Runger::EJSONParser
+  attr_reader :bin_path
 
-    def initialize(bin_path = "ejson")
-      @bin_path = bin_path
-    end
+  def initialize(bin_path = 'ejson')
+    @bin_path = bin_path
+  end
 
-    def call(file_path)
-      return unless File.exist?(file_path)
+  def call(file_path)
+    return unless File.exist?(file_path)
 
-      raw_content = nil
+    raw_content = nil
 
-      stdout, stderr, status = Open3.capture3("#{bin_path} decrypt #{file_path}")
+    stdout, stderr, status = Open3.capture3("#{bin_path} decrypt #{file_path}")
 
-      if status.success?
-        raw_content = JSON.parse(stdout.chomp)
-      else
-        Kernel.warn "Failed to decrypt #{file_path}: #{stderr}"
-      end
+    if status.success?
+      raw_content = JSON.parse(stdout.chomp)
+    else
+      Kernel.warn("Failed to decrypt #{file_path}: #{stderr}")
+    end
 
-      return unless raw_content
+    return unless raw_content
 
-      raw_content.deep_transform_keys do |key|
-        if key[0] == "_"
-          key[1..]
-        else
-          key
-        end
+    raw_content.deep_transform_keys do |key|
+      if key[0] == '_'
+        # rubocop:disable Performance/ArraySemiInfiniteRangeSlice
+        key[1..]
+        # rubocop:enable Performance/ArraySemiInfiniteRangeSlice
+      else
+        key
       end
     end
   end

data/lib/runger/env.rb

@@ -1,72 +1,70 @@
 # frozen_string_literal: true
 
-module Runger
-  # Parses environment variables and provides
-  # method-like access
-  class Env
-    using Runger::Ext::DeepDup
-    using Runger::Ext::Hash
-
-    class << self
-      def from_hash(hash, prefix: nil, memo: {})
-        hash.each do |key, value|
-          prefix_with_key = (prefix && !prefix.empty?) ? "#{prefix}_#{key.to_s.upcase}" : key.to_s.upcase
-
-          if value.is_a?(Hash)
-            from_hash(value, prefix: "#{prefix_with_key}_", memo:)
-          else
-            memo[prefix_with_key] = value.to_s
-          end
+# Parses environment variables and provides
+# method-like access
+class Runger::Env
+  using Runger::Ext::DeepDup
+  using Runger::Ext::Hash
+
+  class << self
+    def from_hash(hash, prefix: nil, memo: {})
+      hash.each do |key, value|
+        prefix_with_key = (prefix && !prefix.empty?) ? "#{prefix}_#{key.to_s.upcase}" : key.to_s.upcase
+
+        if value.is_a?(Hash)
+          from_hash(value, prefix: "#{prefix_with_key}_", memo:)
+        else
+          memo[prefix_with_key] = value.to_s
         end
-
-        memo
       end
+
+      memo
     end
+  end
 
-    include Tracing
+  include ::Runger::Tracing
 
-    attr_reader :data, :traces, :type_cast, :env_container
+  attr_reader :data, :traces, :type_cast, :env_container
 
-    def initialize(type_cast: AutoCast, env_container: ENV)
-      @type_cast = type_cast
-      @data = {}
-      @traces = {}
-      @env_container = env_container
-    end
-
-    def clear
-      data.clear
-      traces.clear
-    end
+  def initialize(type_cast: ::Runger::AutoCast, env_container: ENV)
+    @type_cast = type_cast
+    @data = {}
+    @traces = {}
+    @env_container = env_container
+  end
 
-    def fetch(prefix)
-      return data[prefix].deep_dup if data.key?(prefix)
+  def clear
+    data.clear
+    traces.clear
+  end
 
-      Tracing.capture do
-        data[prefix] = parse_env(prefix)
-      end.then do |trace|
-        traces[prefix] = trace
-      end
+  def fetch(prefix)
+    return data[prefix].deep_dup if data.key?(prefix)
 
-      data[prefix].deep_dup
+    ::Runger::Tracing.capture do
+      data[prefix] = parse_env(prefix)
+    end.then do |trace|
+      traces[prefix] = trace
     end
 
-    def fetch_with_trace(prefix)
-      [fetch(prefix), traces[prefix]]
-    end
+    data[prefix].deep_dup
+  end
 
-    private
+  def fetch_with_trace(prefix)
+    [fetch(prefix), traces[prefix]]
+  end
 
-    def parse_env(prefix)
-      match_prefix = prefix.empty? ? prefix : "#{prefix}_"
-      env_container.each_pair.with_object({}) do |(key, val), data|
-        next unless key.start_with?(match_prefix)
+  private
 
-        path = key.sub(/^#{match_prefix}/, "").downcase
+  def parse_env(prefix)
+    match_prefix = prefix.empty? ? prefix : "#{prefix}_"
+    env_container.each_pair.with_object({}) do |(key, val), data|
+      next unless key.start_with?(match_prefix)
 
-        paths = path.split("__")
-        trace!(:env, *paths, key:) { data.bury(type_cast.call(val), *paths) }
-      end
+      path = key.sub(/^#{match_prefix}/, '').downcase
+
+      paths = path.split('__')
+      trace!(:env, *paths, key:) { data.bury(type_cast.call(val), *paths) }
     end
   end
 end

data/lib/runger/ext/deep_dup.rb

@@ -1,48 +1,45 @@
 # frozen_string_literal: true
 
-module Runger
-  module Ext
-    # Extend Object through refinements
-    module DeepDup
-      refine ::Hash do
-        # Based on ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_dup
-        def deep_dup
-          each_with_object(dup) do |(key, value), hash|
-            hash[key] = if value.is_a?(::Hash) || value.is_a?(::Array)
-              value.deep_dup
-            else
-              value
-            end
+# Extend Object through refinements
+module Runger::Ext::DeepDup
+  refine ::Hash do
+    # Based on ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_dup
+    def deep_dup
+      each_with_object(dup) do |(key, value), hash|
+        hash[key] =
+          if value.is_a?(::Hash) || value.is_a?(::Array)
+            value.deep_dup
+          else
+            value
           end
-        end
-      end
-
-      refine ::Array do
-        # From ActiveSupport http://api.rubyonrails.org/classes/Array.html#method-i-deep_dup
-        def deep_dup
-          map do |value|
-            if value.is_a?(::Hash) || value.is_a?(::Array)
-              value.deep_dup
-            else
-              value
-            end
-          end
-        end
       end
+    end
+  end
 
-      refine ::Object do
-        def deep_dup
-          dup
+  refine ::Array do
+    # From ActiveSupport http://api.rubyonrails.org/classes/Array.html#method-i-deep_dup
+    def deep_dup
+      map do |value|
+        if value.is_a?(::Hash) || value.is_a?(::Array)
+          value.deep_dup
+        else
+          value
         end
       end
+    end
+  end
 
-      refine ::Module do
-        def deep_dup
-          self
-        end
-      end
+  refine ::Object do
+    def deep_dup
+      dup
+    end
+  end
 
-      using self
+  refine ::Module do
+    def deep_dup
+      self
     end
   end
+
+  using self
 end

data/lib/runger/ext/deep_freeze.rb

@@ -1,44 +1,40 @@
 # frozen_string_literal: true
 
-module Runger
-  module Ext
-    # Add #deep_freeze to hashes and arrays
-    module DeepFreeze
-      refine ::Hash do
-        def deep_freeze
-          freeze
-          each_value do |value|
-            value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
-          end
-        end
+# Add #deep_freeze to hashes and arrays
+module Runger::Ext::DeepFreeze
+  refine ::Hash do
+    def deep_freeze
+      freeze
+      each_value do |value|
+        value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
       end
+    end
+  end
 
-      refine ::Array do
-        def deep_freeze
-          freeze
-          each do |value|
-            value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
-          end
-        end
+  refine ::Array do
+    def deep_freeze
+      freeze
+      each do |value|
+        value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
       end
+    end
+  end
 
-      begin
-        require "active_support/core_ext/hash/indifferent_access"
-      rescue LoadError
-      end
+  begin
+    require 'active_support/core_ext/hash/indifferent_access'
+  rescue LoadError
+  end
 
-      if defined?(::ActiveSupport::HashWithIndifferentAccess)
-        refine ::ActiveSupport::HashWithIndifferentAccess do
-          def deep_freeze
-            freeze
-            each_value do |value|
-              value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
-            end
-          end
+  if defined?(::ActiveSupport::HashWithIndifferentAccess)
+    refine ::ActiveSupport::HashWithIndifferentAccess do
+      def deep_freeze
+        freeze
+        each_value do |value|
+          value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
         end
       end
-
-      using self
     end
   end
+
+  using self
 end

data/lib/runger/ext/flatten_names.rb

@@ -1,37 +1,33 @@
 # frozen_string_literal: true
 
-module Runger
-  module Ext
-    # Convert Hash with mixed array and hash values to an
-    # array of paths.
-    module FlattenNames
-      refine ::Array do
-        def flatten_names(prefix, buf)
-          if empty?
-            buf << :"#{prefix}"
-            return buf
-          end
-
-          each_with_object(buf) do |name, acc|
-            if name.is_a?(::Symbol)
-              acc << :"#{prefix}.#{name}"
-            else
-              name.flatten_names(prefix, acc)
-            end
-          end
-        end
+# Convert Hash with mixed array and hash values to an
+# array of paths.
+module Runger::Ext::FlattenNames
+  refine ::Array do
+    def flatten_names(prefix, buf)
+      if empty?
+        buf << :"#{prefix}"
+        return buf
       end
 
-      refine ::Hash do
-        def flatten_names(prefix = nil, buf = [])
-          each_with_object(buf) do |(k, v), acc|
-            parent = prefix ? "#{prefix}.#{k}" : k
-            v.flatten_names(parent, acc)
-          end
+      each_with_object(buf) do |name, acc|
+        if name.is_a?(::Symbol)
+          acc << :"#{prefix}.#{name}"
+        else
+          name.flatten_names(prefix, acc)
         end
       end
+    end
+  end
 
-      using self
+  refine ::Hash do
+    def flatten_names(prefix = nil, buf = [])
+      each_with_object(buf) do |(k, v), acc|
+        parent = prefix ? "#{prefix}.#{k}" : k
+        v.flatten_names(parent, acc)
+      end
     end
   end
+
+  using self
 end

data/lib/runger/ext/hash.rb

@@ -1,40 +1,37 @@
 # frozen_string_literal: true
 
-module Runger
-  module Ext
-    # Extend Hash through refinements
-    module Hash
-      refine ::Hash do
-        def stringify_keys!
-          keys.each do |key|
-            value = delete(key)
-            self[key.to_s] = value
-          end
-
-          self
-        end
+# Extend Hash through refinements
+module Runger::Ext::Hash
+  refine ::Hash do
+    def stringify_keys!
+      keys.each do |key|
+        value = delete(key)
+        self[key.to_s] = value
+      end
 
-        def bury(val, *path)
-          raise ArgumentError, "No path specified" if path.empty?
-          raise ArgumentError, "Path cannot contain nil" if path.compact.size != path.size
+      self
+    end
 
-          last_key = path.pop
-          hash = path.reduce(self) do |hash, k|
-            hash[k] = {} unless hash.key?(k) && hash[k].is_a?(::Hash)
-            hash[k]
-          end
+    def bury(val, *path)
+      raise(ArgumentError, 'No path specified') if path.empty?
+      raise(ArgumentError, 'Path cannot contain nil') if path.compact.size != path.size
 
-          hash[last_key] = val
+      last_key = path.pop
+      hash =
+        path.reduce(self) do |hash, k|
+          hash[k] = {} unless hash.key?(k) && hash[k].is_a?(::Hash)
+          hash[k]
         end
 
-        def deep_transform_keys(&block)
-          each_with_object({}) do |(key, value), result|
-            result[yield(key)] = value.is_a?(::Hash) ? value.deep_transform_keys(&block) : value
-          end
-        end
-      end
+      hash[last_key] = val
+    end
 
-      using self
+    def deep_transform_keys(&block)
+      each_with_object({}) do |(key, value), result|
+        result[yield(key)] = value.is_a?(::Hash) ? value.deep_transform_keys(&block) : value
+      end
     end
   end
+
+  using self
 end

data/lib/runger/ext/string_constantize.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
-module Runger
-  module Ext
-    # Add simple safe_constantize method to String
-    module StringConstantize
-      refine String do
-        def safe_constantize
-          names = split("::")
+# Add simple safe_constantize method to String
+module Runger::Ext::StringConstantize
+  refine String do
+    def safe_constantize
+      names = split('::')
 
-          return nil if names.empty?
+      return nil if names.empty?
 
-          # Remove the first blank element in case of '::ClassName' notation.
-          names.shift if names.size > 1 && names.first.empty?
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
 
-          names.inject(Object) do |constant, name|
-            break if constant.nil?
-            constant.const_get(name, false) if constant.const_defined?(name, false)
-          end
-        end
+      names.inject(Object) do |constant, name|
+        break if constant.nil?
+
+        constant.const_get(name, false) if constant.const_defined?(name, false)
       end
     end
   end

data/lib/runger/loaders/base.rb

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