runger_config 4.0.0 → 5.0.0

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

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

@@ -1,35 +1,31 @@
 # frozen_string_literal: true
 
-module Runger
-  module Rails
-    module Loaders
-      class Secrets < Runger::Loaders::Base
-        def call(name:, **_options)
-          return {} unless ::Rails.application.respond_to?(:secrets)
+class Runger::Rails::Loaders::Secrets < Runger::Loaders::Base
+  def call(name:, **_options)
+    return {} unless ::Rails.application.respond_to?(:secrets)
 
-          # Create a new hash cause secrets are mutable!
-          config = {}
+    # Create a new hash cause secrets are mutable!
+    config = {}
 
-          trace!(:secrets) do
-            secrets.public_send(name)
-          end.then do |secrets|
-            Utils.deep_merge!(config, secrets) if secrets
-          end
+    trace!(:secrets) do
+      secrets.public_send(name)
+    end.then do |secrets|
+      ::Runger::Utils.deep_merge!(config, secrets) if secrets
+    end
+
+    config
+  end
 
-          config
-        end
+  private
 
-        private
+  def secrets
+    @secrets ||=
+      ::Rails.application.secrets.tap do |_|
+        # Reset secrets state if the app hasn't been initialized
+        # See https://github.com/palkan/runger_config/issues/14
+        next if ::Rails.application.initialized?
 
-        def secrets
-          @secrets ||= ::Rails.application.secrets.tap do |_|
-            # Reset secrets state if the app hasn't been initialized
-            # See https://github.com/palkan/runger_config/issues/14
-            next if ::Rails.application.initialized?
-            ::Rails.application.remove_instance_variable(:@secrets)
-          end
-        end
+        ::Rails.application.remove_instance_variable(:@secrets)
       end
-    end
   end
 end

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

@@ -1,9 +1,4 @@
 # frozen_string_literal: true
 
-module Runger
-  module Rails
-    module Loaders
-      class YAML < Runger::Loaders::YAML; end
-    end
-  end
+class Runger::Rails::Loaders::YAML < Runger::Loaders::YAML
 end

data/lib/runger/rails/loaders.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require "runger/rails/loaders/yaml"
-require "runger/rails/loaders/secrets"
-require "runger/rails/loaders/credentials"
+require 'runger/rails/loaders/credentials'
+require 'runger/rails/loaders/secrets'
+require 'runger/rails/loaders/yaml'

data/lib/runger/rails/settings.rb

@@ -2,33 +2,33 @@
 
 # Try to require zeitwerk
 begin
-  require "zeitwerk"
-  require "active_support/dependencies/zeitwerk_integration"
+  require 'active_support/dependencies/zeitwerk_integration'
+  require 'zeitwerk'
 rescue LoadError
 end
 
-module Runger
-  class Settings
-    class << self
-      attr_reader :autoload_static_config_path, :autoloader
-      attr_writer :autoload_via_zeitwerk
+class Runger::Settings
+  class << self
+    attr_reader :autoload_static_config_path, :autoloader
+    attr_writer :autoload_via_zeitwerk
 
-      def autoload_static_config_path=(val)
-        if autoload_via_zeitwerk
-          raise "Cannot setup autoloader after application has been initialized" if ::Rails.application.initialized?
+    def autoload_static_config_path=(val)
+      if autoload_via_zeitwerk
+        raise('Cannot setup autoloader after application has been initialized') if ::Rails.application.initialized?
 
-          return unless ::Rails.root.join(val).exist?
+        return unless ::Rails.root.join(val).exist?
 
-          return if val == autoload_static_config_path
+        return if val == autoload_static_config_path
 
-          autoloader&.unload
+        autoloader&.unload
 
-          @autoload_static_config_path = val
+        @autoload_static_config_path = val
 
-          # See Rails 6 https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
-          # and Rails 7 https://github.com/rails/rails/blob/5462fbd5de1900c1b1ce1c9dc11c1a2d8cdcd809/railties/lib/rails/autoloaders.rb#L15
-          @autoloader = Zeitwerk::Loader.new.tap do |loader|
-            loader.tag = "runger.config"
+        # See Rails 6 https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+        # and Rails 7 https://github.com/rails/rails/blob/5462fbd5de1900c1b1ce1c9dc11c1a2d8cdcd809/railties/lib/rails/autoloaders.rb#L15
+        @autoloader =
+          Zeitwerk::Loader.new.tap do |loader|
+            loader.tag = 'runger.config'
 
             if defined?(ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector)
               loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
@@ -38,46 +38,46 @@ module Runger
             loader.push_dir(::Rails.root.join(val))
             loader.setup
           end
-        else
-          if autoload_static_config_path
-            old_path = ::Rails.root.join(autoload_static_config_path).to_s
-            ActiveSupport::Dependencies.autoload_paths.delete(old_path)
-            ::Rails.application.config.eager_load_paths.delete(old_path)
-          end
-
-          @autoload_static_config_path = val
-          new_path = ::Rails.root.join(val).to_s
-          ActiveSupport::Dependencies.autoload_paths << new_path
-          ::Rails.application.config.eager_load_paths << new_path
+      else
+        if autoload_static_config_path
+          old_path = ::Rails.root.join(autoload_static_config_path).to_s
+          ActiveSupport::Dependencies.autoload_paths.delete(old_path)
+          ::Rails.application.config.eager_load_paths.delete(old_path)
         end
+
+        @autoload_static_config_path = val
+        new_path = ::Rails.root.join(val).to_s
+        ActiveSupport::Dependencies.autoload_paths << new_path
+        ::Rails.application.config.eager_load_paths << new_path
       end
+    end
 
-      def cleanup_autoload_paths
-        return unless autoload_via_zeitwerk
+    def cleanup_autoload_paths
+      return unless autoload_via_zeitwerk
 
-        return unless autoload_static_config_path
-        ActiveSupport::Dependencies.autoload_paths.delete(::Rails.root.join(autoload_static_config_path).to_s)
-      end
+      return unless autoload_static_config_path
 
-      def autoload_via_zeitwerk
-        return @autoload_via_zeitwerk if instance_variable_defined?(:@autoload_via_zeitwerk)
+      ActiveSupport::Dependencies.autoload_paths.delete(::Rails.root.join(autoload_static_config_path).to_s)
+    end
 
-        @autoload_via_zeitwerk = defined?(::Zeitwerk)
-      end
+    def autoload_via_zeitwerk
+      return @autoload_via_zeitwerk if instance_variable_defined?(:@autoload_via_zeitwerk)
 
-      def current_environment
-        @current_environment || ::Rails.env.to_s
-      end
+      @autoload_via_zeitwerk = defined?(::Zeitwerk)
+    end
 
-      def app_root
-        ::Rails.root
-      end
+    def current_environment
+      @current_environment || ::Rails.env.to_s
     end
 
-    self.default_config_path = ->(name) { ::Rails.root.join("config", "#{name}.yml") }
-    self.known_environments = %w[test development production]
-    self.use_local_files ||= ::Rails.env.development?
-    # Don't try read defaults when no key defined
-    self.default_environmental_key = nil
+    def app_root
+      ::Rails.root
+    end
   end
+
+  self.default_config_path = ->(name) { ::Rails.root.join('config', "#{name}.yml") }
+  self.known_environments = %w[test development production]
+  self.use_local_files ||= ::Rails.env.development?
+  # Don't try read defaults when no key defined
+  self.default_environmental_key = nil
 end

data/lib/runger/rails.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
-module Runger
-  module Rails
-  end
+module Runger::Rails
 end
 
-require "runger/rails/settings"
-require "runger/rails/config"
-require "runger/rails/loaders"
+require 'runger/rails/config'
+require 'runger/rails/loaders'
+require 'runger/rails/settings'
 
 # Configure Rails loaders
-Runger.loaders.override :yml, Runger::Rails::Loaders::YAML
+Runger.loaders.override(:yml, Runger::Rails::Loaders::YAML)
 
 if Rails::VERSION::MAJOR >= 7 && Rails::VERSION::MINOR >= 1
-  Runger.loaders.insert_after :yml, :credentials, Runger::Rails::Loaders::Credentials
+  Runger.loaders.insert_after(:yml, :credentials, Runger::Rails::Loaders::Credentials)
 else
-  Runger.loaders.insert_after :yml, :secrets, Runger::Rails::Loaders::Secrets
-  Runger.loaders.insert_after :secrets, :credentials, Runger::Rails::Loaders::Credentials
+  Runger.loaders.insert_after(:yml, :secrets, Runger::Rails::Loaders::Secrets)
+  Runger.loaders.insert_after(:secrets, :credentials, Runger::Rails::Loaders::Credentials)
 end
 
 # Load Railties after configuring loaders.
 # The application could be already initialized, and that would make `Runger.loaders` frozen
-require "runger/railtie"
+require 'runger/railtie'

data/lib/runger/railtie.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Runger # :nodoc:
-  DEFAULT_CONFIGS_PATH = "config/configs"
+  DEFAULT_CONFIGS_PATH = 'config/configs'
 
   class Railtie < ::Rails::Railtie # :nodoc:
     # Add settings to Rails config
@@ -9,6 +9,7 @@ module Runger # :nodoc:
 
     config.before_configuration do
       next if ::Rails.application.initialized?
+
       config.runger_config.autoload_static_config_path = DEFAULT_CONFIGS_PATH
     end
 
@@ -18,7 +19,7 @@ module Runger # :nodoc:
 
     # Remove `autoload_static_config_path` from Rails `autoload_paths`
     # since we use our own autoloading mechanism
-    initializer "runger_config.cleanup_autoload" do
+    initializer 'runger_config.cleanup_autoload' do
       Runger::Settings.cleanup_autoload_paths
     end
 

data/lib/runger/rbs.rb

@@ -3,33 +3,33 @@
 module Runger
   module RBSGenerator
     TYPE_TO_CLASS = {
-      string: "String",
-      integer: "Integer",
-      float: "Float",
-      date: "Date",
-      datetime: "DateTime",
-      uri: "URI",
-      boolean: "bool"
+      string: 'String',
+      integer: 'Integer',
+      float: 'Float',
+      date: 'Date',
+      datetime: 'DateTime',
+      uri: 'URI',
+      boolean: 'bool',
     }.freeze
 
     # Generate RBS signature from a config class
     def to_rbs
-      *namespace, class_name = name.split("::")
+      *namespace, class_name = name.split('::')
 
       buf = []
       indent = 0
-      interface_name = "_Config"
+      interface_name = '_Config'
 
       if namespace.empty?
         interface_name = "_#{class_name}"
       else
-        buf << "module #{namespace.join("::")}"
+        buf << "module #{namespace.join('::')}"
         indent += 1
       end
 
       # Using interface emulates a module we include to provide getters and setters
       # (thus making `super` possible)
-      buf << "#{"  " * indent}interface #{interface_name}"
+      buf << "#{'  ' * indent}interface #{interface_name}"
       indent += 1
 
       # Generating setters and getters for config attributes
@@ -39,17 +39,17 @@ module Runger
         type =
           case type
           in NilClass
-            "untyped"
+            'untyped'
           in Symbol
-            TYPE_TO_CLASS.fetch(type) { defaults[param] ? "Symbol" : "untyped" }
+            TYPE_TO_CLASS.fetch(type) { defaults[param] ? 'Symbol' : 'untyped' }
           in Array
-            "Array[untyped]"
+            'Array[untyped]'
           in array: _, type:, **nil
-            "Array[#{TYPE_TO_CLASS.fetch(type, "untyped")}]"
+            "Array[#{TYPE_TO_CLASS.fetch(type, 'untyped')}]"
           in Hash
-            "Hash[string,untyped]"
+            'Hash[string,untyped]'
           in TrueClass | FalseClass
-            "bool"
+            'bool'
           else
             type.class.to_s
           end
@@ -57,36 +57,36 @@ module Runger
         getter_type = type
         getter_type = "#{type}?" unless required_attributes.include?(param)
 
-        buf << "#{"  " * indent}def #{param}: () -> #{getter_type}"
-        buf << "#{"  " * indent}def #{param}=: (#{type}) -> void"
+        buf << "#{'  ' * indent}def #{param}: () -> #{getter_type}"
+        buf << "#{'  ' * indent}def #{param}=: (#{type}) -> void"
 
-        if type == "bool" || type == "bool?"
-          buf << "#{"  " * indent}def #{param}?: () -> #{getter_type}"
+        if ['bool', 'bool?'].include?(type)
+          buf << "#{'  ' * indent}def #{param}?: () -> #{getter_type}"
         end
       end
 
       indent -= 1
-      buf << "#{"  " * indent}end"
+      buf << "#{'  ' * indent}end"
 
-      buf << ""
+      buf << ''
 
-      buf << "#{"  " * indent}class #{class_name} < #{superclass.name}"
+      buf << "#{'  ' * indent}class #{class_name} < #{superclass.name}"
       indent += 1
 
-      buf << "#{"  " * indent}include #{interface_name}"
+      buf << "#{'  ' * indent}include #{interface_name}"
 
       indent -= 1
-      buf << "#{"  " * indent}end"
+      buf << "#{'  ' * indent}end"
 
       unless namespace.empty?
-        buf << "end"
+        buf << 'end'
       end
 
-      buf << ""
+      buf << ''
 
       buf.join("\n")
     end
   end
 
-  Config.extend RBSGenerator
+  Config.extend(RBSGenerator)
 end