runger_config 4.0.0 → 5.0.0

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

data/lib/runger/loaders/yaml.rb

@@ -1,83 +1,86 @@
 # frozen_string_literal: true
 
-require "pathname"
-require "runger/ext/hash"
+require 'pathname'
+require 'runger/ext/hash'
 
 using Runger::Ext::Hash
 
-module Runger
-  module Loaders
-    class YAML < Base
-      def call(config_path:, **_options)
-        rel_config_path = relative_config_path(config_path).to_s
-        base_config = trace!(:yml, path: rel_config_path) do
-          config = load_base_yml(config_path)
-          environmental?(config) ? config_with_env(config) : config
-        end
-
-        return base_config unless use_local?
-
-        local_path = local_config_path(config_path)
-        local_config = trace!(:yml, path: relative_config_path(local_path).to_s) { load_local_yml(local_path) }
-        Utils.deep_merge!(base_config, local_config)
+class Runger::Loaders::YAML < Runger::Loaders::Base
+  def call(config_path:, **_options)
+    rel_config_path = relative_config_path(config_path).to_s
+    base_config =
+      trace!(:yml, path: rel_config_path) do
+        config = load_base_yml(config_path)
+        environmental?(config) ? config_with_env(config) : config
       end
 
-      private
-
-      def environmental?(parsed_yml)
-        # strange, but still possible
-        return true if Settings.default_environmental_key? && parsed_yml.key?(Settings.default_environmental_key)
-        # possible
-        return true if !Settings.future.unwrap_known_environments && Settings.current_environment
-        # for other environments
-        return true if Settings.known_environments&.any? { parsed_yml.key?(_1) }
-        # preferred
-        parsed_yml.key?(Settings.current_environment)
-      end
+    return base_config unless use_local?
 
-      def config_with_env(config)
-        env_config = config[Settings.current_environment] || {}
-        return env_config unless Settings.default_environmental_key?
+    local_path = local_config_path(config_path)
+    local_config =
+      trace!(:yml, path: relative_config_path(local_path).to_s) {
+        load_local_yml(local_path)
+      }
+    ::Runger::Utils.deep_merge!(base_config, local_config)
+  end
 
-        default_config = config[Settings.default_environmental_key] || {}
-        Utils.deep_merge!(default_config, env_config)
-      end
+  private
 
-      def parse_yml(path)
-        return {} unless File.file?(path)
-        require "yaml" unless defined?(::YAML)
-
-        # By default, YAML load will return `false` when the yaml document is
-        # empty. When this occurs, we return an empty hash instead, to match
-        # the interface when no config file is present.
-        begin
-          if defined?(ERB)
-            ::YAML.load(ERB.new(File.read(path)).result, aliases: true) || {}
-          else
-            ::YAML.load_file(path, aliases: true) || {}
-          end
-        rescue ArgumentError
-          if defined?(ERB)
-            ::YAML.load(ERB.new(File.read(path)).result) || {}
-          else
-            ::YAML.load_file(path) || {}
-          end
-        end
-      end
+  def environmental?(parsed_yml)
+    # strange, but still possible
+    return true if ::Runger::Settings.default_environmental_key? && parsed_yml.key?(::Runger::Settings.default_environmental_key)
+    # possible
+    return true if !::Runger::Settings.future.unwrap_known_environments && ::Runger::Settings.current_environment
+    # for other environments
+    return true if ::Runger::Settings.known_environments&.any? { parsed_yml.key?(_1) }
 
-      alias_method :load_base_yml, :parse_yml
-      alias_method :load_local_yml, :parse_yml
+    # preferred
+    parsed_yml.key?(::Runger::Settings.current_environment)
+  end
 
-      def local_config_path(path)
-        path.sub(".yml", ".local.yml")
-      end
+  def config_with_env(config)
+    env_config = config[::Runger::Settings.current_environment] || {}
+    return env_config unless ::Runger::Settings.default_environmental_key?
+
+    default_config = config[::Runger::Settings.default_environmental_key] || {}
+    ::Runger::Utils.deep_merge!(default_config, env_config)
+  end
+
+  def parse_yml(path)
+    return {} unless File.file?(path)
 
-      def relative_config_path(path)
-        Pathname.new(path).then do |path|
-          return path if path.relative?
-          path.relative_path_from(Settings.app_root)
-        end
+    require 'yaml' unless defined?(::YAML)
+
+    # By default, YAML load will return `false` when the yaml document is
+    # empty. When this occurs, we return an empty hash instead, to match
+    # the interface when no config file is present.
+    begin
+      if defined?(ERB)
+        ::YAML.load(ERB.new(File.read(path)).result, aliases: true) || {}
+      else
+        ::YAML.load_file(path, aliases: true) || {}
+      end
+    rescue ArgumentError
+      if defined?(ERB)
+        ::YAML.load(ERB.new(File.read(path)).result) || {}
+      else
+        ::YAML.load_file(path) || {}
       end
     end
   end
+
+  alias load_base_yml parse_yml
+  alias load_local_yml parse_yml
+
+  def local_config_path(path)
+    path.sub('.yml', '.local.yml')
+  end
+
+  def relative_config_path(path)
+    Pathname.new(path).then do |path|
+      return path if path.relative?
+
+      path.relative_path_from(::Runger::Settings.app_root)
+    end
+  end
 end

data/lib/runger/loaders.rb

@@ -1,77 +1,75 @@
 # frozen_string_literal: true
 
-module Runger
-  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
-
-      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
+class Runger::Loaders::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
+
+  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
 
-require "runger/loaders/base"
-require "runger/loaders/yaml"
-require "runger/loaders/env"
-require "runger/loaders/doppler"
-require "runger/loaders/ejson"
+require 'runger/loaders/base'
+require 'runger/loaders/doppler'
+require 'runger/loaders/ejson'
+require 'runger/loaders/env'
+require 'runger/loaders/yaml'

data/lib/runger/option_parser_builder.rb

@@ -1,29 +1,27 @@
 # frozen_string_literal: true
 
-require "optparse"
+require 'optparse'
 
-module Runger # :nodoc:
-  # Initializes the OptionParser instance using the given configuration
-  class OptionParserBuilder
-    class << self
-      def call(options)
-        OptionParser.new do |opts|
-          options.each do |key, descriptor|
-            opts.on(*option_parser_on_args(key, **descriptor)) do |val|
-              yield [key, val]
-            end
+# Initializes the OptionParser instance using the given configuration
+class Runger::OptionParserBuilder
+  class << self
+    def call(options)
+      OptionParser.new do |opts|
+        options.each do |key, descriptor|
+          opts.on(*option_parser_on_args(key, **descriptor)) do |val|
+            yield([key, val])
           end
         end
       end
+    end
 
-      private
+    private
 
-      def option_parser_on_args(key, flag: false, desc: nil, type: ::String)
-        on_args = ["--#{key.to_s.tr("_", "-")}#{flag ? "" : " VALUE"}"]
-        on_args << type unless flag
-        on_args << desc unless desc.nil?
-        on_args
-      end
+    def option_parser_on_args(key, flag: false, desc: nil, type: ::String)
+      on_args = ["--#{key.to_s.tr('_', '-')}#{flag ? '' : ' VALUE'}"]
+      on_args << type unless flag
+      on_args << desc unless desc.nil?
+      on_args
     end
   end
 end