rubocop 0.87.1

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter displays the report data in format that's
+    # easy to process in the Emacs text editor.
+    # The output is machine-parsable.
+    class EmacsStyleFormatter < BaseFormatter
+      def file_finished(file, offenses)
+        offenses.each do |o|
+          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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter displays just a list of the files with offenses in them,
+    # separated by newlines. The output is machine-parsable.
+    #
+    # Here's the format:
+    #
+    # /some/file
+    # /some/other/file
+    class FileListFormatter < BaseFormatter
+      def file_finished(file, offenses)
+        return if offenses.empty?
+
+        output.printf("%<path>s\n", path: file)
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/formatter_set.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RuboCop
+  module Formatter
+    # This is a collection of formatters. A FormatterSet can hold multiple
+    # formatter instances and provides transparent formatter API methods
+    # which invoke same method of each formatters.
+    class FormatterSet < Array
+      BUILTIN_FORMATTERS_FOR_KEYS = {
+        '[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
+
+      FORMATTER_APIS.each do |method_name|
+        define_method(method_name) do |*args|
+          each { |f| f.send(method_name, *args) }
+        end
+      end
+
+      def initialize(options = {})
+        @options = options # CLI options
+      end
+
+      def file_started(file, options)
+        @options = options[:cli_options]
+        @config_store = options[:config_store]
+        each { |f| f.file_started(file, options) }
+      end
+
+      def file_finished(file, offenses)
+        each { |f| f.file_finished(file, offenses) }
+        offenses
+      end
+
+      def add_formatter(formatter_type, output_path = nil)
+        if output_path
+          dir_path = File.dirname(output_path)
+          FileUtils.mkdir_p(dir_path) unless File.exist?(dir_path)
+          output = File.open(output_path, 'w')
+        else
+          output = $stdout
+        end
+
+        self << formatter_class(formatter_type).new(output, @options)
+      end
+
+      def close_output_files
+        each do |formatter|
+          formatter.output.close if formatter.output.is_a?(File)
+        end
+      end
+
+      private
+
+      def formatter_class(formatter_type)
+        case formatter_type
+        when Class
+          formatter_type
+        when /\A[A-Z]/
+          custom_formatter_class(formatter_type)
+        else
+          builtin_formatter_class(formatter_type)
+        end
+      end
+
+      def builtin_formatter_class(specified_key)
+        matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
+          /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
+        end
+
+        raise %(No formatter for "#{specified_key}") if matching_keys.empty?
+
+        raise %(Cannot determine formatter for "#{specified_key}") if matching_keys.size > 1
+
+        BUILTIN_FORMATTERS_FOR_KEYS[matching_keys.first]
+      end
+
+      def custom_formatter_class(specified_class_name)
+        constant_names = specified_class_name.split('::')
+        constant_names.shift if constant_names.first.empty?
+        constant_names.reduce(Object) do |namespace, constant_name|
+          namespace.const_get(constant_name, false)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/fuubar_style_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+module RuboCop
+  module Formatter
+    # This formatter displays a progress bar and shows details of offenses as
+    # soon as they are detected.
+    # This is inspired by the Fuubar formatter for RSpec by Jeff Kreeftmeijer.
+    # https://github.com/jeffkreeftmeijer/fuubar
+    class FuubarStyleFormatter < ClangStyleFormatter
+      RESET_SEQUENCE = "\e[0m"
+
+      def initialize(*output)
+        @severest_offense = nil
+
+        super
+      end
+
+      def started(target_files)
+        super
+
+        @severest_offense = nil
+
+        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
+        )
+        with_color { @progressbar.start }
+      end
+
+      def file_finished(file, offenses)
+        count_stats(offenses)
+
+        unless offenses.empty?
+          @progressbar.clear
+          report_file(file, offenses)
+        end
+
+        with_color { @progressbar.increment }
+      end
+
+      def count_stats(offenses)
+        super
+
+        offenses = offenses.reject(&:corrected?)
+        return if offenses.empty?
+
+        offenses << @severest_offense if @severest_offense
+        @severest_offense = offenses.max_by(&:severity)
+      end
+
+      def with_color
+        if rainbow.enabled
+          output.write colorize('', progressbar_color).chomp(RESET_SEQUENCE)
+          yield
+          output.write RESET_SEQUENCE
+        else
+          yield
+        end
+      end
+
+      def progressbar_color
+        if @severest_offense
+          COLOR_FOR_SEVERITY[@severest_offense.severity.name]
+        else
+          :green
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/html_formatter.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'erb'
+require 'ostruct'
+require 'base64'
+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>'
+      TEMPLATE_PATH =
+        File.expand_path('../../../assets/output.html.erb', __dir__)
+
+      Color = Struct.new(:red, :green, :blue, :alpha) do
+        def to_s
+          "rgba(#{values.join(', ')})"
+        end
+
+        def fade_out(amount)
+          dup.tap do |color|
+            color.alpha -= amount
+          end
+        end
+      end
+
+      attr_reader :files, :summary
+
+      def initialize(output, options = {})
+        super
+        @files = []
+        @summary = OpenStruct.new(offense_count: 0)
+      end
+
+      def started(target_files)
+        summary.target_files = target_files
+      end
+
+      def file_finished(file, offenses)
+        files << OpenStruct.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)
+
+        # 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
+      end
+
+      # This class provides helper methods used in the ERB template.
+      class ERBContext
+        include PathUtil
+        include TextUtil
+
+        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
+
+        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.
+        def binding
+          super
+        end
+
+        def decorated_message(offense)
+          offense.message.gsub(/`(.+?)`/) do
+            "<code>#{Regexp.last_match(1)}</code>"
+          end
+        end
+
+        def highlighted_source_line(offense)
+          source_before_highlight(offense) +
+            hightlight_source_tag(offense) +
+            source_after_highlight(offense) +
+            possible_ellipses(offense.location)
+        end
+
+        def hightlight_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..-1])
+        end
+
+        def possible_ellipses(location)
+          location.first_line == location.last_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(image)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/json_formatter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+
+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.
+      def hash_for_location(offense)
+        {
+          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
+  end
+end