rubocop-grantbirki 1.75.2

data/lib/rubocop/formatter/html_formatter.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'erb'
+
+module RuboCop
+  module Formatter
+    # This formatter saves the output as an html file.
+    class HTMLFormatter < BaseFormatter
+      ELLIPSES = '<span class="extra-code">...</span>'
+      TEMPLATE_PATH = File.expand_path('../../../assets/output.html.erb', __dir__)
+      CSS_PATH = File.expand_path('../../../assets/output.css.erb', __dir__)
+
+      Color = Struct.new(:red, :green, :blue, :alpha) do
+        def to_s
+          "rgba(#{values.join(', ')})"
+        end
+
+        def fade_out(amount)
+          dup.tap { |color| color.alpha -= amount }
+        end
+      end
+
+      Summary = Struct.new(:offense_count, :inspected_files, :target_files, keyword_init: true)
+      FileOffenses = Struct.new(:path, :offenses, keyword_init: true)
+
+      attr_reader :files, :summary
+
+      def initialize(output, options = {})
+        super
+        @files = []
+        @summary = Summary.new(offense_count: 0)
+      end
+
+      def started(target_files)
+        summary.target_files = target_files
+      end
+
+      def file_finished(file, offenses)
+        files << FileOffenses.new(path: file, offenses: offenses)
+        summary.offense_count += offenses.count
+      end
+
+      def finished(inspected_files)
+        summary.inspected_files = inspected_files
+
+        render_html
+      end
+
+      def render_html
+        context = ERBContext.new(files, summary)
+
+        template = File.read(TEMPLATE_PATH, encoding: Encoding::UTF_8)
+        erb = ERB.new(template)
+        html = erb.result(context.binding).lines.map do |line|
+          line.match?(/\A\s*\z/) ? "\n" : line
+        end.join
+
+        output.write html
+      end
+
+      # This class provides helper methods used in the ERB template.
+      class ERBContext
+        include PathUtil
+        include TextUtil
+
+        LOGO_IMAGE_PATH = File.expand_path('../../../assets/logo.png', __dir__)
+
+        attr_reader :files, :summary
+
+        def initialize(files, summary)
+          @files = files.sort_by(&:path)
+          @summary = summary
+        end
+
+        # Make Kernel#binding public.
+        # rubocop:disable Lint/UselessMethodDefinition
+        def binding
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+
+        def decorated_message(offense)
+          offense.message.gsub(/`(.+?)`/) { "<code>#{escape(Regexp.last_match(1))}</code>" }
+        end
+
+        def highlighted_source_line(offense)
+          source_before_highlight(offense) +
+            highlight_source_tag(offense) +
+            source_after_highlight(offense) +
+            possible_ellipses(offense.location)
+        end
+
+        def highlight_source_tag(offense)
+          "<span class=\"highlight #{offense.severity}\">" \
+            "#{escape(offense.highlighted_area.source)}" \
+            '</span>'
+        end
+
+        def source_before_highlight(offense)
+          source_line = offense.location.source_line
+          escape(source_line[0...offense.highlighted_area.begin_pos])
+        end
+
+        def source_after_highlight(offense)
+          source_line = offense.location.source_line
+          escape(source_line[offense.highlighted_area.end_pos..])
+        end
+
+        def possible_ellipses(location)
+          location.single_line? ? '' : " #{ELLIPSES}"
+        end
+
+        def escape(string)
+          CGI.escapeHTML(string)
+        end
+
+        def base64_encoded_logo_image
+          image = File.read(LOGO_IMAGE_PATH, binmode: true)
+
+          # `Base64.encode64` compatible:
+          # https://github.com/ruby/base64/blob/v0.1.1/lib/base64.rb#L27-L40
+          [image].pack('m')
+        end
+
+        def render_css
+          context = CSSContext.new
+          template = File.read(CSS_PATH, encoding: Encoding::UTF_8)
+          erb = ERB.new(template, trim_mode: '-')
+          erb.result(context.binding).lines.map do |line|
+            line == "\n" ? line : "      #{line}"
+          end.join
+        end
+      end
+
+      # This class provides helper methods used in the ERB CSS template.
+      class CSSContext
+        SEVERITY_COLORS = {
+          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
+          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
+          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
+          error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
+          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
+        }.freeze
+
+        # Make Kernel#binding public.
+        # rubocop:disable Lint/UselessMethodDefinition
+        def binding
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/json_formatter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RuboCop
+  module Formatter
+    # This formatter formats the report data in JSON format.
+    class JSONFormatter < BaseFormatter
+      include PathUtil
+
+      attr_reader :output_hash
+
+      def initialize(output, options = {})
+        super
+        @output_hash = { metadata: metadata_hash, files: [], summary: { offense_count: 0 } }
+      end
+
+      def started(target_files)
+        output_hash[:summary][:target_file_count] = target_files.count
+      end
+
+      def file_finished(file, offenses)
+        output_hash[:files] << hash_for_file(file, offenses)
+        output_hash[:summary][:offense_count] += offenses.count
+      end
+
+      def finished(inspected_files)
+        output_hash[:summary][:inspected_file_count] = inspected_files.count
+        output.write output_hash.to_json
+      end
+
+      def metadata_hash
+        {
+          rubocop_version: RuboCop::Version::STRING,
+          ruby_engine:     RUBY_ENGINE,
+          ruby_version:    RUBY_VERSION,
+          ruby_patchlevel: RUBY_PATCHLEVEL.to_s,
+          ruby_platform:   RUBY_PLATFORM
+        }
+      end
+
+      def hash_for_file(file, offenses)
+        {
+          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?,
+          correctable: offense.correctable?,
+          location:    hash_for_location(offense)
+        }
+      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,
+          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
+  end
+end

data/lib/rubocop/formatter/junit_formatter.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+#
+# 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
+      ESCAPE_MAP = {
+        '"' => '&quot;',
+        "'" => '&apos;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        '&' => '&amp;'
+      }.freeze
+
+      def initialize(output, options = {})
+        super
+
+        @test_case_elements = []
+
+        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
+
+      # rubocop:disable Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength
+      def finished(_inspected_files)
+        output.puts %(<?xml version='1.0'?>)
+        output.puts %(<testsuites>)
+        output.puts %(  <testsuite name='rubocop' tests='#{@inspected_file_count}' failures='#{@offense_count}'>)
+
+        @test_case_elements.each do |test_case_element|
+          if test_case_element.failures.empty?
+            output.puts %(    <testcase classname='#{xml_escape test_case_element.classname}' name='#{test_case_element.name}'/>)
+          else
+            output.puts %(    <testcase classname='#{xml_escape test_case_element.classname}' name='#{test_case_element.name}'>)
+            test_case_element.failures.each do |failure_element|
+              output.puts %(      <failure type='#{failure_element.type}' message='#{xml_escape failure_element.message}'>)
+              output.puts %(        #{xml_escape failure_element.text})
+              output.puts %(      </failure>)
+            end
+            output.puts %(    </testcase>)
+          end
+        end
+
+        output.puts %(  </testsuite>)
+        output.puts %(</testsuites>)
+      end
+      # rubocop:enable Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength
+
+      private
+
+      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)
+        @test_case_elements << TestCaseElement.new(
+          classname: classname_attribute_value(file),
+          name: cop.cop_name
+        ).tap do |test_case_element|
+          add_failure_to(test_case_element, target_offenses, cop.cop_name)
+        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('/', '.')
+        end
+        @classname_attribute_value_cache[file]
+      end
+
+      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|
+          testcase.failures << FailureElement.new(
+            type: cop_name,
+            message: offense.message,
+            text: offense.location.to_s
+          )
+        end
+      end
+
+      def xml_escape(string)
+        string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+      end
+
+      class TestCaseElement # :nodoc:
+        attr_reader :classname, :name, :failures
+
+        def initialize(classname:, name:)
+          @classname = classname
+          @name = name
+          @failures = []
+        end
+      end
+
+      class FailureElement # :nodoc:
+        attr_reader :type, :message, :text
+
+        def initialize(type:, message:, text:)
+          @type = type
+          @message = message
+          @text = text
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/markdown_formatter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter displays the report data in markdown
+    class MarkdownFormatter < BaseFormatter
+      include TextUtil
+      include PathUtil
+      attr_reader :files, :summary
+
+      def initialize(output, options = {})
+        super
+        @files = []
+        @summary = Struct.new(:offense_count, :inspected_files, :target_files).new(0)
+      end
+
+      def started(target_files)
+        summary.target_files = target_files
+      end
+
+      def file_finished(file, offenses)
+        files << Struct.new(:path, :offenses).new(file, offenses)
+        summary.offense_count += offenses.count
+      end
+
+      def finished(inspected_files)
+        summary.inspected_files = inspected_files
+        render_markdown
+      end
+
+      private
+
+      def render_markdown
+        n_files = pluralize(summary.inspected_files.count, 'file')
+        n_offenses = pluralize(summary.offense_count, 'offense', no_for_zero: true)
+
+        output.write "# RuboCop Inspection Report\n\n"
+        output.write "#{n_files} inspected, #{n_offenses} detected:\n\n"
+        write_file_messages
+      end
+
+      def write_file_messages
+        files.each do |file|
+          next if file.offenses.empty?
+
+          write_heading(file)
+          file.offenses.each do |offense|
+            write_context(offense)
+            write_code(offense)
+          end
+        end
+      end
+
+      def write_heading(file)
+        filename = relative_path(file.path)
+        n_offenses = pluralize(file.offenses.count, 'offense')
+
+        output.write "### #{filename} - (#{n_offenses})\n"
+      end
+
+      def write_context(offense)
+        output.write(
+          "  * **Line # #{offense.location.line} - #{offense.severity}:** #{offense.message}\n\n"
+        )
+      end
+
+      def write_code(offense)
+        code = offense.location.source_line + possible_ellipses(offense.location)
+
+        output.write "    ```rb\n    #{code}\n    ```\n\n" unless code.blank?
+      end
+
+      def possible_ellipses(location)
+        location.single_line? ? '' : ' ...'
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+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 in 5 files
+    class OffenseCountFormatter < BaseFormatter
+      attr_reader :offense_counts
+
+      def started(target_files)
+        super
+        @offense_counts = Hash.new(0)
+        @offending_files_count = 0
+        @style_guide_links = {}
+
+        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 }
+        if options[:display_style_guide]
+          offenses.each { |o| @style_guide_links[o.cop_name] ||= o.message[/ \(http\S+\)\Z/] }
+        end
+        @offending_files_count += 1 unless offenses.empty?
+        @progressbar.increment if instance_variable_defined?(:@progressbar)
+      end
+
+      def finished(_inspected_files)
+        report_summary(@offense_counts, @offending_files_count)
+      end
+
+      # rubocop:disable 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)
+
+        output.puts
+
+        column_width = total_count.to_s.length + 2
+        per_cop_counts.each do |cop_name, count|
+          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
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def ordered_offense_counts(offense_counts)
+        offense_counts.sort_by { |k, v| [-v, k] }.to_h
+      end
+
+      def total_offense_count(offense_counts)
+        offense_counts.values.sum
+      end
+
+      def cop_information(cop_name)
+        cop = RuboCop::Cop::Registry.global.find_by_cop_name(cop_name).new
+
+        if cop.correctable?
+          safety = cop.safe_autocorrect? ? 'Safe' : 'Unsafe'
+          correctable = Rainbow(" [#{safety} Correctable]").yellow
+        end
+
+        "#{cop_name}#{correctable}#{@style_guide_links[cop_name]}"
+      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,62 @@
+# 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 { |file, offenses| report_file(file, offenses) }
+        end
+
+        report_summary(inspected_files.size,
+                       @total_offense_count,
+                       @total_correction_count,
+                       @total_correctable_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, correctable_count)
+        super unless offense_count.zero?
+      end
+    end
+  end
+end