rubocop 0.51.0 → 0.87.0

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -5,21 +5,19 @@ module RuboCop
     # This formatter displays a YAML configuration file where all cops that
     # detected any offenses are configured to not detect the offense.
     class DisabledConfigFormatter < BaseFormatter
-      HEADING =
-        ['# This configuration was generated by',
-         '# `%s`',
-         "# on #{Time.now} using RuboCop version #{Version.version}.",
-         '# The point is for the user to remove these configuration records',
-         '# one by one as the offenses are removed from the code base.',
-         '# Note that changes in the inspected code, or installation of new',
-         '# versions of RuboCop, may require this file to be generated again.']
-        .join("\n")
+      HEADING = <<~COMMENTS
+        # This configuration was generated by
+        # `%<command>s`
+        # %<timestamp>susing RuboCop version #{Version.version}.
+        # The point is for the user to remove these configuration records
+        # one by one as the offenses are removed from the code base.
+        # Note that changes in the inspected code, or installation of new
+        # versions of RuboCop, may require this file to be generated again.
+      COMMENTS
 
       @config_to_allow_offenses = {}
       @detected_styles = {}
 
-      COPS = Cop::Cop.registry.to_h
-
       class << self
         attr_accessor :config_to_allow_offenses, :detected_styles
       end
@@ -32,22 +30,21 @@ module RuboCop
 
       def file_started(_file, _file_info)
         @exclude_limit_option = @options[:exclude_limit]
-        @exclude_limit = (
-          @exclude_limit_option ||
-          RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS).to_i
+        @exclude_limit = Integer(@exclude_limit_option ||
+          RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS)
         @show_offense_counts = !@options[:no_offense_counts]
       end
 
       def file_finished(file, offenses)
         offenses.each do |o|
           @cops_with_offenses[o.cop_name] += 1
-          @files_with_offenses[o.cop_name] ||= []
+          @files_with_offenses[o.cop_name] ||= Set.new
           @files_with_offenses[o.cop_name] << file
         end
       end
 
       def finished(_inspected_files)
-        output.puts HEADING % command
+        output.puts format(HEADING, command: command, timestamp: timestamp)
 
         # Syntax isn't a real cop and it can't be disabled.
         @cops_with_offenses.delete('Lint/Syntax')
@@ -55,22 +52,31 @@ module RuboCop
         output_offenses
 
         puts "Created #{output.path}."
-        puts "Run `rubocop --config #{output.path}`, or add `inherit_from: " \
-             "#{output.path}` in a .rubocop.yml file."
       end
 
       private
 
       def command
         command = 'rubocop --auto-gen-config'
+
+        command += ' --auto-gen-only-exclude' if @options[:auto_gen_only_exclude]
+
         if @exclude_limit_option
-          command += format(' --exclude-limit %d', @exclude_limit_option.to_i)
+          command +=
+            format(' --exclude-limit %<limit>d',
+                   limit: Integer(@exclude_limit_option))
         end
         command += ' --no-offense-counts' if @options[:no_offense_counts]
 
+        command += ' --no-auto-gen-timestamp' if @options[:no_auto_gen_timestamp]
+
         command
       end
 
+      def timestamp
+        @options[:no_auto_gen_timestamp] ? '' : "on #{Time.now.utc} "
+      end
+
       def output_offenses
         @cops_with_offenses.sort.each do |cop_name, offense_count|
           output_cop(cop_name, offense_count)
@@ -80,41 +86,65 @@ module RuboCop
       def output_cop(cop_name, offense_count)
         output.puts
         cfg = self.class.config_to_allow_offenses[cop_name] || {}
+        set_max(cfg, cop_name)
 
-        output_cop_comments(output, cfg, cop_name, offense_count)
-        output_cop_config(output, cfg, cop_name)
+        # To avoid malformed YAML when potentially reading the config in
+        # #excludes, we use an output buffer and append it to the actual output
+        # only when it results in valid YAML.
+        output_buffer = StringIO.new
+        output_cop_comments(output_buffer, cfg, cop_name, offense_count)
+        output_cop_config(output_buffer, cfg, cop_name)
+        output.puts(output_buffer.string)
       end
 
-      def output_cop_comments(output, cfg, cop_name, offense_count)
-        output.puts "# Offense count: #{offense_count}" if @show_offense_counts
-        if COPS[cop_name] && COPS[cop_name].first.new.support_autocorrect?
-          output.puts '# Cop supports --auto-correct.'
+      def set_max(cfg, cop_name)
+        return unless cfg[:exclude_limit]
+
+        # In case auto_gen_only_exclude is set, only modify the maximum if the
+        # files are not excluded one by one.
+        if !@options[:auto_gen_only_exclude] ||
+           @files_with_offenses[cop_name].size > @exclude_limit
+          cfg.merge!(cfg[:exclude_limit])
         end
 
+        # Remove already used exclude_limit.
+        cfg.reject! { |key| key == :exclude_limit }
+      end
+
+      def output_cop_comments(output_buffer, cfg, cop_name, offense_count)
+        output_buffer.puts "# Offense count: #{offense_count}" if @show_offense_counts
+
+        cop_class = Cop::Cop.registry.find_by_cop_name(cop_name)
+        output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.new&.support_autocorrect?
+
         default_cfg = default_config(cop_name)
         return unless default_cfg
 
         params = cop_config_params(default_cfg, cfg)
         return if params.empty?
 
-        output_cop_param_comments(params, default_cfg)
+        output_cop_param_comments(output_buffer, params, default_cfg)
       end
 
       def cop_config_params(default_cfg, cfg)
         default_cfg.keys -
-          %w[Description StyleGuide Reference Enabled Exclude] -
+          %w[Description StyleGuide Reference Enabled Exclude Safe
+             SafeAutoCorrect VersionAdded VersionChanged VersionRemoved] -
           cfg.keys
       end
 
-      def output_cop_param_comments(params, default_cfg)
-        output.puts "# Configuration parameters: #{params.join(', ')}."
+      def output_cop_param_comments(output_buffer, params, default_cfg)
+        config_params = params.reject { |p| p.start_with?('Supported') }
+        output_buffer.puts(
+          "# Configuration parameters: #{config_params.join(', ')}."
+        )
 
         params.each do |param|
           value = default_cfg[param]
-          if value.is_a?(Array)
-            next if value.empty?
-            output.puts "# #{param}: #{value.join(', ')}"
-          end
+          next unless value.is_a?(Array)
+          next if value.empty?
+
+          output_buffer.puts "# #{param}: #{value.join(', ')}"
         end
       end
 
@@ -122,38 +152,38 @@ module RuboCop
         RuboCop::ConfigLoader.default_configuration[cop_name]
       end
 
-      def output_cop_config(output, cfg, cop_name)
+      def output_cop_config(output_buffer, cfg, cop_name)
         # 'Enabled' option will be put into file only if exclude
         # limit is exceeded.
         cfg_without_enabled = cfg.reject { |key| key == 'Enabled' }
 
-        output.puts "#{cop_name}:"
+        output_buffer.puts "#{cop_name}:"
         cfg_without_enabled.each do |key, value|
           value = value[0] if value.is_a?(Array)
-          output.puts "  #{key}: #{value}"
+          output_buffer.puts "  #{key}: #{value}"
         end
 
-        output_offending_files(output, cfg_without_enabled, cop_name)
+        output_offending_files(output_buffer, cfg_without_enabled, cop_name)
       end
 
-      def output_offending_files(output, cfg, cop_name)
+      def output_offending_files(output_buffer, cfg, cop_name)
         return unless cfg.empty?
 
-        offending_files = @files_with_offenses[cop_name].uniq.sort
+        offending_files = @files_with_offenses[cop_name].sort
         if offending_files.count > @exclude_limit
-          output.puts '  Enabled: false'
+          output_buffer.puts '  Enabled: false'
         else
-          output_exclude_list(output, offending_files, cop_name)
+          output_exclude_list(output_buffer, offending_files, cop_name)
         end
       end
 
-      def output_exclude_list(output, offending_files, cop_name)
+      def output_exclude_list(output_buffer, offending_files, cop_name)
         require 'pathname'
         parent = Pathname.new(Dir.pwd)
 
-        output.puts '  Exclude:'
-        excludes(offending_files, cop_name, parent).each do |file|
-          output_exclude_path(output, file, parent)
+        output_buffer.puts '  Exclude:'
+        excludes(offending_files, cop_name, parent).each do |exclude_path|
+          output_exclude_path(output_buffer, exclude_path, parent)
         end
       end
 
@@ -169,12 +199,17 @@ module RuboCop
         ((cfg['Exclude'] || []) + offending_files).uniq
       end
 
-      def output_exclude_path(output, file, parent)
-        file_path = Pathname.new(file)
+      def output_exclude_path(output_buffer, exclude_path, parent)
+        # exclude_path is either relative path, an absolute path, or a regexp.
+        file_path = Pathname.new(exclude_path)
         relative = file_path.relative_path_from(parent)
-        output.puts "    - '#{relative}'"
+        output_buffer.puts "    - '#{relative}'"
       rescue ArgumentError
-        output.puts "    - '#{file}'"
+        file = exclude_path
+        output_buffer.puts "    - '#{file}'"
+      rescue TypeError
+        regexp = exclude_path
+        output_buffer.puts "    - !ruby/regexp /#{regexp.source}/"
       end
     end
   end

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -8,17 +8,30 @@ module RuboCop
     class EmacsStyleFormatter < BaseFormatter
       def file_finished(file, offenses)
         offenses.each do |o|
-          message = if o.corrected?
-                      "[Corrected] #{o.message}"
-                    else
-                      o.message
-                    end
-
-          output.printf("%s:%d:%d: %s: %s\n",
-                        file, o.line, o.real_column, o.severity.code,
-                        message.tr("\n", ' '))
+          output.printf(
+            "%<path>s:%<line>d:%<column>d: %<severity>s: %<message>s\n",
+            path: file,
+            line: o.line,
+            column: o.real_column,
+            severity: o.severity.code,
+            message: message(o)
+          )
         end
       end
+
+      private
+
+      def message(offense)
+        message =
+          if offense.corrected_with_todo?
+            "[Todo] #{offense.message}"
+          elsif offense.corrected?
+            "[Corrected] #{offense.message}"
+          else
+            offense.message
+          end
+        message.tr("\n", ' ')
+      end
     end
   end
 end

data/lib/rubocop/formatter/file_list_formatter.rb

@@ -12,7 +12,8 @@ module RuboCop
     class FileListFormatter < BaseFormatter
       def file_finished(file, offenses)
         return if offenses.empty?
-        output.printf("%s\n", file)
+
+        output.printf("%<path>s\n", path: file)
       end
     end
   end

data/lib/rubocop/formatter/formatter_set.rb

@@ -9,18 +9,21 @@ module RuboCop
     # which invoke same method of each formatters.
     class FormatterSet < Array
       BUILTIN_FORMATTERS_FOR_KEYS = {
-        'progress' => ProgressFormatter,
-        'simple'   => SimpleTextFormatter,
-        'clang'    => ClangStyleFormatter,
-        'fuubar'   => FuubarStyleFormatter,
-        'emacs'    => EmacsStyleFormatter,
-        'json'     => JSONFormatter,
-        'html'     => HTMLFormatter,
-        'files'    => FileListFormatter,
-        'offenses' => OffenseCountFormatter,
-        'disabled' => DisabledLinesFormatter,
-        'worst'    => WorstOffendersFormatter,
-        'tap'      => TapFormatter
+        '[a]utogenconf' => AutoGenConfigFormatter,
+        '[c]lang'       => ClangStyleFormatter,
+        '[e]macs'       => EmacsStyleFormatter,
+        '[fi]les'       => FileListFormatter,
+        '[fu]ubar'      => FuubarStyleFormatter,
+        '[h]tml'        => HTMLFormatter,
+        '[j]son'        => JSONFormatter,
+        '[ju]nit'       => JUnitFormatter,
+        '[o]ffenses'    => OffenseCountFormatter,
+        '[pa]cman'      => PacmanFormatter,
+        '[p]rogress'    => ProgressFormatter,
+        '[q]uiet'       => QuietFormatter,
+        '[s]imple'      => SimpleTextFormatter,
+        '[t]ap'         => TapFormatter,
+        '[w]orst'       => WorstOffendersFormatter
       }.freeze
 
       FORMATTER_APIS = %i[started finished].freeze
@@ -79,14 +82,12 @@ module RuboCop
 
       def builtin_formatter_class(specified_key)
         matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
-          key.start_with?(specified_key)
+          /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
         end
 
         raise %(No formatter for "#{specified_key}") if matching_keys.empty?
 
-        if matching_keys.size > 1
-          raise %(Cannot determine formatter for "#{specified_key}")
-        end
+        raise %(Cannot determine formatter for "#{specified_key}") if matching_keys.size > 1
 
         BUILTIN_FORMATTERS_FOR_KEYS[matching_keys.first]
       end

data/lib/rubocop/formatter/fuubar_style_formatter.rb

@@ -9,9 +9,9 @@ module RuboCop
     # This is inspired by the Fuubar formatter for RSpec by Jeff Kreeftmeijer.
     # https://github.com/jeffkreeftmeijer/fuubar
     class FuubarStyleFormatter < ClangStyleFormatter
-      RESET_SEQUENCE = "\e[0m".freeze
+      RESET_SEQUENCE = "\e[0m"
 
-      def initialize(*)
+      def initialize(*output)
         @severest_offense = nil
 
         super

data/lib/rubocop/formatter/html_formatter.rb

@@ -10,9 +10,9 @@ module RuboCop
   module Formatter
     # This formatter saves the output as an html file.
     class HTMLFormatter < BaseFormatter
-      ELLIPSES = '<span class="extra-code">...</span>'.freeze
+      ELLIPSES = '<span class="extra-code">...</span>'
       TEMPLATE_PATH =
-        File.expand_path('../../../../assets/output.html.erb', __FILE__)
+        File.expand_path('../../../assets/output.html.erb', __dir__)
 
       Color = Struct.new(:red, :green, :blue, :alpha) do
         def to_s
@@ -53,7 +53,14 @@ module RuboCop
         context = ERBContext.new(files, summary)
 
         template = File.read(TEMPLATE_PATH, encoding: Encoding::UTF_8)
-        erb = ERB.new(template, nil, '-')
+
+        # The following condition is workaround for until Ruby 2.6 is released.
+        # https://github.com/ruby/ruby/commit/cc777d09f44fa909a336ba14f3aa802ffe16e010
+        erb = if RUBY_VERSION >= '2.6'
+                ERB.new(template, trim_mode: '-')
+              else
+                ERB.new(template, nil, '-')
+              end
         html = erb.result(context.binding)
 
         output.write html
@@ -73,7 +80,7 @@ module RuboCop
         }.freeze
 
         LOGO_IMAGE_PATH =
-          File.expand_path('../../../../assets/logo.png', __FILE__)
+          File.expand_path('../../../assets/logo.png', __dir__)
 
         attr_reader :files, :summary
 
@@ -120,8 +127,8 @@ module RuboCop
           location.first_line == location.last_line ? '' : " #{ELLIPSES}"
         end
 
-        def escape(s)
-          CGI.escapeHTML(s)
+        def escape(string)
+          CGI.escapeHTML(string)
         end
 
         def base64_encoded_logo_image

data/lib/rubocop/formatter/json_formatter.rb

@@ -46,27 +46,34 @@ module RuboCop
 
       def hash_for_file(file, offenses)
         {
-          path:     relative_path(file),
+          path:     smart_path(file),
           offenses: offenses.map { |o| hash_for_offense(o) }
         }
       end
 
       def hash_for_offense(offense)
         {
-          severity: offense.severity.name,
-          message:  offense.message,
-          cop_name: offense.cop_name,
-          corrected: offense.corrected?,
-          location: hash_for_location(offense)
+          severity:    offense.severity.name,
+          message:     offense.message,
+          cop_name:    offense.cop_name,
+          corrected:   offense.corrected?,
+          correctable: offense.correctable?,
+          location:    hash_for_location(offense)
         }
       end
 
       # TODO: Consider better solution for Offense#real_column.
       def hash_for_location(offense)
         {
-          line:   offense.line,
-          column: offense.real_column,
-          length: offense.location.length
+          start_line:   offense.line,
+          start_column: offense.real_column,
+          last_line:    offense.last_line,
+          last_column:  offense.last_column,
+          length:       offense.location.length,
+          # `line` and `column` exist for compatibility.
+          # Use `start_line` and `start_column` instead.
+          line:         offense.line,
+          column:       offense.real_column
         }
       end
     end

data/lib/rubocop/formatter/junit_formatter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+#
+# This code is based on https://github.com/mikian/rubocop-junit-formatter.
+#
+# Copyright (c) 2015 Mikko Kokkonen
+#
+# MIT License
+#
+# https://github.com/mikian/rubocop-junit-formatter/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Formatter
+    # This formatter formats the report data in JUnit format.
+    class JUnitFormatter < BaseFormatter
+      def initialize(output, options = {})
+        super
+
+        @document = REXML::Document.new.tap do |document|
+          document << REXML::XMLDecl.new
+        end
+        testsuites = REXML::Element.new('testsuites', @document)
+        testsuite = REXML::Element.new('testsuite', testsuites)
+        @testsuite = testsuite.tap do |element|
+          element.add_attributes('name' => 'rubocop')
+        end
+      end
+
+      def file_finished(file, offenses)
+        # 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::Cop.all.each do |cop|
+          target_offenses = offenses_for_cop(offenses, cop)
+
+          next unless relevant_for_output?(options, target_offenses)
+
+          REXML::Element.new('testcase', @testsuite).tap do |testcase|
+            testcase.attributes['classname'] = classname_attribute_value(file)
+            testcase.attributes['name'] = cop.cop_name
+
+            add_failure_to(testcase, target_offenses, cop.cop_name)
+          end
+        end
+      end
+
+      def relevant_for_output?(options, target_offenses)
+        !options[:display_only_failed] || target_offenses.any?
+      end
+
+      def offenses_for_cop(all_offenses, cop)
+        all_offenses.select do |offense|
+          offense.cop_name == cop.cop_name
+        end
+      end
+
+      def classname_attribute_value(file)
+        file.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
+      end
+
+      def finished(_inspected_files)
+        @document.write(output, 2)
+      end
+
+      private
+
+      def add_failure_to(testcase, offenses, cop_name)
+        # One failure per offense. Zero failures is a passing test case,
+        # for most surefire/nUnit parsers.
+        offenses.each do |offense|
+          REXML::Element.new('failure', testcase).tap do |failure|
+            failure.attributes['type'] = cop_name
+            failure.attributes['message'] = offense.message
+            failure.add_text(offense.location.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -17,10 +17,27 @@ module RuboCop
       def started(target_files)
         super
         @offense_counts = Hash.new(0)
+
+        return unless output.tty?
+
+        file_phrase = target_files.count == 1 ? 'file' : 'files'
+
+        # 185/407 files |====== 45 ======>                    |  ETA: 00:00:04
+        # %c / %C       |       %w       >         %i         |       %e
+        bar_format = " %c/%C #{file_phrase} |%w>%i| %e "
+
+        @progressbar = ProgressBar.create(
+          output: output,
+          total: target_files.count,
+          format: bar_format,
+          autostart: false
+        )
+        @progressbar.start
       end
 
       def file_finished(_file, offenses)
         offenses.each { |o| @offense_counts[o.cop_name] += 1 }
+        @progressbar.increment if instance_variable_defined?(:@progressbar)
       end
 
       def finished(_inspected_files)

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter prints a PACDOT per every file to be analyzed.
+    # Pacman will "eat" one PACDOT per file when no offense is detected.
+    # Otherwise it will print a Ghost.
+    # This is inspired by the Pacman formatter for RSpec by Carlos Rojas.
+    # https://github.com/go-labs/rspec_pacman_formatter
+    class PacmanFormatter < ClangStyleFormatter
+      include TextUtil
+      attr_accessor :progress_line
+
+      FALLBACK_TERMINAL_WIDTH = 80
+      GHOST = 'ᗣ'
+      PACMAN = Rainbow('ᗧ').yellow.bright
+      PACDOT = Rainbow('•').yellow.bright
+
+      def initialize(output, options = {})
+        super
+        @progress_line = ''
+        @total_files   = 0
+        @repetitions   = 0
+      end
+
+      def started(target_files)
+        super
+        @total_files = target_files.size
+        output.puts "Eating #{pluralize(target_files.size, 'file')}"
+        update_progress_line
+      end
+
+      def file_started(_file, _options)
+        step(PACMAN)
+      end
+
+      def file_finished(file, offenses)
+        count_stats(offenses) unless offenses.empty?
+        next_step(offenses)
+        report_file(file, offenses)
+      end
+
+      def next_step(offenses)
+        return step('.') if offenses.empty?
+
+        ghost_color = COLOR_FOR_SEVERITY[offenses.last.severity.name]
+        step(colorize(GHOST, ghost_color))
+      end
+
+      def cols
+        @cols ||= begin
+          _height, width = $stdout.winsize
+          width.nil? || width.zero? ? FALLBACK_TERMINAL_WIDTH : width
+        end
+      end
+
+      def update_progress_line
+        return pacdots(@total_files) unless @total_files > cols
+        return pacdots(cols) unless (@total_files / cols).eql?(@repetitions)
+
+        pacdots((@total_files - (cols * @repetitions)))
+      end
+
+      def pacdots(number)
+        @progress_line = PACDOT * number
+      end
+
+      def step(character)
+        regex = /#{Regexp.quote(PACMAN)}|#{Regexp.quote(PACDOT)}/
+        @progress_line = @progress_line.sub(regex, character)
+        output.printf("%<line>s\r", line: @progress_line)
+        return unless /ᗣ|\./.match?(@progress_line[-1])
+
+        @repetitions += 1
+        output.puts
+        update_progress_line
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/progress_formatter.rb

@@ -8,7 +8,7 @@ module RuboCop
     class ProgressFormatter < ClangStyleFormatter
       include TextUtil
 
-      DOT = '.'.freeze
+      DOT = '.'
 
       def initialize(output, options = {})
         super

data/lib/rubocop/formatter/quiet_formatter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # If no offenses are found, no output is displayed.
+    # Otherwise, SimpleTextFormatter's output is displayed.
+    class QuietFormatter < SimpleTextFormatter
+      def report_summary(file_count, offense_count, correction_count)
+        super unless offense_count.zero?
+      end
+    end
+  end
+end