rubocop 0.18.1 → 0.19.0

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -6,8 +6,8 @@ module Rubocop
     # The precise location of the problem is shown together with the
     # relevant source code.
     class ClangStyleFormatter < SimpleTextFormatter
-      def report_file(file, offences)
-        offences.each do |o|
+      def report_file(file, offenses)
+        offenses.each do |o|
           output.printf("%s:%d:%d: %s: %s\n",
                         cyan(smart_path(file)), o.line, o.real_column,
                         colored_severity_code(o), message(o))

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -3,37 +3,37 @@
 module Rubocop
   module Formatter
     # This formatter displays a YAML configuration file where all cops that
-    # detected any offences are configured to not detect the offence.
+    # detected any offenses are configured to not detect the offense.
     class DisabledConfigFormatter < BaseFormatter
       HEADING =
         ['# This configuration was generated by `rubocop --auto-gen-config`',
          "# on #{Time.now} using RuboCop version #{Version.version}.",
          '# The point is for the user to remove these configuration records',
-         '# one by one as the offences are removed from the code base.',
+         '# 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")
 
-      @config_to_allow_offences = {}
+      @config_to_allow_offenses = {}
 
       COPS = Cop::Cop.all.group_by { |c| c.cop_name }
 
       class << self
-        attr_accessor :config_to_allow_offences
+        attr_accessor :config_to_allow_offenses
       end
 
-      def file_finished(file, offences)
-        @cops_with_offences ||= Hash.new(0)
-        offences.each { |o| @cops_with_offences[o.cop_name] += 1 }
+      def file_finished(file, offenses)
+        @cops_with_offenses ||= Hash.new(0)
+        offenses.each { |o| @cops_with_offenses[o.cop_name] += 1 }
       end
 
       def finished(inspected_files)
         output.puts HEADING
-        @cops_with_offences.sort.each do |cop_name, offence_count|
+        @cops_with_offenses.sort.each do |cop_name, offense_count|
           output.puts
-          cfg = self.class.config_to_allow_offences[cop_name]
+          cfg = self.class.config_to_allow_offenses[cop_name]
           cfg ||= { 'Enabled' => false }
-          output_cop_comments(output, cfg, cop_name, offence_count)
+          output_cop_comments(output, cfg, cop_name, offense_count)
           output.puts "#{cop_name}:"
           cfg.each { |key, value| output.puts "  #{key}: #{value}" }
         end
@@ -42,8 +42,8 @@ module Rubocop
         puts "add inherit_from: #{output.path} in a .rubocop.yml file."
       end
 
-      def output_cop_comments(output, cfg, cop_name, offence_count)
-        output.puts "# Offence count: #{offence_count}"
+      def output_cop_comments(output, cfg, cop_name, offense_count)
+        output.puts "# Offense count: #{offense_count}"
         if COPS[cop_name] && COPS[cop_name].first.new.support_autocorrect?
           output.puts '# Cop supports --auto-correct.'
         end

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -4,9 +4,10 @@ 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, offences)
-        offences.each do |o|
+      def file_finished(file, offenses)
+        offenses.each do |o|
           message = o.corrected? ? '[Corrected] ' : ''
           message << o.message
 

data/lib/rubocop/formatter/file_list_formatter.rb

@@ -2,16 +2,16 @@
 
 module Rubocop
   module Formatter
-    # This formatter displays just a list of the files with offences in them,
-    # separated by newlines.
+    # 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, offences)
-        return if offences.empty?
+      def file_finished(file, offenses)
+        return if offenses.empty?
         output.printf("%s\n", file)
       end
     end

data/lib/rubocop/formatter/formatter_set.rb

@@ -10,10 +10,11 @@ module Rubocop
         'progress' => ProgressFormatter,
         'simple'   => SimpleTextFormatter,
         'clang'    => ClangStyleFormatter,
+        'fuubar'   => FuubarStyleFormatter,
         'emacs'    => EmacsStyleFormatter,
         'json'     => JSONFormatter,
         'files'    => FileListFormatter,
-        'offences' => OffenceCountFormatter
+        'offenses' => OffenseCountFormatter
       }
 
       FORMATTER_APIS = [:started, :file_started, :file_finished, :finished]

data/lib/rubocop/formatter/fuubar_style_formatter.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+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 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 do |a, b|
+          a.severity_level <=> b.severity_level
+        end
+      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]
+        else
+          :green
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/json_formatter.rb

@@ -14,7 +14,7 @@ module Rubocop
         @output_hash = {
           metadata: metadata_hash,
           files:    [],
-          summary:  { offence_count: 0 }
+          summary:  { offense_count: 0 }
         }
       end
 
@@ -22,9 +22,9 @@ module Rubocop
         output_hash[:summary][:target_file_count] = target_files.count
       end
 
-      def file_finished(file, offences)
-        output_hash[:files] << hash_for_file(file, offences)
-        output_hash[:summary][:offence_count] += offences.count
+      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)
@@ -42,28 +42,29 @@ module Rubocop
         }
       end
 
-      def hash_for_file(file, offences)
+      def hash_for_file(file, offenses)
         {
           path:     relative_path(file),
-          offences: offences.map { |o| hash_for_offence(o) }
+          offenses: offenses.map { |o| hash_for_offense(o) }
         }
       end
 
-      def hash_for_offence(offence)
+      def hash_for_offense(offense)
         {
-          severity: offence.severity,
-          message:  offence.message,
-          cop_name: offence.cop_name,
-          corrected: offence.corrected?,
-          location: hash_for_location(offence)
+          severity: offense.severity,
+          message:  offense.message,
+          cop_name: offense.cop_name,
+          corrected: offense.corrected?,
+          location: hash_for_location(offense)
         }
       end
 
-      # TODO: Consider better solution for Offence#real_column.
-      def hash_for_location(offence)
+      # TODO: Consider better solution for Offense#real_column.
+      def hash_for_location(offense)
         {
-          line:   offence.line,
-          column: offence.real_column
+          line:   offense.line,
+          column: offense.real_column,
+          length: offense.location.length
         }
       end
 

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+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)
+      end
+
+      def file_finished(file, offenses)
+        offenses.each { |o| @offense_counts[o.cop_name] += 1 }
+      end
+
+      def finished(inspected_files)
+        report_summary(inspected_files.count,
+                       ordered_offense_counts(@offense_counts))
+      end
+
+      def report_summary(file_count, offense_counts)
+        output.puts
+
+        offense_count = total_offense_count(offense_counts)
+        offense_counts.each do |cop_name, count|
+          output.puts "#{count.to_s.ljust(offense_count.to_s.length + 2)}" \
+                      "#{cop_name}\n"
+        end
+        output.puts '--'
+        output.puts "#{offense_count}  Total"
+
+        output.puts
+      end
+
+      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/progress_formatter.rb

@@ -2,52 +2,52 @@
 
 module Rubocop
   module Formatter
-    # This formatter display dots for files with no offences and
+    # 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
       def started(target_files)
         super
-        @offences_for_files = {}
+        @offenses_for_files = {}
         file_phrase = target_files.count == 1 ? 'file' : 'files'
         output.puts "Inspecting #{target_files.count} #{file_phrase}"
       end
 
-      def file_finished(file, offences)
-        unless offences.empty?
-          count_stats(offences)
-          @offences_for_files[file] = offences
+      def file_finished(file, offenses)
+        unless offenses.empty?
+          count_stats(offenses)
+          @offenses_for_files[file] = offenses
         end
 
-        report_file_as_mark(file, offences)
+        report_file_as_mark(file, offenses)
       end
 
       def finished(inspected_files)
         output.puts
 
-        unless @offences_for_files.empty?
+        unless @offenses_for_files.empty?
           output.puts
-          output.puts 'Offences:'
+          output.puts 'Offenses:'
           output.puts
 
-          @offences_for_files.each do |file, offences|
-            report_file(file, offences)
+          @offenses_for_files.each do |file, offenses|
+            report_file(file, offenses)
           end
         end
 
         report_summary(inspected_files.count,
-                       @total_offence_count,
+                       @total_offense_count,
                        @total_correction_count)
       end
 
-      def report_file_as_mark(file, offences)
-        mark = if offences.empty?
+      def report_file_as_mark(file, offenses)
+        mark = if offenses.empty?
                  green('.')
                else
-                 highest_offence = offences.max do |a, b|
+                 highest_offense = offenses.max do |a, b|
                    a.severity_level <=> b.severity_level
                  end
-                 colored_severity_code(highest_offence)
+                 colored_severity_code(highest_offense)
                end
 
         output.write mark

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -4,8 +4,8 @@ require 'rubocop/formatter/colorizable'
 
 module Rubocop
   module Formatter
-    # A basic formatter that displays only files with offences.
-    # Offences are displayed at compact form - just the
+    # 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
@@ -20,45 +20,45 @@ module Rubocop
       }.freeze
 
       def started(target_files)
-        @total_offence_count = 0
+        @total_offense_count = 0
         @total_correction_count = 0
       end
 
-      def file_finished(file, offences)
-        return if offences.empty?
-        count_stats(offences)
-        report_file(file, offences)
+      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_offence_count,
+                       @total_offense_count,
                        @total_correction_count)
       end
 
-      def report_file(file, offences)
+      def report_file(file, offenses)
         output.puts yellow("== #{smart_path(file)} ==")
 
-        offences.each do |o|
+        offenses.each do |o|
           output.printf("%s:%3d:%3d: %s\n",
                         colored_severity_code(o),
                         o.line, o.real_column, message(o))
         end
       end
 
-      def report_summary(file_count, offence_count, correction_count)
+      def report_summary(file_count, offense_count, correction_count)
         summary = pluralize(file_count, 'file')
         summary << ' inspected, '
 
-        offences_text = pluralize(offence_count, 'offence', no_for_zero: true)
-        offences_text << ' detected'
-        summary << colorize(offences_text, offence_count.zero? ? :green : :red)
+        offenses_text = pluralize(offense_count, 'offense', no_for_zero: true)
+        offenses_text << ' detected'
+        summary << colorize(offenses_text, offense_count.zero? ? :green : :red)
 
         if correction_count > 0
           summary << ', '
-          correction_text = pluralize(correction_count, 'offence')
+          correction_text = pluralize(correction_count, 'offense')
           correction_text << ' corrected'
-          color = correction_count == offence_count ? :green : :cyan
+          color = correction_count == offense_count ? :green : :cyan
           summary << colorize(correction_text, color)
         end
 
@@ -68,9 +68,9 @@ module Rubocop
 
       private
 
-      def count_stats(offences)
-        @total_offence_count += offences.count
-        @total_correction_count += offences.select(&:corrected?).count
+      def count_stats(offenses)
+        @total_offense_count += offenses.count
+        @total_correction_count += offenses.select(&:corrected?).count
       end
 
       def smart_path(path)
@@ -84,14 +84,14 @@ module Rubocop
         end
       end
 
-      def colored_severity_code(offence)
-        color = COLOR_FOR_SEVERITY[offence.severity]
-        colorize(offence.severity_code, color)
+      def colored_severity_code(offense)
+        color = COLOR_FOR_SEVERITY[offense.severity]
+        colorize(offense.severity_code, color)
       end
 
-      def message(offence)
-        message = offence.corrected? ? green('[Corrected] ') : ''
-        message << offence.message
+      def message(offense)
+        message = offense.corrected? ? green('[Corrected] ') : ''
+        message << offense.message
       end
 
       def pluralize(number, thing, options = {})