rubocop 0.48.1 → 1.16.0

data/lib/rubocop/formatter/git_hub_actions_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter formats report data as GitHub Workflow commands resulting
+    # in GitHub check annotations when run within GitHub Actions.
+    class GitHubActionsFormatter < BaseFormatter
+      ESCAPE_MAP = { '%' => '%25', "\n" => '%0A', "\r" => '%0D' }.freeze
+
+      def file_finished(file, offenses)
+        offenses.each { |offense| report_offense(file, offense) }
+      end
+
+      private
+
+      def github_escape(string)
+        string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+      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.fetch(:fail_level, :refactor)
+          RuboCop::Cop::Severity.new(name)
+        end
+      end
+
+      def github_severity(offense)
+        offense.severity < minimum_severity_to_fail ? 'warning' : 'error'
+      end
+
+      def report_offense(file, offense)
+        output.printf(
+          "\n::%<severity>s file=%<file>s,line=%<line>d,col=%<column>d::%<message>s\n",
+          severity: github_severity(offense),
+          file: file,
+          line: offense.line,
+          column: offense.real_column,
+          message: github_escape(offense.message)
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/html_formatter.rb

@@ -4,15 +4,14 @@ require 'cgi'
 require 'erb'
 require 'ostruct'
 require 'base64'
-require 'rubocop/formatter/text_util'
+require_relative 'text_util'
 
 module RuboCop
   module Formatter
     # This formatter saves the output as an html file.
     class HTMLFormatter < BaseFormatter
-      ELLIPSES = '<span class="extra-code">...</span>'.freeze
-      TEMPLATE_PATH =
-        File.expand_path('../../../../assets/output.html.erb', __FILE__)
+      ELLIPSES = '<span class="extra-code">...</span>'
+      TEMPLATE_PATH = File.expand_path('../../../assets/output.html.erb', __dir__)
 
       Color = Struct.new(:red, :green, :blue, :alpha) do
         def to_s
@@ -20,9 +19,7 @@ module RuboCop
         end
 
         def fade_out(amount)
-          dup.tap do |color|
-            color.alpha -= amount
-          end
+          dup.tap { |color| color.alpha -= amount }
         end
       end
 
@@ -53,7 +50,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
@@ -72,8 +76,7 @@ module RuboCop
           fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
         }.freeze
 
-        LOGO_IMAGE_PATH =
-          File.expand_path('../../../../assets/logo.png', __FILE__)
+        LOGO_IMAGE_PATH = File.expand_path('../../../assets/logo.png', __dir__)
 
         attr_reader :files, :summary
 
@@ -83,14 +86,14 @@ module RuboCop
         end
 
         # Make Kernel#binding public.
+        # rubocop:disable Lint/UselessMethodDefinition
         def binding
           super
         end
+        # rubocop:enable Lint/UselessMethodDefinition
 
         def decorated_message(offense)
-          offense.message.gsub(/`(.+?)`/) do
-            "<code>#{Regexp.last_match(1)}</code>"
-          end
+          offense.message.gsub(/`(.+?)`/) { "<code>#{Regexp.last_match(1)}</code>" }
         end
 
         def highlighted_source_line(offense)
@@ -120,8 +123,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

@@ -13,11 +13,7 @@ module RuboCop
 
       def initialize(output, options = {})
         super
-        @output_hash = {
-          metadata: metadata_hash,
-          files:    [],
-          summary:  { offense_count: 0 }
-        }
+        @output_hash = { metadata: metadata_hash, files: [], summary: { offense_count: 0 } }
       end
 
       def started(target_files)
@@ -46,27 +42,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,93 @@
+# 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 { |document| document << REXML::XMLDecl.new }
+        testsuites = REXML::Element.new('testsuites', @document)
+        testsuite = REXML::Element.new('testsuite', testsuites)
+        @testsuite = testsuite.tap { |element| element.add_attributes('name' => 'rubocop') }
+
+        reset_count
+      end
+
+      def file_finished(file, offenses)
+        @inspected_file_count += 1
+
+        # 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|
+          target_offenses = offenses_for_cop(offenses, cop)
+          @offense_count += target_offenses.count
+
+          next unless relevant_for_output?(options, target_offenses)
+
+          add_testcase_element_to_testsuite_element(file, target_offenses, cop)
+        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 { |offense| offense.cop_name == cop.cop_name }
+      end
+
+      def add_testcase_element_to_testsuite_element(file, target_offenses, cop)
+        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
+
+      def classname_attribute_value(file)
+        file.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
+      end
+
+      def finished(_inspected_files)
+        @testsuite.add_attributes('tests' => @inspected_file_count, 'failures' => @offense_count)
+        @document.write(output, 2)
+      end
+
+      private
+
+      def reset_count
+        @inspected_file_count = 0
+        @offense_count = 0
+      end
+
+      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,16 +17,34 @@ 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)
         report_summary(@offense_counts)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def report_summary(offense_counts)
         per_cop_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
@@ -42,13 +60,14 @@ module RuboCop
 
         output.puts
       end
+      # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
-        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+        offense_counts.sort_by { |k, v| [-v, k] }.to_h
       end
 
       def total_offense_count(offense_counts)
-        offense_counts.values.inject(0, :+)
+        offense_counts.values.sum
       end
     end
   end

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
@@ -38,14 +38,13 @@ module RuboCop
           output.puts 'Offenses:'
           output.puts
 
-          @offenses_for_files.each do |file, offenses|
-            report_file(file, offenses)
-          end
+          @offenses_for_files.each { |file, offenses| report_file(file, offenses) }
         end
 
         report_summary(inspected_files.size,
                        @total_offense_count,
-                       @total_correction_count)
+                       @total_correction_count,
+                       @total_correctable_count)
       end
 
       def report_file_as_mark(offenses)

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, correctable_count)
+        super unless offense_count.zero?
+      end
+    end
+  end
+end