rubocop-performance 1.23.1 → 1.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 332ca643753a81ff66c4a6050117f7a479bd3aaa3f186c361a596d06b16aa9b5
-  data.tar.gz: 2fb149f85f986d9d0302e6fbe4c7389f312bb93a15a93cec49ffd74495853c78
+  metadata.gz: c195b128694fb4d65674a0d361a04e6db9c10671a2d04c59f714b92abf7a7192
+  data.tar.gz: 4e487319e1b81dc1f9aa515960f2b0546cfdf73483f8baac14de35049086a97a
 SHA512:
-  metadata.gz: e03b8e178f4cde75ef5d82aa7483da512f2816afd82c97b414a4bfcd7afacf589ebb033d6bed40d0968217ec0ff24cb69e2a6c4f28a52ecbdb31cef5599e5386
-  data.tar.gz: 410a72e5e85fe6cdc8002b51c8b185dc4d2a1dea5f3a5889c146364c2a20b5b50256c2a90fef59604137dd75d83f20c17ec65991eac6b8dab15e046184e1f006
+  metadata.gz: db0f96d9a383aca44da3760e9a22a54aaa17d59f6e24fb4de891954120f57ce38487fae8ce3436f0082d49b414f1c3e2aeea63bf5802e6bff43eea42760a11d9
+  data.tar.gz: 2e351cffc40a87a928472c300a11bd6fe7e4959dbf30d94aadd2246c71e9ab873bcf54971201fe62c2824c2982c381810ea0d8c9e228f09d0f0dbd0ed3cd8e2f

data/README.md

@@ -30,13 +30,13 @@ ways to do this:
 Put this into your `.rubocop.yml`.
 
 ```yaml
-require: rubocop-performance
+plugins: rubocop-performance
 ```
 
 Alternatively, use the following array notation when specifying multiple extensions.
 
 ```yaml
-require:
+plugins:
   - rubocop-other-extension
   - rubocop-performance
 ```
@@ -44,10 +44,13 @@ require:
 Now you can run `rubocop` and it will automatically load the RuboCop Performance
 cops together with the standard cops.
 
+> [!NOTE]
+> The plugin system is supported in RuboCop 1.72+. In earlier versions, use `require` instead of `plugins`.
+
 ### Command line
 
 ```sh
-$ rubocop --require rubocop-performance
+$ rubocop --plugin rubocop-performance
 ```
 
 ### Rake task
@@ -56,7 +59,7 @@ $ rubocop --require rubocop-performance
 require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new do |task|
-  task.requires << 'rubocop-performance'
+  task.plugins << 'rubocop-performance'
 end
 ```
 

data/config/default.yml

@@ -381,3 +381,9 @@ Performance/UriDefaultParser:
   Description: 'Use `URI::DEFAULT_PARSER` instead of `URI::Parser.new`.'
   Enabled: true
   VersionAdded: '0.50'
+
+Performance/ZipWithoutBlock:
+  Description: 'Checks for `map { |id| [id] }` and suggests replacing it with `zip`.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '1.24'

data/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb

@@ -44,8 +44,8 @@ module RuboCop
 
         def_node_matcher :endless_range?, <<~PATTERN
           {
-            ({irange erange} nil? (int positive?))
-            ({irange erange} (int positive?) nil?)
+            (range nil? (int positive?))
+            (range (int positive?) nil?)
           }
         PATTERN
 

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -58,6 +58,7 @@ module RuboCop
       class CaseWhenSplat < Base
         include Alignment
         include RangeHelp
+        include CommentsHelp
         extend AutoCorrector
 
         MSG = 'Reordering `when` conditions with a splat to the end of the `when` branches can improve performance.'
@@ -116,11 +117,18 @@ module RuboCop
         def reordering_correction(when_node)
           new_condition = replacement(when_node.conditions)
 
-          if same_line?(when_node, when_node.body)
-            new_condition_with_then(when_node, new_condition)
-          else
-            new_branch_without_then(when_node, new_condition)
-          end
+          condition =
+            if same_line?(when_node, when_node.body)
+              new_condition_with_then(when_node, new_condition)
+            else
+              new_branch_without_then(when_node, new_condition)
+            end
+
+          condition_comments = comments_in_range(when_node).map do |comment_node|
+            "#{indent_for(comment_node)}#{comment_node.source}"
+          end.join("\n")
+
+          "#{condition}#{condition_comments}"
         end
 
         def when_branch_range(when_node)
@@ -134,7 +142,13 @@ module RuboCop
         end
 
         def new_branch_without_then(node, new_condition)
-          "\n#{indent_for(node)}when #{new_condition}\n#{indent_for(node.body)}#{node.body.source}"
+          new_branch = "\n#{indent_for(node)}when #{new_condition}\n"
+
+          if node.body
+            "#{new_branch}#{indent_for(node.body)}#{node.body.source}"
+          else
+            new_branch
+          end
         end
 
         def indent_for(node)

data/lib/rubocop/cop/performance/chain_array_allocation.rb

@@ -45,6 +45,8 @@ module RuboCop
 
         RETURNS_NEW_ARRAY = (ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK).freeze
 
+        RESTRICT_ON_SEND = RETURNS_NEW_ARRAY
+
         MSG = 'Use unchained `%<method>s` and `%<second_method>s!` ' \
               '(followed by `return array` if required) instead of chaining ' \
               '`%<method>s...%<second_method>s`.'
@@ -52,7 +54,7 @@ module RuboCop
         def_node_matcher :chain_array_allocation?, <<~PATTERN
           (send {
             (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar send})
-            ({block numblock} (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
+            (any_block (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
             (send _ $%RETURNS_NEW_ARRAY ...)
           } $%HAS_MUTATION_ALTERNATIVE ...)
         PATTERN
@@ -73,7 +75,7 @@ module RuboCop
         def enumerable_select_method?(node)
           # NOTE: `QueryMethods#select` in Rails accepts positional arguments, whereas `Enumerable#select` does not.
           #        This difference can be utilized to reduce the knowledge requirements related to `select`.
-          (node.block_type? || node.numblock_type?) && node.send_node.arguments.empty?
+          node.any_block_type? && node.send_node.arguments.empty?
         end
       end
     end

data/lib/rubocop/cop/performance/collection_literal_in_loop.rb

@@ -12,6 +12,14 @@ module RuboCop
       # You can set the minimum number of elements to consider
       # an offense with `MinSize`.
       #
+      # NOTE: Since Ruby 3.4, certain simple arguments to `Array#include?` are
+      # optimized directly in Ruby. This avoids allocations without changing the
+      # code, as such no offense will be registered in those cases. Currently that
+      # includes: strings, `self`, local variables, instance variables, and method
+      # calls without arguments. Additionally, any number of methods can be chained:
+      # `[1, 2, 3].include?(@foo)` and `[1, 2, 3].include?(@foo.bar.baz)` both avoid
+      # the array allocation.
+      #
       # @example
       #   # bad
       #   users.select do |user|
@@ -55,6 +63,8 @@ module RuboCop
 
         ARRAY_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_ARRAY_METHODS).to_set.freeze
 
+        ARRAY_INCLUDE_OPTIMIZED_TYPES = %i[str self lvar ivar send].freeze
+
         NONMUTATING_HASH_METHODS = %i[< <= == > >= [] any? assoc compact dig
                                       each each_key each_pair each_value empty?
                                       eql? fetch fetch_values filter flatten has_key?
@@ -65,6 +75,8 @@ module RuboCop
 
         HASH_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_HASH_METHODS).to_set.freeze
 
+        RESTRICT_ON_SEND = ARRAY_METHODS + HASH_METHODS
+
         def_node_matcher :kernel_loop?, <<~PATTERN
           (block
             (send {nil? (const nil? :Kernel)} :loop)
@@ -78,8 +90,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          receiver, method, = *node.children
-          return unless check_literal?(receiver, method) && parent_is_loop?(receiver)
+          receiver, method, *arguments = *node.children
+          return unless check_literal?(receiver, method, arguments) && parent_is_loop?(receiver)
 
           message = format(MSG, literal_class: literal_class(receiver))
           add_offense(receiver, message: message)
@@ -87,12 +99,33 @@ module RuboCop
 
         private
 
-        def check_literal?(node, method)
+        def check_literal?(node, method, arguments)
           !node.nil? &&
             nonmutable_method_of_array_or_hash?(node, method) &&
             node.children.size >= min_size &&
-            node.recursive_basic_literal?
+            node.recursive_basic_literal? &&
+            !optimized_array_include?(node, method, arguments)
+        end
+
+        # Since Ruby 3.4, simple arguments to Array#include? are optimized.
+        # See https://github.com/ruby/ruby/pull/12123 for more details.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def optimized_array_include?(node, method, arguments)
+          return false unless target_ruby_version >= 3.4 && node.array_type? && method == :include?
+          # Disallow include?(1, 2)
+          return false if arguments.count != 1
+
+          arg = arguments.first
+          # Allow `include?(foo.bar.baz.bat)`
+          while arg.send_type?
+            return false if arg.arguments.any? # Disallow include?(foo(bar))
+            break unless arg.receiver
+
+            arg = arg.receiver
+          end
+          ARRAY_INCLUDE_OPTIMIZED_TYPES.include?(arg.type)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def nonmutable_method_of_array_or_hash?(node, method)
           (node.array_type? && ARRAY_METHODS.include?(method)) ||

data/lib/rubocop/cop/performance/fixed_size.rb

@@ -75,7 +75,7 @@ module RuboCop
         end
 
         def allowed_parent?(node)
-          node && (node.casgn_type? || node.block_type?)
+          node&.type?(:casgn, :any_block)
         end
 
         def contains_splat?(node)

data/lib/rubocop/cop/performance/inefficient_hash_search.rb

@@ -84,8 +84,7 @@ module RuboCop
         end
 
         def use_long_method
-          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config && preferred_config['EnforcedStyle'] == 'long' && preferred_config['Enabled']
+          config.for_enabled_cop('Style/PreferredHashMethods')['EnforcedStyle'] == 'long'
         end
 
         def correct_argument(node)

data/lib/rubocop/cop/performance/range_include.rb

@@ -38,7 +38,7 @@ module RuboCop
         # (We don't even catch it if the Range is in double parens)
 
         def_node_matcher :range_include, <<~PATTERN
-          (call {irange erange (begin {irange erange})} ${:include? :member?} ...)
+          (call {range (begin range)} ${:include? :member?} ...)
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/performance/redundant_match.rb

@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def call_like?(arg)
-          arg.call_type? || arg.yield_type? || arg.super_type?
+          arg.type?(:call, :yield, :super)
         end
       end
     end

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -239,7 +239,7 @@ module RuboCop
 
         def scope_root(node)
           node.each_ancestor.find do |ancestor|
-            ancestor.def_type? || ancestor.defs_type? || ancestor.class_type? || ancestor.module_type?
+            ancestor.type?(:def, :defs, :class, :module)
           end
         end
 

data/lib/rubocop/cop/performance/string_identifier_argument.rb

@@ -16,19 +16,19 @@ module RuboCop
       #   send('do_something')
       #   attr_accessor 'do_something'
       #   instance_variable_get('@ivar')
-      #   respond_to?("string_#{interpolation}")
       #
       #   # good
       #   send(:do_something)
       #   attr_accessor :do_something
       #   instance_variable_get(:@ivar)
-      #   respond_to?(:"string_#{interpolation}")
       #
       #   # good - these methods don't support namespaced symbols
       #   const_get("#{module_path}::Base")
       #   const_source_location("#{module_path}::Base")
       #   const_defined?("#{module_path}::Base")
       #
+      #   # good - using a symbol when string interpolation is involved causes a performance regression.
+      #   respond_to?("string_#{interpolation}")
       #
       class StringIdentifierArgument < Base
         extend AutoCorrector
@@ -40,8 +40,6 @@ module RuboCop
           protected public public_constant module_function
         ].freeze
 
-        INTERPOLATION_IGNORE_METHODS = %i[const_get const_source_location const_defined?].freeze
-
         TWO_ARGUMENTS_METHOD = :alias_method
         MULTIPLE_ARGUMENTS_METHODS = %i[
           attr_accessor attr_reader attr_writer private private_constant
@@ -59,7 +57,7 @@ module RuboCop
           deprecate_constant remove_const ruby2_keywords define_singleton_method instance_variable_defined?
           instance_variable_get instance_variable_set method public_method public_send remove_instance_variable
           respond_to? send singleton_method __send__
-        ] + COMMAND_METHODS + INTERPOLATION_IGNORE_METHODS).freeze
+        ] + COMMAND_METHODS).freeze
 
         def on_send(node)
           return if COMMAND_METHODS.include?(node.method_name) && node.receiver
@@ -83,13 +81,7 @@ module RuboCop
                         [node.first_argument]
                       end
 
-          arguments.compact.filter { |argument| string_argument_compatible?(argument, node) }
-        end
-
-        def string_argument_compatible?(argument, node)
-          return true if argument.str_type?
-
-          argument.dstr_type? && INTERPOLATION_IGNORE_METHODS.none? { |method| node.method?(method) }
+          arguments.compact.filter(&:str_type?)
         end
 
         def register_offense(argument, argument_value)

data/lib/rubocop/cop/performance/times_map.rb

@@ -36,6 +36,13 @@ module RuboCop
         MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'
         RESTRICT_ON_SEND = %i[map collect].freeze
 
+        def_node_matcher :times_map_call, <<~PATTERN
+          {
+            (any_block $(call (call $!nil? :times) {:map :collect}) ...)
+            $(call (call $!nil? :times) {:map :collect} (block_pass ...))
+          }
+        PATTERN
+
         def on_send(node)
           check(node)
         end
@@ -45,6 +52,7 @@ module RuboCop
           check(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -62,7 +70,7 @@ module RuboCop
 
         def handleable_receiver?(node)
           receiver = node.receiver.receiver
-          return true if receiver.literal? && (receiver.int_type? || receiver.float_type?)
+          return true if receiver.literal? && receiver.type?(:int, :float)
 
           node.receiver.dot?
         end
@@ -75,13 +83,6 @@ module RuboCop
                      end
           format(template, count: count.source, map_or_collect: map_or_collect.method_name)
         end
-
-        def_node_matcher :times_map_call, <<~PATTERN
-          {
-            ({block numblock} $(call (call $!nil? :times) {:map :collect}) ...)
-            $(call (call $!nil? :times) {:map :collect} (block_pass ...))
-          }
-        PATTERN
       end
     end
   end

data/lib/rubocop/cop/performance/zip_without_block.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # Checks for `map { |id| [id] }` and suggests replacing it with `zip`.
+      #
+      # @safety
+      #   This cop is unsafe for novel definitions of `map` and `collect`
+      #   on non-Enumerable objects that do not respond to `zip`.
+      #   To make your object enumerable, define an `each` method
+      #   as described in https://ruby-doc.org/core/Enumerable.html
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].map { |id| [id] }
+      #
+      #   # good
+      #   [1, 2, 3].zip
+      class ZipWithoutBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Use `zip` without a block argument instead.'
+        RESTRICT_ON_SEND = Set.new(%i[map collect]).freeze
+
+        # @!method map_with_array?(node)
+        def_node_matcher :map_with_array?, <<~PATTERN
+          {
+            (block (call !nil? RESTRICT_ON_SEND) (args (arg _)) (array (lvar _)))
+            (numblock (call !nil? RESTRICT_ON_SEND) 1 (array (lvar _)))
+            (itblock (call !nil? RESTRICT_ON_SEND) :it (array (lvar _)))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless map_with_array?(node.parent)
+
+          register_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(node)
+          offense_range = offense_range(node)
+          add_offense(offense_range) do |corrector|
+            corrector.replace(offense_range, 'zip')
+          end
+        end
+
+        def offense_range(node)
+          node.loc.selector.join(node.parent.loc.end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance_cops.rb

@@ -54,3 +54,4 @@ require_relative 'performance/times_map'
 require_relative 'performance/unfreeze_string'
 require_relative 'performance/uri_default_parser'
 require_relative 'performance/chain_array_allocation'
+require_relative 'performance/zip_without_block'

data/lib/rubocop/performance/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Performance
+    # A plugin that integrates RuboCop Performance with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-performance',
+          version: Version::STRING,
+          homepage: 'https://github.com/rubocop/rubocop-performance',
+          description: 'A collection of RuboCop cops to check for performance optimizations in Ruby code.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join('../../..')
+
+        ConfigObsoletion.files << project_root.join('config', 'obsoletion.yml')
+
+        LintRoller::Rules.new(type: :path, config_format: :rubocop, value: project_root.join('config', 'default.yml'))
+      end
+    end
+  end
+end

data/lib/rubocop/performance/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Performance
     # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.23.1'
+      STRING = '1.25.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/lib/rubocop/performance.rb

@@ -1,14 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  # RuboCop Performance project namespace
+  # RuboCop Performance project namespace.
   module Performance
-    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
-
-    ::RuboCop::ConfigObsoletion.files << PROJECT_ROOT.join('config', 'obsoletion.yml')
   end
 end

data/lib/rubocop-performance.rb

@@ -4,10 +4,7 @@ require 'rubocop'
 
 require_relative 'rubocop/performance'
 require_relative 'rubocop/performance/version'
-require_relative 'rubocop/performance/inject'
-
-RuboCop::Performance::Inject.defaults!
-
+require_relative 'rubocop/performance/plugin'
 require_relative 'rubocop/cop/performance_cops'
 
 RuboCop::Cop::Lint::UnusedMethodArgument.singleton_class.prepend(

metadata

@@ -1,23 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.23.1
+  version: 1.25.0
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-04 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.48.1
+        version: 1.75.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -27,7 +42,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.48.1
+        version: 1.75.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -37,7 +52,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.31.1
+        version: 1.38.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -47,7 +62,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.31.1
+        version: 1.38.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -119,9 +134,10 @@ files:
 - lib/rubocop/cop/performance/times_map.rb
 - lib/rubocop/cop/performance/unfreeze_string.rb
 - lib/rubocop/cop/performance/uri_default_parser.rb
+- lib/rubocop/cop/performance/zip_without_block.rb
 - lib/rubocop/cop/performance_cops.rb
 - lib/rubocop/performance.rb
-- lib/rubocop/performance/inject.rb
+- lib/rubocop/performance/plugin.rb
 - lib/rubocop/performance/version.rb
 homepage: https://github.com/rubocop/rubocop-performance
 licenses:
@@ -130,9 +146,11 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
   changelog_uri: https://github.com/rubocop/rubocop-performance/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-performance/
-  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.23/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.25/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
   rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Performance::Plugin
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -147,7 +165,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.1
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.
 test_files: []

data/lib/rubocop/performance/inject.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Performance
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end