runger_config 4.0.0 → 5.1.0

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

data/lib/runger/loaders/doppler.rb

@@ -1,61 +1,57 @@
 # frozen_string_literal: true
 
-require "uri"
-require "net/http"
-require "json"
+require 'json'
+require 'net/http'
+require 'uri'
 
-module Runger
-  module Loaders
-    class Doppler < Base
-      class RequestError < StandardError; end
+class Runger::Loaders::Doppler < Runger::Loaders::Base
+  class RequestError < StandardError; end
 
-      class << self
-        attr_accessor :download_url
-        attr_writer :token
+  class << self
+    attr_accessor :download_url
+    attr_writer :token
 
-        def token
-          @token || ENV["DOPPLER_TOKEN"]
-        end
-      end
+    def token
+      @token || ENV.fetch('DOPPLER_TOKEN', nil)
+    end
+  end
 
-      self.download_url = "https://api.doppler.com/v3/configs/config/secrets/download"
+  self.download_url = 'https://api.doppler.com/v3/configs/config/secrets/download'
 
-      def call(env_prefix:, **_options)
-        env_payload = parse_doppler_response(url: Doppler.download_url, token: Doppler.token)
+  def call(env_prefix:, **_options)
+    env_payload = parse_doppler_response(url: Runger::Loaders::Doppler.download_url, token: Runger::Loaders::Doppler.token)
 
-        env = ::Runger::Env.new(type_cast: ::Runger::NoCast, env_container: env_payload)
+    env = ::Runger::Env.new(type_cast: ::Runger::NoCast, env_container: env_payload)
 
-        env.fetch_with_trace(env_prefix).then do |(conf, trace)|
-          Tracing.current_trace&.merge!(trace)
-          conf
-        end
-      end
+    env.fetch_with_trace(env_prefix).then do |(conf, trace)|
+      ::Runger::Tracing.current_trace&.merge!(trace)
+      conf
+    end
+  end
 
-      private
+  private
 
-      def parse_doppler_response(url:, token:)
-        response = fetch_doppler_config(url, token)
+  def parse_doppler_response(url:, token:)
+    response = fetch_doppler_config(url, token)
 
-        unless response.is_a?(Net::HTTPSuccess)
-          raise RequestError, "#{response.code} #{response.message}"
-        end
+    unless response.is_a?(Net::HTTPSuccess)
+      raise(RequestError, "#{response.code} #{response.message}")
+    end
 
-        JSON.parse(response.read_body)
-      end
+    JSON.parse(response.read_body)
+  end
 
-      def fetch_doppler_config(url, token)
-        uri = URI.parse(url)
-        raise "Doppler token is required to load configuration from Doppler" if token.nil?
+  def fetch_doppler_config(url, token)
+    uri = URI.parse(url)
+    raise('Doppler token is required to load configuration from Doppler') if token.nil?
 
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true if uri.scheme == "https"
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == 'https'
 
-        request = Net::HTTP::Get.new(uri)
-        request["Accept"] = "application/json"
-        request["Authorization"] = "Bearer #{token}"
+    request = Net::HTTP::Get.new(uri)
+    request['Accept'] = 'application/json'
+    request['Authorization'] = "Bearer #{token}"
 
-        http.request(request)
-      end
-    end
+    http.request(request)
   end
 end

data/lib/runger/loaders/ejson.rb

@@ -1,89 +1,91 @@
 # frozen_string_literal: true
 
-require "runger/ejson_parser"
+require 'runger/ejson_parser'
 
-module Runger
-  module Loaders
-    class EJSON < Base
-      class << self
-        attr_accessor :bin_path
-      end
-
-      self.bin_path = "ejson"
-
-      def call(name:, ejson_namespace: name, ejson_parser: Runger::EJSONParser.new(EJSON.bin_path), **_options)
-        configs = []
+class Runger::Loaders::EJSON < Runger::Loaders::Base
+  class << self
+    attr_accessor :bin_path
+  end
 
-        rel_config_paths.each do |rel_config_path|
-          secrets_hash, rel_path =
-            extract_hash_from_rel_config_path(
-              ejson_parser: ejson_parser,
-              rel_config_path: rel_config_path
-            )
+  self.bin_path = 'ejson'
 
-          next unless secrets_hash
+  def call(
+    name:,
+    ejson_namespace: name,
+    ejson_parser: Runger::EJSONParser.new(Runger::Loaders::EJSON.bin_path),
+    **_options
+  )
+    configs = []
 
-          config_hash = if ejson_namespace
-            secrets_hash[ejson_namespace]
-          else
-            secrets_hash.except("_public_key")
-          end
+    rel_config_paths.each do |rel_config_path|
+      secrets_hash, rel_path =
+        extract_hash_from_rel_config_path(
+          ejson_parser:,
+          rel_config_path:,
+        )
 
-          next unless config_hash.is_a?(Hash)
+      next unless secrets_hash
 
-          configs <<
-            trace!(:ejson, path: rel_path) do
-              config_hash
-            end
+      config_hash =
+        if ejson_namespace
+          secrets_hash[ejson_namespace]
+        else
+          secrets_hash.except('_public_key')
         end
 
-        return {} if configs.empty?
+      next unless config_hash.is_a?(Hash)
 
-        configs.inject do |result_config, next_config|
-          Utils.deep_merge!(result_config, next_config)
+      configs <<
+        trace!(:ejson, path: rel_path) do
+          config_hash
         end
-      end
+    end
 
-      private
+    return {} if configs.empty?
 
-      def rel_config_paths
-        chain = [environmental_rel_config_path]
+    configs.inject do |result_config, next_config|
+      ::Runger::Utils.deep_merge!(result_config, next_config)
+    end
+  end
 
-        chain << "secrets.local.ejson" if use_local?
+  private
 
-        chain
-      end
+  def rel_config_paths
+    chain = [environmental_rel_config_path]
 
-      def environmental_rel_config_path
-        if Settings.current_environment
-          # if environment file is absent, then take data from the default one
-          [
-            "#{Settings.current_environment}/secrets.ejson",
-            default_rel_config_path
-          ]
-        else
-          default_rel_config_path
-        end
-      end
+    chain << 'secrets.local.ejson' if use_local?
+
+    chain
+  end
 
-      def default_rel_config_path
-        "secrets.ejson"
-      end
+  def environmental_rel_config_path
+    if ::Runger::Settings.current_environment
+      # if environment file is absent, then take data from the default one
+      [
+        "#{::Runger::Settings.current_environment}/secrets.ejson",
+        default_rel_config_path,
+      ]
+    else
+      default_rel_config_path
+    end
+  end
 
-      def extract_hash_from_rel_config_path(ejson_parser:, rel_config_path:)
-        rel_config_path = [rel_config_path] unless rel_config_path.is_a?(Array)
+  def default_rel_config_path
+    'secrets.ejson'
+  end
 
-        rel_config_path.each do |rel_conf_path|
-          rel_path = "config/#{rel_conf_path}"
-          abs_path = "#{Settings.app_root}/#{rel_path}"
+  def extract_hash_from_rel_config_path(ejson_parser:, rel_config_path:)
+    rel_config_path = Array(rel_config_path)
 
-          result = ejson_parser.call(abs_path)
+    rel_config_path.each do |rel_conf_path|
+      rel_path = "config/#{rel_conf_path}"
+      abs_path = "#{::Runger::Settings.app_root}/#{rel_path}"
 
-          return [result, rel_path] if result
-        end
+      result = ejson_parser.call(abs_path)
 
-        nil
-      end
+      return [result, rel_path] if result
     end
+
+    nil
   end
 end

data/lib/runger/loaders/env.rb

@@ -1,16 +1,12 @@
 # frozen_string_literal: true
 
-module Runger
-  module Loaders
-    class Env < Base
-      def call(env_prefix:, **_options)
-        env = ::Runger::Env.new(type_cast: ::Runger::NoCast)
+class Runger::Loaders::Env < Runger::Loaders::Base
+  def call(env_prefix:, **_options)
+    env = ::Runger::Env.new(type_cast: ::Runger::NoCast)
 
-        env.fetch_with_trace(env_prefix).then do |(conf, trace)|
-          Tracing.current_trace&.merge!(trace)
-          conf
-        end
-      end
+    env.fetch_with_trace(env_prefix).then do |(conf, trace)|
+      ::Runger::Tracing.current_trace&.merge!(trace)
+      conf
     end
   end
 end