rubocop 1.84.2 → 1.86.1

data/lib/rubocop/cop/style/tally_method.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for manual counting patterns that can be replaced by `Enumerable#tally`.
+      #
+      # The cop detects the following patterns:
+      #
+      # - `each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }`
+      # - `group_by(&:itself).transform_values(&:count)`
+      # - `group_by { |x| x }.transform_values(&:size)`
+      # - `group_by { |x| x }.transform_values { |v| v.length }`
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Enumerable` by static analysis, so the correction may
+      #   not be actually equivalent.
+      #
+      # @example
+      #   # bad
+      #   array.each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }
+      #
+      #   # bad
+      #   array.group_by(&:itself).transform_values(&:count)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values(&:size)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values { |v| v.length }
+      #
+      #   # good
+      #   array.tally
+      #
+      class TallyMethod < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.7
+
+        MSG_EACH_WITH_OBJECT = 'Use `tally` instead of `each_with_object`.'
+        MSG_GROUP_BY = 'Use `tally` instead of `group_by` and `transform_values`.'
+        RESTRICT_ON_SEND = %i[each_with_object transform_values].freeze
+        COUNTING_METHODS = %i[count size length].to_set.freeze
+
+        # Pattern 1: collection.each_with_object(Hash.new(0)) { |elem, hash| hash[elem] += 1 }
+        # @!method tally_each_with_object?(node)
+        def_node_matcher :tally_each_with_object?, <<~PATTERN
+          {
+            (block
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              (args (arg _elem) (arg _hash))
+              (op_asgn
+                (send (lvar _hash) :[] (lvar _elem)) :+ (int 1)))
+            (numblock
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              2
+              (op_asgn
+                (send (lvar :_2) :[] (lvar :_1)) :+ (int 1)))
+          }
+        PATTERN
+
+        # Pattern 2: collection.group_by(&:itself).transform_values(&:count/size/length)
+        # @!method tally_group_by_symbol?(node)
+        def_node_matcher :tally_group_by_symbol?, <<~PATTERN
+          (call
+            (call _ :group_by (block_pass (sym :itself)))
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 3: collection.group_by { |x| x }.transform_values(&:count/size/length)
+        # @!method tally_group_by_identity_block?(node)
+        def_node_matcher :tally_group_by_identity_block?, <<~PATTERN
+          (call
+            {
+              (block (call _ :group_by) (args (arg _x)) (lvar _x))
+              (numblock (call _ :group_by) 1 (lvar :_1))
+              (itblock (call _ :group_by) :it (lvar :it))
+            }
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 4: collection.group_by(&:itself).transform_values { |v| v.count/size/length }
+        #            collection.group_by { |x| x }.transform_values { |v| v.count/size/length }
+        # @!method tally_group_by_transform_block?(node)
+        def_node_matcher :tally_group_by_transform_block?, <<~PATTERN
+          {
+            (block
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              (args (arg _v))
+              (send (lvar _v) %COUNTING_METHODS))
+            (numblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              1
+              (send (lvar :_1) %COUNTING_METHODS))
+            (itblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              :it
+              (send (lvar :it) %COUNTING_METHODS))
+          }
+        PATTERN
+        def on_send(node)
+          if node.method?(:each_with_object)
+            check_each_with_object(node)
+          elsif node.method?(:transform_values)
+            check_transform_values(node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_each_with_object(node)
+          block_node = node.block_node
+          return unless block_node
+          return unless tally_each_with_object?(block_node)
+
+          add_offense(node.loc.selector, message: MSG_EACH_WITH_OBJECT) do |corrector|
+            corrector.replace(replacement_range(node, block_node), 'tally')
+          end
+        end
+
+        def check_transform_values(node)
+          if tally_group_by_symbol?(node) || tally_group_by_identity_block?(node)
+            register_group_by_offense(node, node)
+          elsif (block_node = node.block_node) && tally_group_by_transform_block?(block_node)
+            register_group_by_offense(node, block_node)
+          end
+        end
+
+        def register_group_by_offense(transform_node, end_node)
+          group_by_node = group_by_send_node(transform_node)
+
+          add_offense(group_by_node.loc.selector, message: MSG_GROUP_BY) do |corrector|
+            corrector.replace(replacement_range(group_by_node, end_node), 'tally')
+          end
+        end
+
+        def group_by_send_node(transform_node)
+          receiver = transform_node.receiver
+          if receiver.type?(:any_block)
+            receiver.send_node
+          else
+            receiver
+          end
+        end
+
+        def replacement_range(start_node, end_node)
+          range_between(start_node.loc.selector.begin_pos, end_node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_comma_in_block_args.rb

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)

data/lib/rubocop/cop/style/trailing_method_end_statement.rb

@@ -45,6 +45,7 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n#{' ' * node.loc.keyword.column}")
           end
         end
+        alias on_defs on_def
 
         private
 

data/lib/rubocop/cop/style/yoda_expression.rb

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def supported_operators
-          Array(cop_config['SupportedOperators'])
+          @supported_operators ||= Array(cop_config['SupportedOperators']).freeze
         end
 
         def offended_ancestor?(node)

data/lib/rubocop/cop/variable_force/branch.rb

@@ -346,8 +346,8 @@ module RuboCop
           end
         end
 
-        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
-          classes[klass.type] = klass
+        CLASSES_BY_TYPE = Base.classes.to_h do |klass|
+          [klass.type, klass]
         end
       end
     end

data/lib/rubocop/directive_comment.rb

@@ -52,7 +52,8 @@ module RuboCop
     def initialize(comment, cop_registry = Cop::Registry.global)
       @comment = comment
       @cop_registry = cop_registry
-      @match_data = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      match_data = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      @match_data = match_data&.pre_match&.match?(/\A#\s*\z/) ? nil : match_data
       @mode, @cops = match_captures
     end
 

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -233,7 +233,7 @@ module RuboCop
 
       def output_exclude_list(output_buffer, offending_files, cop_name)
         require 'pathname'
-        parent = Pathname.new(Dir.pwd)
+        parent = Pathname.new(PathUtil.pwd)
 
         output_buffer.puts '  Exclude:'
         excludes(offending_files, cop_name, parent).each do |exclude_path|

data/lib/rubocop/formatter/formatter_set.rb

@@ -57,7 +57,7 @@ module RuboCop
         if output_path
           dir_path = File.dirname(output_path)
           FileUtils.mkdir_p(dir_path)
-          output = File.open(output_path, 'w')
+          output = File.open(output_path, 'w') # rubocop:disable Style/FileOpen
         else
           output = $stdout
         end

data/lib/rubocop/formatter/junit_formatter.rb

@@ -93,7 +93,7 @@ module RuboCop
 
       def classname_attribute_value(file)
         @classname_attribute_value_cache ||= Hash.new do |hash, key|
-          hash[key] = key.delete_suffix('.rb').gsub("#{Dir.pwd}/", '').tr('/', '.')
+          hash[key] = key.delete_suffix('.rb').gsub("#{PathUtil.pwd}/", '').tr('/', '.')
         end
         @classname_attribute_value_cache[file]
       end

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'colorizable'
-
 module RuboCop
   module Formatter
     # A basic formatter that displays only files with offenses.

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -24,7 +24,7 @@ module RuboCop
       def file_finished(file, offenses)
         return if offenses.empty?
 
-        path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+        path = Pathname.new(file).relative_path_from(Pathname.new(PathUtil.pwd))
         @offense_counts[path] = offenses.size
       end
 

data/lib/rubocop/formatter.rb

@@ -3,32 +3,33 @@
 module RuboCop
   # The bootstrap module for formatter.
   module Formatter
-    require_relative 'formatter/text_util'
+    autoload :Colorizable, 'rubocop/formatter/colorizable'
+    autoload :TextUtil, 'rubocop/formatter/text_util'
 
-    require_relative 'formatter/base_formatter'
-    require_relative 'formatter/simple_text_formatter'
+    autoload :BaseFormatter, 'rubocop/formatter/base_formatter'
+    autoload :SimpleTextFormatter, 'rubocop/formatter/simple_text_formatter'
 
     # relies on simple text
-    require_relative 'formatter/clang_style_formatter'
-    require_relative 'formatter/disabled_config_formatter'
-    require_relative 'formatter/emacs_style_formatter'
-    require_relative 'formatter/file_list_formatter'
-    require_relative 'formatter/fuubar_style_formatter'
-    require_relative 'formatter/github_actions_formatter'
-    require_relative 'formatter/html_formatter'
-    require_relative 'formatter/json_formatter'
-    require_relative 'formatter/junit_formatter'
-    require_relative 'formatter/markdown_formatter'
-    require_relative 'formatter/offense_count_formatter'
-    require_relative 'formatter/pacman_formatter'
-    require_relative 'formatter/progress_formatter'
-    require_relative 'formatter/quiet_formatter'
-    require_relative 'formatter/tap_formatter'
-    require_relative 'formatter/worst_offenders_formatter'
+    autoload :ClangStyleFormatter, 'rubocop/formatter/clang_style_formatter'
+    autoload :DisabledConfigFormatter, 'rubocop/formatter/disabled_config_formatter'
+    autoload :EmacsStyleFormatter, 'rubocop/formatter/emacs_style_formatter'
+    autoload :FileListFormatter, 'rubocop/formatter/file_list_formatter'
+    autoload :FuubarStyleFormatter, 'rubocop/formatter/fuubar_style_formatter'
+    autoload :GitHubActionsFormatter, 'rubocop/formatter/github_actions_formatter'
+    autoload :HTMLFormatter, 'rubocop/formatter/html_formatter'
+    autoload :JSONFormatter, 'rubocop/formatter/json_formatter'
+    autoload :JUnitFormatter, 'rubocop/formatter/junit_formatter'
+    autoload :MarkdownFormatter, 'rubocop/formatter/markdown_formatter'
+    autoload :OffenseCountFormatter, 'rubocop/formatter/offense_count_formatter'
+    autoload :PacmanFormatter, 'rubocop/formatter/pacman_formatter'
+    autoload :ProgressFormatter, 'rubocop/formatter/progress_formatter'
+    autoload :QuietFormatter, 'rubocop/formatter/quiet_formatter'
+    autoload :TapFormatter, 'rubocop/formatter/tap_formatter'
+    autoload :WorstOffendersFormatter, 'rubocop/formatter/worst_offenders_formatter'
 
     # relies on progress formatter
-    require_relative 'formatter/auto_gen_config_formatter'
+    autoload :AutoGenConfigFormatter, 'rubocop/formatter/auto_gen_config_formatter'
 
-    require_relative 'formatter/formatter_set'
+    autoload :FormatterSet, 'rubocop/formatter/formatter_set'
   end
 end

data/lib/rubocop/lsp/diagnostic.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'language_server-protocol'
 require_relative 'disable_comment_edits'
 require_relative 'severity'
 

data/lib/rubocop/lsp/routes.rb

@@ -61,9 +61,16 @@ module RuboCop
 
       handle 'initialized' do |_request|
         version = RuboCop::Version::STRING
-        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
-
-        Logger.log("RuboCop #{version} language server#{yjit} initialized, PID #{Process.pid}")
+        # Only one JIT can be enabled at the same time, since YJIT and ZJIT are mutually exclusive.
+        jit = if Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled?
+                '+YJIT'
+              elsif Object.const_defined?('RubyVM::ZJIT') && RubyVM::ZJIT.enabled?
+                '+ZJIT'
+              else
+                ''
+              end
+
+        Logger.log("RuboCop #{version} language server#{jit} initialized, PID #{Process.pid}")
       end
 
       handle 'shutdown' do |request|

data/lib/rubocop/mcp/server.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+begin
+  require 'mcp'
+
+  required_mcp_version = '0.6.0'
+
+  if Gem::Version.new(required_mcp_version) > Gem::Version.new(MCP::VERSION)
+    # While `mcp` is not a runtime dependency, users may have an outdated version installed.
+    warn <<~MESSAGE
+      Error: `mcp` gem version #{MCP::VERSION} was loaded, but `rubocop --mcp` requires #{required_mcp_version}.
+      - If you're using Bundler and don't yet have `gem 'mcp'` as a dependency, add it now.
+      - If you're using Bundler and already have `gem 'mcp'` as a dependency, update it to the most recent version.
+      - If you don't use Bundler, run `gem update mcp`.
+    MESSAGE
+    exit!
+  end
+rescue LoadError => e
+  raise unless e.path == 'mcp'
+
+  warn <<~MESSAGE
+    Error: Unable to load `mcp` gem. Add `gem 'mcp', '~> 0.6'` to your Gemfile, or run `gem install mcp`.
+  MESSAGE
+
+  exit!
+end
+
+require_relative '../lsp'
+require_relative '../lsp/runtime'
+
+module RuboCop
+  module MCP
+    # RuboCop MCP Server.
+    # @api private
+    class Server
+      def initialize(config_store)
+        @config_store = config_store
+        @runtime = RuboCop::LSP::Runtime.new(@config_store)
+        @options = {}
+      end
+
+      def start
+        # No `protocol_version` is specified because draft feature by default can be used.
+        server = ::MCP::Server.new(
+          name: 'rubocop_mcp_server',
+          version: RuboCop::Version::STRING,
+          tools: [inspection_tool, autocorrection_tool]
+        )
+
+        ::MCP::Server::Transports::StdioTransport.new(server).open
+      end
+
+      private
+
+      def inspection_tool
+        build_tool(
+          name: 'rubocop_inspection',
+          description: 'Inspect Ruby code for offenses. ' \
+                       'Provide `source_code` to check inline code or `path` to check files.',
+          title: "RuboCop's inspection",
+          destructive_hint: false,
+          idempotent_hint: true,
+          read_only_hint: true,
+          safety_required: false
+        ) do |path, source_code|
+          run_inspection(path, source_code)
+        end
+      end
+
+      def autocorrection_tool
+        build_tool(
+          name: 'rubocop_autocorrection',
+          description: 'Autocorrect RuboCop offenses in Ruby code. ' \
+                       'Provide `source_code` to correct inline code or `path` to correct files. ' \
+                       'Set `safety` to false to include unsafe corrections.',
+          title: "RuboCop's autocorrection",
+          destructive_hint: true,
+          idempotent_hint: false,
+          read_only_hint: false,
+          safety_required: true
+        ) do |path, source_code, safety|
+          run_autocorrection(path, source_code, safety)
+        end
+      end
+
+      def run_inspection(path, source_code)
+        if source_code
+          offenses = @runtime.offenses(path || 'example.rb', source_code, source_code.encoding)
+          offenses.to_json
+        else
+          process_files(path, filter_empty: true) do |file, source|
+            offenses = @runtime.offenses(file, source, source.encoding)
+
+            { path: PathUtil.relative_path(file), offenses: offenses }
+          end
+        end
+      end
+
+      def run_autocorrection(path, source_code, safety)
+        command = safety ? 'rubocop.formatAutocorrects' : 'rubocop.formatAutocorrectsAll'
+
+        if source_code
+          @runtime.format(path || 'example.rb', source_code, command: command).tap do |corrected|
+            write_file(path, corrected) if path
+          end
+        else
+          process_files(path) do |file, source|
+            @runtime.format(file, source, command: command).then do |corrected|
+              write_file(file, corrected)
+
+              { path: PathUtil.relative_path(file), corrected: source != corrected }
+            end
+          end
+        end
+      end
+
+      def process_files(path, filter_empty: false)
+        target_finder = RuboCop::TargetFinder.new(@config_store, @options)
+        target_files = target_finder.find(path ? [path] : [], :only_recognized_file_types)
+        all_files = target_files.map { |file| yield(file, read_file(file)) }
+        files = filter_empty ? all_files.reject { |f| f[:offenses]&.empty? } : all_files
+
+        { files: files, summary: build_summary(target_files, all_files) }.to_json
+      end
+
+      def read_file(file)
+        config = @config_store.for_file(file)
+        RuboCop::ProcessedSource.from_file(
+          file, config.target_ruby_version, parser_engine: config.parser_engine
+        ).raw_source
+      rescue Errno::ENOENT
+        raise RuboCop::Error, "No such file or directory: #{file}"
+      end
+
+      def write_file(file, content)
+        File.write(file, content)
+      rescue Errno::EACCES
+        raise RuboCop::Error, "Permission denied: #{file}"
+      rescue Errno::ENOSPC
+        raise RuboCop::Error, "No space left on device: #{file}"
+      rescue Errno::EROFS
+        raise RuboCop::Error, "Read-only file system: #{file}"
+      end
+
+      # NOTE: It is useful for RuboCop's result summary to be shown in the LLM's responses
+      # during interactions, so the summary is returned in a form that is easy for the LLM
+      # to reason about. Since LLM execution is non-deterministic, it is also sensible to
+      # compute the summary deterministically at this stage.
+      def build_summary(target_files, files)
+        summary = { target_file_count: target_files.count }
+        if files.first&.key?(:offenses)
+          summary[:offense_count] = files.sum { |f| f[:offenses].size }
+        else
+          summary[:corrected_file_count] = files.count { |f| f[:corrected] }
+        end
+        summary
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def build_tool(
+        name:, description:,
+        title:, destructive_hint:, idempotent_hint:, read_only_hint:, safety_required:
+      )
+        if safety_required
+          safety_property = { safety: { type: 'boolean' } }
+          required = ['safety']
+        else
+          safety_property = {}
+          required = nil
+        end
+
+        ::MCP::Tool.define(
+          name: name,
+          description: description,
+          input_schema: {
+            properties: {
+              path: { type: 'string' },
+              source_code: { type: 'string' }
+            }.merge(safety_property),
+            required: required
+          }.compact,
+          annotations: {
+            title: title,
+            destructive_hint: destructive_hint,
+            idempotent_hint: idempotent_hint,
+            open_world_hint: false,
+            read_only_hint: read_only_hint
+          }
+        ) do |path: nil, source_code: nil, safety: true|
+          result = yield(path, source_code, safety)
+
+          ::MCP::Tool::Response.new([{ type: 'text', text: result }])
+        rescue RuboCop::Error => e
+          ::MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+    end
+  end
+end

data/lib/rubocop/options.rb

@@ -16,7 +16,7 @@ module RuboCop
                       'root of the project. RuboCop will use this path to determine which ' \
                       'cops are enabled (via eg. Include/Exclude), and so that certain cops ' \
                       'like Naming/FileName can be checked.'
-    EXITING_OPTIONS = %i[version verbose_version show_cops show_docs_url lsp].freeze
+    EXITING_OPTIONS = %i[version verbose_version show_cops show_docs_url lsp mcp].freeze
     DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
@@ -57,6 +57,7 @@ module RuboCop
         add_check_options(opts)
         add_cache_options(opts)
         add_lsp_option(opts)
+        add_mcp_option(opts)
         add_server_options(opts)
         add_output_options(opts)
         add_autocorrection_options(opts)
@@ -215,6 +216,12 @@ module RuboCop
       end
     end
 
+    def add_mcp_option(opts)
+      section(opts, 'MCP Option') do
+        option(opts, '--mcp')
+      end
+    end
+
     def add_server_options(opts)
       section(opts, 'Server Options') do
         option(opts, '--[no-]server')
@@ -651,6 +658,8 @@ module RuboCop
       server_status:                    'Show server status.',
       no_detach:                        'Run the server process in the foreground.',
       lsp:                              'Start a language server listening on STDIN.',
+      mcp:                              ['Start an MCP (Model Context Protocol) server that',
+                                         'communicates over stdio.'],
       raise_cop_error:                  ['Raise cop-related errors with cause and location.',
                                          'This is used to prevent cops from failing silently.',
                                          'Default is false.'],

data/lib/rubocop/path_util.rb

@@ -10,7 +10,19 @@ module RuboCop
 
     module_function
 
-    def relative_path(path, base_dir = Dir.pwd)
+    # Returns the current working directory, cached for the duration of a run.
+    # Dir.pwd is a syscall; caching it avoids repeated overhead since RuboCop
+    # never changes the working directory during a run.
+    def pwd
+      @pwd ||= Dir.pwd
+    end
+
+    # Reset the cached pwd. Only needed in tests that use Dir.chdir.
+    def reset_pwd
+      @pwd = nil
+    end
+
+    def relative_path(path, base_dir = PathUtil.pwd)
       PathUtil.relative_paths_cache[base_dir][path] ||=
         # Optimization for the common case where path begins with the base
         # dir. Just cut off the first part.
@@ -41,7 +53,7 @@ module RuboCop
           path.uri.to_s
         else
           # Ideally, we calculate this relative to the project root.
-          base_dir = Dir.pwd
+          base_dir = PathUtil.pwd
 
           if path.start_with? base_dir
             relative_path(path, base_dir)

data/lib/rubocop/plugin/loader.rb

@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def require_plugin(require_path)
-          FeatureLoader.load(config_directory_path: Dir.pwd, feature: require_path)
+          FeatureLoader.load(config_directory_path: PathUtil.pwd, feature: require_path)
         end
 
         def constantize_plugin_from_gemspec_metadata(plugin_name)