rubocop 0.93.1 → 1.79.2

data/lib/rubocop/runner.rb

@@ -8,25 +8,51 @@ module RuboCop
   class Runner # rubocop:disable Metrics/ClassLength
     # An exception indicating that the inspection loop got stuck correcting
     # offenses back and forth.
-    class InfiniteCorrectionLoop < RuntimeError
+    class InfiniteCorrectionLoop < StandardError
       attr_reader :offenses
 
       def initialize(path, offenses_by_iteration, loop_start: -1)
         @offenses = offenses_by_iteration.flatten.uniq
-        root_cause = offenses_by_iteration[loop_start..-1]
+        root_cause = offenses_by_iteration[loop_start..]
                      .map { |x| x.map(&:cop_name).uniq.join(', ') }
                      .join(' -> ')
 
         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
 
     # @api private
     MAX_ITERATIONS = 200
 
+    # @api private
+    REDUNDANT_COP_DISABLE_DIRECTIVE_RULES = %w[
+      Lint/RedundantCopDisableDirective RedundantCopDisableDirective Lint
+    ].freeze
+
     attr_reader :errors, :warnings
     attr_writer :aborting
 
@@ -60,11 +86,19 @@ module RuboCop
 
     private
 
-    # Warms up the RuboCop cache by forking a suitable number of rubocop
+    # Warms up the RuboCop cache by forking a suitable number of RuboCop
     # instances that each inspects its allotted group of files.
     def warm_cache(target_files)
+      saved_options = @options.dup
+      if target_files.length <= 1
+        puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug]
+        return
+      end
       puts 'Running parallel inspection' if @options[:debug]
-      Parallel.each(target_files, &method(:file_offenses))
+      %i[autocorrect safe_autocorrect].each { |opt| @options[opt] = false }
+      Parallel.each(target_files) { |target_file| file_offenses(target_file) }
+    ensure
+      @options = saved_options
     end
 
     def find_target_files(paths)
@@ -101,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
@@ -112,17 +146,18 @@ module RuboCop
     end
 
     def list_files(paths)
-      paths.each do |path|
-        puts PathUtil.relative_path(path)
-      end
+      paths.each { |path| puts PathUtil.relative_path(path) }
     end
 
     def process_file(file)
       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
@@ -145,10 +180,10 @@ module RuboCop
 
       if cache&.valid?
         offenses = cache.load
-        # If we're running --auto-correct and the cache says there are
+        # If we're running --autocorrect and the cache says there are
         # offenses, we need to actually inspect the file. If the cache shows no
         # offenses, we're good.
-        real_run_needed = @options[:auto_correct] && offenses.any?
+        real_run_needed = @options[:autocorrect] && offenses.any?
       else
         real_run_needed = true
       end
@@ -188,41 +223,37 @@ module RuboCop
     end
 
     def check_for_redundant_disables?(source)
-      !source.disabled_line_ranges.empty? && !filtered_run?
+      return false if source.disabled_line_ranges.empty? || except_redundant_cop_disable_directive?
+
+      !@options[:only]
     end
 
     def redundant_cop_disable_directive(file)
       config = @config_store.for_file(file)
-      if config.for_cop(Cop::Lint::RedundantCopDisableDirective)
-               .fetch('Enabled')
-        cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
-        yield cop if cop.relevant_file?(file)
-      end
+      return unless config.for_cop(Cop::Lint::RedundantCopDisableDirective).fetch('Enabled')
+
+      cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
+      yield cop if cop.relevant_file?(file)
     end
 
-    def filtered_run?
-      @options[:except] || @options[:only]
+    def except_redundant_cop_disable_directive?
+      @options[:except] && (@options[:except] & REDUNDANT_COP_DISABLE_DIRECTIVE_RULES).any?
     end
 
     def file_started(file)
       puts "Scanning #{file}" if @options[:debug]
-      formatter_set.file_started(file,
-                                 cli_options: @options,
-                                 config_store: @config_store)
+      formatter_set.file_started(file, cli_options: @options, config_store: @config_store)
     end
 
     def file_finished(file, offenses)
-      if @options[:display_only_fail_level_offenses]
-        offenses = offenses.select { |o| considered_failure?(o) }
-      end
+      offenses = offenses_to_report(offenses)
       formatter_set.file_finished(file, offenses)
     end
 
     def cached_run?
       @cached_run ||=
         (@options[:cache] == 'true' ||
-         @options[:cache] != 'false' &&
-         @config_store.for_pwd.for_all_cops['UseCache']) &&
+         (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) &&
         # When running --auto-gen-config, there's some processing done in the
         # cops related to calculating the Max parameters for Metrics cops. We
         # need to do that processing and cannot use caching.
@@ -248,7 +279,7 @@ module RuboCop
       # error message.
       offenses_by_iteration = []
 
-      # When running with --auto-correct, we need to inspect the file (which
+      # When running with --autocorrect, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
@@ -312,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)
@@ -323,11 +376,16 @@ module RuboCop
       Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
     end
 
-    def mobilized_cop_classes(config)
+    def mobilized_cop_classes(config) # rubocop:disable Metrics/AbcSize
       @mobilized_cop_classes ||= {}.compare_by_identity
       @mobilized_cop_classes[config] ||= begin
         cop_classes = Cop::Registry.all
 
+        # `@options[:only]` and `@options[:except]` are not qualified until
+        # needed so that the Registry can be fully loaded, including any
+        # cops added by `require`s.
+        qualify_option_cop_names
+
         OptionsValidator.new(@options).validate_cop_options
 
         if @options[:only]
@@ -342,6 +400,16 @@ module RuboCop
       end
     end
 
+    def qualify_option_cop_names
+      %i[only except].each do |option|
+        next unless @options[option]
+
+        @options[option].map! do |cop_name|
+          Cop::Registry.qualified_cop_name(cop_name, "--#{option} option")
+        end
+      end
+    end
+
     def filter_cop_classes(cop_classes, config)
       # use only cops that link to a style guide if requested
       return unless style_guide_cops_only?(config)
@@ -357,42 +425,90 @@ module RuboCop
       @formatter_set ||= begin
         set = Formatter::FormatterSet.new(@options)
         pairs = @options[:formatters] || [['progress']]
-        pairs.each do |formatter_key, output_path|
-          set.add_formatter(formatter_key, output_path)
-        end
+        pairs.each { |formatter_key, output_path| set.add_formatter(formatter_key, output_path) }
         set
       end
     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 offense_displayed?(offense)
+      if @options[:display_only_fail_level_offenses]
+        considered_failure?(offense)
+      elsif @options[:display_only_safe_correctable]
+        supports_safe_autocorrect?(offense)
+      elsif @options[:display_only_correctable]
+        offense.correctable?
+      else
+        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)
+
+      offense.correctable? &&
+        cop_class&.support_autocorrect? && mark_as_safe_by_config?(default_cfg)
+    end
+
+    def mark_as_safe_by_config?(config)
+      config.nil? || (config.fetch('Safe', true) && config.fetch('SafeAutoCorrect', true))
+    end
+
+    def default_config(cop_name)
+      RuboCop::ConfigLoader.default_configuration[cop_name]
+    end
+
     def minimum_severity_to_fail
       @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)
-      ruby_version = @config_store.for_file(file).target_ruby_version
-
-      if @options[:stdin]
-        ProcessedSource.new(@options[:stdin], ruby_version, file)
-      else
-        begin
-          ProcessedSource.from_file(file, ruby_version)
-        rescue Errno::ENOENT
-          raise RuboCop::Error, "No such file or directory: #{file}"
-        end
-      end
-    end
+      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,
+                             parser_engine: parser_engine,
+                             prism_result: @prism_result
+                           )
+                         else
+                           begin
+                             ProcessedSource.from_file(
+                               file, ruby_version, parser_engine: parser_engine
+                             )
+                           rescue Errno::ENOENT
+                             raise RuboCop::Error, "No such file or directory: #{file}"
+                           end
+                         end
+      processed_source.config = config
+      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

@@ -0,0 +1,208 @@
+# 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.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # Caches the states of server process.
+    # @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
+
+        # Searches for Gemfile or gems.rb in the current dir or any parent dirs
+        def project_dir
+          current_dir = Dir.pwd
+          while current_dir != '/'
+            return current_dir if GEMFILE_NAMES.any? do |gemfile|
+              File.exist?(File.join(current_dir, gemfile))
+            end
+
+            current_dir = File.expand_path('..', current_dir)
+          end
+          # If we can't find a Gemfile, just use the current directory
+          Dir.pwd
+        end
+
+        def project_dir_cache_key
+          @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?
+          end
+        end
+
+        def cache_path
+          cache_root_dir = if cache_root_path
+                             File.join(cache_root_path, 'rubocop_cache')
+                           else
+                             cache_root_dir_from_config
+                           end
+
+          File.expand_path(File.join(cache_root_dir, 'server'))
+        end
+
+        def cache_root_dir_from_config
+          CacheConfig.root_dir do
+            # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
+            # so that only the necessary `CacheRootDirectory` can be obtained.
+            config_path = ConfigFinder.find_config_path(Dir.pwd)
+            file_contents = File.read(config_path)
+
+            # 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')
+              config_yaml == false ? nil : config_yaml
+            end
+
+            config_yaml&.dig('AllCops', 'CacheRootDirectory')
+          end
+        end
+
+        def port_path
+          dir.join('port')
+        end
+
+        def token_path
+          dir.join('token')
+        end
+
+        def pid_path
+          dir.join('pid')
+        end
+
+        def lock_path
+          dir.join('lock')
+        end
+
+        def status_path
+          dir.join('status')
+        end
+
+        def version_path
+          dir.join('version')
+        end
+
+        def stderr_path
+          dir.join('stderr')
+        end
+
+        def pid_running?
+          Process.kill(0, pid_path.read.to_i) == 1
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG
+          false
+        end
+
+        def acquire_lock
+          lock_file = File.open(lock_path, File::CREAT)
+          # flock returns 0 if successful, and false if not.
+          flock_result = lock_file.flock(File::LOCK_EX | File::LOCK_NB)
+          yield flock_result != false
+        ensure
+          lock_file.flock(File::LOCK_UN)
+          lock_file.close
+        end
+
+        def write_port_and_token_files(port:, token:)
+          port_path.write(port)
+          token_path.write(token)
+        end
+
+        def write_pid_file
+          pid_path.write(Process.pid)
+          yield
+        ensure
+          dir.rmtree
+        end
+
+        def write_status_file(status)
+          status_path.write(status)
+        end
+
+        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
+end