runger_config 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b64cf53f84cf85e579523fa523e04afdd2c32dd75b219cf5a700df552368ded
-  data.tar.gz: 59459b83f4aff3789c5289a1ed5c33b686dd5012a73eff0ae4627e5eb2e3a3a2
+  metadata.gz: 81aff8e187347108683968d2aa3a9fecae6a7195d6261b0809658031204bef71
+  data.tar.gz: 740300783062b617a412f05c9b1f65757a81bef733a77e0e86361ce41a4a00b8
 SHA512:
-  metadata.gz: f7b719cb241b1e1d5c4d7d12d1563179e38e68f7aa777142c4ae8d497d13542f1a07c3b17f9ac7c6c9b9117a5b2bb20cbaab5a8b46a07bbab239cda1f3b5703e
-  data.tar.gz: 6f2156c5baecc455d4747a70351844c5161e9bb266743ed372dcde9634b6a6054524c354f85629863094e56b9311aa1e706b914ac405412008bb2980ac645bc8
+  metadata.gz: 42f3055ac5a872743e63b982a74afc7a26852681432f091e520cf690df78eef5787f84390f620fd7210edf67cada60c5aa08c127eb97ef1ef478e0603ff16020
+  data.tar.gz: 0cf7835d45cc7bbbcfc6247d58890beaef9e8cfd8784534bc97281857a5ebfec4d75e763a86bf195b96759c2be740d0b78247aa4aef30c79c6994203a8a0bb2f

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## v5.0.0 (2023-12-29)
+
+- Don't use anonymous keyword rest arguments in block
+
 ## v4.0.0 (2023-11-19)
 
 - [BREAKING] Rename from Anyway Config to Runger Config

data/lib/generators/runger/app_config/app_config_generator.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-require "generators/runger/config/config_generator"
+require 'generators/runger/config/config_generator'
 
-module Runger
-  module Generators
-    class AppConfigGenerator < ConfigGenerator
-      source_root ConfigGenerator.source_root
+class Runger::Generators::AppConfigGenerator < Runger::Generators::ConfigGenerator
+  source_root ::Runger::Generators::ConfigGenerator.source_root
 
-      private
+  private
 
-      def config_root
-        "app/configs"
-      end
-    end
+  def config_root
+    'app/configs'
   end
 end

data/lib/generators/runger/config/config_generator.rb

@@ -1,46 +1,49 @@
 # frozen_string_literal: true
 
-require "rails/generators"
-
-module Runger
-  module Generators
-    class ConfigGenerator < ::Rails::Generators::NamedBase
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :yml, type: :boolean
-      class_option :app, type: :boolean, default: false
-      argument :parameters, type: :array, default: [], banner: "param1 param2"
-
-      # check_class_collision suffix: "Config"
-
-      def run_install_if_needed
-        return if ::Rails.root.join(static_config_root, "application_config.rb").exist?
-        generate "runger:install"
-      end
-
-      def create_config
-        template "config.rb", File.join(config_root, class_path, "#{file_name}_config.rb")
-      end
-
-      def create_yml
-        create_yml = options.fetch(:yml) { yes?("Would you like to generate a #{file_name}.yml file?") }
-        return unless create_yml
-        template "config.yml", File.join("config", "#{file_name}.yml")
-      end
-
-      private
-
-      def static_config_root
-        Runger::Settings.autoload_static_config_path || Runger::DEFAULT_CONFIGS_PATH
-      end
-
-      def config_root
-        if options[:app]
-          "app/configs"
-        else
-          static_config_root
-        end
-      end
+require 'rails/generators'
+
+module Runger::Generators ; end
+
+class Runger::Generators::ConfigGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+
+  class_option :yml, type: :boolean
+  class_option :app, type: :boolean, default: false
+  argument :parameters, type: :array, default: [], banner: 'param1 param2'
+
+  # check_class_collision suffix: "Config"
+
+  def run_install_if_needed
+    return if ::Rails.root.join(static_config_root, 'application_config.rb').exist?
+
+    generate('runger:install')
+  end
+
+  def create_config
+    template('config.rb', File.join(config_root, class_path, "#{file_name}_config.rb"))
+  end
+
+  def create_yml
+    create_yml =
+      options.fetch(:yml) {
+        yes?("Would you like to generate a #{file_name}.yml file?")
+      }
+    return unless create_yml
+
+    template('config.yml', File.join('config', "#{file_name}.yml"))
+  end
+
+  private
+
+  def static_config_root
+    Runger::Settings.autoload_static_config_path || Runger::DEFAULT_CONFIGS_PATH
+  end
+
+  def config_root
+    if options[:app]
+      'app/configs'
+    else
+      static_config_root
     end
   end
 end

data/lib/generators/runger/install/install_generator.rb

@@ -1,47 +1,45 @@
 # frozen_string_literal: true
 
-require "rails/generators"
-
-module Runger
-  module Generators
-    class InstallGenerator < ::Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :configs_path, type: :string
-
-      def copy_application_config
-        template "application_config.rb", File.join(static_config_root, "application_config.rb")
-      end
-
-      def add_local_files_to_gitignore
-        if File.exist?(File.join(destination_root, ".gitignore"))
-          append_to_file ".gitignore", "\n/config/*.local.yml\n/config/credentials/local.*\n"
-        end
-      end
-
-      # rubocop:disable Layout/HeredocIndentation
-      def add_setup_autoload_to_config
-        maybe_comment_indented = default_configs_path? ? "    # " : "    "
-        inject_into_file "config/application.rb", after: %r{< Rails::Application\n} do
-          <<-RUBY
+require 'rails/generators'
+
+module Runger::Generators ; end
+
+class Runger::Generators::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+
+  class_option :configs_path, type: :string
+
+  def copy_application_config
+    template('application_config.rb', File.join(static_config_root, 'application_config.rb'))
+  end
+
+  def add_local_files_to_gitignore
+    if File.exist?(File.join(destination_root, '.gitignore'))
+      append_to_file('.gitignore', "\n/config/*.local.yml\n/config/credentials/local.*\n")
+    end
+  end
+
+  # rubocop:disable Layout/HeredocIndentation
+  def add_setup_autoload_to_config
+    maybe_comment_indented = default_configs_path? ? '    # ' : '    '
+    inject_into_file('config/application.rb', after: %r{< Rails::Application\n}) do
+      <<-RUBY
     # Configure the path for configuration classes that should be used before initialization
     # NOTE: path should be relative to the project root (Rails.root)
 #{maybe_comment_indented}config.runger_config.autoload_static_config_path = "#{static_config_root}"
-#{maybe_comment_indented.sub(/\s+$/, "")}
-          RUBY
-        end
-      end
-      # rubocop:enable Layout/HeredocIndentation
+#{maybe_comment_indented.sub(/\s+$/, '')}
+      RUBY
+    end
+  end
+  # rubocop:enable Layout/HeredocIndentation
 
-      private
+  private
 
-      def static_config_root
-        options[:configs_path] || Runger::Settings.autoload_static_config_path || Runger::DEFAULT_CONFIGS_PATH
-      end
+  def static_config_root
+    options[:configs_path] || Runger::Settings.autoload_static_config_path || Runger::DEFAULT_CONFIGS_PATH
+  end
 
-      def default_configs_path?
-        static_config_root == (Runger::Settings.autoload_static_config_path || Runger::DEFAULT_CONFIGS_PATH)
-      end
-    end
+  def default_configs_path?
+    static_config_root == (Runger::Settings.autoload_static_config_path || Runger::DEFAULT_CONFIGS_PATH)
   end
 end

data/lib/runger/auto_cast.rb

@@ -23,11 +23,11 @@ module Runger
         when /\A(nil|null)\z/i
           nil
         when /\A\d+\z/
-          val.to_i
+          Integer(val, 10)
         when /\A\d*\.\d+\z/
-          val.to_f
+          Float(val)
         when /\A['"].*['"]\z/
-          val.gsub(/(\A['"]|['"]\z)/, "")
+          val.gsub(/(\A['"]|['"]\z)/, '')
         else
           val
         end

data/lib/runger/config.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "active_support/all"
-require "runger/optparse_config"
-require "runger/dynamic_config"
+require 'active_support/all'
+require 'runger/dynamic_config'
+require 'runger/optparse_config'
 
 module Runger # :nodoc:
   using Runger::Ext::DeepDup
@@ -20,6 +20,8 @@ module Runger # :nodoc:
   # Provides `attr_config` method to describe
   # configuration parameters and set defaults
   class Config
+    include OptparseConfig
+    include DynamicConfig
     PARAM_NAME = /^[a-z_](\w+)?$/
 
     # List of names that couldn't be used as config names
@@ -53,9 +55,6 @@ module Runger # :nodoc:
 
     class ValidationError < Error; end
 
-    include OptparseConfig
-    include DynamicConfig
-
     class BlockCallback
       attr_reader :block
 
@@ -83,17 +82,18 @@ module Runger # :nodoc:
         new_defaults = hargs.deep_dup
         new_defaults.stringify_keys!
 
-        defaults.merge! new_defaults
+        defaults.merge!(new_defaults)
 
         new_keys = ((args + new_defaults.keys) - config_attributes)
 
-        validate_param_names! new_keys.map(&:to_s)
+        validate_param_names!(new_keys.map(&:to_s))
 
         new_keys.map!(&:to_sym)
 
         unless (reserved_names = (new_keys & RESERVED_NAMES)).empty?
-          raise ArgumentError, "Can not use the following reserved names as config attrubutes: " \
-            "#{reserved_names.sort.map(&:to_s).join(", ")}"
+          raise(ArgumentError,
+            'Can not use the following reserved names as config attrubutes: ' \
+            "#{reserved_names.sort.map(&:to_s).join(', ')}")
         end
 
         config_attributes.push(*new_keys)
@@ -104,33 +104,39 @@ module Runger # :nodoc:
         # having `true` or `false` as default values
         new_defaults.each do |key, val|
           next unless val.is_a?(TrueClass) || val.is_a?(FalseClass)
-          alias_method :"#{key}?", :"#{key}"
+
+          alias_method(:"#{key}?", :"#{key}")
         end
       end
 
       def defaults
         return @defaults if instance_variable_defined?(:@defaults)
 
-        @defaults = if superclass < Runger::Config
-          superclass.defaults.deep_dup
-        else
-          new_empty_config
-        end
+        @defaults =
+          if superclass < Runger::Config
+            superclass.defaults.deep_dup
+          else
+            new_empty_config
+          end
       end
 
       def config_attributes
         return @config_attributes if instance_variable_defined?(:@config_attributes)
 
-        @config_attributes = if superclass < Runger::Config
-          superclass.config_attributes.dup
-        else
-          []
-        end
+        @config_attributes =
+          if superclass < Runger::Config
+            superclass.config_attributes.dup
+          else
+            []
+          end
       end
 
       def required(*names, env: nil, **nested)
         unknown_names = names + nested.keys - config_attributes
-        raise ArgumentError, "Unknown config param: #{unknown_names.join(",")}" if unknown_names.any?
+        if unknown_names.any?
+          raise(ArgumentError,
+            "Unknown config param: #{unknown_names.join(',')}")
+        end
 
         return unless Settings.matching_env?(env)
 
@@ -141,15 +147,19 @@ module Runger # :nodoc:
       def required_attributes
         return @required_attributes if instance_variable_defined?(:@required_attributes)
 
-        @required_attributes = if superclass < Runger::Config
-          superclass.required_attributes.dup
-        else
-          []
-        end
+        @required_attributes =
+          if superclass < Runger::Config
+            superclass.required_attributes.dup
+          else
+            []
+          end
       end
 
       def on_load(*names, &block)
-        raise ArgumentError, "Either methods or block should be specified, not both" if block && !names.empty?
+        if block && !names.empty?
+          raise(ArgumentError,
+            'Either methods or block should be specified, not both')
+        end
 
         if block
           load_callbacks << BlockCallback.new(block)
@@ -161,11 +171,12 @@ module Runger # :nodoc:
       def load_callbacks
         return @load_callbacks if instance_variable_defined?(:@load_callbacks)
 
-        @load_callbacks = if superclass <= Runger::Config
-          superclass.load_callbacks.dup
-        else
-          []
-        end
+        @load_callbacks =
+          if superclass <= Runger::Config
+            superclass.load_callbacks.dup
+          else
+            []
+          end
       end
 
       def config_name(val = nil)
@@ -192,11 +203,12 @@ module Runger # :nodoc:
 
         return @env_prefix if instance_variable_defined?(:@env_prefix)
 
-        @env_prefix = if superclass < Runger::Config && superclass.explicit_config_name?
-          superclass.env_prefix
-        else
-          config_name.upcase
-        end
+        @env_prefix =
+          if superclass < Runger::Config && superclass.explicit_config_name?
+            superclass.env_prefix
+          else
+            config_name.upcase
+          end
       end
 
       def loader_options(val = nil)
@@ -204,34 +216,36 @@ module Runger # :nodoc:
 
         return @loader_options if instance_variable_defined?(:@loader_options)
 
-        @loader_options = if superclass < Runger::Config
-          superclass.loader_options
-        else
-          {}
-        end
+        @loader_options =
+          if superclass < Runger::Config
+            superclass.loader_options
+          else
+            {}
+          end
       end
 
       def new_empty_config = {}
 
       def coerce_types(mapping)
-        Utils.deep_merge!(coercion_mapping, mapping)
+        ::Runger::Utils.deep_merge!(coercion_mapping, mapping)
 
         mapping.each do |key, val|
           type = val.is_a?(::Hash) ? val[:type] : val
           next if type != :boolean
 
-          alias_method :"#{key}?", :"#{key}"
+          alias_method(:"#{key}?", :"#{key}")
         end
       end
 
       def coercion_mapping
         return @coercion_mapping if instance_variable_defined?(:@coercion_mapping)
 
-        @coercion_mapping = if superclass < Runger::Config
-          superclass.coercion_mapping.deep_dup
-        else
-          {}
-        end
+        @coercion_mapping =
+          if superclass < Runger::Config
+            superclass.coercion_mapping.deep_dup
+          else
+            {}
+          end
       end
 
       def type_caster(val = nil)
@@ -250,11 +264,12 @@ module Runger # :nodoc:
 
         return @fallback_type_caster if instance_variable_defined?(:@fallback_type_caster)
 
-        @fallback_type_caster = if superclass < Runger::Config
-          superclass.fallback_type_caster.deep_dup
-        else
-          ::Runger::AutoCast
-        end
+        @fallback_type_caster =
+          if superclass < Runger::Config
+            superclass.fallback_type_caster.deep_dup
+          else
+            ::Runger::AutoCast
+          end
       end
 
       def disable_auto_cast!
@@ -265,7 +280,7 @@ module Runger # :nodoc:
 
       def define_config_accessor(*names)
         names.each do |name|
-          accessors_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          accessors_module.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
             def #{name}=(val)
               __trace__&.record_value(val, "#{name}", **Tracing.current_trace_source)
               values[:#{name}] = val
@@ -281,31 +296,33 @@ module Runger # :nodoc:
       def accessors_module
         return @accessors_module if instance_variable_defined?(:@accessors_module)
 
-        @accessors_module = Module.new.tap do |mod|
-          include mod
-        end
+        @accessors_module =
+          Module.new.tap do |mod|
+            include mod
+          end
       end
 
       def build_config_name
         unless name
-          raise "Please, specify config name explicitly for anonymous class " \
-            "via `config_name :my_config`"
+          raise('Please, specify config name explicitly for anonymous class ' \
+                'via `config_name :my_config`')
         end
 
-        unless name.underscore.gsub("/", "_") =~ /(\w+)_config\z/
-          raise "Couldn't infer config name, please, specify it explicitly " \
-            "via `config_name :my_config`"
+        unless name.underscore.tr('/', '_') =~ /(\w+)_config\z/
+          raise("Couldn't infer config name, please, specify it explicitly " \
+                'via `config_name :my_config`')
         end
 
-        Regexp.last_match[1].delete_suffix("_config").tap(&:downcase!)
+        Regexp.last_match[1].delete_suffix('_config').tap(&:downcase!)
       end
 
       def validate_param_names!(names)
-        invalid_names = names.reject { |name| name =~ PARAM_NAME }
+        invalid_names = names.grep_v(PARAM_NAME)
         return if invalid_names.empty?
 
-        raise ArgumentError, "Invalid attr_config name: #{invalid_names.join(", ")}.\n" \
-          "Valid names must satisfy /#{PARAM_NAME.source}/."
+        raise(ArgumentError,
+          "Invalid attr_config name: #{invalid_names.join(', ')}.\n" \
+          "Valid names must satisfy /#{PARAM_NAME.source}/.")
       end
     end
 
@@ -325,7 +342,7 @@ module Runger # :nodoc:
     def initialize(overrides = nil)
       @config_name = self.class.config_name
 
-      raise ArgumentError, "Config name is missing" unless @config_name
+      raise(ArgumentError, 'Config name is missing') unless @config_name
 
       @env_prefix = self.class.env_prefix
       @values = {}
@@ -348,25 +365,26 @@ module Runger # :nodoc:
     def load(overrides = nil)
       base_config = self.class.defaults.deep_dup
 
-      trace = Tracing.capture do
-        Tracing.trace!(:defaults) { base_config }
+      trace =
+        Tracing.capture do
+          Tracing.trace!(:defaults) { base_config }
 
-        config_path = resolve_config_path(config_name, env_prefix)
+          config_path = resolve_config_path(config_name, env_prefix)
 
-        load_from_sources(
-          base_config,
-          name: config_name,
-          env_prefix:,
-          config_path:,
-          **self.class.loader_options
-        )
+          load_from_sources(
+            base_config,
+            name: config_name,
+            env_prefix:,
+            config_path:,
+            **self.class.loader_options,
+          )
 
-        if overrides
-          Tracing.trace!(:load) { overrides }
+          if overrides
+            Tracing.trace!(:load) { overrides }
 
-          Utils.deep_merge!(base_config, overrides)
+            ::Runger::Utils.deep_merge!(base_config, overrides)
+          end
         end
-      end
 
       base_config.each do |key, val|
         write_config_attr(key.to_sym, val)
@@ -385,9 +403,9 @@ module Runger # :nodoc:
       self
     end
 
-    def load_from_sources(base_config, **)
+    def load_from_sources(base_config, **options)
       Runger.loaders.each do |(_id, loader)|
-        Utils.deep_merge!(base_config, loader.call(**))
+        ::Runger::Utils.deep_merge!(base_config, loader.call(**options))
       end
       base_config
     end
@@ -406,7 +424,7 @@ module Runger # :nodoc:
     end
 
     def resolve_config_path(name, env_prefix)
-      Runger.env.fetch(env_prefix).delete("conf") || Settings.default_config_path.call(name)
+      Runger.env.fetch(env_prefix).delete('conf') || Settings.default_config_path.call(name)
     end
 
     def deconstruct_keys(keys) = values.deconstruct_keys(keys)
@@ -414,20 +432,21 @@ module Runger # :nodoc:
     def to_source_trace = __trace__&.to_h
 
     def inspect
-      "#<#{self.class}:0x#{vm_object_id.rjust(16, "0")} config_name=\"#{config_name}\" env_prefix=\"#{env_prefix}\" " \
-      "values=#{values.inspect}>"
+      "#<#{self.class}:0x#{vm_object_id.rjust(16,
+        '0')} config_name=\"#{config_name}\" env_prefix=\"#{env_prefix}\" " \
+        "values=#{values.inspect}>"
     end
 
     def pretty_print(q)
-      q.object_group self do
+      q.object_group(self) do
         q.nest(1) do
           q.breakable
           q.text "config_name=#{config_name.inspect}"
           q.breakable
           q.text "env_prefix=#{env_prefix.inspect}"
           q.breakable
-          q.text "values:"
-          q.pp __trace__
+          q.text 'values:'
+          q.pp(__trace__)
         end
       end
     end
@@ -442,11 +461,12 @@ module Runger # :nodoc:
 
     def validate_required_attributes!
       self.class.required_attributes.select do |name|
-        val = values.dig(*name.to_s.split(".").map(&:to_sym))
+        val = values.dig(*name.to_s.split('.').map(&:to_sym))
         val.nil? || (val.is_a?(String) && val.empty?)
       end.then do |missing|
         next if missing.empty?
-        raise_validation_error "The following config parameters for `#{self.class.name}(config_name: #{self.class.config_name})` are missing or empty: #{missing.join(", ")}"
+
+        raise_validation_error("The following config parameters for `#{self.class.name}(config_name: #{self.class.config_name})` are missing or empty: #{missing.join(', ')}")
       end
     end
 
@@ -459,7 +479,7 @@ module Runger # :nodoc:
     end
 
     def raise_validation_error(msg)
-      raise ValidationError, msg
+      raise(ValidationError, msg)
     end
 
     def __type_caster__