runger_config 4.0.0 → 5.1.0

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

data/lib/runger/optparse_config.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "runger/option_parser_builder"
+require 'runger/option_parser_builder'
 
-require "runger/ext/deep_dup"
+require 'runger/ext/deep_dup'
 
 module Runger
   using Runger::Ext::DeepDup
@@ -19,7 +19,7 @@ module Runger
 
       def describe_options(**hargs)
         hargs.each do |name, desc|
-          if String === desc
+          if desc.is_a?(String)
             option_parser_descriptors[name.to_s][:desc] = desc
           else
             option_parser_descriptors[name.to_s].merge!(desc)
@@ -70,13 +70,14 @@ module Runger
     end
 
     def option_parser
-      @option_parser ||= OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
-                           write_config_attr(key, val)
-                         end.tap do |parser|
-        self.class.option_parser_extensions.map do |extension|
-          extension.call(parser, self)
+      @option_parser ||=
+        OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
+          write_config_attr(key, val)
+        end.tap do |parser|
+          self.class.option_parser_extensions.map do |extension|
+            extension.call(parser, self)
+          end
         end
-      end
     end
 
     def parse_options!(options)
@@ -86,7 +87,7 @@ module Runger
     end
 
     def self.included(base)
-      base.extend ClassMethods
+      base.extend(ClassMethods)
     end
   end
 end

data/lib/runger/rails/autoload.rb

@@ -2,39 +2,37 @@
 
 # This module is used to detect a Rails application and activate the corresponding plugins
 # when Runger Config is loaded before Rails (e.g., in config/puma.rb).
-module Runger
-  module Rails
-    class << self
-      attr_reader :tracer, :name_method
-      attr_accessor :disable_postponed_load_warning
+module Runger::Rails
+  class << self
+    attr_reader :tracer, :name_method
+    attr_accessor :disable_postponed_load_warning
 
-      private
+    private
 
-      def tracepoint_class_callback(event)
-        # Ignore singletons
-        return if event.self.singleton_class?
+    def tracepoint_class_callback(event)
+      # Ignore singletons
+      return if event.self.singleton_class?
 
-        # We wait till `rails/application/configuration.rb` has been loaded, since we rely on it
-        # See https://github.com/palkan/runger_config/issues/134
-        return unless name_method.bind_call(event.self) == "Rails::Application::Configuration"
+      # We wait till `rails/application/configuration.rb` has been loaded, since we rely on it
+      # See https://github.com/palkan/runger_config/issues/134
+      return unless name_method.bind_call(event.self) == 'Rails::Application::Configuration'
 
-        tracer.disable
+      tracer.disable
 
-        unless disable_postponed_load_warning
-          warn "Runger Config was loaded before Rails. Activating Runger Config Rails plugins now.\n" \
-                "NOTE: Already loaded configs were provisioned without Rails-specific sources."
-        end
-
-        require "runger/rails"
+      unless disable_postponed_load_warning
+        warn("Runger Config was loaded before Rails. Activating Runger Config Rails plugins now.\n" \
+             'NOTE: Already loaded configs were provisioned without Rails-specific sources.')
       end
-    end
 
-    # TruffleRuby doesn't support TracePoint's end event
-    unless defined?(::TruffleRuby)
-      @tracer = TracePoint.new(:end, &method(:tracepoint_class_callback))
-      @tracer.enable
-      # Use `Module#name` instead of `self.name` to handle overwritten `name` method
-      @name_method = Module.instance_method(:name)
+      require 'runger/rails'
     end
   end
+
+  # TruffleRuby doesn't support TracePoint's end event
+  unless defined?(::TruffleRuby)
+    @tracer = TracePoint.new(:end, &method(:tracepoint_class_callback))
+    @tracer.enable
+    # Use `Module#name` instead of `self.name` to handle overwritten `name` method
+    @name_method = Module.instance_method(:name)
+  end
 end

data/lib/runger/rails/config.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/indifferent_access"
+require 'active_support/core_ext/hash/indifferent_access'
 
-module Runger
-  module Rails
-    # Enhance config to be more Railsy-like:
-    # – accept hashes with indeferent access
-    # - load data from secrets
-    # - recognize Rails env when loading from YML
-    module Config
-      module ClassMethods
-        # Make defaults to be a Hash with indifferent access
-        def new_empty_config
-          {}.with_indifferent_access
-        end
-      end
-    end
+module Runger::Rails::Config ; end
+
+# Enhance config to be more Railsy-like:
+# – accept hashes with indeferent access
+# - load data from secrets
+# - recognize Rails env when loading from YML
+module Runger::Rails::Config::ClassMethods
+  # Make defaults to be a Hash with indifferent access
+  def new_empty_config
+    {}.with_indifferent_access
   end
 end
 
-Runger::Config.prepend Runger::Rails::Config
-Runger::Config.singleton_class.prepend Runger::Rails::Config::ClassMethods
+Runger::Config.prepend(Runger::Rails::Config)
+Runger::Config.singleton_class.prepend(Runger::Rails::Config::ClassMethods)

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

@@ -1,62 +1,58 @@
 # frozen_string_literal: true
 
-module Runger
-  module Rails
-    module Loaders
-      class Credentials < Runger::Loaders::Base
-        LOCAL_CONTENT_PATH = "config/credentials/local.yml.enc"
-
-        def call(name:, **_options)
-          return {} unless ::Rails.application.respond_to?(:credentials)
-
-          # do not load from credentials if we're in the context
-          # of the `credentials:edit` command
-          return {} if defined?(::Rails::Command::CredentialsCommand)
-
-          # Create a new hash cause credentials are mutable!
-          config = {}
-
-          trace!(
-            :credentials,
-            store: credentials_path
-          ) do
-            ::Rails.application.credentials.config[name.to_sym]
-          end.then do |creds|
-            Utils.deep_merge!(config, creds) if creds
-          end
-
-          if use_local?
-            trace!(:credentials, store: LOCAL_CONTENT_PATH) do
-              local_credentials(name)
-            end.then { |creds| Utils.deep_merge!(config, creds) if creds }
-          end
-
-          config
-        end
-
-        private
-
-        def local_credentials(name)
-          local_creds_path = ::Rails.root.join(LOCAL_CONTENT_PATH).to_s
-
-          return unless File.file?(local_creds_path)
-
-          creds = ::Rails.application.encrypted(
-            local_creds_path,
-            key_path: ::Rails.root.join("config/credentials/local.key")
-          )
-
-          creds.config[name.to_sym]
-        end
-
-        def credentials_path
-          if ::Rails.application.config.respond_to?(:credentials)
-            ::Rails.root.join(::Rails.application.config.credentials.content_path).relative_path_from(::Rails.root).to_s
-          else
-            "config/credentials.yml.enc"
-          end
-        end
-      end
+module Runger::Rails::Loaders ; end
+
+class Runger::Rails::Loaders::Credentials < Runger::Loaders::Base
+  LOCAL_CONTENT_PATH = 'config/credentials/local.yml.enc'
+
+  def call(name:, **_options)
+    return {} unless ::Rails.application.respond_to?(:credentials)
+
+    # do not load from credentials if we're in the context
+    # of the `credentials:edit` command
+    return {} if defined?(::Rails::Command::CredentialsCommand)
+
+    # Create a new hash cause credentials are mutable!
+    config = {}
+
+    trace!(
+      :credentials,
+      store: credentials_path,
+    ) do
+      ::Rails.application.credentials.config[name.to_sym]
+    end.then do |creds|
+      Runger::Utils.deep_merge!(config, creds) if creds
+    end
+
+    if use_local?
+      trace!(:credentials, store: LOCAL_CONTENT_PATH) do
+        local_credentials(name)
+      end.then { |creds| Runger::Utils.deep_merge!(config, creds) if creds }
+    end
+
+    config
+  end
+
+  private
+
+  def local_credentials(name)
+    local_creds_path = ::Rails.root.join(LOCAL_CONTENT_PATH).to_s
+
+    return unless File.file?(local_creds_path)
+
+    creds = ::Rails.application.encrypted(
+      local_creds_path,
+      key_path: ::Rails.root.join('config/credentials/local.key'),
+    )
+
+    creds.config[name.to_sym]
+  end
+
+  def credentials_path
+    if ::Rails.application.config.respond_to?(:credentials)
+      ::Rails.root.join(::Rails.application.config.credentials.content_path).relative_path_from(::Rails.root).to_s
+    else
+      'config/credentials.yml.enc'
     end
   end
 end