rubocop 1.71.1 → 1.92.0

data/lib/rubocop/formatter/json_formatter.rb

@@ -13,19 +13,29 @@ module RuboCop
       def initialize(output, options = {})
         super
         @output_hash = { metadata: metadata_hash, files: [], summary: { offense_count: 0 } }
+        @problems = {}
       end
 
       def started(target_files)
         output_hash[:summary][:target_file_count] = target_files.count
       end
 
+      def file_problems(file, errors, warnings)
+        @problems[file] = hash_for_problems(file, errors, warnings)
+      end
+
       def file_finished(file, offenses)
-        output_hash[:files] << hash_for_file(file, offenses)
+        entry = hash_for_file(file, offenses)
+        problems = @problems.delete(file)
+        entry.merge!(problems) if problems
+
+        output_hash[:files] << entry
         output_hash[:summary][:offense_count] += offenses.count
       end
 
       def finished(inspected_files)
         output_hash[:summary][:inspected_file_count] = inspected_files.count
+        output_hash[:summary].merge!(problem_counts(output_hash[:files]))
         output.write output_hash.to_json
       end
 
@@ -46,8 +56,34 @@ module RuboCop
         }
       end
 
-      def hash_for_offense(offense)
+      # A cop that crashes fails once per node it visits, so messages that
+      # differ only in their line and column are listed once, at the first place
+      # they happened. They name the file the way its entry does. The keys are
+      # absent when there's nothing to report, which keeps them additive for
+      # existing consumers.
+      def hash_for_problems(file, errors, warnings)
+        return {} if errors.empty? && warnings.empty?
+
+        path = smart_path(file)
+        location = /#{Regexp.escape(File.expand_path(file))}((?::\d+)*)/
+
+        { errors: errors, warnings: warnings }.filter_map do |key, messages|
+          next if messages.empty?
+
+          messages = messages.uniq { |message| message.gsub(location, '') }
+          [key, messages.map { |message| message.gsub(location) { path + Regexp.last_match(1) } }]
+        end.to_h
+      end
+
+      def problem_counts(files)
         {
+          error_count: files.sum { |f| f[:errors]&.size.to_i },
+          warning_count: files.sum { |f| f[:warnings]&.size.to_i }
+        }.reject { |_, count| count.zero? }
+      end
+
+      def hash_for_offense(offense)
+        hash = {
           severity:    offense.severity.name,
           message:     offense.message,
           cop_name:    offense.cop_name,
@@ -55,18 +91,57 @@ module RuboCop
           correctable: offense.correctable?,
           location:    hash_for_location(offense)
         }
+
+        # Suppressed offenses appear only under `--display-suppressed`, so
+        # these keys are additive for existing consumers.
+        if offense.disabled?
+          hash[:suppressed] = true
+          hash[:justification] = offense.justification
+        end
+
+        # The edits autocorrection would make, so a consumer can apply or review
+        # them without running autocorrection itself. Additive, and absent when
+        # the offense has no correction.
+        hash[:correction] = correction_for(offense) unless offense.corrections.empty?
+
+        hash
+      end
+
+      def correction_for(offense)
+        { safe: offense.correction_safe, edits: edits_for(offense) }
+      end
+
+      def edits_for(offense)
+        buffer = offense.location.source_buffer
+
+        offense.corrections.map do |correction|
+          # Built as a range so the columns follow the same 1-based convention
+          # as `hash_for_location`, end-exclusive column included.
+          range = ::Parser::Source::Range.new(buffer, correction.begin_pos, correction.end_pos)
+
+          hash_for_edit_range(range).merge!(
+            begin_pos: correction.begin_pos,
+            end_pos: correction.end_pos,
+            replacement: correction.replacement
+          )
+        end
+      end
+
+      def hash_for_edit_range(range)
+        {
+          start_line: range.line,
+          start_column: range.column + 1,
+          last_line: range.last_line,
+          last_column: range.last_column.zero? ? 1 : range.last_column
+        }
       end
 
-      # TODO: Consider better solution for Offense#real_column.
-      #       The minimum value of `start_column: real_column` is 1.
-      #       So, the minimum value of `last_column` should be 1.
-      #       And non-zero value of `last_column` should be used as is.
       def hash_for_location(offense)
         {
           start_line:   offense.line,
           start_column: offense.real_column,
           last_line:    offense.last_line,
-          last_column:  offense.last_column.zero? ? 1 : offense.last_column,
+          last_column:  offense.real_last_column,
           length:       offense.location.length,
           # `line` and `column` exist for compatibility.
           # Use `start_line` and `start_column` instead.

data/lib/rubocop/formatter/junit_formatter.rb

@@ -25,21 +25,21 @@ module RuboCop
         super
 
         @test_case_elements = []
+        @config_store = nil
 
         reset_count
       end
 
+      def file_started(_file, options)
+        @config_store = options[:config_store]
+      end
+
       def file_finished(file, offenses)
         @inspected_file_count += 1
+        @offense_count += offenses.count
 
-        # TODO: Returns all cops with the same behavior as
-        # the original rubocop-junit-formatter.
-        # https://github.com/mikian/rubocop-junit-formatter/blob/v0.1.4/lib/rubocop/formatter/junit_formatter.rb#L9
-        #
-        # In the future, it would be preferable to return only enabled cops.
-        Cop::Registry.all.each do |cop|
+        cops_for(file).each do |cop|
           target_offenses = offenses_for_cop(offenses, cop)
-          @offense_count += target_offenses.count
 
           next unless relevant_for_output?(options, target_offenses)
 
@@ -47,7 +47,7 @@ module RuboCop
         end
       end
 
-      # rubocop:disable Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength
+      # rubocop:disable-next Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength -- the XML is emitted line by line
       def finished(_inspected_files)
         output.puts %(<?xml version='1.0'?>)
         output.puts %(<testsuites>)
@@ -70,10 +70,17 @@ module RuboCop
         output.puts %(  </testsuite>)
         output.puts %(</testsuites>)
       end
-      # rubocop:enable Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength
 
       private
 
+      def cops_for(file)
+        # `file_started` is not called when this formatter is used directly through the API,
+        # in which case all cops are returned for compatibility.
+        return Cop::Registry.all if @config_store.nil?
+
+        registry.enabled(@config_store.for_file(file))
+      end
+
       def relevant_for_output?(options, target_offenses)
         !options[:display_only_failed] || target_offenses.any?
       end
@@ -91,9 +98,19 @@ module RuboCop
         end
       end
 
+      # Filtering by badge keeps lazy-loaded cops unloaded; `Registry#enabled` then loads only
+      # the enabled cops, the same set the runner mobilizes.
+      def registry
+        @registry ||= Cop::Registry.global.filter_by_badge(options) do |badge|
+          next false if badge.department == :Test || badge.match_name?(options[:except])
+
+          options[:only].nil? || badge.match_name?(options[:only])
+        end
+      end
+
       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/markdown_formatter.rb

@@ -6,6 +6,7 @@ module RuboCop
     class MarkdownFormatter < BaseFormatter
       include TextUtil
       include PathUtil
+
       attr_reader :files, :summary
 
       def initialize(output, options = {})

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -14,6 +14,8 @@ module RuboCop
     # --
     # 29  Total in 5 files
     class OffenseCountFormatter < BaseFormatter
+      include TextUtil
+
       attr_reader :offense_counts
 
       def started(target_files)
@@ -24,7 +26,7 @@ module RuboCop
 
         return unless output.tty?
 
-        file_phrase = target_files.count == 1 ? 'file' : 'files'
+        file_phrase = target_files.one? ? 'file' : 'files'
 
         # 185/407 files |====== 45 ======>                    |  ETA: 00:00:04
         # %c / %C       |       %w       >         %i         |       %e
@@ -52,7 +54,7 @@ module RuboCop
         report_summary(@offense_counts, @offending_files_count)
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def report_summary(offense_counts, offending_files_count)
         per_cop_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
@@ -64,11 +66,10 @@ module RuboCop
           output.puts "#{count.to_s.ljust(column_width)}#{cop_information(cop_name)}"
         end
         output.puts '--'
-        output.puts "#{total_count}  Total in #{offending_files_count} files"
+        output.puts "#{total_count}  Total in #{pluralize(offending_files_count, 'file')}"
 
         output.puts
       end
-      # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
         offense_counts.sort_by { |k, v| [-v, k] }.to_h

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'io/console'
+
 module RuboCop
   module Formatter
     # This formatter prints a PACDOT per every file to be analyzed.
@@ -9,6 +11,7 @@ module RuboCop
     # https://github.com/go-labs/rspec_pacman_formatter
     class PacmanFormatter < ClangStyleFormatter
       include TextUtil
+
       attr_accessor :progress_line
 
       FALLBACK_TERMINAL_WIDTH = 80
@@ -49,7 +52,7 @@ module RuboCop
 
       def cols
         @cols ||= begin
-          _height, width = $stdout.winsize
+          _height, width = output.winsize if output.tty?
           width.nil? || width.zero? ? FALLBACK_TERMINAL_WIDTH : width
         end
       end
@@ -58,7 +61,7 @@ module RuboCop
         return pacdots(@total_files) unless @total_files > cols
         return pacdots(cols) unless (@total_files / cols).eql?(@repetitions)
 
-        pacdots((@total_files - (cols * @repetitions)))
+        pacdots(@total_files - (cols * @repetitions))
       end
 
       def pacdots(number)

data/lib/rubocop/formatter/sarif_formatter.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module RuboCop
+  module Formatter
+    # This formatter formats the report data in SARIF 2.1.0, the OASIS standard
+    # for static analysis results. It's understood by GitHub code scanning,
+    # Azure DevOps, and other tools that aggregate analyzer output.
+    #
+    # SARIF only knows three severity levels, so RuboCop's `info`, `refactor`
+    # and `convention` severities are all reported as `note`.
+    class SARIFFormatter < BaseFormatter
+      SCHEMA_URI = 'https://json.schemastore.org/sarif-2.1.0.json'
+      SARIF_VERSION = '2.1.0'
+      INFORMATION_URI = 'https://rubocop.org'
+
+      SEVERITY_LEVELS = {
+        info: 'note',
+        refactor: 'note',
+        convention: 'note',
+        warning: 'warning',
+        error: 'error',
+        fatal: 'error'
+      }.freeze
+
+      def initialize(output, options = {})
+        super
+
+        @rules = []
+        @rule_indexes = {}
+        @results = []
+        @config_store = nil
+      end
+
+      def file_started(_file, options)
+        @config_store = options[:config_store]
+      end
+
+      def file_finished(file, offenses)
+        line_hash_counts = Hash.new(0)
+        offenses.each do |offense|
+          @results << result_for(file, offense, line_hash_counts)
+        end
+      end
+
+      def finished(_inspected_files)
+        output.write(report.to_json)
+      end
+
+      private
+
+      def report
+        {
+          '$schema': SCHEMA_URI,
+          version: SARIF_VERSION,
+          runs: [{ tool: { driver: driver }, results: @results }]
+        }
+      end
+
+      def driver
+        {
+          name: 'RuboCop',
+          version: RuboCop::Version::STRING,
+          semanticVersion: RuboCop::Version::STRING,
+          informationUri: INFORMATION_URI,
+          rules: @rules
+        }
+      end
+
+      def result_for(file, offense, line_hash_counts)
+        result = {
+          ruleId: offense.cop_name,
+          ruleIndex: rule_index_for(file, offense),
+          level: SEVERITY_LEVELS.fetch(offense.severity.name, 'warning'),
+          message: { text: offense.message },
+          locations: [location_for(file, offense)],
+          partialFingerprints: fingerprints_for(offense, line_hash_counts)
+        }
+
+        # Suppressed offenses are only reported under `--display-suppressed`.
+        # SARIF has a first-class representation for them, so consumers can
+        # tell them apart from offenses that were never triggered.
+        result[:suppressions] = [suppression_for(offense)] if offense.disabled?
+        result
+      end
+
+      # The URI is relative to the working directory, which is what consumers
+      # expect to resolve against their own checkout. No `uriBaseId`: it would
+      # have to be declared under `originalUriBaseIds` to mean anything, and
+      # every consumer that matters resolves relative paths without it.
+      def location_for(file, offense)
+        {
+          physicalLocation: {
+            artifactLocation: { uri: uri_for(file) },
+            region: region_for(offense)
+          }
+        }
+      end
+
+      def region_for(offense)
+        # SARIF columns are 1-based and `endColumn` points at the character
+        # *after* the region, while `real_last_column` is the last character.
+        {
+          startLine: offense.first_line,
+          startColumn: offense.real_column,
+          endLine: offense.last_line,
+          endColumn: offense.real_last_column + 1
+        }
+      end
+
+      # GitHub uses these to match an alert across runs. Without them it falls
+      # back to the file path, which makes alerts churn whenever a file moves.
+      # Repeats of the same hash within a file get a `:N` suffix, like GitHub's
+      # own fingerprints, so two offenses on one line don't merge into one alert.
+      # The first occurrence keeps the bare hash to match earlier reports.
+      def fingerprints_for(offense, line_hash_counts)
+        line_hash = Digest::SHA256.hexdigest("#{offense.cop_name}#{offense.location.source_line}")
+        count = line_hash_counts[line_hash] += 1
+        { primaryLocationLineHash: count == 1 ? line_hash : "#{line_hash}:#{count}" }
+      end
+
+      def suppression_for(offense)
+        suppression = { kind: 'inSource' }
+        suppression[:justification] = offense.justification if offense.justification
+        suppression
+      end
+
+      def rule_index_for(file, offense)
+        @rule_indexes[offense.cop_name] ||= begin
+          @rules << rule_for(file, offense)
+          @rules.size - 1
+        end
+      end
+
+      def rule_for(file, offense)
+        cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name)
+        description = description_for(file, offense)
+        help_uri = cop_class && Cop::Documentation.url_for(cop_class, config_for(file))
+
+        rule = {
+          id: offense.cop_name,
+          name: offense.cop_name,
+          shortDescription: { text: description },
+          fullDescription: { text: description },
+          help: help_for(description, help_uri),
+          defaultConfiguration: { level: default_level_for(file, offense, cop_class) },
+          properties: { tags: [offense.cop_name.split('/').first] }
+        }
+        rule[:helpUri] = help_uri if help_uri
+        rule
+      end
+
+      def help_for(description, help_uri)
+        help = { text: description }
+        help[:markdown] = "#{description}\n\n[Documentation](#{help_uri})" if help_uri
+        help
+      end
+
+      def description_for(file, offense)
+        cop_config(file, offense)['Description'] || offense.cop_name
+      end
+
+      def default_level_for(file, offense, cop_class)
+        severity = cop_config(file, offense)['Severity'] ||
+                   Cop::Base::DEPARTMENT_SEVERITIES.fetch(cop_class&.department, :convention)
+
+        SEVERITY_LEVELS.fetch(severity.to_sym, 'warning')
+      end
+
+      def cop_config(file, offense)
+        config_for(file)&.for_cop(offense.cop_name) || {}
+      end
+
+      # `file_started` is not called when a formatter is used directly through
+      # the API, so there may be no config to consult.
+      def config_for(file)
+        @config_store&.for_file(file)
+      end
+
+      def uri_for(file)
+        PathUtil.smart_path(file).tr('\\', '/')
+      end
+    end
+  end
+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.
@@ -88,7 +86,9 @@ module RuboCop
 
       def message(offense)
         message =
-          if offense.corrected_with_todo?
+          if offense.disabled?
+            magenta('[Suppressed] ')
+          elsif offense.corrected_with_todo?
             green('[Todo] ')
           elsif offense.corrected?
             green('[Corrected] ')
@@ -106,7 +106,7 @@ module RuboCop
         include Colorizable
         include TextUtil
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def initialize(
           file_count, offense_count, correction_count, correctable_count, rainbow,
           safe_autocorrect: false
@@ -118,7 +118,6 @@ module RuboCop
           @rainbow = rainbow
           @safe_autocorrect = safe_autocorrect
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def summary
           if @correction_count.positive?

data/lib/rubocop/formatter/tap_formatter.rb

@@ -39,8 +39,11 @@ module RuboCop
       def report_highlighted_area(highlighted_area)
         space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
         source_area = highlighted_area.source
-        output.puts("# #{' ' * Unicode::DisplayWidth.of(space_area)}" \
-                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
+        output.puts("# #{to_whitespace(space_area)}#{'^' * Unicode::DisplayWidth.of(source_area)}")
+      end
+
+      def to_whitespace(string)
+        "#{string.delete("^\t")}#{' ' * Unicode::DisplayWidth.of(string.delete("\t"))}"
       end
 
       def report_offense(file, offense)
@@ -65,7 +68,9 @@ module RuboCop
 
       def message(offense)
         message =
-          if offense.corrected_with_todo?
+          if offense.disabled?
+            '[Suppressed] '
+          elsif offense.corrected_with_todo?
             '[Todo] '
           elsif offense.corrected?
             '[Corrected] '

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -14,6 +14,8 @@ module RuboCop
     # --
     # 29  Total in 2 files
     class WorstOffendersFormatter < BaseFormatter
+      include TextUtil
+
       attr_reader :offense_counts
 
       def started(target_files)
@@ -24,7 +26,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
 
@@ -32,7 +34,7 @@ module RuboCop
         report_summary(@offense_counts)
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def report_summary(offense_counts)
         per_file_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
@@ -46,11 +48,10 @@ module RuboCop
         end
 
         output.puts '--'
-        output.puts "#{total_count}  Total in #{file_count} files"
+        output.puts "#{total_count}  Total in #{pluralize(file_count, 'file')}"
 
         output.puts
       end
-      # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
         offense_counts.sort_by { |k, v| [-v, k] }.to_h

data/lib/rubocop/formatter.rb

@@ -3,32 +3,34 @@
 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 :SARIFFormatter, 'rubocop/formatter/sarif_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/lockfile.rb

@@ -59,6 +59,18 @@ module RuboCop
       end
     end
 
+    # Names of gems sourced from a local path, i.e. `path:` dependencies and the
+    # project's own gem when the `Gemfile` uses `gemspec`. Git sources are not
+    # included: their code lives outside the project, like a released gem's.
+    # @return [Array<String>]
+    def path_sourced_gem_names
+      return [] unless parser
+
+      parser.specs.filter_map do |spec|
+        spec.name if path_source?(spec.source)
+      end
+    end
+
     # Whether this lockfile includes the named gem, directly or indirectly.
     # @param [String] name
     # @return [Boolean]
@@ -68,6 +80,12 @@ module RuboCop
 
     private
 
+    # `Bundler::Source::Git` is a subclass of `Bundler::Source::Path`, but a git
+    # source is a remote one.
+    def path_source?(source)
+      source.is_a?(::Bundler::Source::Path) && !source.is_a?(::Bundler::Source::Git)
+    end
+
     # @return [Bundler::LockfileParser, nil]
     def parser
       return @parser if defined?(@parser)