rubocop 0.8.3 → 0.9.0

data/lib/rubocop/formatter/base_formatter.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+# rubocop:disable LineLength
+
+module Rubocop
+  module Formatter
+    # Abstract base class for formatter, implements all public API methods.
+    #
+    # ## Creating Custom Formatter
+    #
+    # You can create a custom formatter by subclassing
+    # `Rubocop::Formatter::BaseFormatter` and override some methods,
+    # or implement all the methods by duck typing.
+    #
+    # ## Using Custom Formatter in Command Line
+    #
+    # You can tell RuboCop to use your custom formatter with a combination of
+    # `--format` and `--require` option.
+    # For example, when you have defined `MyCustomFormatter` in
+    # `./path/to/my_custom_formatter.rb`, you would type this command:
+    #
+    #     rubocop --require ./path/to/my_custom_formatter --format MyCustomFormatter
+    #
+    # Note: The path passed to `--require` is directly passed to
+    # `Kernel.require`.
+    # If your custom formatter file is not in `$LOAD_PATH`,
+    # you need to specify the path as relative path prefixed with `./`
+    # explicitly, or absolute path.
+    #
+    # ## Method Invocation Order
+    #
+    # For example, when RuboCop inspects 2 files,
+    # the invocation order should be like this:
+    #
+    # * `#initialize`
+    # * `#started`
+    # * `#file_started`
+    # * `#file_finished`
+    # * `#file_started`
+    # * `#file_finished`
+    # * `#finished`
+    #
+    class BaseFormatter
+      # rubocop:enable LineLength
+
+      # @api public
+      #
+      # @!attribute [r] output
+      #
+      # @return [IO]
+      #   the IO object passed to `#initialize`
+      #
+      # @see #initialize
+      attr_reader :output
+
+      # @api public
+      #
+      # @param output [IO]
+      #   `$stdout` or opened file
+      def initialize(output)
+        @output = output
+      end
+
+      # @api public
+      #
+      # Invoked once before any files are inspected.
+      #
+      # @param target_files [Array(String)]
+      #   all target file paths to be inspected
+      #
+      # @return [void]
+      def started(target_files)
+      end
+
+      # @api public
+      #
+      # Invoked at the beginning of inspecting each files.
+      #
+      # @param file [String]
+      #   the file path
+      #
+      # @param options [Hash]
+      #   file specific information, currently this is always empty.
+      #
+      # @return [void]
+      def file_started(file, options)
+      end
+
+      # @api public
+      #
+      # Invoked at the end of inspecting each files.
+      #
+      # @param file [String]
+      #   the file path
+      #
+      # @param offences [Array(Rubocop::Cop::Offence)]
+      #   all detected offences for the file
+      #
+      # @return [void]
+      #
+      # @see Rubocop::Cop::Offence
+      def file_finished(file, offences)
+      end
+
+      # @api public
+      #
+      # Invoked after all files are inspected, or interrupted by user.
+      #
+      # @param inspected_files [Array(String)]
+      #   the inspected file paths.
+      #   This would be same as `target_files` passed to `#started`
+      #   unless RuboCop is interrupted by user.
+      #
+      # @return [void]
+      def finished(inspected_files)
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Formatter
+    # This formatter formats report data in clang style.
+    # 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|
+          output.printf("%s:%d:%d: %s: %s\n",
+                        smart_path(file).color(:cyan), o.line, o.real_column,
+                        o.clang_severity, o.message)
+          output.puts(o.location.source_line)
+          output.puts(' ' * o.location.column +
+                      '^' * o.location.column_range.count)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Formatter
+    # This formatter displays the report data in format that's
+    # easy to process in the Emacs text editor.
+    class EmacsStyleFormatter < SimpleTextFormatter
+      def report_file(file, offences)
+        offences.each do |o|
+          output.printf("%s:%d:%d: %s: %s\n",
+                        file, o.line, o.real_column, o.encode_severity,
+                        o.message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/formatter_set.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+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 = {
+        'progress' => ProgressFormatter,
+        'simple'   => SimpleTextFormatter,
+        'clang'    => ClangStyleFormatter,
+        'emacs'    => EmacsStyleFormatter,
+        'json'     => JSONFormatter
+      }
+
+      FORMATTER_APIS = [:started, :file_started, :file_finished, :finished]
+
+      def initialize(report_summary = true)
+        @reports_summary = report_summary
+      end
+
+      FORMATTER_APIS.each do |method_name|
+        define_method(method_name) do |*args|
+          each { |f| f.send(method_name, *args) }
+        end
+      end
+
+      def add_formatter(formatter_key, output_path = nil)
+        formatter_class = if formatter_key =~ /\A[A-Z]/
+                            custom_formatter_class(formatter_key)
+                          else
+                            builtin_formatter_class(formatter_key)
+                          end
+
+        output = output_path ? File.open(output_path, 'w') : $stdout
+
+        formatter = formatter_class.new(output)
+        if formatter.respond_to?(:reports_summary=)
+          # TODO: Consider dropping -s/--silent option
+          formatter.reports_summary = @reports_summary
+        end
+        self << formatter
+      end
+
+      def close_output_files
+        each do |formatter|
+          formatter.output.close if formatter.output.is_a?(File)
+        end
+      end
+
+      private
+
+      def builtin_formatter_class(specified_key)
+        matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
+          key.start_with?(specified_key)
+        end
+
+        if matching_keys.empty?
+          fail %(No formatter for "#{specified_key}")
+        elsif matching_keys.size > 1
+          fail %(Cannot determine formatter for "#{specified_key}")
+        end
+
+        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/json_formatter.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'json'
+require 'pathname'
+
+module Rubocop
+  module Formatter
+    # This formatter formats the report data in JSON format.
+    class JSONFormatter < BaseFormatter
+      attr_reader :output_hash
+
+      def initialize(output)
+        super
+        @output_hash = {
+          metadata: metadata_hash,
+             files: [],
+           summary: { offence_count: 0 }
+        }
+      end
+
+      def started(target_files)
+        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
+      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, offences)
+        {
+              path: relative_path(file),
+          offences: offences.map { |o| hash_for_offence(o) }
+        }
+      end
+
+      def hash_for_offence(offence)
+        {
+          severity: offence.severity,
+           message: offence.message,
+          cop_name: offence.cop_name,
+          location: hash_for_location(offence)
+        }
+      end
+
+      # TODO: Consider better solution for Offence#real_column.
+      def hash_for_location(offence)
+        {
+            line: offence.line,
+          column: offence.real_column
+        }
+      end
+
+      private
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(Pathname.getwd).to_s
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/progress_formatter.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Rubocop
+  module Formatter
+    # This formatter display dots for files with no offences 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
+      COLOR_FOR_SEVERITY = {
+          refactor: :yellow,
+        convention: :yellow,
+           warning: :magenta,
+             error: :red,
+             fatal: :red
+      }
+
+      def started(target_files)
+        super
+        @offences_for_files = {}
+        file_phrase = target_files.count == 1 ? 'file' : 'files'
+        output.puts "Inspecting #{target_files.count} #{file_phrase}"
+      end
+
+      def file_finished(file, offences)
+        @total_offence_count += offences.count
+        @offences_for_files[file] = offences unless offences.empty?
+        report_file_as_mark(file, offences)
+      end
+
+      def finished(inspected_files)
+        output.puts
+
+        return unless reports_summary?
+
+        unless @offences_for_files.empty?
+          output.puts
+          output.puts 'Offences:'
+          output.puts
+
+          @offences_for_files.each do |file, offences|
+            report_file(file, offences)
+          end
+        end
+
+        report_summary(inspected_files.count, @total_offence_count)
+      end
+
+      def report_file_as_mark(file, offences)
+        mark = if offences.empty?
+                 '.'.color(:green)
+               else
+                 highest_offence = offences.max do |a, b|
+                   a.severity_level <=> b.severity_level
+                 end
+                 color = COLOR_FOR_SEVERITY[highest_offence.severity]
+                 highest_offence.encode_severity.color(color)
+               end
+
+        output.write mark
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Rubocop
+  module Formatter
+    # A basic formatter that displays only files with offences.
+    # Offences are displayed at compact form - just the
+    # location of the problem and the associated message.
+    class SimpleTextFormatter < BaseFormatter
+      attr_accessor :reports_summary
+      alias_method :reports_summary?, :reports_summary
+
+      def started(target_files)
+        @total_offence_count = 0
+      end
+
+      def file_finished(file, offences)
+        return if offences.empty?
+        @total_offence_count += offences.count
+        report_file(file, offences)
+      end
+
+      def finished(inspected_files)
+        if reports_summary?
+          report_summary(inspected_files.count, @total_offence_count)
+        end
+      end
+
+      def report_file(file, offences)
+        output.puts "== #{smart_path(file)} ==".color(:yellow)
+        output.puts offences.join("\n")
+      end
+
+      def report_summary(file_count, offence_count)
+        summary = ''
+
+        plural = file_count == 0 || file_count > 1 ? 's' : ''
+        summary << "#{file_count} file#{plural} inspected, "
+
+        offences_string = case offence_count
+                          when 0 then 'no offences'
+                          when 1 then '1 offence'
+                          else "#{offence_count} offences"
+                          end
+        summary << "#{offences_string} detected"
+          .color(offence_count.zero? ? :green : :red)
+
+        output.puts
+        output.puts summary
+      end
+
+      protected
+
+      def smart_path(path)
+        if path.start_with?(Dir.pwd)
+          Pathname.new(path).relative_path_from(Pathname.getwd).to_s
+        else
+          path
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/version.rb

@@ -1,7 +1,21 @@
 # encoding: utf-8
 
 module Rubocop
+  # This module holds the RuboCop version information.
   module Version
-    STRING = '0.8.3'
+    STRING = '0.9.0'
+
+    MSG = '%s (using Parser %s, running on %s %s %s)'
+
+    module_function
+
+    def version(debug = false)
+      if debug
+        sprintf(MSG, STRING, Parser::VERSION,
+                RUBY_ENGINE, RUBY_VERSION, RUBY_PLATFORM)
+      else
+        STRING
+      end
+    end
   end
 end