runger_config 4.0.0 → 5.1.0

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

data/lib/runger/settings.rb

@@ -1,111 +1,109 @@
 # frozen_string_literal: true
 
-require "pathname"
-
-module Runger
-  # Use Settings name to not confuse with Config.
-  #
-  # Settings contain the library-wide configuration.
-  class Settings
-    # Future encapsulates settings that will be introduced in the upcoming version
-    # with the default values, which could break compatibility
-    class Future
-      class << self
-        def setting(name, default_value)
-          settings[name] = default_value
-
-          define_method(name) do
-            store[name]
-          end
-
-          define_method(:"#{name}=") do |val|
-            store[name] = val
-          end
-        end
+require 'pathname'
+
+# Use Settings name to not confuse with Config.
+#
+# Settings contain the library-wide configuration.
+class Runger::Settings
+  # Future encapsulates settings that will be introduced in the upcoming version
+  # with the default values, which could break compatibility
+  class Future
+    class << self
+      def setting(name, default_value)
+        settings[name] = default_value
 
-        def settings
-          @settings ||= {}
+        define_method(name) do
+          store[name]
         end
-      end
 
-      def initialize
-        @store = {}
+        define_method(:"#{name}=") do |val|
+          store[name] = val
+        end
       end
 
-      def use(*names)
-        store.clear
-        names.each { store[_1] = self.class.settings[_1] }
+      def settings
+        @settings ||= {}
       end
+    end
 
-      setting :unwrap_known_environments, true
-
-      private
+    def initialize
+      @store = {}
+    end
 
-      attr_reader :store
+    def use(*names)
+      store.clear
+      names.each { store[_1] = self.class.settings[_1] }
     end
 
-    class << self
-      # Define whether to load data from
-      # *.yml.local (or credentials/local.yml.enc)
-      attr_accessor :use_local_files,
-        :current_environment,
-        :default_environmental_key,
-        :known_environments
-
-      # A proc returning a path to YML config file given the config name
-      attr_reader :default_config_path
-
-      def default_config_path=(val)
-        if val.is_a?(Proc)
-          @default_config_path = val
-          return
-        end
+    setting :unwrap_known_environments, true
 
-        val = val.to_s
+    private
 
-        @default_config_path = ->(name) { File.join(val, "#{name}.yml") }
+    attr_reader :store
+  end
+
+  class << self
+    # Define whether to load data from
+    # *.yml.local (or credentials/local.yml.enc)
+    attr_accessor :use_local_files,
+      :current_environment,
+      :default_environmental_key,
+      :known_environments
+
+    # A proc returning a path to YML config file given the config name
+    attr_reader :default_config_path
+
+    def default_config_path=(val)
+      if val.is_a?(Proc)
+        @default_config_path = val
+        return
       end
 
-      # Enable source tracing
-      attr_accessor :tracing_enabled
+      val = val.to_s
 
-      def future
-        @future ||= Future.new
-      end
+      @default_config_path = ->(name) { File.join(val, "#{name}.yml") }
+    end
 
-      def app_root
-        Pathname.new(Dir.pwd)
-      end
+    # Enable source tracing
+    attr_accessor :tracing_enabled
 
-      def default_environmental_key?
-        !default_environmental_key.nil?
-      end
+    def future
+      @future ||= Future.new
+    end
 
-      def matching_env?(env)
-        return true if env.nil? || env.to_s == current_environment
-
-        if env.is_a?(::Hash)
-          envs = env[:except]
-          excluded_envs = [envs].flat_map(&:to_s)
-          excluded_envs.none?(current_environment)
-        elsif env.is_a?(::Array)
-          env.flat_map(&:to_s).include?(current_environment)
-        else
-          false
-        end
+    def app_root
+      Pathname.new(Dir.pwd)
+    end
+
+    def default_environmental_key?
+      !default_environmental_key.nil?
+    end
+
+    def matching_env?(env)
+      return true if env.nil? || env.to_s == current_environment
+
+      if env.is_a?(::Hash)
+        envs = env[:except]
+        excluded_envs = [envs].flat_map(&:to_s)
+        excluded_envs.none?(current_environment)
+      elsif env.is_a?(::Array)
+        env.flat_map(&:to_s).include?(current_environment)
+      else
+        false
       end
     end
+  end
 
-    # By default, use RUNGER_ENV
-    self.current_environment = ENV["RUNGER_ENV"]
+  # By default, use RUNGER_ENV
+  self.current_environment = ENV.fetch('RUNGER_ENV', nil)
 
-    # By default, use local files only in development (that's the purpose if the local files)
-    self.use_local_files = (ENV["RUNGER_ENV"] == "development" || ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development" || (defined?(Rails) && Rails.env.development?))
+  # By default, use local files only in development (that's the purpose if the local files)
+  self.use_local_files = (ENV['RUNGER_ENV'] == 'development' || ENV['RACK_ENV'] == 'development' || ENV['RAILS_ENV'] == 'development' || (defined?(Rails) && Rails.env.development?))
 
-    # By default, consider configs are stored in the ./config folder
-    self.default_config_path = ->(name) { "./config/#{name}.yml" }
+  # By default, consider configs are stored in the ./config folder
+  self.default_config_path = ->(name) { "./config/#{name}.yml" }
 
-    # Tracing is enabled by default
-    self.tracing_enabled = true
-  end
+  # Tracing is enabled by default
+  self.tracing_enabled = true
 end

data/lib/runger/testing/helpers.rb

@@ -1,36 +1,34 @@
 # frozen_string_literal: true
 
-module Runger
-  module Testing
-    module Helpers
-      # Sets the ENV variables to the provided
-      # values and restore outside the block
-      #
-      # Also resets Runger.env before and after calling the block
-      # to make sure that the values are not cached.
-      #
-      # NOTE: to remove the env value, pass `nil` as the value
-      def with_env(data)
-        was_values = []
+module Runger::Testing::Helpers
+  # Sets the ENV variables to the provided
+  # values and restore outside the block
+  #
+  # Also resets Runger.env before and after calling the block
+  # to make sure that the values are not cached.
+  #
+  # NOTE: to remove the env value, pass `nil` as the value
+  def with_env(data)
+    was_values = []
 
-        data.each do |key, val|
-          was_values << [key, ENV[key]]
-          next ENV.delete(key) if val.nil?
-          ENV[key] = val
-        end
+    data.each do |key, val|
+      was_values << [key, ENV.fetch(key, nil)]
+      next ENV.delete(key) if val.nil?
 
-        # clear cached env values
-        Runger.env.clear
-        yield
-      ensure
-        was_values.each do |(key, val)|
-          next ENV.delete(key) if val.nil?
-          ENV[key] = val
-        end
+      ENV[key] = val
+    end
+
+    # clear cached env values
+    Runger.env.clear
+    yield
+  ensure
+    was_values.each do |(key, val)|
+      next ENV.delete(key) if val.nil?
 
-        # clear cache again
-        Runger.env.clear
-      end
+      ENV[key] = val
     end
+
+    # clear cache again
+    Runger.env.clear
   end
 end

data/lib/runger/testing.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require "runger/testing/helpers"
+require 'runger/testing/helpers'
 
 if defined?(RSpec::Core) && RSpec.respond_to?(:configure)
   RSpec.configure do |config|
     config.include(
       Runger::Testing::Helpers,
       type: :config,
-      file_path: %r{spec/configs}
+      file_path: %r{spec/configs},
     )
   end
 end