rbhint 0.8.5.rc1

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter displays the list of offended cops with a count of how
+    # many offenses of their kind were found. Ordered by desc offense count
+    #
+    # Here's the format:
+    #
+    # 26  LineLength
+    # 3   OneLineConditional
+    # --
+    # 29  Total
+    class OffenseCountFormatter < BaseFormatter
+      attr_reader :offense_counts
+
+      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)
+
+        output.puts
+
+        per_cop_counts.each do |cop_name, count|
+          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}" \
+                      "#{cop_name}\n"
+        end
+        output.puts '--'
+        output.puts "#{total_count}  Total"
+
+        output.puts
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def ordered_offense_counts(offense_counts)
+        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+      end
+
+      def total_offense_count(offense_counts)
+        offense_counts.values.inject(0, :+)
+      end
+    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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter display dots for files with no offenses and
+    # letters for files with problems in the them. In the end it
+    # appends the regular report data in the clang style format.
+    class ProgressFormatter < ClangStyleFormatter
+      include TextUtil
+
+      DOT = '.'
+
+      def initialize(output, options = {})
+        super
+        @dot = green(DOT)
+      end
+
+      def started(target_files)
+        super
+        @offenses_for_files = {}
+        output.puts "Inspecting #{pluralize(target_files.size, 'file')}"
+      end
+
+      def file_finished(file, offenses)
+        unless offenses.empty?
+          count_stats(offenses)
+          @offenses_for_files[file] = offenses
+        end
+
+        report_file_as_mark(offenses)
+      end
+
+      def finished(inspected_files)
+        output.puts
+
+        unless @offenses_for_files.empty?
+          output.puts
+          output.puts 'Offenses:'
+          output.puts
+
+          @offenses_for_files.each do |file, offenses|
+            report_file(file, offenses)
+          end
+        end
+
+        report_summary(inspected_files.size,
+                       @total_offense_count,
+                       @total_correction_count)
+      end
+
+      def report_file_as_mark(offenses)
+        mark = if offenses.empty?
+                 @dot
+               else
+                 highest_offense = offenses.max_by(&:severity)
+                 colored_severity_code(highest_offense)
+               end
+
+        output.write mark
+      end
+    end
+  end
+end

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

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'colorizable'
+require_relative 'text_util'
+
+module RuboCop
+  module Formatter
+    # A basic formatter that displays only files with offenses.
+    # Offenses are displayed at compact form - just the
+    # location of the problem and the associated message.
+    class SimpleTextFormatter < BaseFormatter
+      include Colorizable
+      include PathUtil
+
+      COLOR_FOR_SEVERITY = {
+        refactor:   :yellow,
+        convention: :yellow,
+        warning:    :magenta,
+        error:      :red,
+        fatal:      :red
+      }.freeze
+
+      def started(_target_files)
+        @total_offense_count = 0
+        @total_correction_count = 0
+      end
+
+      def file_finished(file, offenses)
+        return if offenses.empty?
+
+        count_stats(offenses)
+        report_file(file, offenses)
+      end
+
+      def finished(inspected_files)
+        report_summary(inspected_files.count,
+                       @total_offense_count,
+                       @total_correction_count)
+      end
+
+      def report_file(file, offenses)
+        output.puts yellow("== #{smart_path(file)} ==")
+
+        offenses.each do |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
+
+      def report_summary(file_count, offense_count, correction_count)
+        report = Report.new(file_count,
+                            offense_count,
+                            correction_count,
+                            rainbow)
+
+        output.puts
+        output.puts report.summary
+      end
+
+      private
+
+      def count_stats(offenses)
+        @total_offense_count += offenses.count
+        @total_correction_count += offenses.count(&:corrected?)
+      end
+
+      def colored_severity_code(offense)
+        color = COLOR_FOR_SEVERITY[offense.severity.name]
+        colorize(offense.severity.code, color)
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/m, yellow('\1'))
+      end
+
+      def message(offense)
+        message =
+          if offense.corrected_with_todo?
+            green('[Todo] ')
+          elsif offense.corrected?
+            green('[Corrected] ')
+          else
+            ''
+          end
+
+        "#{message}#{annotate_message(offense.message)}"
+      end
+
+      # A helper class for building the report summary text.
+      class Report
+        include Colorizable
+        include TextUtil
+
+        def initialize(file_count, offense_count, correction_count, rainbow)
+          @file_count = file_count
+          @offense_count = offense_count
+          @correction_count = correction_count
+          @rainbow = rainbow
+        end
+
+        def summary
+          if @correction_count.positive?
+            "#{files} inspected, #{offenses} detected, #{corrections} corrected"
+          else
+            "#{files} inspected, #{offenses} detected"
+          end
+        end
+
+        private
+
+        attr_reader :rainbow
+
+        def files
+          pluralize(@file_count, 'file')
+        end
+
+        def offenses
+          text = pluralize(@offense_count, 'offense', no_for_zero: true)
+          color = @offense_count.zero? ? :green : :red
+
+          colorize(text, color)
+        end
+
+        def corrections
+          text = pluralize(@correction_count, 'offense')
+          color = @correction_count == @offense_count ? :green : :cyan
+
+          colorize(text, color)
+        end
+      end
+    end
+  end
+end