rubocop 0.74.0 → 0.78.0

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -42,9 +42,13 @@ module RuboCop
         output.puts yellow("== #{smart_path(file)} ==")
 
         offenses.each do |o|
-          output.printf("%s:%3d:%3d: %s\n",
-                        colored_severity_code(o),
-                        o.line, o.real_column, message(o))
+          output.printf(
+            "%<severity>s:%3<line>d:%3<column>d: %<message>s\n",
+            severity: colored_severity_code(o),
+            line: o.line,
+            column: o.real_column,
+            message: message(o)
+          )
         end
       end
 
@@ -75,7 +79,15 @@ module RuboCop
       end
 
       def message(offense)
-        message = offense.corrected? ? green('[Corrected] ') : ''
+        message =
+          if offense.corrected_with_todo?
+            green('[Todo] ')
+          elsif offense.corrected?
+            green('[Corrected] ')
+          else
+            ''
+          end
+
         "#{message}#{annotate_message(offense.message)}"
       end
 

data/lib/rubocop/formatter/tap_formatter.rb

@@ -42,20 +42,23 @@ module RuboCop
       end
 
       def report_offense(file, offense)
-        output.printf("# %s:%d:%d: %s: %s\n",
-                      cyan(smart_path(file)), offense.line, offense.real_column,
-                      colored_severity_code(offense), message(offense))
+        output.printf(
+          "# %<path>s:%<line>d:%<column>d: %<severity>s: %<message>s\n",
+          path: cyan(smart_path(file)),
+          line: offense.line,
+          column: offense.real_column,
+          severity: colored_severity_code(offense),
+          message: message(offense)
+        )
 
-        # rubocop:disable Lint/HandleExceptions
         begin
           return unless valid_line?(offense)
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
+        rescue IndexError # rubocop:disable Lint/SuppressedException
           # range is not on a valid line; perhaps the source file is empty
         end
-        # rubocop:enable Lint/HandleExceptions
       end
 
       def annotate_message(msg)
@@ -63,7 +66,15 @@ module RuboCop
       end
 
       def message(offense)
-        message = offense.corrected? ? '[Corrected] ' : ''
+        message =
+          if offense.corrected_with_todo?
+            '[Todo] '
+          elsif offense.corrected?
+            '[Corrected] '
+          else
+            ''
+          end
+
         "#{message}#{annotate_message(offense.message)}"
       end
     end

data/lib/rubocop/magic_comment.rb

@@ -42,6 +42,10 @@ module RuboCop
       frozen_string_literal == true
     end
 
+    def valid_literal_value?
+      [true, false].include?(frozen_string_literal)
+    end
+
     # Was a magic comment for the frozen string literal found?
     #
     # @return [Boolean]

data/lib/rubocop/node_pattern.rb

@@ -380,7 +380,7 @@ module RuboCop
         def compile_seq_head
           return unless seq_head?
 
-          fail_due_to 'sequences can not start with <' \
+          fail_due_to 'sequences cannot start with <' \
             if @terms[0].respond_to? :call
 
           with_seq_head_context(@terms[0])
@@ -429,12 +429,13 @@ module RuboCop
         [0..Float::INFINITY, 'true']
       end
 
+      # rubocop:disable Metrics/AbcSize
       # rubocop:disable Metrics/MethodLength
       def compile_any_order(capture_all = nil)
         rest = capture_rest = nil
         patterns = []
         with_temp_variables do |child, matched|
-          tokens_until('>', 'any child').each do
+          tokens_until('>', 'any child') do
             fail_due_to 'ellipsis must be at the end of <>' if rest
             token = tokens.shift
             case token
@@ -448,6 +449,7 @@ module RuboCop
         end
       end
       # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
 
       def insure_same_captures(enum, what)
         return to_enum __method__, enum, what unless block_given?

data/lib/rubocop/options.rb

@@ -255,21 +255,27 @@ module RuboCop
       @options = options
     end
 
+    def validate_cop_options
+      %i[only except].each do |opt|
+        OptionsValidator.validate_cop_list(@options[opt])
+      end
+    end
+
     # rubocop:disable Metrics/AbcSize
     def validate_compatibility # rubocop:disable Metrics/MethodLength
-      if only_includes_unneeded_disable?
-        raise OptionArgumentError, 'Lint/UnneededCopDisableDirective can not ' \
+      if only_includes_redundant_disable?
+        raise OptionArgumentError, 'Lint/RedundantCopDisableDirective cannot ' \
                                    'be used with --only.'
       end
       if except_syntax?
-        raise OptionArgumentError, 'Syntax checking can not be turned off.'
+        raise OptionArgumentError, 'Syntax checking cannot be turned off.'
       end
       unless boolean_or_empty_cache?
         raise OptionArgumentError, '-C/--cache argument must be true or false'
       end
 
       if display_only_fail_level_offenses_with_autocorrect?
-        raise OptionArgumentError, '--autocorrect can not be used with ' \
+        raise OptionArgumentError, '--autocorrect cannot be used with ' \
           '--display-only-fail-level-offenses'
       end
       validate_auto_gen_config
@@ -323,8 +329,8 @@ module RuboCop
         auto_gen_config: '-P/--parallel uses caching to speed up execution, ' \
                          'while --auto-gen-config needs a non-cached run, ' \
                          'so they cannot be combined.',
-        fail_fast: '-P/--parallel can not be combined with -F/--fail-fast.',
-        auto_correct: '-P/--parallel can not be combined with --auto-correct.'
+        fail_fast: '-P/--parallel cannot be combined with -F/--fail-fast.',
+        auto_correct: '-P/--parallel cannot be combined with --auto-correct.'
       }
 
       combos.each do |key, msg|
@@ -332,10 +338,10 @@ module RuboCop
       end
     end
 
-    def only_includes_unneeded_disable?
+    def only_includes_redundant_disable?
       @options.key?(:only) &&
-        (@options[:only] & %w[Lint/UnneededCopDisableDirective
-                              UnneededCopDisableDirective]).any?
+        (@options[:only] & %w[Lint/RedundantCopDisableDirective
+                              RedundantCopDisableDirective]).any?
     end
 
     def display_only_fail_level_offenses_with_autocorrect?
@@ -367,8 +373,9 @@ module RuboCop
   # This module contains help texts for command line options.
   module OptionsHelp
     MAX_EXCL = RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS.to_s
+    # rubocop:disable Layout/LineLength
+    FORMATTER_OPTION_LIST = RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS.keys
 
-    # rubocop:disable Metrics/LineLength
     TEXT = {
       only:                             'Run only the given cop(s).',
       only_guide_cops:                  ['Run only cops for rules that link to a',
@@ -394,7 +401,7 @@ module RuboCop
                                          "properties to generate. Default is #{MAX_EXCL}."],
       disable_uncorrectable:            ['Used with --auto-correct to annotate any',
                                          'offenses that do not support autocorrect',
-                                         'with `rubocop:disable` comments.'],
+                                         'with `rubocop:todo` comments.'],
       force_exclusion:                  ['Force excluding files specified in the',
                                          'configuration `Exclude` even if they are',
                                          'explicitly passed as arguments.'],
@@ -407,20 +414,8 @@ module RuboCop
       format:                           ['Choose an output formatter. This option',
                                          'can be specified multiple times to enable',
                                          'multiple formatters at the same time.',
-                                         '  [p]rogress (default)',
-                                         '  [s]imple',
-                                         '  [c]lang',
-                                         '  [d]isabled cops via inline comments',
-                                         '  [fu]ubar',
-                                         '  [e]macs',
-                                         '  [j]son',
-                                         '  [h]tml',
-                                         '  [fi]les',
-                                         '  [o]ffenses',
-                                         '  [w]orst',
-                                         '  [t]ap',
-                                         '  [q]uiet',
-                                         '  [a]utogenconf',
+                                         '[p]rogress is used by default',
+                                         *FORMATTER_OPTION_LIST.map { |item| "  #{item}" },
                                          '  custom formatter class name'],
       out:                              ['Write output to a file instead of STDOUT.',
                                          'This option applies to the previously',
@@ -460,6 +455,6 @@ module RuboCop
                                          'reports. This is useful for editor integration.'],
       init:                             'Generate a .rubocop.yml file in the current directory.'
     }.freeze
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
   end
 end

data/lib/rubocop/processed_source.rb

@@ -163,7 +163,7 @@ module RuboCop
         ast, comments, tokens = parser.tokenize(@buffer)
 
         ast.respond_to?(:complete!) && ast.complete!
-      rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
+      rescue Parser::SyntaxError # rubocop:disable Lint/SuppressedException
         # All errors are in diagnostics. No need to handle exception.
       end
 

data/lib/rubocop/rake_task.rb

@@ -70,6 +70,7 @@ module RuboCop
           RakeFileUtils.verbose(verbose) do
             yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
             options = full_options.unshift('--auto-correct')
+            options.delete('--parallel')
             run_cli(verbose, options)
           end
         end

data/lib/rubocop/result_cache.rb

@@ -77,12 +77,13 @@ module RuboCop
       config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
-    def initialize(file, options, config_store, cache_root = nil)
+    def initialize(file, team, options, config_store, cache_root = nil)
       cache_root ||= ResultCache.cache_root(config_store)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root, rubocop_checksum,
-                        relevant_options_digest(options),
+      @path = File.join(cache_root,
+                        rubocop_checksum,
+                        context_checksum(team, options),
                         file_checksum(file, config_store))
       @cached_data = CachedData.new(file)
     end
@@ -100,7 +101,7 @@ module RuboCop
 
       begin
         FileUtils.mkdir_p(dir)
-      rescue Errno::EACCES => e
+      rescue Errno::EACCES, Errno::EROFS => e
         warn "Couldn't create cache directory. Continuing without cache."\
              "\n  #{e.message}"
         return
@@ -182,10 +183,25 @@ module RuboCop
     # don't affect caching.
     def relevant_options_digest(options)
       options = options.reject { |key, _| NON_CHANGING.include?(key) }
-      options = options.to_s.gsub(/[^a-z]+/i, '_')
-      # We must avoid making file names too long for some filesystems to handle
-      # If they are short, we can leave them human-readable
-      options.length <= 32 ? options : Digest::SHA1.hexdigest(options)
+      options.to_s.gsub(/[^a-z]+/i, '_')
+    end
+
+    # The external dependency checksums are cached per RuboCop team so that
+    # the checksums don't need to be recomputed for each file.
+    def team_checksum(team)
+      @checksum_by_team ||= {}
+      @checksum_by_team[team.object_id] ||= team.external_dependency_checksum
+    end
+
+    # We combine team and options into a single "context" checksum to avoid
+    # making file names that are too long for some filesystems to handle.
+    # This context is for anything that's not (1) the RuboCop executable
+    # checksum or (2) the inspected file checksum.
+    def context_checksum(team, options)
+      Digest::SHA1.hexdigest([
+        team_checksum(team),
+        relevant_options_digest(options)
+      ].join)
     end
   end
 end

data/lib/rubocop/runner.rb

@@ -104,30 +104,31 @@ module RuboCop
     end
 
     def process_file(file)
-      puts "Scanning #{file}" if @options[:debug]
       file_started(file)
-
       offenses = file_offenses(file)
-      if @options[:display_only_fail_level_offenses]
-        offenses = offenses.select { |o| considered_failure?(o) }
-      end
-      formatter_set.file_finished(file, offenses)
-      offenses
     rescue InfiniteCorrectionLoop => e
-      formatter_set.file_finished(file, e.offenses.compact.sort.freeze)
+      offenses = e.offenses.compact.sort.freeze
       raise
+    ensure
+      file_finished(file, offenses || [])
     end
 
     def file_offenses(file)
       file_offense_cache(file) do
         source = get_processed_source(file)
         source, offenses = do_inspection_loop(file, source)
-        add_unneeded_disables(file, offenses.compact.sort, source)
+        add_redundant_disables(file, offenses.compact.sort, source)
       end
     end
 
+    def cached_result(file, team)
+      ResultCache.new(file, team, @options, @config_store)
+    end
+
     def file_offense_cache(file)
-      cache = ResultCache.new(file, @options, @config_store) if cached_run?
+      config = @config_store.for(file)
+      cache = cached_result(file, standby_team(config)) if cached_run?
+
       if cache&.valid?
         offenses = cache.load
         # If we're running --auto-correct and the cache says there are
@@ -146,48 +147,66 @@ module RuboCop
       offenses
     end
 
-    def add_unneeded_disables(file, offenses, source)
-      if check_for_unneeded_disables?(source)
-        config = @config_store.for(file)
-        if config.for_cop(Cop::Lint::UnneededCopDisableDirective)
-                 .fetch('Enabled')
-          cop = Cop::Lint::UnneededCopDisableDirective.new(config, @options)
-          if cop.relevant_file?(file)
-            cop.check(offenses, source.disabled_line_ranges, source.comments)
-            offenses += cop.offenses
-            autocorrect_unneeded_disables(source, cop)
-          end
+    def add_redundant_disables(file, offenses, source)
+      if check_for_redundant_disables?(source)
+        redundant_cop_disable_directive(file) do |cop|
+          cop.check(offenses, source.disabled_line_ranges, source.comments)
+          offenses += cop.offenses
+          offenses += autocorrect_redundant_disables(file, source, cop,
+                                                     offenses)
         end
-        offenses
       end
 
       offenses.sort.reject(&:disabled?).freeze
     end
 
-    def check_for_unneeded_disables?(source)
+    def check_for_redundant_disables?(source)
       !source.disabled_line_ranges.empty? && !filtered_run?
     end
 
+    def redundant_cop_disable_directive(file)
+      config = @config_store.for(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
+    end
+
     def filtered_run?
       @options[:except] || @options[:only]
     end
 
-    def autocorrect_unneeded_disables(source, cop)
+    def autocorrect_redundant_disables(file, source, cop, offenses)
       cop.processed_source = source
 
-      Cop::Team.new(
-        RuboCop::Cop::Registry.new,
-        nil,
-        @options
-      ).autocorrect(source.buffer, [cop])
+      team = Cop::Team.new(RuboCop::Cop::Registry.new, nil, @options)
+      team.autocorrect(source.buffer, [cop])
+
+      return [] unless team.updated_source_file?
+
+      # Do one extra inspection loop if any redundant disables were
+      # removed. This is done in order to find rubocop:enable directives that
+      # have now become useless.
+      _source, new_offenses = do_inspection_loop(file,
+                                                 get_processed_source(file))
+      new_offenses - offenses
     end
 
     def file_started(file)
+      puts "Scanning #{file}" if @options[:debug]
       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
+      formatter_set.file_finished(file, offenses)
+    end
+
     def cached_run?
       @cached_run ||=
         (@options[:cache] == 'true' ||
@@ -195,7 +214,7 @@ module RuboCop
          @config_store.for(Dir.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 can not use caching.
+        # need to do that processing and cannot use caching.
         !@options[:auto_gen_config] &&
         # We can't cache results from code which is piped in to stdin
         !@options[:stdin]
@@ -285,9 +304,7 @@ module RuboCop
       @mobilized_cop_classes[config.object_id] ||= begin
         cop_classes = Cop::Cop.all
 
-        %i[only except].each do |opt|
-          OptionsValidator.validate_cop_list(@options[opt])
-        end
+        OptionsValidator.new(@options).validate_cop_options
 
         if @options[:only]
           cop_classes.select! { |c| c.match?(@options[:only]) }
@@ -348,5 +365,15 @@ module RuboCop
         ProcessedSource.from_file(file, ruby_version)
       end
     end
+
+    # A Cop::Team instance is stateful and may change when inspecting.
+    # The "standby" team for a given config is an initialized but
+    # otherwise dormant team that can be used for config- and option-
+    # level caching in ResultCache.
+    def standby_team(config)
+      @team_by_config ||= {}
+      @team_by_config[config.object_id] ||=
+        Cop::Team.new(mobilized_cop_classes(config), config, @options)
+    end
   end
 end