rubocop 1.44.1 → 1.78.0

data/lib/rubocop/rspec/shared_contexts.rb

@@ -11,6 +11,8 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       # Make sure to expand all symlinks in the path first. Otherwise we may
       # get mismatched pathnames when loading config files later on.
       tmpdir = File.realpath(tmpdir)
+      # Make upwards search for .rubocop.yml files stop at this directory.
+      RuboCop::FileFinder.root_level = tmpdir
 
       virtual_home = File.expand_path(File.join(tmpdir, 'home'))
       Dir.mkdir(virtual_home)
@@ -21,9 +23,6 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       root = example.metadata[:root]
       working_dir = root ? File.join(base_dir, 'work', root) : File.join(base_dir, 'work')
 
-      # Make upwards search for .rubocop.yml files stop at this directory.
-      RuboCop::FileFinder.root_level = working_dir
-
       begin
         FileUtils.mkdir_p(working_dir)
 
@@ -51,6 +50,26 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
   end
 end
 
+# Workaround for https://github.com/rubocop/rubocop/issues/12978,
+# there should already be no gemfile in the temp directory
+RSpec.shared_context 'isolated bundler' do
+  around do |example|
+    # No bundler env and reset cached gemfile path
+    Bundler.with_unbundled_env do
+      old_values = Bundler.instance_variables.to_h do |name|
+        [name, Bundler.instance_variable_get(name)]
+      end
+      Bundler.instance_variables.each { |name| Bundler.remove_instance_variable(name) }
+      example.call
+    ensure
+      Bundler.instance_variables.each { |name| Bundler.remove_instance_variable(name) }
+      old_values.each do |name, value|
+        Bundler.instance_variable_set(name, value)
+      end
+    end
+  end
+end
+
 RSpec.shared_context 'maintain registry' do
   around(:each) { |example| RuboCop::Cop::Registry.with_temporary_global { example.run } }
 
@@ -61,15 +80,30 @@ RSpec.shared_context 'maintain registry' do
   end
 end
 
+RSpec.shared_context 'maintain default configuration' do
+  around(:each) do |example|
+    # Make a copy of the current configuration that will not change when source hash changes
+    default_configuration = RuboCop::ConfigLoader.default_configuration
+    config = RuboCop::Config.create(
+      default_configuration.to_h.clone,
+      default_configuration.loaded_path
+    )
+
+    example.run
+
+    RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+  end
+end
+
 # This context assumes nothing and defines `cop`, among others.
 RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
   ### Meant to be overridden at will
 
   let(:cop_class) do
     unless described_class.is_a?(Class) && described_class < RuboCop::Cop::Base
-      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`, ' \
-            'or RuboCop::Cop::Cop for legacy)'
+      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`)'
     end
+
     described_class
   end
 
@@ -79,6 +113,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
   let(:cop_options) { {} }
 
+  let(:gem_versions) { {} }
+
   ### Utilities
 
   def source_range(range, buffer: source_buffer)
@@ -101,17 +137,30 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
   let(:cur_cop_config) do
     RuboCop::ConfigLoader
       .default_configuration.for_cop(cop_class)
-      .merge({
-               'Enabled' => true, # in case it is 'pending'
-               'AutoCorrect' => true # in case defaults set it to false
-             })
+      .merge(
+        'Enabled' => true, # in case it is 'pending'
+        'AutoCorrect' => 'always' # in case defaults set it to 'disabled' or false
+      )
       .merge(cop_config)
   end
 
   let(:config) do
     hash = { 'AllCops' => all_cops_config, cop_class.cop_name => cur_cop_config }.merge!(other_cops)
 
-    RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
+    config = RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
+
+    rails_version_in_gemfile = Gem::Version.new(
+      rails_version || RuboCop::Config::DEFAULT_RAILS_VERSION
+    )
+
+    allow(config).to receive(:gem_versions_in_target).and_return(
+      {
+        'railties' => rails_version_in_gemfile,
+        **gem_versions.transform_values { |value| Gem::Version.new(value) }
+      }
+    )
+
+    config
   end
 
   let(:cop) { cop_class.new(config, cop_options) }
@@ -129,46 +178,94 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
+RSpec.shared_context 'mock obsoletion' do
+  include_context 'mock console output'
+
+  let(:obsoletion_configuration_path) { 'obsoletions.yml' }
+
+  before do
+    RuboCop::ConfigObsoletion.reset!
+    allow(RuboCop::ConfigObsoletion).to receive(:files).and_return([obsoletion_configuration_path])
+  end
+
+  after do
+    RuboCop::ConfigObsoletion.reset!
+  end
+end
+
+RSpec.shared_context 'lsp' do
+  before do
+    RuboCop::LSP.enable
+  end
+
+  after do
+    RuboCop::LSP.disable
+  end
+end
+
 RSpec.shared_context 'ruby 2.0' do
-  let(:ruby_version) { 2.0 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.0 }
 end
 
 RSpec.shared_context 'ruby 2.1' do
-  let(:ruby_version) { 2.1 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.1 }
 end
 
 RSpec.shared_context 'ruby 2.2' do
-  let(:ruby_version) { 2.2 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.2 }
 end
 
 RSpec.shared_context 'ruby 2.3' do
-  let(:ruby_version) { 2.3 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.3 }
 end
 
 RSpec.shared_context 'ruby 2.4' do
-  let(:ruby_version) { 2.4 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.4 }
 end
 
 RSpec.shared_context 'ruby 2.5' do
-  let(:ruby_version) { 2.5 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.5 }
 end
 
 RSpec.shared_context 'ruby 2.6' do
-  let(:ruby_version) { 2.6 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.6 }
 end
 
 RSpec.shared_context 'ruby 2.7' do
-  let(:ruby_version) { 2.7 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.7 }
 end
 
 RSpec.shared_context 'ruby 3.0' do
-  let(:ruby_version) { 3.0 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 3.0 }
 end
 
 RSpec.shared_context 'ruby 3.1' do
-  let(:ruby_version) { 3.1 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 3.1 }
 end
 
 RSpec.shared_context 'ruby 3.2' do
-  let(:ruby_version) { 3.2 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 3.2 }
+end
+
+RSpec.shared_context 'ruby 3.3' do
+  let(:ruby_version) { 3.3 }
+end
+
+RSpec.shared_context 'ruby 3.4' do
+  let(:ruby_version) { 3.4 }
+end
+
+RSpec.shared_context 'ruby 3.5' do
+  let(:ruby_version) { 3.5 }
 end

data/lib/rubocop/rspec/support.rb

@@ -4,16 +4,19 @@
 
 require_relative 'cop_helper'
 require_relative 'expect_offense'
-require_relative 'host_environment_simulation_helper'
 require_relative 'parallel_formatter'
 require_relative 'shared_contexts'
 
 RSpec.configure do |config|
   config.include CopHelper
-  config.include HostEnvironmentSimulatorHelper
+  config.include RuboCop::RSpec::ExpectOffense
   config.include_context 'config', :config
   config.include_context 'isolated environment', :isolated_environment
+  config.include_context 'isolated bundler', :isolated_bundler
+  config.include_context 'lsp', :lsp
   config.include_context 'maintain registry', :restore_registry
+  config.include_context 'maintain default configuration', :restore_configuration
+  config.include_context 'mock obsoletion', :mock_obsoletion
   config.include_context 'ruby 2.0', :ruby20
   config.include_context 'ruby 2.1', :ruby21
   config.include_context 'ruby 2.2', :ruby22
@@ -25,4 +28,7 @@ RSpec.configure do |config|
   config.include_context 'ruby 3.0', :ruby30
   config.include_context 'ruby 3.1', :ruby31
   config.include_context 'ruby 3.2', :ruby32
+  config.include_context 'ruby 3.3', :ruby33
+  config.include_context 'ruby 3.4', :ruby34
+  config.include_context 'ruby 3.5', :ruby35
 end

data/lib/rubocop/runner.rb

@@ -20,7 +20,28 @@ module RuboCop
         message = 'Infinite loop detected'
         message += " in #{path}" if path
         message += " and caused by #{root_cause}" if root_cause
-        super message
+        super(message)
+      end
+    end
+
+    class << self
+      # @return [Array<#call>]
+      def ruby_extractors
+        @ruby_extractors ||= [default_ruby_extractor]
+      end
+
+      private
+
+      # @return [#call]
+      def default_ruby_extractor
+        lambda do |processed_source|
+          [
+            {
+              offset: 0,
+              processed_source: processed_source
+            }
+          ]
+        end
       end
     end
 
@@ -114,7 +135,7 @@ module RuboCop
         offenses = process_file(file)
         yield file
 
-        if offenses.any? { |o| considered_failure?(o) }
+        if offenses.any? { |o| considered_failure?(o) && offense_displayed?(o) }
           break false if @options[:fail_fast]
 
           next false
@@ -132,8 +153,11 @@ module RuboCop
       file_started(file)
       offenses = file_offenses(file)
     rescue InfiniteCorrectionLoop => e
+      raise e if @options[:raise_cop_error]
+
+      errors << e
+      warn Rainbow(e.message).red
       offenses = e.offenses.compact.sort.freeze
-      raise
     ensure
       file_finished(file, offenses || [])
     end
@@ -319,10 +343,32 @@ module RuboCop
     end
 
     def inspect_file(processed_source, team = mobilize_team(processed_source))
-      report = team.investigate(processed_source)
-      @errors.concat(team.errors)
-      @warnings.concat(team.warnings)
-      [report.offenses, team.updated_source_file?]
+      extracted_ruby_sources = extract_ruby_sources(processed_source)
+      offenses = extracted_ruby_sources.flat_map do |extracted_ruby_source|
+        report = team.investigate(
+          extracted_ruby_source[:processed_source],
+          offset: extracted_ruby_source[:offset],
+          original: processed_source
+        )
+        @errors.concat(team.errors)
+        @warnings.concat(team.warnings)
+        report.offenses
+      end
+      [offenses, team.updated_source_file?]
+    end
+
+    def extract_ruby_sources(processed_source)
+      self.class.ruby_extractors.find do |ruby_extractor|
+        result = ruby_extractor.call(processed_source)
+        break result if result
+      rescue StandardError
+        location = if ruby_extractor.is_a?(Proc)
+                     ruby_extractor.source_location
+                   else
+                     ruby_extractor.method(:call).source_location
+                   end
+        raise Error, "Ruby extractor #{location[0]} failed to process #{processed_source.path}."
+      end
     end
 
     def mobilize_team(processed_source)
@@ -385,26 +431,30 @@ module RuboCop
     end
 
     def considered_failure?(offense)
-      # For :autocorrect level, any offense - corrected or not - is a failure.
       return false if offense.disabled?
 
-      return true if @options[:fail_level] == :autocorrect
+      # For :autocorrect level, any correctable offense is a failure, regardless of severity
+      return true if @options[:fail_level] == :autocorrect && offense.correctable?
 
       !offense.corrected? && offense.severity >= minimum_severity_to_fail
     end
 
-    def offenses_to_report(offenses)
+    def offense_displayed?(offense)
       if @options[:display_only_fail_level_offenses]
-        offenses.select { |o| considered_failure?(o) }
+        considered_failure?(offense)
       elsif @options[:display_only_safe_correctable]
-        offenses.select { |o| supports_safe_autocorrect?(o) }
+        supports_safe_autocorrect?(offense)
       elsif @options[:display_only_correctable]
-        offenses.select(&:correctable?)
+        offense.correctable?
       else
-        offenses
+        true
       end
     end
 
+    def offenses_to_report(offenses)
+      offenses.select { |o| offense_displayed?(o) }
+    end
+
     def supports_safe_autocorrect?(offense)
       cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name)
       default_cfg = default_config(offense.cop_name)
@@ -425,19 +475,31 @@ module RuboCop
       @minimum_severity_to_fail ||= begin
         # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail
         name = @options[:fail_level] || :refactor
-        RuboCop::Cop::Severity.new(name)
+
+        # autocorrect is a fake level - use the default
+        RuboCop::Cop::Severity.new(name == :autocorrect ? :refactor : name)
       end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def get_processed_source(file)
       config = @config_store.for_file(file)
       ruby_version = config.target_ruby_version
+      parser_engine = config.parser_engine
 
       processed_source = if @options[:stdin]
-                           ProcessedSource.new(@options[:stdin], ruby_version, file)
+                           ProcessedSource.new(
+                             @options[:stdin],
+                             ruby_version,
+                             file,
+                             parser_engine: parser_engine,
+                             prism_result: @prism_result
+                           )
                          else
                            begin
-                             ProcessedSource.from_file(file, ruby_version)
+                             ProcessedSource.from_file(
+                               file, ruby_version, parser_engine: parser_engine
+                             )
                            rescue Errno::ENOENT
                              raise RuboCop::Error, "No such file or directory: #{file}"
                            end
@@ -446,6 +508,7 @@ module RuboCop
       processed_source.registry = mobilized_cop_classes(config)
       processed_source
     end
+    # rubocop:enable Metrics/MethodLength
 
     # A Cop::Team instance is stateful and may change when inspecting.
     # The "standby" team for a given config is an initialized but

data/lib/rubocop/server/cache.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'pathname'
+require 'yaml'
 require_relative '../cache_config'
 require_relative '../config_finder'
+require_relative '../path_util'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -19,6 +22,7 @@ module RuboCop
     # @api private
     class Cache
       GEMFILE_NAMES = %w[Gemfile gems.rb].freeze
+      LOCKFILE_NAMES = %w[Gemfile.lock gems.locked].freeze
 
       class << self
         attr_accessor :cache_root_path
@@ -41,6 +45,24 @@ module RuboCop
           @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
         end
 
+        # rubocop:disable Metrics/AbcSize
+        def restart_key(args_config_file_path: nil)
+          lockfile_path = LOCKFILE_NAMES.map do |lockfile_name|
+            Pathname(project_dir).join(lockfile_name)
+          end.find(&:exist?)
+          version_data = lockfile_path&.read || RuboCop::Version::STRING
+          config_data = Pathname(
+            args_config_file_path || ConfigFinder.find_config_path(Dir.pwd)
+          ).read
+          yaml = load_erb_templated_yaml(config_data)
+
+          inherit_from_data = inherit_from_data(yaml)
+          require_data = require_data(yaml)
+
+          Digest::SHA1.hexdigest(version_data + config_data + inherit_from_data + require_data)
+        end
+        # rubocop:enable Metrics/AbcSize
+
         def dir
           Pathname.new(File.join(cache_path, project_dir_cache_key)).tap do |d|
             d.mkpath unless d.exist?
@@ -61,16 +83,13 @@ module RuboCop
           CacheConfig.root_dir do
             # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
             # so that only the necessary `CacheRootDirectory` can be obtained.
-            require 'yaml'
             config_path = ConfigFinder.find_config_path(Dir.pwd)
-
-            require 'erb'
             file_contents = File.read(config_path)
-            yaml_code = ERB.new(file_contents).result
 
-            config_yaml = YAML.safe_load(
-              yaml_code, permitted_classes: [Regexp, Symbol], aliases: true
-            )
+            # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
+            next unless file_contents.include?('CacheRootDirectory')
+
+            config_yaml = load_erb_templated_yaml(file_contents)
 
             # For compatibility with Ruby 3.0 or lower.
             if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
@@ -111,7 +130,7 @@ module RuboCop
 
         def pid_running?
           Process.kill(0, pid_path.read.to_i) == 1
-        rescue Errno::ESRCH, Errno::ENOENT
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG
           false
         end
 
@@ -144,6 +163,45 @@ module RuboCop
         def write_version_file(version)
           version_path.write(version)
         end
+
+        def inherit_from_data(yaml)
+          return '' unless (inherit_from_paths = yaml['inherit_from'])
+
+          Array(inherit_from_paths).map do |path|
+            next if PathUtil.remote_file?(path)
+
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        def require_data(yaml)
+          return '' unless (require_paths = yaml['require'])
+
+          Array(require_paths).map do |path|
+            # NOTE: This targets only relative or absolute path specifications.
+            # For example, specifications like `require: rubocop-performance`,
+            # which can be loaded from `$LOAD_PATH`, are ignored.
+            next unless path.start_with?('.', '/')
+
+            # NOTE: `.so` files are not typically specified, so only `.rb` files are targeted.
+            path = "#{path}.rb" unless path.end_with?('.rb')
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        private
+
+        def load_erb_templated_yaml(content)
+          require 'erb'
+          yaml_code = ERB.new(content).result
+
+          require 'yaml'
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+        end
       end
     end
   end

data/lib/rubocop/server/cli.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'rainbow'
 require_relative '../arguments_env'
 require_relative '../arguments_file'
 
@@ -23,15 +22,21 @@ module RuboCop
       STATUS_ERROR = 2
 
       SERVER_OPTIONS = %w[
-        --server --no-server --server-status --restart-server --start-server --stop-server
+        --server
+        --no-server
+        --server-status
+        --restart-server
+        --start-server
+        --stop-server
+        --no-detach
       ].freeze
       EXCLUSIVE_OPTIONS = (SERVER_OPTIONS - %w[--server --no-server]).freeze
+      NO_DETACH_OPTIONS = %w[--server --start-server --restart-server].freeze
 
       def initialize
         @exit = false
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       def run(argv = ARGV)
         unless Server.support_server?
           return error('RuboCop server is not supported by this Ruby.') if use_server_option?(argv)
@@ -40,16 +45,34 @@ module RuboCop
         end
 
         Cache.cache_root_path = fetch_cache_root_path_from(argv)
-        deleted_server_arguments = delete_server_argument_from(argv)
 
-        if deleted_server_arguments.size >= 2
-          return error("#{deleted_server_arguments.join(', ')} cannot be specified together.")
+        process_arguments(argv)
+      end
+
+      def exit?
+        @exit
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def process_arguments(argv)
+        server_arguments = delete_server_argument_from(argv)
+
+        detach = !server_arguments.delete('--no-detach')
+
+        if server_arguments.size >= 2
+          return error("#{server_arguments.join(', ')} cannot be specified together.")
         end
 
-        server_command = deleted_server_arguments.first
+        server_command = server_arguments.first
+
+        unless detach || NO_DETACH_OPTIONS.include?(server_command)
+          return error("#{server_command} cannot be combined with --no-detach.")
+        end
 
         if EXCLUSIVE_OPTIONS.include?(server_command) && argv.count > allowed_option_count
-          return error("#{server_command} cannot be combined with other options.")
+          return error("#{server_command} cannot be combined with #{argv[0]}.")
         end
 
         if server_command.nil?
@@ -57,23 +80,17 @@ module RuboCop
                            ArgumentsFile.read_as_arguments.delete('--server')
         end
 
-        run_command(server_command)
+        run_command(server_command, detach: detach)
 
         STATUS_SUCCESS
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      def exit?
-        @exit
-      end
-
-      private
-
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
-      def run_command(server_command)
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def run_command(server_command, detach:)
         case server_command
         when '--server'
-          Server::ClientCommand::Start.new.run unless Server.running?
+          Server::ClientCommand::Start.new(detach: detach).run unless Server.running?
         when '--no-server'
           Server::ClientCommand::Stop.new.run if Server.running?
         when '--restart-server'
@@ -81,7 +98,7 @@ module RuboCop
           Server::ClientCommand::Restart.new.run
         when '--start-server'
           @exit = true
-          Server::ClientCommand::Start.new.run
+          Server::ClientCommand::Start.new(detach: detach).run
         when '--stop-server'
           @exit = true
           Server::ClientCommand::Stop.new.run
@@ -90,7 +107,7 @@ module RuboCop
           Server::ClientCommand::Status.new.run
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       def fetch_cache_root_path_from(arguments)
         cache_root = arguments.detect { |argument| argument.start_with?('--cache-root') }
@@ -118,6 +135,8 @@ module RuboCop
       end
 
       def error(message)
+        require 'rainbow'
+
         @exit = true
         warn Rainbow(message).red
 

data/lib/rubocop/server/client_command/base.rb

@@ -38,6 +38,16 @@ module RuboCop
             warn 'RuboCop server is not running.' unless running
           end
         end
+
+        class << self
+          def args_config_file_path
+            first_args_config_key_index = ARGV.index { |value| ['-c', '--config'].include?(value) }
+
+            return if first_args_config_key_index.nil?
+
+            ARGV[first_args_config_key_index + 1]
+          end
+        end
       end
     end
   end