rubocop 0.8.3 → 0.9.0

data/lib/rubocop/cli.rb

@@ -6,6 +6,8 @@ module Rubocop
   # The CLI is a class responsible of handling all the command line interface
   # logic.
   class CLI
+    DEFAULT_FORMATTER = 'progress'
+
     # If set true while running,
     # RuboCop will abort processing and exit gracefully.
     attr_accessor :wants_to_quit
@@ -15,10 +17,8 @@ module Rubocop
 
     def initialize
       @cops = Cop::Cop.all
-      @processed_file_count = 0
-      @total_offences = 0
       @errors = []
-      @options = { mode: :default }
+      @options = {}
       ConfigStore.prepare
     end
 
@@ -29,45 +29,42 @@ module Rubocop
     def run(args = ARGV)
       trap_interrupt
 
-      parse_options(args)
-
       begin
-        validate_only_option if @options[:only]
-      rescue ArgumentError => e
-        puts e.message
+        parse_options(args)
+      rescue => e
+        $stderr.puts e.message
         return 1
       end
 
-      target_files(args).each do |file|
-        break if wants_to_quit?
+      # filter out Rails cops unless requested
+      @cops.reject! { |cop_klass| cop_klass.rails? } unless @options[:rails]
 
-        config = ConfigStore.for(file)
-        report = Report.create(file, @options[:mode])
+      target_files = target_files(args)
+      target_files.each(&:freeze).freeze
+      inspected_files = []
+      any_failed = false
 
-        puts "Scanning #{file}" if @options[:debug]
+      formatter_set.started(target_files)
 
-        syntax_cop = Rubocop::Cop::Syntax.new
-        syntax_cop.debug = @options[:debug]
-        syntax_cop.inspect_file(file)
+      target_files.each do |file|
+        break if wants_to_quit?
 
-        # In case of a syntax error we just report that error and do
-        # no more checking in the file.
-        unless syntax_cop.offences.map(&:severity).include?(:error)
-          inspect_file(file, config, report)
-        end
+        puts "Scanning #{file}" if @options[:debug]
+        formatter_set.file_started(file, {})
 
-        report << syntax_cop
-        @total_offences += syntax_cop.offences.count
+        offences = inspect_file(file)
 
-        @processed_file_count += 1
-        report.display unless report.empty?
+        any_failed = true unless offences.empty?
+        inspected_files << file
+        formatter_set.file_finished(file, offences.freeze)
       end
 
-      unless @options[:silent]
-        display_summary(@processed_file_count, @total_offences, @errors)
-      end
+      formatter_set.finished(inspected_files.freeze)
+      formatter_set.close_output_files
 
-      (@total_offences == 0) && !wants_to_quit ? 0 : 1
+      display_error_summary(@errors) unless @options[:silent]
+
+      !any_failed && !wants_to_quit ? 0 : 1
     end
 
     def validate_only_option
@@ -76,44 +73,56 @@ module Rubocop
       end
     end
 
-    def inspect_file(file, config, report)
+    def inspect_file(file)
       begin
-        ast, comments, tokens, source = CLI.parse(file) do |source_buffer|
-          source_buffer.read
-        end
-      rescue Parser::SyntaxError, Encoding::UndefinedConversionError,
-        ArgumentError => e
+        ast, comments, tokens, source_buffer, source, syntax_offences =
+          CLI.parse(file) { |sb| sb.read }
+
+      rescue Encoding::UndefinedConversionError, ArgumentError => e
         handle_error(e, "An error occurred while parsing #{file}.".color(:red))
-        return
+        return []
       end
 
+      # If we got any syntax errors, return only the syntax offences.
+      # Parser may return nil for AST even though there are no syntax errors.
+      # e.g. sources which contain only comments
+      return syntax_offences unless syntax_offences.empty?
+
+      config = ConfigStore.for(file)
       disabled_lines = disabled_lines_in(source)
 
-      @cops.each do |cop_class|
+      set_config_for_all_cops(config)
+
+      @cops.reduce([]) do |offences, cop_class|
         cop_name = cop_class.cop_name
-        cop_class.config = config.for_cop(cop_name)
         if config.cop_enabled?(cop_name)
-          cop = setup_cop(cop_class,
-                          disabled_lines)
+          cop = setup_cop(cop_class, disabled_lines)
           if !@options[:only] || @options[:only] == cop_name
             begin
-              cop.inspect(source, tokens, ast, comments)
+              cop.inspect(source_buffer, source, tokens, ast, comments)
             rescue => e
               handle_error(e,
                            "An error occurred while #{cop.name}".color(:red) +
                            " cop was inspecting #{file}.".color(:red))
             end
           end
-          @total_offences += cop.offences.count
-          report << cop if cop.has_report?
+          offences.concat(cop.offences)
         end
+        offences
+      end.sort
+    end
+
+    def set_config_for_all_cops(config)
+      @cops.each do |cop_class|
+        cop_class.config = config.for_cop(cop_class.cop_name)
       end
     end
 
-    def setup_cop(cop_class, disabled_lines)
+    def setup_cop(cop_class, disabled_lines = nil)
       cop = cop_class.new
       cop.debug = @options[:debug]
-      cop.disabled_lines = disabled_lines[cop_class.cop_name]
+      cop.autocorrect = @options[:autocorrect]
+      cop.disabled_lines = disabled_lines[cop_class.cop_name] if disabled_lines
       cop
     end
 
@@ -127,35 +136,83 @@ module Rubocop
       end
     end
 
+    # rubocop:disable MethodLength
     def parse_options(args)
+      convert_deprecated_options!(args)
+
       OptionParser.new do |opts|
         opts.banner = 'Usage: rubocop [options] [file1, file2, ...]'
 
-        opts.on('-d', '--debug', 'Display debug info') do |d|
+        opts.on('-d', '--debug', 'Display debug info.') do |d|
           @options[:debug] = d
         end
-        opts.on('-e', '--emacs', 'Emacs style output') do
-          @options[:mode] = :emacs_style
-        end
-        opts.on('-c FILE', '--config FILE', 'Configuration file') do |f|
+        opts.on('-c', '--config FILE', 'Specify configuration file.') do |f|
           @options[:config] = f
           ConfigStore.set_options_config(@options[:config])
         end
-        opts.on('--only COP', 'Run just one cop') do |s|
+        opts.on('--only COP', 'Run just one cop.') do |s|
           @options[:only] = s
+          validate_only_option
+        end
+        opts.on('-f', '--format FORMATTER',
+                'Choose an output formatter. This option',
+                'can be specified multiple times to enable',
+                'multiple formatters at the same time.',
+                '  [p]rogress (default)',
+                '  [s]imple',
+                '  [c]lang',
+                '  [e]macs',
+                '  [j]son',
+                '  custom formatter class name') do |key|
+          @options[:formatters] ||= []
+          @options[:formatters] << [key]
+        end
+        opts.on('-o', '--out FILE',
+                'Write output to a file instead of STDOUT.',
+                'This option applies to the previously',
+                'specified --format, or the default format',
+                'if no format is specified.') do |path|
+          @options[:formatters] ||= [[DEFAULT_FORMATTER]]
+          @options[:formatters].last << path
+        end
+        opts.on('-r', '--require FILE', 'Require Ruby file.') do |f|
+          require f
+        end
+        opts.on('-R', '--rails', 'Run extra Rails cops.') do |r|
+          @options[:rails] = r
         end
-        opts.on('-s', '--silent', 'Silence summary') do |s|
+        opts.on('-a', '--auto-correct', 'Auto-correct offences.') do |a|
+          @options[:autocorrect] = a
+        end
+        opts.on('-s', '--silent', 'Silence summary.') do |s|
           @options[:silent] = s
         end
-        opts.on('-n', '--no-color', 'Disable color output') do |s|
+        opts.on('-n', '--no-color', 'Disable color output.') do |s|
           Sickill::Rainbow.enabled = false
         end
-        opts.on('-v', '--version', 'Display version') do
-          puts Rubocop::Version::STRING
+        opts.on('-v', '--version', 'Display version.') do
+          puts Rubocop::Version.version(false)
+          exit(0)
+        end
+        opts.on('-V', '--verbose-version', 'Display verbose version.') do
+          puts Rubocop::Version.version(true)
           exit(0)
         end
       end.parse!(args)
     end
+    # rubocop:enable MethodLength
+
+    def convert_deprecated_options!(args)
+      args.map! do |arg|
+        case arg
+        when '-e', '--emacs'
+          deprecate("#{arg} option", '--format emacs', '1.0.0')
+          %w(--format emacs)
+        else
+          arg
+        end
+      end.flatten!
+    end
 
     def trap_interrupt
       Signal.trap('INT') do
@@ -166,26 +223,15 @@ module Rubocop
       end
     end
 
-    def display_summary(num_files, total_offences, errors)
-      plural = num_files == 0 || num_files > 1 ? 's' : ''
-      print "\n#{num_files} file#{plural} inspected, "
-      offences_string = if total_offences.zero?
-                          'no offences'
-                        elsif total_offences == 1
-                          '1 offence'
-                        else
-                          "#{total_offences} offences"
-                        end
-      puts "#{offences_string} detected"
-        .color(total_offences.zero? ? :green : :red)
-
-      if errors.count > 0
-        plural = errors.count > 1 ? 's' : ''
-        puts "\n#{errors.count} error#{plural} occurred:".color(:red)
-        errors.each { |error| puts error }
-        puts 'Errors are usually caused by RuboCop bugs.'
-        puts 'Please, report your problems to RuboCop\'s issue tracker.'
-      end
+    def display_error_summary(errors)
+      return if errors.empty?
+      plural = errors.count > 1 ? 's' : ''
+      puts "\n#{errors.count} error#{plural} occurred:".color(:red)
+      errors.each { |error| puts error }
+      puts 'Errors are usually caused by RuboCop bugs.'
+      puts 'Please, report your problems to RuboCop\'s issue tracker.'
+      puts 'Mention the following information in the issue report:'
+      puts Rubocop::Version.version(true)
     end
 
     def disabled_lines_in(source)
@@ -222,25 +268,41 @@ module Rubocop
     def self.parse(file)
       parser = Parser::CurrentRuby.new
 
-      parser.diagnostics.all_errors_are_fatal = true
-      parser.diagnostics.ignore_warnings      = true
+      # On JRuby and Rubinius, there's a risk that we hang in
+      # tokenize() if we don't set the all errors as fatal flag.
+      parser.diagnostics.all_errors_are_fatal = RUBY_ENGINE != 'ruby'
+      parser.diagnostics.ignore_warnings      = false
 
+      diagnostics = []
       parser.diagnostics.consumer = lambda do |diagnostic|
-        $stderr.puts(diagnostic.render)
+        diagnostics << diagnostic
       end
 
       source_buffer = Parser::Source::Buffer.new(file, 1)
       yield source_buffer
 
-      ast, comments, tokens = parser.tokenize(source_buffer)
+      begin
+        ast, comments, tokens = parser.tokenize(source_buffer)
+      rescue Parser::SyntaxError # rubocop:disable HandleExceptions
+        # All errors are in diagnostics. No need to handle exception.
+      end
+
+      if tokens
+        tokens = tokens.map do |t|
+          type, details = *t
+          text, range = *details
+          Rubocop::Cop::Token.new(range, type, text)
+        end
+      end
 
-      tokens = tokens.map do |t|
-        type, details = *t
-        text, range = *details
-        Rubocop::Cop::Token.new(range, type, text)
+      syntax_offences = diagnostics.map do |d|
+        Cop::Offence.new(d.level, d.location, "#{d.message}",
+                         'Syntax')
       end
 
-      [ast, comments, tokens, source_buffer.source.split($RS)]
+      source = source_buffer.source.split($RS)
+
+      [ast, comments, tokens, source_buffer, source, syntax_offences]
     end
 
     # Generate a list of target files by expanding globing patterns
@@ -262,7 +324,7 @@ module Rubocop
         end
       end
 
-      files.uniq
+      files.map { |f| File.expand_path(f) }.uniq
     end
 
     # Finds all Ruby source files under the current or other supplied
@@ -274,13 +336,13 @@ module Rubocop
     # @param root Root directory under which to search for ruby source files
     # @return [Array] Array of filenames
     def ruby_files(root = Dir.pwd)
-      files = Dir["#{root}/**/*"].reject { |file| FileTest.directory? file }
+      files = Dir["#{root}/**/*"].select { |file| FileTest.file?(file) }
 
       rb = []
 
       rb += files.select { |file| File.extname(file) == '.rb' }
       rb += files.select do |file|
-        if File.extname(file) == ''
+        if File.extname(file) == '' && !excluded_file?(file)
           begin
             File.open(file) { |f| f.readline } =~ /#!.*ruby/
           rescue EOFError, ArgumentError => e
@@ -295,10 +357,7 @@ module Rubocop
         config.file_to_include?(file)
       end
 
-      rb.reject do |file|
-        config = ConfigStore.for(file)
-        config.file_to_exclude?(file)
-      end.uniq
+      rb.reject { |file| excluded_file?(file) }.uniq
     end
 
     private
@@ -306,8 +365,34 @@ module Rubocop
     def log_error(e, msg = '')
       if @options[:debug]
         error_message = "#{e.class}, #{e.message}"
-        STDERR.puts "#{msg}\t#{error_message}"
+        warn "#{msg}\t#{error_message}"
+      end
+    end
+
+    def formatter_set
+      @formatter_set ||= begin
+        set = Formatter::FormatterSet.new(!@options[:silent])
+        pairs = @options[:formatters] || [[DEFAULT_FORMATTER]]
+        pairs.each do |formatter_key, output_path|
+          set.add_formatter(formatter_key, output_path)
+        end
+        set
+      rescue => error
+        warn error.message
+        exit(1)
       end
     end
+
+    def deprecate(subject, alternative = nil, version = nil)
+      message =  "#{subject} is deprecated"
+      message << " and will be removed in RuboCop #{version}" if version
+      message << '.'
+      message << " Please use #{alternative} instead." if alternative
+      warn message
+    end
+
+    def excluded_file?(file)
+      ConfigStore.for(file).file_to_exclude?(file)
+    end
   end
 end

data/lib/rubocop/config.rb

@@ -5,6 +5,11 @@ require 'yaml'
 require 'pathname'
 
 module Rubocop
+  # This class represents the configuration of the RuboCop application
+  # and all its cops. A Config is associated with a YAML configuration
+  # file from which it was read. Several different Configs can be used
+  # during a run of the rubocop program, if files in several
+  # directories are inspected.
   class Config < DelegateClass(Hash)
     class ValidationError < StandardError; end
 
@@ -16,22 +21,43 @@ module Rubocop
 
     class << self
       def load_file(path)
+        path = File.absolute_path(path)
         hash = YAML.load_file(path)
 
         base_configs(path, hash['inherit_from']).reverse.each do |base_config|
           base_config.each do |key, value|
             if value.is_a?(Hash)
+              if key == 'AllCops' && value['Excludes']
+                correct_relative_excludes(value, base_config, path)
+              end
               hash[key] = hash.has_key?(key) ? merge(value, hash[key]) : value
             end
           end
         end
 
         hash.delete('inherit_from')
-        config = new(hash, File.realpath(path))
+        config = new(hash, path)
         config.warn_unless_valid
         config
       end
 
+      def correct_relative_excludes(all_cops, base_config, path)
+        all_cops['Excludes'].map! do |exclude_elem|
+          if exclude_elem.is_a?(String) && exclude_elem =~ %r([^/].*/)
+            rel_path = relative_path(base_config.loaded_path,
+                                     File.dirname(path))
+            rel_path.to_s.sub(/#{DOTFILE}$/, '') + exclude_elem
+          else
+            exclude_elem
+          end
+        end
+      end
+
+      def relative_path(path, base)
+        path_name = Pathname.new(File.expand_path(path))
+        path_name.relative_path_from(Pathname.new(base)).to_s
+      end
+
       # Return a recursive merge of two hashes. That is, a normal hash
       # merge, with the addition that any value that is a hash, and
       # occurs in both arguments, will also be merged. And so on.
@@ -72,21 +98,34 @@ module Rubocop
       # user's home directory is checked. If there's no .rubocop.yml
       # there either, the path to the default file is returned.
       def configuration_file_for(target_dir)
-        possible_config_files = dirs_to_search(target_dir).map do |dir|
-          File.join(dir, DOTFILE)
-        end
-
-        found_file = possible_config_files.find do |config_file|
-          File.exist?(config_file)
-        end
-        found_file || DEFAULT_FILE
+        config_files_in_path(target_dir).first || DEFAULT_FILE
       end
 
       def configuration_from_file(config_file)
         config = load_file(config_file)
+        found_files = config_files_in_path(config_file)
+        if found_files.any? && found_files.last != config_file
+          add_excludes_from_higher_level(config, load_file(found_files.last))
+        end
         merge_with_default(config, config_file)
       end
 
+      def add_excludes_from_higher_level(config, highest_config)
+        if highest_config['AllCops'] && highest_config['AllCops']['Excludes']
+          config['AllCops'] ||= {}
+          config['AllCops']['Excludes'] ||= []
+          highest_config['AllCops']['Excludes'].each do |path|
+            unless path.is_a?(Regexp) || path.start_with?('/')
+              diff_in_level = config.loaded_path.count('/') -
+                highest_config.loaded_path.count('/')
+              path = '../' * diff_in_level + path
+            end
+            config['AllCops']['Excludes'] << path
+          end
+          config['AllCops']['Excludes'].uniq!
+        end
+      end
+
       def default_configuration
         @default_configuration ||= load_file(DEFAULT_FILE)
       end
@@ -97,6 +136,13 @@ module Rubocop
 
       private
 
+      def config_files_in_path(target)
+        possible_config_files = dirs_to_search(target).map do |dir|
+          File.join(dir, DOTFILE)
+        end
+        possible_config_files.select { |config_file| File.exist?(config_file) }
+      end
+
       def dirs_to_search(target_dir)
         dirs_to_search = []
         target_dir_pathname = Pathname.new(File.expand_path(target_dir))
@@ -181,8 +227,7 @@ module Rubocop
 
     def relative_path_to_loaded_dir(file)
       return file unless loaded_path
-      file_pathname = Pathname.new(File.expand_path(file))
-      file_pathname.relative_path_from(loaded_dir_pathname).to_s
+      Config.relative_path(file, loaded_dir_pathname)
     end
 
     def loaded_dir_pathname